Line data Source code
1 : /*
2 : * SPDX-License-Identifier: GPL-3.0-only
3 : * MuseScore-Studio-CLA-applies
4 : *
5 : * MuseScore Studio
6 : * Music Composition & Notation
7 : *
8 : * Copyright (C) 2021 MuseScore Limited and others
9 : *
10 : * This program is free software: you can redistribute it and/or modify
11 : * it under the terms of the GNU General Public License version 3 as
12 : * published by the Free Software Foundation.
13 : *
14 : * This program is distributed in the hope that it will be useful,
15 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : * GNU General Public License for more details.
18 : *
19 : * You should have received a copy of the GNU General Public License
20 : * along with this program. If not, see <https://www.gnu.org/licenses/>.
21 : */
22 :
23 : #include "ove.h"
24 :
25 : #include <QFile>
26 : #include <QtMath>
27 :
28 : #include "engraving/engravingerrors.h"
29 :
30 : #include "engraving/dom/factory.h"
31 : #include "engraving/dom/sig.h"
32 : #include "engraving/dom/arpeggio.h"
33 : #include "engraving/dom/articulation.h"
34 : #include "engraving/dom/box.h"
35 : #include "engraving/dom/bracket.h"
36 : #include "engraving/dom/breath.h"
37 : #include "engraving/editing/editstaffbrackets.h"
38 : #include "engraving/dom/chord.h"
39 : #include "engraving/dom/clef.h"
40 : #include "engraving/dom/drumset.h"
41 : #include "engraving/dom/dynamic.h"
42 : #include "engraving/dom/hairpin.h"
43 : #include "engraving/dom/harmony.h"
44 : #include "engraving/dom/glissando.h"
45 : #include "engraving/dom/keysig.h"
46 : #include "engraving/dom/layoutbreak.h"
47 : #include "engraving/dom/lyrics.h"
48 : #include "engraving/dom/measure.h"
49 : #include "engraving/dom/note.h"
50 : #include "engraving/dom/accidental.h"
51 : #include "engraving/dom/ottava.h"
52 : #include "engraving/dom/part.h"
53 : #include "engraving/dom/pedal.h"
54 : #include "engraving/dom/pitchspelling.h"
55 : #include "engraving/dom/measurerepeat.h"
56 : #include "engraving/dom/rest.h"
57 : #include "engraving/dom/masterscore.h"
58 : #include "engraving/dom/segment.h"
59 : #include "engraving/dom/slur.h"
60 : #include "engraving/dom/tie.h"
61 : #include "engraving/dom/staff.h"
62 : #include "engraving/dom/tempotext.h"
63 : #include "engraving/dom/text.h"
64 : #include "engraving/types/constants.h"
65 : #include "engraving/dom/timesig.h"
66 : #include "engraving/dom/tuplet.h"
67 : #include "engraving/dom/tremolosinglechord.h"
68 : #include "engraving/dom/volta.h"
69 : #include "engraving/dom/chordlist.h"
70 : #include "engraving/dom/rehearsalmark.h"
71 : #include "engraving/dom/marker.h"
72 : #include "engraving/dom/jump.h"
73 : #include "engraving/dom/bracketitem.h"
74 : #include "engraving/editing/transpose.h"
75 :
76 : #include "modularity/ioc.h"
77 : #include "importexport/ove/ioveconfiguration.h"
78 :
79 : #include "global/realfn.h"
80 :
81 : #include "log.h"
82 :
83 : namespace ove {
84 4 : static std::shared_ptr<mu::iex::ove::IOveConfiguration> configuration()
85 : {
86 8 : return muse::modularity::globalIoc()->resolve<mu::iex::ove::IOveConfiguration>("iex_ove");
87 : }
88 : }
89 :
90 : using namespace mu::engraving;
91 :
92 : class MeasureToTick
93 : {
94 : public:
95 : MeasureToTick();
96 : ~MeasureToTick();
97 :
98 : public:
99 : void build(ovebase::OveSong* ove, int quarter);
100 :
101 : int getTick(int measure, int tick_pos);
102 : static int unitToTick(int unit, int quarter);
103 :
104 : struct TimeTick {
105 : int m_numerator;
106 : int m_denominator;
107 : int m_measure;
108 : int m_tick;
109 : bool m_isSymbol;
110 :
111 56 : TimeTick()
112 56 : : m_numerator(4), m_denominator(4), m_measure(0), m_tick(0), m_isSymbol(false) {}
113 : };
114 : QList<TimeTick> getTimeTicks() const;
115 :
116 : private:
117 : int m_quarter;
118 : ovebase::OveSong* m_ove;
119 : QList<TimeTick> m_tts;
120 : };
121 :
122 56 : int getMeasureTick(int quarter, int num, int den)
123 : {
124 56 : return quarter * 4 * num / den;
125 : }
126 :
127 2 : MeasureToTick::MeasureToTick()
128 : {
129 2 : m_quarter = 480;
130 2 : m_ove = 0;
131 2 : }
132 :
133 2 : MeasureToTick::~MeasureToTick()
134 : {
135 2 : }
136 :
137 2 : void MeasureToTick::build(ovebase::OveSong* ove, int quarter)
138 : {
139 : unsigned int i;
140 2 : int currentTick = 0;
141 2 : unsigned int measureCount = ove->getMeasureCount();
142 :
143 2 : m_quarter = quarter;
144 2 : m_ove = ove;
145 2 : m_tts.clear();
146 :
147 11 : for (i = 0; i < measureCount; ++i) {
148 9 : ovebase::Measure* measure = m_ove->getMeasure(i);
149 9 : ovebase::TimeSignature* time = measure->getTime();
150 9 : TimeTick tt;
151 9 : bool change = false;
152 :
153 9 : tt.m_tick = currentTick;
154 9 : tt.m_numerator = time->getNumerator();
155 9 : tt.m_denominator = time->getDenominator();
156 9 : tt.m_measure = i;
157 9 : tt.m_isSymbol = time->getIsSymbol();
158 :
159 9 : if (i == 0) {
160 2 : change = true;
161 : } else {
162 7 : ovebase::TimeSignature* previousTime = m_ove->getMeasure(i - 1)->getTime();
163 :
164 7 : if (time->getNumerator() != previousTime->getNumerator()
165 7 : || time->getDenominator() != previousTime->getDenominator()) {
166 0 : change = true;
167 7 : } else if (time->getIsSymbol() != previousTime->getIsSymbol()) {
168 0 : change = true;
169 : }
170 : }
171 :
172 9 : if (change) {
173 2 : m_tts.push_back(tt);
174 : }
175 :
176 9 : currentTick += getMeasureTick(m_quarter, tt.m_numerator, tt.m_denominator);
177 : }
178 2 : }
179 :
180 47 : int MeasureToTick::getTick(int measure, int tick_pos)
181 : {
182 47 : TimeTick tt;
183 :
184 47 : for (int i = 0; i < m_tts.size(); ++i) {
185 47 : if (measure >= m_tts[i].m_measure && (i == m_tts.size() - 1 || measure < m_tts[i + 1].m_measure)) {
186 94 : int measuresTick = (measure - m_tts[i].m_measure) * getMeasureTick(m_quarter, m_tts[i].m_numerator,
187 47 : m_tts[i].m_denominator);
188 47 : return m_tts[i].m_tick + measuresTick + tick_pos;
189 : }
190 : }
191 :
192 0 : return 0;
193 : }
194 :
195 0 : int MeasureToTick::unitToTick(int unit, int quarter)
196 : {
197 : // 0x100 correspond to quarter tick
198 0 : float ratio = (float)unit / (float)256.0;
199 0 : int tick = ratio * quarter;
200 0 : return tick;
201 : }
202 :
203 2 : QList<MeasureToTick::TimeTick> MeasureToTick::getTimeTicks() const
204 : {
205 2 : return m_tts;
206 : }
207 :
208 : class OveToMScore
209 : {
210 : public:
211 : OveToMScore();
212 : ~OveToMScore();
213 :
214 : public:
215 : void convert(ovebase::OveSong* oveData, Score* score);
216 :
217 : private:
218 : void createStructure();
219 : void convertHeader();
220 : void convertGroups();
221 : void convertTrackHeader(ovebase::Track* track, Part* part);
222 : void convertTrackElements(int track);
223 : void convertLineBreak();
224 : void convertSignatures();
225 : void convertMeasures();
226 : void convertMeasure(Measure* measure);
227 : void convertMeasureMisc(Measure* measure, int part, int staff, int track);
228 : void convertNotes(Measure* measure, int part, int staff, int track);
229 : void convertArticulation(Measure* measure, Chord* cr, int track, int absTick, ovebase::Articulation* art);
230 : void convertLyrics(Measure* measure, int part, int staff, int track);
231 : void convertHarmonies(Measure* measure, int part, int staff, int track);
232 : void convertRepeats(Measure* measure, int part, int staff, int track);
233 : void convertDynamics(Measure* measure, int part, int staff, int track);
234 : void convertExpressions(Measure* measure, int part, int staff, int track);
235 : void convertLines(Measure* measure);
236 : void convertSlurs(Measure* measure, int part, int staff, int track);
237 : void convertGlissandos(Measure* measure, int part, int staff, int track);
238 : void convertWedges(Measure* measure, int part, int staff, int track);
239 : void convertOctaveShifts(Measure* measure, int part, int staff, int track);
240 :
241 : ovebase::NoteContainer* getContainerByPos(int part, int staff, const ovebase::MeasurePos& pos);
242 : // ovebase::MusicData* getMusicDataByUnit(int part, int staff, int measure, int unit, ovebase::MusicDataType type);
243 : ovebase::MusicData* getCrossMeasureElementByPos(int part, int staff, const ovebase::MeasurePos& pos, int voice,
244 : ovebase::MusicDataType type);
245 : ChordRest* findChordRestByPos(int absTick, int track);
246 :
247 : void clearUp();
248 :
249 : private:
250 : ovebase::OveSong* m_ove;
251 : Score* m_score;
252 : MeasureToTick* m_mtt;
253 :
254 : Pedal* m_pedal;
255 : };
256 :
257 2 : OveToMScore::OveToMScore()
258 : {
259 2 : m_ove = 0;
260 2 : m_mtt = new MeasureToTick();
261 2 : m_pedal = 0;
262 2 : }
263 :
264 2 : OveToMScore::~OveToMScore()
265 : {
266 2 : delete m_mtt;
267 2 : }
268 :
269 2 : void OveToMScore::convert(ovebase::OveSong* ove, Score* score)
270 : {
271 2 : m_ove = ove;
272 2 : m_score = score;
273 2 : m_mtt->build(m_ove, m_ove->getQuarter());
274 :
275 2 : convertHeader();
276 2 : createStructure();
277 2 : convertGroups();
278 2 : convertSignatures();
279 : // convertLineBreak();
280 :
281 2 : int staffCount = 0;
282 4 : for (int i = 0; i < m_ove->getPartCount(); ++i) {
283 2 : int partStaffCount = m_ove->getStaffCount(i);
284 2 : Part* part = m_score->parts().at(i);
285 :
286 4 : for (int j = 0; j < partStaffCount; ++j) {
287 2 : ovebase::Track* track = m_ove->getTrack(i, j);
288 :
289 2 : convertTrackHeader(track, part);
290 : }
291 :
292 2 : staffCount += partStaffCount;
293 : }
294 :
295 2 : convertMeasures();
296 :
297 : // convert elements by ove track sequence
298 2 : staffCount = 0;
299 4 : for (int i = 0; i < m_ove->getPartCount(); ++i) {
300 2 : int partStaffCount = m_ove->getStaffCount(i);
301 :
302 4 : for (int j = 0; j < partStaffCount; ++j) {
303 2 : int trackIndex = staffCount + j;
304 :
305 2 : convertTrackElements(trackIndex);
306 : }
307 :
308 2 : staffCount += partStaffCount;
309 : }
310 :
311 2 : clearUp();
312 2 : }
313 :
314 2 : void OveToMScore::createStructure()
315 : {
316 : int i;
317 4 : for (i = 0; i < m_ove->getPartCount(); ++i) {
318 2 : int partStaffCount = m_ove->getStaffCount(i);
319 2 : Part* part = new Part(m_score);
320 :
321 4 : for (int j = 0; j < partStaffCount; ++j) {
322 : //ovebase::Track* track = m_ove->getTrack(i, j);
323 2 : Staff* staff = Factory::createStaff(part);
324 2 : m_score->appendStaff(staff);
325 : }
326 :
327 2 : m_score->appendPart(part);
328 2 : part->setStaves(partStaffCount);
329 : }
330 :
331 11 : for (i = 0; i < m_ove->getMeasureCount(); ++i) {
332 9 : Measure* measure = Factory::createMeasure(m_score);
333 9 : int tick = m_mtt->getTick(i, 0);
334 9 : measure->setTick(Fraction::fromTicks(tick));
335 9 : measure->setMeasureNumber(i);
336 9 : m_score->measures()->append(measure);
337 : }
338 2 : }
339 :
340 2 : void OveToMScore::clearUp()
341 : {
342 2 : if (m_pedal != NULL) {
343 0 : delete m_pedal;
344 0 : m_pedal = 0;
345 : }
346 2 : }
347 :
348 2 : ovebase::Staff* getStaff(const ovebase::OveSong* ove, int track)
349 : {
350 2 : if (ove->getLineCount() > 0) {
351 2 : ovebase::Line* line = ove->getLine(0);
352 2 : if (line != 0 && line->getStaffCount() > 0) {
353 2 : ovebase::Staff* staff = line->getStaff(track);
354 2 : return staff;
355 : }
356 : }
357 :
358 0 : return 0;
359 : }
360 :
361 : namespace ove {
362 6 : void addText(VBox*& vbox, Score* s, QString strTxt, TextStyleType stl)
363 : {
364 6 : if (!strTxt.isEmpty()) {
365 6 : if (vbox == 0) {
366 2 : vbox = Factory::createVBox(s);
367 : }
368 6 : Text* text = Factory::createText(vbox, stl);
369 6 : text->setPlainText(strTxt);
370 6 : vbox->add(text);
371 : }
372 6 : }
373 : }
374 :
375 2 : void OveToMScore::convertHeader()
376 : {
377 2 : VBox* vbox = 0;
378 2 : QList<QString> titles = m_ove->getTitles();
379 2 : if (!titles.empty() && !titles[0].isEmpty()) {
380 2 : QString title = titles[0];
381 2 : m_score->setMetaTag(u"movementTitle", title);
382 2 : ove::addText(vbox, m_score, title, TextStyleType::TITLE);
383 2 : }
384 :
385 2 : QList<QString> copyrights = m_ove->getCopyrights();
386 2 : if (!copyrights.empty() && !copyrights[0].isEmpty()) {
387 2 : QString copyright = copyrights[0];
388 2 : m_score->setMetaTag(u"copyright", copyright);
389 2 : }
390 :
391 2 : QList<QString> annotates = m_ove->getAnnotates();
392 2 : if (!annotates.empty() && !annotates[0].isEmpty()) {
393 2 : QString annotate = annotates[0];
394 2 : ove::addText(vbox, m_score, annotate, TextStyleType::LYRICIST);
395 2 : }
396 :
397 2 : QList<QString> writers = m_ove->getWriters();
398 2 : if (!writers.empty()) {
399 2 : QString composer = writers[0];
400 2 : m_score->setMetaTag(u"composer", composer);
401 2 : ove::addText(vbox, m_score, composer, TextStyleType::COMPOSER);
402 2 : }
403 :
404 2 : if (writers.size() > 1) {
405 0 : QString lyricist = writers[1];
406 0 : ove::addText(vbox, m_score, lyricist, TextStyleType::LYRICIST);
407 0 : }
408 :
409 2 : if (vbox) {
410 2 : vbox->setTick(Fraction(0, 1));
411 2 : m_score->measures()->append(vbox);
412 : }
413 2 : }
414 :
415 2 : void OveToMScore::convertGroups()
416 : {
417 : int i;
418 2 : int staffCount = 0;
419 2 : const std::vector<Part*>& parts = m_score->parts();
420 4 : for (i = 0; i < m_ove->getPartCount(); ++i) {
421 2 : int partStaffCount = m_ove->getStaffCount(i);
422 : //if(parts == 0)
423 : // continue;
424 2 : Part* part = parts.at(i);
425 2 : if (part == 0) {
426 0 : continue;
427 : }
428 :
429 4 : for (int j = 0; j < partStaffCount; ++j) {
430 2 : int staffIndex = staffCount + j;
431 2 : Staff* staff = m_score->staff(staffIndex);
432 2 : if (staff == 0) {
433 0 : continue;
434 : }
435 :
436 : // brace
437 2 : if (j == 0 && partStaffCount == 2) {
438 0 : EditStaffBrackets::setBracketType(m_score, staffIndex, 0, BracketType::BRACE);
439 0 : EditStaffBrackets::setBracketSpan(m_score, staffIndex, 0, 2);
440 0 : staff->setBarLineSpan(true);
441 : }
442 :
443 : // bracket
444 2 : ovebase::Staff* staffPtr = getStaff(m_ove, staffIndex);
445 2 : if (staffPtr != 0 && staffPtr->getGroupType() == ovebase::GroupType::Bracket) {
446 0 : int span = staffPtr->getGroupStaffCount() + 1;
447 0 : int endStaff = staffIndex + span;
448 0 : if (span > 0 && endStaff >= staffIndex && endStaff <= m_ove->getTrackCount()) {
449 0 : EditStaffBrackets::addBracket(m_score, staffIndex,
450 0 : Factory::createBracketItem(m_score->dummy(), BracketType::NORMAL, span));
451 0 : staff->setBarLineSpan(static_cast<bool>(span));
452 : }
453 : }
454 : }
455 :
456 2 : staffCount += partStaffCount;
457 : }
458 2 : }
459 :
460 2 : ClefType OveClefToClef(ovebase::ClefType type)
461 : {
462 2 : ClefType clef = ClefType::G;
463 2 : switch (type) {
464 2 : case ovebase::ClefType::Treble: {
465 2 : clef = ClefType::G;
466 2 : break;
467 : }
468 0 : case ovebase::ClefType::Bass: {
469 0 : clef = ClefType::F;
470 0 : break;
471 : }
472 0 : case ovebase::ClefType::Alto: {
473 0 : clef = ClefType::C3;
474 0 : break;
475 : }
476 0 : case ovebase::ClefType::UpAlto: {
477 0 : clef = ClefType::C4;
478 0 : break;
479 : }
480 0 : case ovebase::ClefType::DownDownAlto: {
481 0 : clef = ClefType::C1;
482 0 : break;
483 : }
484 0 : case ovebase::ClefType::DownAlto: {
485 0 : clef = ClefType::C2;
486 0 : break;
487 : }
488 0 : case ovebase::ClefType::UpUpAlto: {
489 0 : clef = ClefType::C5;
490 0 : break;
491 : }
492 0 : case ovebase::ClefType::Treble8va: {
493 0 : clef = ClefType::G8_VA;
494 0 : break;
495 : }
496 0 : case ovebase::ClefType::Bass8va: {
497 0 : clef = ClefType::F_8VA;
498 0 : break;
499 : }
500 0 : case ovebase::ClefType::Treble8vb: {
501 0 : clef = ClefType::G8_VB;
502 0 : break;
503 : }
504 0 : case ovebase::ClefType::Bass8vb: {
505 0 : clef = ClefType::F8_VB;
506 0 : break;
507 : }
508 0 : case ovebase::ClefType::Percussion1: {
509 0 : clef = ClefType::PERC;
510 0 : break;
511 : }
512 0 : case ovebase::ClefType::Percussion2: {
513 0 : clef = ClefType::PERC2;
514 0 : break;
515 : }
516 0 : case ovebase::ClefType::TAB: {
517 0 : clef = ClefType::TAB;
518 0 : break;
519 : }
520 0 : default:
521 0 : break;
522 : }
523 2 : return clef;
524 : }
525 :
526 6 : NoteHeadGroup getHeadGroup(ovebase::NoteHeadType type)
527 : {
528 6 : NoteHeadGroup headGroup = NoteHeadGroup::HEAD_NORMAL;
529 6 : switch (type) {
530 6 : case ovebase::NoteHeadType::Standard: {
531 6 : headGroup = NoteHeadGroup::HEAD_NORMAL;
532 6 : break;
533 : }
534 0 : case ovebase::NoteHeadType::Invisible: {
535 0 : break;
536 : }
537 0 : case ovebase::NoteHeadType::Rhythmic_Slash: {
538 0 : headGroup = NoteHeadGroup::HEAD_SLASH;
539 0 : break;
540 : }
541 0 : case ovebase::NoteHeadType::Percussion: {
542 0 : headGroup = NoteHeadGroup::HEAD_XCIRCLE;
543 0 : break;
544 : }
545 0 : case ovebase::NoteHeadType::Closed_Rhythm: {
546 0 : headGroup = NoteHeadGroup::HEAD_CROSS;
547 0 : break;
548 : }
549 0 : case ovebase::NoteHeadType::Open_Rhythm: {
550 0 : headGroup = NoteHeadGroup::HEAD_CROSS;
551 0 : break;
552 : }
553 0 : case ovebase::NoteHeadType::Closed_Slash: {
554 0 : headGroup = NoteHeadGroup::HEAD_SLASH;
555 0 : break;
556 : }
557 0 : case ovebase::NoteHeadType::Open_Slash: {
558 0 : headGroup = NoteHeadGroup::HEAD_SLASH;
559 0 : break;
560 : }
561 0 : case ovebase::NoteHeadType::Closed_Do: {
562 0 : headGroup = NoteHeadGroup::HEAD_DO;
563 0 : break;
564 : }
565 0 : case ovebase::NoteHeadType::Open_Do: {
566 0 : headGroup = NoteHeadGroup::HEAD_DO;
567 0 : break;
568 : }
569 0 : case ovebase::NoteHeadType::Closed_Re: {
570 0 : headGroup = NoteHeadGroup::HEAD_RE;
571 0 : break;
572 : }
573 0 : case ovebase::NoteHeadType::Open_Re: {
574 0 : headGroup = NoteHeadGroup::HEAD_RE;
575 0 : break;
576 : }
577 0 : case ovebase::NoteHeadType::Closed_Mi: {
578 0 : headGroup = NoteHeadGroup::HEAD_MI;
579 0 : break;
580 : }
581 0 : case ovebase::NoteHeadType::Open_Mi: {
582 0 : headGroup = NoteHeadGroup::HEAD_MI;
583 0 : break;
584 : }
585 0 : case ovebase::NoteHeadType::Closed_Fa: {
586 0 : headGroup = NoteHeadGroup::HEAD_FA;
587 0 : break;
588 : }
589 0 : case ovebase::NoteHeadType::Open_Fa: {
590 0 : headGroup = NoteHeadGroup::HEAD_FA;
591 0 : break;
592 : }
593 0 : case ovebase::NoteHeadType::Closed_Sol: {
594 0 : break;
595 : }
596 0 : case ovebase::NoteHeadType::Open_Sol: {
597 0 : break;
598 : }
599 0 : case ovebase::NoteHeadType::Closed_La: {
600 0 : headGroup = NoteHeadGroup::HEAD_LA;
601 0 : break;
602 : }
603 0 : case ovebase::NoteHeadType::Open_La: {
604 0 : headGroup = NoteHeadGroup::HEAD_LA;
605 0 : break;
606 : }
607 0 : case ovebase::NoteHeadType::Closed_Ti: {
608 0 : headGroup = NoteHeadGroup::HEAD_TI;
609 0 : break;
610 : }
611 0 : case ovebase::NoteHeadType::Open_Ti: {
612 0 : headGroup = NoteHeadGroup::HEAD_TI;
613 0 : break;
614 : }
615 0 : default: {
616 0 : break;
617 : }
618 : }
619 :
620 6 : return headGroup;
621 : }
622 :
623 2 : void OveToMScore::convertTrackHeader(ovebase::Track* track, Part* part)
624 : {
625 2 : if (track == 0 || part == 0) {
626 0 : return;
627 : }
628 :
629 2 : QString longName = track->getName();
630 2 : if (longName != QString() && track->getShowName()) {
631 0 : part->setPlainLongName(longName);
632 : }
633 :
634 2 : QString shortName = track->getBriefName();
635 2 : if (shortName != QString() && track->getShowBriefName()) {
636 0 : part->setPlainShortName(shortName);
637 : }
638 :
639 2 : part->setMidiProgram(track->getPatch());
640 :
641 2 : if (m_ove->getShowTransposeTrack() && track->getTranspose() != 0) {
642 0 : mu::engraving::Interval interval = part->instrument()->transpose();
643 0 : interval.diatonic = -track->getTranspose();
644 0 : part->instrument()->setTranspose(interval);
645 : }
646 :
647 : // DrumSet
648 2 : if (track->getStartClef() == ovebase::ClefType::Percussion1 || track->getStartClef() == ovebase::ClefType::Percussion2) {
649 : // use overture drumset
650 0 : Drumset* drumset = new Drumset();
651 0 : for (int i = 0; i < DRUM_INSTRUMENTS; ++i) {
652 0 : drumset->drum(i).name = smDrumset->drum(i).name;
653 0 : drumset->drum(i).notehead = smDrumset->drum(i).notehead;
654 0 : drumset->drum(i).line = smDrumset->drum(i).line;
655 0 : drumset->drum(i).stemDirection = smDrumset->drum(i).stemDirection;
656 0 : drumset->drum(i).voice = smDrumset->drum(i).voice;
657 0 : drumset->drum(i).shortcut = smDrumset->drum(i).shortcut;
658 0 : drumset->drum(i).panelRow = smDrumset->drum(i).panelRow;
659 0 : drumset->drum(i).panelColumn = smDrumset->drum(i).panelColumn;
660 : }
661 0 : QList<ovebase::Track::DrumNode> nodes = track->getDrumKit();
662 0 : for (int i = 0; i < nodes.size(); ++i) {
663 0 : int pitch = nodes[i].m_pitch;
664 0 : ovebase::Track::DrumNode node = nodes[i];
665 0 : if (pitch < DRUM_INSTRUMENTS) {
666 0 : drumset->drum(pitch).line = node.m_line;
667 0 : drumset->drum(pitch).notehead = getHeadGroup(ovebase::NoteHeadType(node.m_headType));
668 0 : drumset->drum(pitch).voice = node.m_voice;
669 : }
670 : }
671 :
672 0 : part->instrument()->channel(0)->setBank(128);
673 0 : part->setMidiProgram(0);
674 0 : part->instrument()->setDrumset(smDrumset);
675 0 : part->instrument()->setDrumset(drumset);
676 0 : }
677 2 : }
678 :
679 0 : static OttavaType OctaveShiftTypeToInt(ovebase::OctaveShiftType type)
680 : {
681 0 : OttavaType subtype = OttavaType::OTTAVA_8VA;
682 0 : switch (type) {
683 0 : case ovebase::OctaveShiftType::OS_8: {
684 0 : subtype = OttavaType::OTTAVA_8VA;
685 0 : break;
686 : }
687 0 : case ovebase::OctaveShiftType::OS_15: {
688 0 : subtype = OttavaType::OTTAVA_15MA;
689 0 : break;
690 : }
691 0 : case ovebase::OctaveShiftType::OS_Minus_8: {
692 0 : subtype = OttavaType::OTTAVA_8VB;
693 0 : break;
694 : }
695 0 : case ovebase::OctaveShiftType::OS_Minus_15: {
696 0 : subtype = OttavaType::OTTAVA_15MB;
697 0 : break;
698 : }
699 0 : default:
700 0 : break;
701 : }
702 :
703 0 : return subtype;
704 : }
705 :
706 2 : void OveToMScore::convertTrackElements(int track)
707 : {
708 2 : Ottava* ottava = 0;
709 :
710 11 : for (int i = 0; i < m_ove->getTrackBarCount(); ++i) {
711 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(track, i);
712 9 : if (measureData == 0) {
713 0 : continue;
714 : }
715 :
716 : // octave shift
717 9 : QList<ovebase::MusicData*> octaves = measureData->getMusicDatas(ovebase::MusicDataType::OctaveShift_EndPoint);
718 9 : for (int j = 0; j < octaves.size(); ++j) {
719 0 : ovebase::OctaveShiftEndPoint* octave = static_cast<ovebase::OctaveShiftEndPoint*>(octaves[j]);
720 0 : int absTick = m_mtt->getTick(i, octave->getTick());
721 :
722 0 : if (octave->getOctaveShiftPosition() == ovebase::OctaveShiftPosition::Start) {
723 0 : if (ottava == 0) {
724 0 : ottava = Factory::createOttava(m_score->dummy());
725 0 : ottava->setTrack(track * VOICES);
726 0 : ottava->setOttavaType(OctaveShiftTypeToInt(octave->getOctaveShiftType()));
727 :
728 0 : int y_off = 0;
729 0 : switch (octave->getOctaveShiftType()) {
730 0 : case ovebase::OctaveShiftType::OS_8:
731 : case ovebase::OctaveShiftType::OS_15: {
732 0 : y_off = -3;
733 0 : break;
734 : }
735 0 : case ovebase::OctaveShiftType::OS_Minus_8:
736 : case ovebase::OctaveShiftType::OS_Minus_15: {
737 0 : y_off = 8;
738 0 : break;
739 : }
740 0 : default: {
741 0 : break;
742 : }
743 : }
744 :
745 0 : if (y_off != 0) {
746 0 : ottava->setOffset(muse::PointF(0, y_off * m_score->style().spatium()));
747 : }
748 :
749 0 : ottava->setTick(Fraction::fromTicks(absTick));
750 : } else {
751 0 : LOGD("overlapping octave-shift not supported");
752 0 : delete ottava;
753 0 : ottava = 0;
754 : }
755 0 : } else if (octave->getOctaveShiftPosition() == ovebase::OctaveShiftPosition::Stop) {
756 0 : if (ottava != 0) {
757 0 : ottava->setTick2(Fraction::fromTicks(absTick));
758 0 : m_score->addSpanner(ottava);
759 0 : ottava->staff()->updateOttava();
760 0 : ottava = 0;
761 : } else {
762 0 : LOGD("octave-shift stop without start");
763 : }
764 : }
765 : }
766 9 : }
767 2 : }
768 :
769 0 : void OveToMScore::convertLineBreak()
770 : {
771 0 : for (MeasureBase* mb = m_score->measures()->first(); mb; mb = mb->next()) {
772 0 : if (!mb->isMeasure()) {
773 0 : continue;
774 : }
775 0 : Measure* measure = toMeasure(mb);
776 :
777 0 : for (int i = 0; i < m_ove->getLineCount(); ++i) {
778 0 : ovebase::Line* line = m_ove->getLine(i);
779 0 : if (measure->measureNumber() > 0) {
780 0 : if ((int)line->getBeginBar() + (int)line->getBarCount() - 1 == measure->measureNumber()) {
781 0 : LayoutBreak* lb = Factory::createLayoutBreak(measure);
782 0 : lb->setTrack(0);
783 0 : lb->setLayoutBreakType(LayoutBreakType::LINE);
784 0 : measure->add(lb);
785 : }
786 : }
787 : }
788 : }
789 0 : }
790 :
791 2 : void OveToMScore::convertSignatures()
792 : {
793 : int i;
794 : int j;
795 : int k;
796 :
797 : // Time
798 2 : const QList<MeasureToTick::TimeTick> tts = m_mtt->getTimeTicks();
799 4 : for (i = 0; i < (int)tts.size(); ++i) {
800 2 : MeasureToTick::TimeTick tt = tts[i];
801 2 : Fraction f(tt.m_numerator, tt.m_denominator);
802 :
803 2 : TimeSigMap* sigmap = m_score->sigmap();
804 2 : sigmap->add(tt.m_tick, f);
805 :
806 2 : Measure* measure = m_score->tick2measure(Fraction::fromTicks(tt.m_tick));
807 2 : if (measure) {
808 4 : for (size_t staffIdx = 0; staffIdx < m_score->nstaves(); ++staffIdx) {
809 2 : TimeSigType subtype = TimeSigType::NORMAL;
810 2 : if (tt.m_numerator == 4 && tt.m_denominator == 4 && tt.m_isSymbol) {
811 0 : subtype = TimeSigType::FOUR_FOUR;
812 2 : } else if (tt.m_numerator == 2 && tt.m_denominator == 2 && tt.m_isSymbol) {
813 0 : subtype = TimeSigType::ALLA_BREVE;
814 : }
815 :
816 2 : Segment* seg = measure->getSegment(SegmentType::TimeSig, Fraction::fromTicks(tt.m_tick));
817 2 : TimeSig* ts = Factory::createTimeSig(seg);
818 2 : ts->setTrack(static_cast<int>(staffIdx) * VOICES);
819 2 : ts->setSig(Fraction(tt.m_numerator, tt.m_denominator), subtype);
820 2 : seg->add(ts);
821 : }
822 : }
823 : }
824 :
825 : // Key
826 2 : int staffCount = 0;
827 2 : bool createKey = false;
828 4 : for (i = 0; i < m_ove->getPartCount(); ++i) {
829 2 : int partStaffCount = m_ove->getStaffCount(i);
830 :
831 4 : for (j = 0; j < partStaffCount; ++j) {
832 2 : Staff& staff = *m_score->staff(staffCount + j);
833 11 : for (k = 0; k < m_ove->getMeasureCount(); ++k) {
834 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(i, j, k);
835 :
836 9 : if (measureData != 0) {
837 9 : ovebase::Key* keyPtr = measureData->getKey();
838 :
839 9 : if (k == 0 || keyPtr->getKey() != keyPtr->getPreviousKey()) {
840 2 : Fraction tick = Fraction::fromTicks(m_mtt->getTick(k, 0));
841 2 : int keyValue = keyPtr->getKey();
842 2 : Measure* measure = m_score->tick2measure(tick);
843 2 : if (measure) {
844 2 : KeySigEvent ke;
845 2 : Key key = Key(keyValue);
846 2 : Key cKey = key;
847 2 : Interval v = staff.part()->instrument(tick)->transpose();
848 2 : if (!v.isZero() && !m_score->style().styleB(Sid::concertPitch)) {
849 0 : cKey = Transpose::transposeKey(key, v);
850 : // if there are more than 6 accidentals in transposing key, it cannot be PreferSharpFlat::AUTO
851 0 : if ((key > 6 || key < -6) && staff.part()->preferSharpFlat() == PreferSharpFlat::AUTO) {
852 0 : staff.part()->setPreferSharpFlat(PreferSharpFlat::NONE);
853 : }
854 : }
855 2 : ke.setConcertKey(cKey);
856 2 : ke.setKey(key);
857 2 : staff.setKey(tick, ke);
858 :
859 2 : Segment* s = measure->getSegment(SegmentType::KeySig, tick);
860 2 : KeySig* keysig = Factory::createKeySig(s);
861 2 : keysig->setTrack((staffCount + j) * VOICES);
862 2 : keysig->setKeySigEvent(ke);
863 2 : s->add(keysig);
864 :
865 2 : createKey = true;
866 2 : }
867 : }
868 : }
869 : }
870 : }
871 :
872 2 : staffCount += partStaffCount;
873 : }
874 :
875 2 : if (!createKey) {
876 0 : staffCount = 0;
877 0 : for (i = 0; i < m_ove->getPartCount(); ++i) {
878 0 : int partStaffCount = m_ove->getStaffCount(i);
879 :
880 0 : for (j = 0; j < partStaffCount; ++j) {
881 0 : Measure* measure = m_score->tick2measure(Fraction::fromTicks(m_mtt->getTick(0, 0)));
882 0 : if (measure) {
883 0 : Segment* s = measure->getSegment(SegmentType::KeySig, Fraction(0, 1));
884 0 : KeySig* keysig = Factory::createKeySig(s);
885 0 : keysig->setTrack((staffCount + j) * VOICES);
886 0 : keysig->setKeySigEvent(KeySigEvent());
887 0 : s->add(keysig);
888 : }
889 : }
890 0 : staffCount += partStaffCount;
891 : }
892 : }
893 :
894 : // Clef
895 2 : staffCount = 0;
896 4 : for (i = 0; i < m_ove->getPartCount(); ++i) {
897 2 : int partStaffCount = m_ove->getStaffCount(i);
898 4 : for (j = 0; j < partStaffCount; ++j) {
899 : // start clef
900 2 : Staff* staff = m_score->staff(staffCount + j);
901 2 : if (staff) {
902 2 : ovebase::Track* track = m_ove->getTrack(i, j);
903 2 : ClefType clefType = OveClefToClef(track->getStartClef());
904 2 : Measure* measure = m_score->tick2measure(Fraction(0, 1));
905 : // staff->setClef(0, clefType);
906 :
907 : // note: also generate symbol for tick 0
908 : // was not necessary before 0.9.6
909 2 : Segment* s = measure->getSegment(SegmentType::HeaderClef, Fraction(0, 1));
910 2 : Clef* clef = Factory::createClef(s);
911 2 : clef->setClefType(clefType);
912 2 : clef->setTrack((staffCount + j) * VOICES);
913 2 : s->add(clef);
914 : }
915 :
916 : // clef in measure
917 11 : for (k = 0; k < m_ove->getMeasureCount(); ++k) {
918 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(i, j, k);
919 9 : QList<ovebase::MusicData*> clefs = measureData->getMusicDatas(ovebase::MusicDataType::Clef);
920 9 : Measure* measure = m_score->tick2measure(Fraction::fromTicks(m_mtt->getTick(k, 0)));
921 :
922 9 : for (int l = 0; l < clefs.size(); ++l) {
923 0 : if (measure != 0) {
924 0 : ovebase::Clef* clefPtr = static_cast<ovebase::Clef*>(clefs[l]);
925 0 : int absTick = m_mtt->getTick(k, clefPtr->getTick());
926 0 : ClefType clefType = OveClefToClef(clefPtr->getClefType());
927 :
928 0 : Segment* s = measure->getSegment(SegmentType::Clef, Fraction::fromTicks(absTick));
929 0 : Clef* clef = Factory::createClef(s);
930 0 : clef->setClefType(clefType);
931 0 : clef->setTrack((staffCount + j) * VOICES);
932 0 : s->add(clef);
933 : }
934 : }
935 9 : }
936 : }
937 :
938 2 : staffCount += partStaffCount;
939 : }
940 :
941 : // Tempo
942 2 : std::map<int, double> tempos;
943 4 : for (i = 0; i < m_ove->getPartCount(); ++i) {
944 2 : int partStaffCount = m_ove->getStaffCount(i);
945 :
946 4 : for (j = 0; j < partStaffCount; ++j) {
947 11 : for (k = 0; k < m_ove->getMeasureCount(); ++k) {
948 9 : ovebase::Measure* measure = m_ove->getMeasure(k);
949 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(i, j, k);
950 9 : QList<ovebase::MusicData*> tempoPtrs = measureData->getMusicDatas(ovebase::MusicDataType::Tempo);
951 :
952 9 : if (k == 0
953 9 : || (k > 0 && qAbs(measure->getTypeTempo() - m_ove->getMeasure(k - 1)->getTypeTempo()) > 0.01)) {
954 2 : int tick = m_mtt->getTick(k, 0);
955 2 : tempos[tick] = measure->getTypeTempo();
956 : }
957 :
958 11 : for (int l = 0; l < tempoPtrs.size(); ++l) {
959 2 : ovebase::Tempo* ptr = static_cast<ovebase::Tempo*>(tempoPtrs[l]);
960 2 : int tick = m_mtt->getTick(measure->getBarNumber()->getIndex(), ptr->getTick());
961 2 : double tempo = ptr->getQuarterTempo() > 0 ? ptr->getQuarterTempo() : 1.0;
962 :
963 2 : tempos[tick] = tempo;
964 : }
965 9 : }
966 : }
967 : }
968 :
969 2 : std::map<int, double>::iterator it;
970 2 : double lastTempo = 0.0;
971 5 : for (it=tempos.begin(); it != tempos.end(); ++it) {
972 3 : if (it == tempos.begin() || !muse::RealIsEqual((*it).second, lastTempo)) {
973 2 : const double tpo = ((*it).second) / 60.0;
974 2 : const bool isDefault = it == tempos.begin() && muse::RealIsEqual(tpo, Constants::DEFAULT_TEMPO.val);
975 :
976 2 : if (!isDefault) {
977 2 : Fraction tick = Fraction::fromTicks((*it).first);
978 2 : Measure* measure = m_score->tick2measure(tick);
979 2 : if (measure) {
980 2 : Segment* s = measure->getSegment(SegmentType::ChordRest, tick);
981 2 : TempoText* t = Factory::createTempoText(s);
982 2 : t->setXmlText(String(u"<sym>metNoteQuarterUp</sym> = %1").arg(qRound(tpo * 60.0)));
983 2 : t->setTempo(tpo);
984 2 : t->setVisible(false);
985 2 : t->setTrack(0);
986 2 : s->add(t);
987 : }
988 : }
989 : }
990 :
991 3 : lastTempo = (*it).second;
992 : }
993 2 : }
994 :
995 0 : int ContainerToTick(ovebase::NoteContainer* container, int quarter)
996 : {
997 0 : int tick = ovebase::NoteTypeToTick(container->getNoteType(), quarter);
998 :
999 0 : int dotLength = tick;
1000 0 : for (int i = 0; i < container->getDot(); ++i) {
1001 0 : dotLength /= 2;
1002 : }
1003 0 : dotLength = tick - dotLength;
1004 :
1005 0 : if (container->getTuplet() > 0) {
1006 0 : tick = tick * container->getSpace() / container->getTuplet();
1007 : }
1008 :
1009 0 : tick += dotLength;
1010 :
1011 0 : return tick;
1012 : }
1013 :
1014 0 : const ovebase::Tuplet* getTuplet(const QList<ovebase::MusicData*>& tuplets, int unit)
1015 : {
1016 0 : for (int i = 0; i < tuplets.size(); ++i) {
1017 0 : const ovebase::MusicData* data = tuplets[i];
1018 0 : if (unit >= data->start()->getOffset() && unit <= data->stop()->getOffset()) {
1019 0 : const ovebase::Tuplet* tuplet = static_cast<ovebase::Tuplet*>(tuplets[i]);
1020 0 : return tuplet;
1021 : }
1022 : }
1023 0 : return 0;
1024 : }
1025 :
1026 16 : TDuration OveNoteType_To_Duration(ovebase::NoteType noteType)
1027 : {
1028 16 : TDuration d;
1029 16 : switch (noteType) {
1030 0 : case ovebase::NoteType::Note_DoubleWhole: {
1031 0 : d.setType(DurationType::V_BREVE);
1032 0 : break;
1033 : }
1034 0 : case ovebase::NoteType::Note_Whole: {
1035 0 : d.setType(DurationType::V_WHOLE);
1036 0 : break;
1037 : }
1038 0 : case ovebase::NoteType::Note_Half: {
1039 0 : d.setType(DurationType::V_HALF);
1040 0 : break;
1041 : }
1042 14 : case ovebase::NoteType::Note_Quarter: {
1043 14 : d.setType(DurationType::V_QUARTER);
1044 14 : break;
1045 : }
1046 2 : case ovebase::NoteType::Note_Eight: {
1047 2 : d.setType(DurationType::V_EIGHTH);
1048 2 : break;
1049 : }
1050 0 : case ovebase::NoteType::Note_Sixteen: {
1051 0 : d.setType(DurationType::V_16TH);
1052 0 : break;
1053 : }
1054 0 : case ovebase::NoteType::Note_32: {
1055 0 : d.setType(DurationType::V_32ND);
1056 0 : break;
1057 : }
1058 0 : case ovebase::NoteType::Note_64: {
1059 0 : d.setType(DurationType::V_64TH);
1060 0 : break;
1061 : }
1062 0 : case ovebase::NoteType::Note_128: {
1063 0 : d.setType(DurationType::V_128TH);
1064 0 : break;
1065 : }
1066 0 : case ovebase::NoteType::Note_256: {
1067 0 : d.setType(DurationType::V_256TH);
1068 0 : break;
1069 : }
1070 : // case ovebase::NoteType::Note_512: {
1071 : // d.setType(DurationType::V_512TH);
1072 : // break;
1073 : // }
1074 : // case ovebase::NoteType::Note_1024: {
1075 : // d.setType(DurationType::V_1024TH);
1076 : // break;
1077 : // }
1078 0 : default:
1079 0 : d.setType(DurationType::V_QUARTER);
1080 0 : break;
1081 : }
1082 :
1083 16 : return d;
1084 : }
1085 :
1086 6 : int accidentalToAlter(ovebase::AccidentalType type)
1087 : {
1088 6 : int alter = 0;
1089 :
1090 6 : switch (type) {
1091 6 : case ovebase::AccidentalType::Normal:
1092 : case ovebase::AccidentalType::Natural:
1093 : case ovebase::AccidentalType::Natural_Caution: {
1094 6 : alter = 0;
1095 6 : break;
1096 : }
1097 0 : case ovebase::AccidentalType::Sharp:
1098 : case ovebase::AccidentalType::Sharp_Caution: {
1099 0 : alter = 1;
1100 0 : break;
1101 : }
1102 0 : case ovebase::AccidentalType::Flat:
1103 : case ovebase::AccidentalType::Flat_Caution: {
1104 0 : alter = -1;
1105 0 : break;
1106 : }
1107 0 : case ovebase::AccidentalType::DoubleSharp:
1108 : case ovebase::AccidentalType::DoubleSharp_Caution: {
1109 0 : alter = 2;
1110 0 : break;
1111 : }
1112 0 : case ovebase::AccidentalType::DoubleFlat:
1113 : case ovebase::AccidentalType::DoubleFlat_Caution: {
1114 0 : alter = -2;
1115 0 : break;
1116 : }
1117 0 : default:
1118 0 : break;
1119 : }
1120 :
1121 6 : return alter;
1122 : }
1123 :
1124 6 : void getMiddleToneOctave(ovebase::ClefType clef, ovebase::ToneType& tone, int& octave)
1125 : {
1126 6 : tone = ovebase::ToneType::B;
1127 6 : octave = 4;
1128 :
1129 6 : switch (clef) {
1130 6 : case ovebase::ClefType::Treble: {
1131 6 : tone = ovebase::ToneType::B;
1132 6 : octave = 4;
1133 6 : break;
1134 : }
1135 0 : case ovebase::ClefType::Treble8va: {
1136 0 : tone = ovebase::ToneType::B;
1137 0 : octave = 5;
1138 0 : break;
1139 : }
1140 0 : case ovebase::ClefType::Treble8vb: {
1141 0 : tone = ovebase::ToneType::B;
1142 0 : octave = 3;
1143 0 : break;
1144 : }
1145 0 : case ovebase::ClefType::Bass: {
1146 0 : tone = ovebase::ToneType::D;
1147 0 : octave = 3;
1148 0 : break;
1149 : }
1150 0 : case ovebase::ClefType::Bass8va: {
1151 0 : tone = ovebase::ToneType::D;
1152 0 : octave = 4;
1153 0 : break;
1154 : }
1155 0 : case ovebase::ClefType::Bass8vb: {
1156 0 : tone = ovebase::ToneType::D;
1157 0 : octave = 2;
1158 0 : break;
1159 : }
1160 0 : case ovebase::ClefType::Alto: {
1161 0 : tone = ovebase::ToneType::C;
1162 0 : octave = 4;
1163 0 : break;
1164 : }
1165 0 : case ovebase::ClefType::UpAlto: {
1166 0 : tone = ovebase::ToneType::A;
1167 0 : octave = 3;
1168 0 : break;
1169 : }
1170 0 : case ovebase::ClefType::DownDownAlto: {
1171 0 : tone = ovebase::ToneType::G;
1172 0 : octave = 4;
1173 0 : break;
1174 : }
1175 0 : case ovebase::ClefType::DownAlto: {
1176 0 : tone = ovebase::ToneType::E;
1177 0 : octave = 4;
1178 0 : break;
1179 : }
1180 0 : case ovebase::ClefType::UpUpAlto: {
1181 0 : tone = ovebase::ToneType::F;
1182 0 : octave = 3;
1183 0 : break;
1184 : }
1185 0 : case ovebase::ClefType::Percussion1: {
1186 0 : tone = ovebase::ToneType::A;
1187 0 : octave = 3;
1188 0 : break;
1189 : }
1190 0 : case ovebase::ClefType::Percussion2: {
1191 0 : tone = ovebase::ToneType::A;
1192 0 : octave = 3;
1193 0 : break;
1194 : }
1195 0 : case ovebase::ClefType::TAB: {
1196 0 : break;
1197 : }
1198 0 : default:
1199 0 : break;
1200 : }
1201 6 : }
1202 :
1203 6 : ovebase::ClefType getClefType(ovebase::MeasureData* measure, int tick)
1204 : {
1205 6 : ovebase::ClefType type = measure->getClef()->getClefType();
1206 6 : QList<ovebase::MusicData*> clefs = measure->getMusicDatas(ovebase::MusicDataType::Clef);
1207 :
1208 6 : for (int i = 0; i < clefs.size(); ++i) {
1209 0 : if (tick < clefs[i]->getTick()) {
1210 0 : break;
1211 : }
1212 0 : if (tick >= clefs[i]->getTick()) {
1213 0 : ovebase::Clef* clef = static_cast<ovebase::Clef*>(clefs[i]);
1214 0 : type = clef->getClefType();
1215 : }
1216 : }
1217 :
1218 6 : return type;
1219 6 : }
1220 :
1221 2 : void OveToMScore::convertMeasures()
1222 : {
1223 13 : for (MeasureBase* mb = m_score->measures()->first(); mb; mb = mb->next()) {
1224 11 : if (!mb->isMeasure()) {
1225 2 : continue;
1226 : }
1227 9 : Measure* measure = toMeasure(mb);
1228 9 : int tick = measure->tick().ticks();
1229 9 : measure->setTicks(m_score->sigmap()->timesig(tick).timesig());
1230 9 : measure->setTimesig(m_score->sigmap()->timesig(tick).timesig()); //?
1231 9 : convertMeasure(measure);
1232 : }
1233 :
1234 : // convert based on notes
1235 13 : for (MeasureBase* mb = m_score->measures()->first(); mb; mb = mb->next()) {
1236 11 : if (!mb->isMeasure()) {
1237 2 : continue;
1238 : }
1239 9 : Measure* measure = toMeasure(mb);
1240 :
1241 9 : convertLines(measure);
1242 : }
1243 2 : }
1244 :
1245 9 : void OveToMScore::convertMeasure(Measure* measure)
1246 : {
1247 9 : int staffCount = 0;
1248 9 : int measureCount = m_ove->getMeasureCount();
1249 :
1250 18 : for (int i = 0; i < m_ove->getPartCount(); ++i) {
1251 9 : int partStaffCount = m_ove->getStaffCount(i);
1252 :
1253 18 : for (int j = 0; j < partStaffCount; ++j) {
1254 9 : int measureID = measure->measureNumber();
1255 :
1256 9 : if (measureID >= 0 && measureID < measureCount) {
1257 9 : int trackIndex = (staffCount + j) * VOICES;
1258 :
1259 9 : convertMeasureMisc(measure, i, j, trackIndex);
1260 9 : convertNotes(measure, i, j, trackIndex);
1261 9 : convertLyrics(measure, i, j, trackIndex);
1262 9 : convertHarmonies(measure, i, j, trackIndex);
1263 9 : convertRepeats(measure, i, j, trackIndex);
1264 9 : convertDynamics(measure, i, j, trackIndex);
1265 9 : convertExpressions(measure, i, j, trackIndex);
1266 : }
1267 : }
1268 :
1269 9 : staffCount += partStaffCount;
1270 : }
1271 9 : }
1272 :
1273 9 : void OveToMScore::convertLines(Measure* measure)
1274 : {
1275 9 : int staffCount = 0;
1276 9 : int measureCount = m_ove->getMeasureCount();
1277 :
1278 18 : for (int i = 0; i < m_ove->getPartCount(); ++i) {
1279 9 : int partStaffCount = m_ove->getStaffCount(i);
1280 :
1281 18 : for (int j = 0; j < partStaffCount; ++j) {
1282 9 : int measureID = measure->measureNumber();
1283 :
1284 9 : if (measureID >= 0 && measureID < measureCount) {
1285 9 : int trackIndex = (staffCount + j) * VOICES;
1286 :
1287 9 : convertSlurs(measure, i, j, trackIndex);
1288 9 : convertGlissandos(measure, i, j, trackIndex);
1289 9 : convertWedges(measure, i, j, trackIndex);
1290 : }
1291 : }
1292 :
1293 9 : staffCount += partStaffCount;
1294 : }
1295 9 : }
1296 :
1297 9 : void OveToMScore::convertMeasureMisc(Measure* measure, int part, int staff, int track)
1298 : {
1299 9 : ovebase::Measure* measurePtr = m_ove->getMeasure(measure->measureNumber());
1300 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
1301 9 : if (measurePtr == 0 || measureData == 0) {
1302 0 : return;
1303 : }
1304 :
1305 : // pickup
1306 9 : if (measurePtr->getIsPickup()) {
1307 0 : measure->setExcludeFromNumbering(true);
1308 : }
1309 :
1310 : // multiple measure rest
1311 9 : if (measurePtr->getIsMultiMeasureRest()) {
1312 0 : measure->setBreakMultiMeasureRest(true);
1313 : }
1314 :
1315 : // barline
1316 9 : BarLineType bartype = BarLineType::NORMAL;
1317 :
1318 9 : switch (measurePtr->getRightBarline()) {
1319 6 : case ovebase::BarLineType::Default: {
1320 6 : bartype = BarLineType::NORMAL;
1321 6 : break;
1322 : }
1323 0 : case ovebase::BarLineType::Double: {
1324 0 : bartype = BarLineType::DOUBLE;
1325 0 : break;
1326 : }
1327 0 : case ovebase::BarLineType::Final: {
1328 0 : bartype = BarLineType::END;
1329 0 : break;
1330 : }
1331 0 : case ovebase::BarLineType::Null: {
1332 0 : bartype = BarLineType::NORMAL;
1333 0 : break;
1334 : }
1335 0 : case ovebase::BarLineType::RepeatLeft: {
1336 0 : bartype = BarLineType::START_REPEAT;
1337 0 : measure->setRepeatStart(true);
1338 0 : break;
1339 : }
1340 3 : case ovebase::BarLineType::RepeatRight: {
1341 3 : bartype = BarLineType::END_REPEAT;
1342 3 : measure->setRepeatEnd(true);
1343 3 : break;
1344 : }
1345 0 : case ovebase::BarLineType::Dashed: {
1346 0 : bartype = BarLineType::BROKEN;
1347 0 : break;
1348 : }
1349 0 : default:
1350 0 : break;
1351 : }
1352 :
1353 9 : if (bartype != BarLineType::NORMAL && bartype != BarLineType::END_REPEAT && bartype != BarLineType::START_REPEAT
1354 0 : && bartype != BarLineType::END_START_REPEAT && bartype != BarLineType::END) {
1355 0 : measure->setEndBarLineType(bartype, 0);
1356 : }
1357 :
1358 9 : if (bartype == BarLineType::END_REPEAT) {
1359 3 : measure->setRepeatEnd(true);
1360 : }
1361 :
1362 9 : if (measurePtr->getLeftBarline() == ovebase::BarLineType::RepeatLeft) {
1363 : //bartype = BarLineType::START_REPEAT;
1364 0 : measure->setRepeatStart(true);
1365 : }
1366 :
1367 : // rehearsal
1368 : int i;
1369 18 : QList<ovebase::MusicData*> texts = measureData->getMusicDatas(ovebase::MusicDataType::Text);
1370 9 : for (i = 0; i < texts.size(); ++i) {
1371 0 : ovebase::Text* textPtr = static_cast<ovebase::Text*>(texts[i]);
1372 0 : if (textPtr->getTextType() == ovebase::Text::Type::Rehearsal) {
1373 0 : Segment* s = measure->getSegment(SegmentType::ChordRest,
1374 0 : Fraction::fromTicks(m_mtt->getTick(measure->measureNumber(), 0)));
1375 0 : RehearsalMark* text = Factory::createRehearsalMark(s);
1376 0 : text->setPlainText(textPtr->getText());
1377 0 : text->setTrack(track);
1378 0 : s->add(text);
1379 : }
1380 : }
1381 :
1382 : // tempo
1383 18 : QList<ovebase::MusicData*> tempos = measureData->getMusicDatas(ovebase::MusicDataType::Tempo);
1384 11 : for (i = 0; i < tempos.size(); ++i) {
1385 2 : ovebase::Tempo* tempoPtr = static_cast<ovebase::Tempo*>(tempos[i]);
1386 2 : int absTick = m_mtt->getTick(measure->measureNumber(), tempoPtr->getTick());
1387 2 : Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
1388 2 : TempoText* t = new TempoText(s);
1389 2 : double tpo = (tempoPtr->getQuarterTempo()) / 60.0;
1390 :
1391 2 : t->setTempo(tpo);
1392 2 : QString durationTempoL;
1393 2 : QString durationTempoR;
1394 2 : if (static_cast<int>(tempoPtr->getLeftNoteType())) {
1395 2 : durationTempoL = TempoText::duration2tempoTextString(OveNoteType_To_Duration(tempoPtr->getLeftNoteType()));
1396 : }
1397 2 : if (static_cast<int>(tempoPtr->getRightNoteType())) {
1398 2 : durationTempoR = TempoText::duration2tempoTextString(OveNoteType_To_Duration(tempoPtr->getRightNoteType()));
1399 : }
1400 2 : QString textTempo;
1401 2 : if (tempoPtr->getShowBeforeText()) {
1402 0 : textTempo += (tempoPtr->getLeftText()).toHtmlEscaped();
1403 : }
1404 2 : if (tempoPtr->getShowMark()) {
1405 0 : if (!textTempo.isEmpty()) {
1406 0 : textTempo += " ";
1407 : }
1408 0 : if (tempoPtr->getShowParenthesis()) {
1409 0 : textTempo += "(";
1410 : }
1411 0 : textTempo += durationTempoL;
1412 0 : if (tempoPtr->getLeftNoteDot()) {
1413 0 : textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
1414 : }
1415 0 : textTempo += " = ";
1416 0 : switch (tempoPtr->getRightSideType()) {
1417 0 : case 1:
1418 0 : textTempo += durationTempoR;
1419 0 : if (tempoPtr->getRightNoteDot()) {
1420 0 : textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
1421 : }
1422 0 : break;
1423 0 : case 2:
1424 0 : textTempo += (tempoPtr->getRightText()).toHtmlEscaped();
1425 0 : break;
1426 0 : case 3:
1427 0 : textTempo += QString::number(qFloor(tempoPtr->getTypeTempo()));
1428 0 : break;
1429 0 : case 0:
1430 : default:
1431 0 : textTempo += QString::number(tempoPtr->getTypeTempo());
1432 0 : break;
1433 : }
1434 0 : if (tempoPtr->getShowParenthesis()) {
1435 0 : textTempo += ")";
1436 : }
1437 : }
1438 2 : if (textTempo.isEmpty()) {
1439 2 : textTempo = durationTempoL;
1440 2 : if (tempoPtr->getLeftNoteDot()) {
1441 0 : textTempo += "<sym>space</sym><sym>metAugmentationDot</sym>";
1442 : }
1443 2 : textTempo += " = " + QString::number(tempoPtr->getTypeTempo());
1444 2 : t->setVisible(false);
1445 : }
1446 2 : t->setXmlText(textTempo);
1447 2 : t->setTrack(track);
1448 :
1449 2 : s->add(t);
1450 2 : }
1451 : }
1452 :
1453 : // beam in grace
1454 0 : int getGraceLevel(const QList<ovebase::NoteContainer*>& containers, int tick, int unit)
1455 : {
1456 0 : int level = 0; // normal chord rest
1457 :
1458 0 : for (int i = 0; i < containers.size(); ++i) {
1459 0 : ovebase::NoteContainer* container = containers[i];
1460 0 : if (container->getTick() > tick) {
1461 0 : break;
1462 : }
1463 :
1464 0 : if (container->getIsGrace() && container->getTick() == tick
1465 0 : && unit <= container->start()->getOffset()) {
1466 0 : ++level;
1467 : }
1468 : }
1469 :
1470 0 : return level;
1471 : }
1472 :
1473 6 : bool isRestDefaultLine(ovebase::Note* rest, ovebase::NoteType noteType)
1474 : {
1475 6 : bool isDefault = true;
1476 6 : switch (noteType) {
1477 6 : case ovebase::NoteType::Note_DoubleWhole:
1478 : case ovebase::NoteType::Note_Whole:
1479 : case ovebase::NoteType::Note_Half:
1480 : case ovebase::NoteType::Note_Quarter: {
1481 6 : if (rest->getLine() != 0) {
1482 0 : isDefault = false;
1483 : }
1484 6 : break;
1485 : }
1486 0 : case ovebase::NoteType::Note_Eight: {
1487 0 : if (rest->getLine() != 1) {
1488 0 : isDefault = false;
1489 : }
1490 0 : break;
1491 : }
1492 0 : case ovebase::NoteType::Note_Sixteen:
1493 : case ovebase::NoteType::Note_32: {
1494 0 : if (rest->getLine() != -1) {
1495 0 : isDefault = false;
1496 : }
1497 0 : break;
1498 : }
1499 0 : case ovebase::NoteType::Note_64: {
1500 0 : if (rest->getLine() != -3) {
1501 0 : isDefault = false;
1502 : }
1503 0 : break;
1504 : }
1505 0 : case ovebase::NoteType::Note_128: {
1506 0 : if (rest->getLine() != -4) {
1507 0 : isDefault = false;
1508 : }
1509 0 : break;
1510 : }
1511 0 : default: {
1512 0 : break;
1513 : }
1514 : }
1515 :
1516 6 : return isDefault;
1517 : }
1518 :
1519 0 : Drumset* getDrumset(Score* score, int part)
1520 : {
1521 0 : Part* p = score->parts().at(part);
1522 0 : return const_cast<Drumset*>(p->instrument()->drumset()); // TODO: remove cast
1523 : }
1524 :
1525 9 : void OveToMScore::convertNotes(Measure* measure, int part, int staff, int track)
1526 : {
1527 : int j;
1528 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
1529 9 : QList<ovebase::NoteContainer*> containers = measureData->getNoteContainers();
1530 : QList<ovebase::MusicData*> tuplets = measureData->getCrossMeasureElements(ovebase::MusicDataType::Tuplet,
1531 9 : ovebase::MeasureData::PairType::Start);
1532 : QList<ovebase::MusicData*> beams = measureData->getCrossMeasureElements(ovebase::MusicDataType::Beam,
1533 9 : ovebase::MeasureData::PairType::Start);
1534 9 : Tuplet* tuplet = 0;
1535 9 : ChordRest* cr = 0;
1536 9 : int partStaffCount = m_ove->getStaffCount(part);
1537 :
1538 9 : if (containers.empty()) {
1539 3 : int absTick = m_mtt->getTick(measure->measureNumber(), 0);
1540 3 : Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
1541 3 : cr = Factory::createRest(s);
1542 3 : cr->setTicks(measure->ticks());
1543 3 : cr->setDurationType(DurationType::V_MEASURE);
1544 3 : cr->setTrack(track);
1545 3 : s->add(cr);
1546 : }
1547 9 : QList<mu::engraving::Chord*> graceNotes;
1548 21 : for (int i = 0; i < containers.size(); ++i) {
1549 12 : ovebase::NoteContainer* container = containers[i];
1550 12 : int tick = m_mtt->getTick(measure->measureNumber(), container->getTick());
1551 12 : int noteTrack = track + container->getVoice();
1552 :
1553 12 : if (container->getIsRest()) {
1554 6 : TDuration duration = OveNoteType_To_Duration(container->getNoteType());
1555 6 : duration.setDots(container->getDot());
1556 6 : Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(tick));
1557 6 : cr = Factory::createRest(s);
1558 6 : cr->setTicks(duration.fraction());
1559 6 : cr->setDurationType(duration);
1560 6 : cr->setTrack(noteTrack);
1561 6 : cr->setVisible(container->getShow());
1562 6 : s->add(cr);
1563 :
1564 6 : QList<ovebase::Note*> notes = container->getNotesRests();
1565 12 : for (j = 0; j < notes.size(); ++j) {
1566 6 : ovebase::Note* notePtr = notes[j];
1567 6 : if (!isRestDefaultLine(notePtr, container->getNoteType()) && notePtr->getLine() != 0) {
1568 0 : double yOffset = -(double)(notePtr->getLine());
1569 0 : int stepOffset = cr->staff()->staffType(cr->tick())->stepOffset();
1570 0 : yOffset -= qreal(stepOffset);
1571 0 : yOffset *= m_score->style().spatium() / 2.0;
1572 0 : cr->ryoffset() = yOffset;
1573 0 : cr->setAutoplace(false);
1574 : }
1575 : }
1576 6 : } else {
1577 6 : QList<ovebase::Note*> notes = container->getNotesRests();
1578 :
1579 6 : cr = measure->findChord(Fraction::fromTicks(tick), noteTrack);
1580 6 : if (cr == 0) {
1581 6 : cr = Factory::createChord(m_score->dummy());
1582 6 : cr->setTrack(noteTrack);
1583 :
1584 : // grace
1585 6 : if (container->getIsGrace()) {
1586 0 : TDuration duration = OveNoteType_To_Duration(container->getGraceNoteType());
1587 0 : duration.setDots(container->getDot());
1588 0 : ((mu::engraving::Chord*)cr)->setNoteType(NoteType::APPOGGIATURA);
1589 :
1590 0 : if (duration.type() == DurationType::V_QUARTER) {
1591 0 : ((mu::engraving::Chord*)cr)->setNoteType(NoteType::GRACE4);
1592 0 : cr->setDurationType(DurationType::V_QUARTER);
1593 0 : } else if (duration.type() == DurationType::V_16TH) {
1594 0 : ((mu::engraving::Chord*)cr)->setNoteType(NoteType::GRACE16);
1595 0 : cr->setDurationType(DurationType::V_16TH);
1596 0 : } else if (duration.type() == DurationType::V_32ND) {
1597 0 : ((mu::engraving::Chord*)cr)->setNoteType(NoteType::GRACE32);
1598 0 : cr->setDurationType(DurationType::V_32ND);
1599 : } else {
1600 0 : cr->setDurationType(DurationType::V_EIGHTH);
1601 : }
1602 :
1603 : // st = SegmentType::Grace;
1604 : } else {
1605 6 : TDuration duration = OveNoteType_To_Duration(container->getNoteType());
1606 6 : duration.setDots(container->getDot());
1607 :
1608 6 : if (duration.type() == DurationType::V_INVALID) {
1609 0 : duration.setType(DurationType::V_QUARTER);
1610 : }
1611 6 : cr->setDurationType(duration);
1612 : // append grace notes before
1613 6 : int ii = -1;
1614 6 : for (ii = graceNotes.size() - 1; ii >= 0; ii--) {
1615 0 : mu::engraving::Chord* gc = graceNotes[ii];
1616 0 : if (gc->voice() == cr->voice()) {
1617 0 : cr->add(gc);
1618 : }
1619 : }
1620 6 : graceNotes.clear();
1621 : }
1622 6 : cr->setTicks(cr->durationType().fraction());
1623 :
1624 6 : if (!container->getIsGrace()) {
1625 6 : Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(tick));
1626 6 : s->add(cr);
1627 : } else {
1628 0 : graceNotes.append(static_cast<mu::engraving::Chord*>(cr));
1629 : }
1630 : }
1631 :
1632 6 : cr->setVisible(container->getShow());
1633 6 : cr->setSmall(container->getIsCue());
1634 12 : for (j = 0; j < notes.size(); ++j) {
1635 6 : ovebase::Note* oveNote = notes[j];
1636 6 : Note* note = Factory::createNote(mu::engraving::toChord(cr));
1637 6 : int pitch = oveNote->getNote();
1638 :
1639 6 : note->setUserVelocity(oveNote->getOnVelocity());
1640 6 : note->setPitch(pitch);
1641 :
1642 : // tpc
1643 6 : bool setDirection = false;
1644 6 : ovebase::ClefType clefType = getClefType(measureData, container->getTick());
1645 6 : if (clefType == ovebase::ClefType::Percussion1 || clefType == ovebase::ClefType::Percussion2) {
1646 0 : Drumset* drumset = getDrumset(m_score, part);
1647 0 : if (drumset != 0) {
1648 0 : if (!drumset->isValid(pitch)) {
1649 0 : LOGD("unmapped drum note 0x%02x %d", note->pitch(), note->pitch());
1650 : } else {
1651 0 : note->setHeadGroup(drumset->noteHead(pitch));
1652 0 : int line = drumset->line(pitch);
1653 0 : note->setLine(line);
1654 0 : note->setTpcFromPitch();
1655 0 : ((mu::engraving::Chord*)cr)->setStemDirection(drumset->stemDirection(pitch));
1656 0 : setDirection = true;
1657 : }
1658 : } else {
1659 : // no drumset, we don't allow mid staff percussion
1660 0 : note->setTpc(14);
1661 : }
1662 0 : } else {
1663 6 : const int OCTAVE = 7;
1664 : ovebase::ToneType clefMiddleTone;
1665 : int clefMiddleOctave;
1666 6 : getMiddleToneOctave(clefType, clefMiddleTone, clefMiddleOctave);
1667 6 : int absLine = static_cast<int>(clefMiddleTone) + clefMiddleOctave * OCTAVE + oveNote->getLine();
1668 6 : if ((partStaffCount == 2) && oveNote->getOffsetStaff()) {
1669 0 : absLine += 2 * (oveNote->getOffsetStaff());
1670 : }
1671 6 : int tone = absLine % OCTAVE;
1672 6 : int alter = accidentalToAlter(oveNote->getAccidental());
1673 6 : NoteVal nv(pitch);
1674 6 : note->setTrack(cr->track());
1675 6 : note->setNval(nv, Fraction::fromTicks(tick));
1676 : // note->setTpcFromPitch();
1677 6 : note->setTpc(step2tpc(tone, AccidentalVal(alter)));
1678 6 : if (oveNote->getShowAccidental()) {
1679 0 : mu::engraving::Accidental* a = Factory::createAccidental(m_score->dummy());
1680 0 : bool bracket = static_cast<int>(oveNote->getAccidental()) & 0x8;
1681 0 : AccidentalType at = mu::engraving::AccidentalType::NONE;
1682 0 : switch (alter) {
1683 0 : case 0: at = mu::engraving::AccidentalType::NATURAL;
1684 0 : break;
1685 0 : case 1: at = mu::engraving::AccidentalType::SHARP;
1686 0 : break;
1687 0 : case -1: at = mu::engraving::AccidentalType::FLAT;
1688 0 : break;
1689 0 : case 2: at = mu::engraving::AccidentalType::SHARP2;
1690 0 : break;
1691 0 : case -2: at = mu::engraving::AccidentalType::FLAT2;
1692 0 : break;
1693 : }
1694 0 : a->setAccidentalType(at);
1695 0 : a->setBracket(AccidentalBracket(bracket));
1696 0 : a->setRole(mu::engraving::AccidentalRole::USER);
1697 0 : note->add(a);
1698 : }
1699 6 : note->setHeadGroup(getHeadGroup(oveNote->getHeadType()));
1700 : }
1701 6 : if ((oveNote->getHeadType() == ovebase::NoteHeadType::Invisible) || !(oveNote->getShow())) {
1702 0 : note->setVisible(false);
1703 : }
1704 : // tie
1705 6 : if ((int(oveNote->getTiePos()) & int(ovebase::TiePos::LeftEnd)) == int(ovebase::TiePos::LeftEnd)) {
1706 0 : Tie* tie = new Tie(m_score->dummy());
1707 0 : note->setTieFor(tie);
1708 0 : tie->setStartNote(note);
1709 0 : tie->setTrack(noteTrack);
1710 : }
1711 :
1712 : // pitch must be set before adding note to chord as note
1713 : // is inserted into pitch sorted list (ws)
1714 6 : cr->add(note);
1715 :
1716 : // cr->setVisible(oveNote->getShow());
1717 6 : ((mu::engraving::Chord*)cr)->setNoStem(int(container->getNoteType()) <= int(ovebase::NoteType::Note_Whole));
1718 6 : if (!setDirection) {
1719 6 : ((mu::engraving::Chord*)cr)->setStemDirection(container->getStemUp() ? DirectionV::UP : DirectionV::DOWN);
1720 : }
1721 :
1722 : // cross staff
1723 6 : int staffMove = 0;
1724 6 : if (partStaffCount == 2) { // treble-bass
1725 0 : staffMove = oveNote->getOffsetStaff();
1726 : }
1727 6 : cr->setStaffMove(staffMove);
1728 : }
1729 6 : }
1730 :
1731 : // beam
1732 : // BeamMode bm = container->getIsRest() ? BeamMode::NONE : BeamMode::AUTO;
1733 12 : BeamMode bm = BeamMode::NONE;
1734 12 : if (container->getInBeam()) {
1735 0 : ovebase::MeasurePos pos = container->start()->shiftMeasure(0);
1736 0 : ovebase::MusicData* data = getCrossMeasureElementByPos(part, staff, pos,
1737 0 : container->getVoice(), ovebase::MusicDataType::Beam);
1738 :
1739 0 : if (data != 0) {
1740 0 : ovebase::Beam* beam = static_cast<ovebase::Beam*>(data);
1741 0 : ovebase::MeasurePos startPos = beam->start()->shiftMeasure(0);
1742 0 : ovebase::MeasurePos stopPos = beam->stop()->shiftMeasure(beam->start()->getMeasure());
1743 :
1744 0 : if (startPos == pos) {
1745 0 : bm = BeamMode::BEGIN;
1746 0 : } else if (stopPos == pos) {
1747 0 : bm = BeamMode::END;
1748 : } else {
1749 0 : bm = BeamMode::MID;
1750 : }
1751 0 : }
1752 0 : }
1753 12 : cr->setBeamMode(bm);
1754 :
1755 : // tuplet
1756 12 : if (container->getTuplet() > 0) {
1757 0 : if (tuplet == 0) {
1758 0 : bool create = true;
1759 :
1760 : // check tuplet start
1761 0 : if (container->getNoteType() < ovebase::NoteType::Note_Eight) {
1762 0 : const ovebase::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
1763 0 : if (oveTuplet == 0) {
1764 0 : create = false;
1765 : }
1766 : }
1767 :
1768 0 : if (create) {
1769 0 : tuplet = new Tuplet(measure);
1770 0 : tuplet->setTrack(noteTrack);
1771 0 : tuplet->setRatio(Fraction(container->getTuplet(), container->getSpace()));
1772 0 : TDuration duration = OveNoteType_To_Duration(container->getNoteType());
1773 0 : tuplet->setBaseLen(duration);
1774 0 : tuplet->setTick(Fraction::fromTicks(tick));
1775 : // measure->add(tuplet);
1776 : }
1777 : }
1778 :
1779 0 : if (tuplet != 0) {
1780 0 : cr->setTuplet(tuplet);
1781 0 : tuplet->add(cr);
1782 : }
1783 :
1784 0 : if (tuplet != 0) {
1785 : // check tuplet end
1786 0 : const ovebase::Tuplet* oveTuplet = getTuplet(tuplets, container->start()->getOffset());
1787 0 : if (oveTuplet != 0) {
1788 : // set direction
1789 0 : tuplet->setDirection(
1790 0 : oveTuplet->getLeftShoulder()->getYOffset() < 0 ? DirectionV::UP : DirectionV::DOWN);
1791 :
1792 0 : if (container->start()->getOffset() == oveTuplet->stop()->getOffset()) {
1793 0 : tuplet = 0;
1794 : }
1795 : }
1796 : }
1797 : }
1798 :
1799 : // articulation
1800 24 : QList<ovebase::Articulation*> articulations = container->getArticulations();
1801 12 : for (j = 0; j < articulations.size(); ++j) {
1802 0 : convertArticulation(measure, mu::engraving::toChord(cr), noteTrack, tick, articulations[j]);
1803 : }
1804 : }
1805 9 : }
1806 :
1807 0 : void OveToMScore::convertArticulation(
1808 : Measure* measure, Chord* cr,
1809 : int track, int absTick, ovebase::Articulation* art)
1810 : {
1811 0 : switch (art->getArtType()) {
1812 0 : case ovebase::ArticulationType::Major_Trill:
1813 : case ovebase::ArticulationType::Minor_Trill: {
1814 0 : Articulation* a = Factory::createArticulation(cr);
1815 0 : a->setSymId(SymId::ornamentTrill);
1816 0 : cr->add(a);
1817 0 : break;
1818 : }
1819 0 : case ovebase::ArticulationType::Trill_Section: {
1820 0 : break;
1821 : }
1822 0 : case ovebase::ArticulationType::Inverted_Short_Mordent:
1823 : case ovebase::ArticulationType::Inverted_Long_Mordent: {
1824 0 : Articulation* a = Factory::createArticulation(cr);
1825 0 : a->setSymId(SymId::ornamentMordent);
1826 0 : cr->add(a);
1827 0 : break;
1828 : }
1829 0 : case ovebase::ArticulationType::Short_Mordent: {
1830 0 : Articulation* a = Factory::createArticulation(cr);
1831 0 : a->setSymId(SymId::ornamentShortTrill);
1832 0 : cr->add(a);
1833 0 : break;
1834 : }
1835 0 : case ovebase::ArticulationType::Turn: {
1836 0 : Articulation* a = Factory::createArticulation(cr);
1837 0 : a->setSymId(SymId::ornamentTurn);
1838 0 : cr->add(a);
1839 0 : break;
1840 : }
1841 : // case ovebase::ArticulationType::Flat_Accidental_For_Trill:
1842 : // case ovebase::ArticulationType::Sharp_Accidental_For_Trill:
1843 : // case ovebase::ArticulationType::Natural_Accidental_For_Trill:
1844 0 : case ovebase::ArticulationType::Tremolo_Eighth: {
1845 0 : TremoloSingleChord* t = Factory::createTremoloSingleChord(cr);
1846 0 : t->setTremoloType(TremoloType::R8);
1847 0 : cr->add(t);
1848 0 : break;
1849 : }
1850 0 : case ovebase::ArticulationType::Tremolo_Sixteenth: {
1851 0 : TremoloSingleChord* t = Factory::createTremoloSingleChord(cr);
1852 0 : t->setTremoloType(TremoloType::R16);
1853 0 : cr->add(t);
1854 0 : break;
1855 : }
1856 0 : case ovebase::ArticulationType::Tremolo_Thirty_Second: {
1857 0 : TremoloSingleChord* t = Factory::createTremoloSingleChord(cr);
1858 0 : t->setTremoloType(TremoloType::R32);
1859 0 : cr->add(t);
1860 0 : break;
1861 : }
1862 0 : case ovebase::ArticulationType::Tremolo_Sixty_Fourth: {
1863 0 : TremoloSingleChord* t = Factory::createTremoloSingleChord(cr);
1864 0 : t->setTremoloType(TremoloType::R64);
1865 0 : cr->add(t);
1866 0 : break;
1867 : }
1868 0 : case ovebase::ArticulationType::Marcato: {
1869 0 : Articulation* a = Factory::createArticulation(cr);
1870 0 : a->setSymId(SymId::articAccentAbove);
1871 0 : cr->add(a);
1872 0 : break;
1873 : }
1874 0 : case ovebase::ArticulationType::Marcato_Dot: {
1875 0 : Articulation* a = Factory::createArticulation(cr);
1876 0 : a->setSymId(SymId::articAccentAbove);
1877 0 : cr->add(a);
1878 :
1879 0 : a = Factory::createArticulation(cr);
1880 0 : a->setSymId(SymId::articStaccatoAbove);
1881 0 : cr->add(a);
1882 0 : break;
1883 : }
1884 0 : case ovebase::ArticulationType::Heavy_Attack: {
1885 0 : Articulation* a = Factory::createArticulation(cr);
1886 0 : a->setSymId(SymId::articAccentAbove);
1887 0 : cr->add(a);
1888 :
1889 0 : a = Factory::createArticulation(cr);
1890 0 : a->setSymId(SymId::articTenutoAbove);
1891 0 : cr->add(a);
1892 0 : break;
1893 : }
1894 0 : case ovebase::ArticulationType::SForzando: {
1895 0 : Articulation* a = Factory::createArticulation(cr);
1896 0 : a->setUp(true);
1897 0 : a->setSymId(SymId::articMarcatoAbove);
1898 0 : cr->add(a);
1899 0 : break;
1900 : }
1901 0 : case ovebase::ArticulationType::SForzando_Inverted: {
1902 0 : Articulation* a = Factory::createArticulation(cr);
1903 0 : a->setUp(false);
1904 0 : a->setSymId(SymId::articMarcatoAbove);
1905 0 : cr->add(a);
1906 0 : break;
1907 : }
1908 0 : case ovebase::ArticulationType::SForzando_Dot: {
1909 0 : Articulation* a = Factory::createArticulation(cr);
1910 0 : a->setUp(true);
1911 0 : a->setSymId(SymId::articMarcatoAbove);
1912 0 : cr->add(a);
1913 :
1914 0 : a = Factory::createArticulation(cr);
1915 0 : a->setSymId(SymId::articStaccatoAbove);
1916 0 : cr->add(a);
1917 0 : break;
1918 : }
1919 0 : case ovebase::ArticulationType::SForzando_Dot_Inverted: {
1920 0 : Articulation* a = Factory::createArticulation(cr);
1921 0 : a->setUp(false);
1922 0 : a->setSymId(SymId::articMarcatoAbove);
1923 0 : cr->add(a);
1924 :
1925 0 : a = Factory::createArticulation(cr);
1926 0 : a->setSymId(SymId::articStaccatoAbove);
1927 0 : cr->add(a);
1928 0 : break;
1929 : }
1930 0 : case ovebase::ArticulationType::Heavier_Attack: {
1931 0 : Articulation* a = Factory::createArticulation(cr);
1932 0 : a->setUp(true);
1933 0 : a->setSymId(SymId::articMarcatoAbove);
1934 0 : cr->add(a);
1935 :
1936 0 : a = Factory::createArticulation(cr);
1937 0 : a->setSymId(SymId::articTenutoAbove);
1938 0 : cr->add(a);
1939 0 : break;
1940 : }
1941 0 : case ovebase::ArticulationType::Staccatissimo: {
1942 0 : Articulation* a = Factory::createArticulation(cr);
1943 0 : a->setUp(true);
1944 0 : a->setSymId(SymId::articStaccatissimoAbove);
1945 0 : cr->add(a);
1946 0 : break;
1947 : }
1948 0 : case ovebase::ArticulationType::Staccato: {
1949 0 : Articulation* a = Factory::createArticulation(cr);
1950 0 : a->setSymId(SymId::articStaccatoAbove);
1951 0 : cr->add(a);
1952 0 : break;
1953 : }
1954 0 : case ovebase::ArticulationType::Tenuto: {
1955 0 : Articulation* a = Factory::createArticulation(cr);
1956 0 : a->setSymId(SymId::articTenutoAbove);
1957 0 : cr->add(a);
1958 0 : break;
1959 : }
1960 0 : case ovebase::ArticulationType::Pause: {
1961 0 : Segment* seg = measure->getSegment(SegmentType::Breath,
1962 0 : Fraction::fromTicks(absTick + (cr ? cr->actualTicks().ticks() : 0)));
1963 0 : Breath* b = Factory::createBreath(seg);
1964 0 : b->setTrack(track);
1965 0 : seg->add(b);
1966 0 : break;
1967 : }
1968 0 : case ovebase::ArticulationType::Grand_Pause: {
1969 0 : break;
1970 : }
1971 0 : case ovebase::ArticulationType::Up_Bow: {
1972 0 : Articulation* a = Factory::createArticulation(cr);
1973 0 : a->setSymId(SymId::stringsUpBow);
1974 0 : cr->add(a);
1975 0 : break;
1976 : }
1977 0 : case ovebase::ArticulationType::Down_Bow: {
1978 0 : Articulation* a = Factory::createArticulation(cr);
1979 0 : a->setSymId(SymId::stringsDownBow);
1980 0 : cr->add(a);
1981 0 : break;
1982 : }
1983 0 : case ovebase::ArticulationType::Up_Bow_Inverted: {
1984 0 : Articulation* a = Factory::createArticulation(cr);
1985 0 : a->setSymId(SymId::stringsUpBow);
1986 0 : a->ryoffset() = 5.3;
1987 0 : cr->add(a);
1988 0 : break;
1989 : }
1990 0 : case ovebase::ArticulationType::Down_Bow_Inverted: {
1991 0 : Articulation* a = Factory::createArticulation(cr);
1992 0 : a->setSymId(SymId::stringsDownBow);
1993 0 : a->ryoffset() = 5.3;
1994 0 : cr->add(a);
1995 0 : break;
1996 : }
1997 0 : case ovebase::ArticulationType::Natural_Harmonic: {
1998 0 : Articulation* a = Factory::createArticulation(cr);
1999 0 : a->setSymId(SymId::stringsHarmonic);
2000 0 : cr->add(a);
2001 0 : break;
2002 : }
2003 0 : case ovebase::ArticulationType::Artificial_Harmonic: {
2004 0 : break;
2005 : }
2006 0 : case ovebase::ArticulationType::Finger_1:
2007 : case ovebase::ArticulationType::Finger_2:
2008 : case ovebase::ArticulationType::Finger_3:
2009 : case ovebase::ArticulationType::Finger_4:
2010 : case ovebase::ArticulationType::Finger_5: {
2011 0 : break;
2012 : }
2013 0 : case ovebase::ArticulationType::Plus_Sign: {
2014 0 : Articulation* a = Factory::createArticulation(cr);
2015 0 : a->setSymId(SymId::brassMuteClosed);
2016 0 : cr->add(a);
2017 0 : break;
2018 : }
2019 0 : case ovebase::ArticulationType::Arpeggio: {
2020 : // there can be only one
2021 0 : if (!(static_cast<mu::engraving::Chord*>(cr))->arpeggio()) {
2022 0 : Arpeggio* a = Factory::createArpeggio(cr);
2023 0 : a->setArpeggioType(ArpeggioType::NORMAL);
2024 : /*
2025 : if (art->getPlacementAbove()){
2026 : a->setSubtype(ArpeggioType::UP);
2027 : } else {
2028 : a->setSubtype(ARpeggioType::DOWN);
2029 : }
2030 : */
2031 0 : cr->add(a);
2032 : }
2033 :
2034 0 : break;
2035 : }
2036 0 : case ovebase::ArticulationType::Fermata: {
2037 0 : Articulation* a = Factory::createArticulation(cr);
2038 0 : a->setUp(true);
2039 0 : a->setSymId(SymId::fermataAbove);
2040 0 : cr->add(a);
2041 0 : break;
2042 : }
2043 0 : case ovebase::ArticulationType::Fermata_Inverted: {
2044 0 : Articulation* a = Factory::createArticulation(cr);
2045 0 : a->setDirection(DirectionV::DOWN);
2046 0 : a->setSymId(SymId::fermataBelow);
2047 0 : cr->add(a);
2048 0 : break;
2049 : }
2050 0 : case ovebase::ArticulationType::Pedal_Down: {
2051 0 : if (m_pedal) {
2052 0 : delete m_pedal;
2053 0 : m_pedal = 0;
2054 : } else {
2055 0 : m_pedal = Factory::createPedal(m_score->dummy());
2056 0 : m_pedal->setTrack(track);
2057 0 : Segment* seg = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2058 0 : m_pedal->setTick(seg->tick());
2059 : }
2060 0 : break;
2061 : }
2062 0 : case ovebase::ArticulationType::Pedal_Up: {
2063 0 : if (m_pedal) {
2064 0 : Segment* seg = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2065 0 : m_pedal->setTick2(seg->tick());
2066 0 : m_score->addSpanner(m_pedal);
2067 0 : m_pedal = 0;
2068 : }
2069 0 : break;
2070 : }
2071 : // case ovebase::ArticulationType::Toe_Pedal:
2072 : // case ovebase::ArticulationType::Heel_Pedal:
2073 : // case ovebase::ArticulationType::Toe_To_Heel_Pedal:
2074 : // case ovebase::ArticulationType::Heel_To_Toe_Pedal:
2075 : // case ovebase::ArticulationType::Open_String:
2076 0 : default:
2077 0 : break;
2078 : }
2079 0 : }
2080 :
2081 9 : void OveToMScore::convertLyrics(Measure* measure, int part, int staff, int track)
2082 : {
2083 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2084 9 : if (measureData == 0) {
2085 0 : return;
2086 : }
2087 :
2088 9 : QList<ovebase::MusicData*> lyrics = measureData->getMusicDatas(ovebase::MusicDataType::Lyric);
2089 :
2090 9 : for (int i = 0; i < lyrics.size(); ++i) {
2091 0 : ovebase::Lyric* oveLyric = static_cast<ovebase::Lyric*>(lyrics[i]);
2092 0 : int tick = m_mtt->getTick(measure->measureNumber(), oveLyric->getTick());
2093 :
2094 0 : Lyrics* lyric = Factory::createLyrics(m_score->dummy());
2095 0 : lyric->setVerse(oveLyric->getVerse());
2096 0 : lyric->setPlainText(oveLyric->getLyric());
2097 0 : lyric->setTrack(track);
2098 0 : Segment* segment = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(tick));
2099 0 : if (segment->element(track)) {
2100 0 : toChordRest(segment->element(track))->add(lyric);
2101 : }
2102 : }
2103 9 : }
2104 :
2105 0 : static const ChordDescription* harmonyFromXml(Harmony* h, const muse::String& kind)
2106 : {
2107 0 : String lowerCaseKind = kind.toLower();
2108 0 : const ChordList* cl = h->score()->chordList();
2109 0 : for (const auto& p : *cl) {
2110 0 : const ChordDescription& cd = p.second;
2111 0 : if (lowerCaseKind == cd.xmlKind) {
2112 0 : return &cd;
2113 : }
2114 : }
2115 0 : return nullptr;
2116 0 : }
2117 :
2118 9 : void OveToMScore::convertHarmonies(Measure* measure, int part, int staff, int track)
2119 : {
2120 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2121 9 : if (measureData == 0) {
2122 0 : return;
2123 : }
2124 :
2125 9 : QList<ovebase::MusicData*> harmonies = measureData->getMusicDatas(ovebase::MusicDataType::Harmony);
2126 :
2127 9 : for (int i = 0; i < harmonies.size(); ++i) {
2128 0 : ovebase::Harmony* harmonyPtr = static_cast<ovebase::Harmony*>(harmonies[i]);
2129 0 : int absTick = m_mtt->getTick(measure->measureNumber(), harmonyPtr->getTick());
2130 :
2131 0 : Harmony* harmony = Factory::createHarmony(m_score->dummy());
2132 0 : HarmonyInfo* info = new HarmonyInfo(measure->score());
2133 :
2134 : // TODO - does this need to be key-aware?
2135 0 : harmony->setTrack(track);
2136 0 : info->setRootTpc(step2tpc(harmonyPtr->getRoot(), AccidentalVal(harmonyPtr->getAlterRoot())));
2137 0 : if (harmonyPtr->getBass() != ovebase::INVALID_NOTE
2138 0 : && (harmonyPtr->getBass() != harmonyPtr->getRoot()
2139 0 : || (harmonyPtr->getBass() == harmonyPtr->getRoot()
2140 0 : && harmonyPtr->getAlterBass() != harmonyPtr->getAlterRoot()))) {
2141 0 : info->setBassTpc(step2tpc(harmonyPtr->getBass(), AccidentalVal(harmonyPtr->getAlterBass())));
2142 : }
2143 0 : const ChordDescription* d = harmonyFromXml(harmony, harmonyPtr->getHarmonyType());
2144 0 : if (d != 0) {
2145 0 : info->setId(d->id);
2146 0 : info->setTextName(d->names.front());
2147 : } else {
2148 0 : info->setId(-1);
2149 0 : info->setTextName(harmonyPtr->getHarmonyType());
2150 : }
2151 :
2152 0 : harmony->addChord(info);
2153 :
2154 0 : Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2155 0 : s->add(harmony);
2156 : }
2157 9 : }
2158 :
2159 : /*
2160 : ovebase::MusicData* OveToMScore::getMusicDataByUnit(int part, int staff, int measure, int unit, ovebase::MusicDataType type)
2161 : {
2162 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure);
2163 : if (measureData != 0) {
2164 : const QList<ovebase::MusicData*>& datas = measureData->getMusicDatas(type);
2165 : for (unsigned int i = 0; i < datas.size(); ++i){
2166 : if (datas[i]->getTick() == unit) { // different measurement
2167 : return datas[i];
2168 : }
2169 : }
2170 : }
2171 :
2172 : return 0;
2173 : }
2174 : */
2175 :
2176 0 : ovebase::MusicData* OveToMScore::getCrossMeasureElementByPos(int part, int staff, const ovebase::MeasurePos& pos, int voice,
2177 : ovebase::MusicDataType type)
2178 : {
2179 0 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, pos.getMeasure());
2180 0 : if (measureData != 0) {
2181 : const QList<ovebase::MusicData*>& datas
2182 0 : = measureData->getCrossMeasureElements(type, ovebase::MeasureData::PairType::All);
2183 0 : for (int i = 0; i < datas.size(); ++i) {
2184 0 : ovebase::MeasurePos dataStart = datas[i]->start()->shiftMeasure(0);
2185 0 : ovebase::MeasurePos dataStop = datas[i]->stop()->shiftMeasure(datas[i]->start()->getMeasure());
2186 :
2187 0 : if (dataStart <= pos && dataStop >= pos && (int)datas[i]->getVoice() == voice) {
2188 0 : return datas[i];
2189 : }
2190 0 : }
2191 0 : }
2192 :
2193 0 : return 0;
2194 : }
2195 :
2196 0 : ovebase::NoteContainer* OveToMScore::getContainerByPos(int part, int staff, const ovebase::MeasurePos& pos)
2197 : {
2198 0 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, pos.getMeasure());
2199 0 : if (measureData != 0) {
2200 0 : const QList<ovebase::NoteContainer*>& containers = measureData->getNoteContainers();
2201 0 : for (int i = 0; i < containers.size(); ++i) {
2202 0 : if (pos == containers[i]->start()->shiftMeasure(0)) {
2203 0 : return containers[i];
2204 : }
2205 : }
2206 0 : }
2207 :
2208 0 : return 0;
2209 : }
2210 :
2211 9 : void OveToMScore::convertRepeats(Measure* measure, int part, int staff, int track)
2212 : {
2213 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2214 9 : if (measureData == 0) {
2215 0 : return;
2216 : }
2217 :
2218 : int i;
2219 9 : QList<ovebase::MusicData*> repeats = measureData->getMusicDatas(ovebase::MusicDataType::Repeat);
2220 :
2221 9 : for (i = 0; i < repeats.size(); ++i) {
2222 0 : ovebase::RepeatSymbol* repeatPtr = static_cast<ovebase::RepeatSymbol*>(repeats[i]);
2223 0 : ovebase::RepeatType type = repeatPtr->getRepeatType();
2224 0 : EngravingItem* e = 0;
2225 :
2226 0 : switch (type) {
2227 0 : case ovebase::RepeatType::Segno: {
2228 0 : Marker* m = Factory::createMarker(measure);
2229 0 : m->setMarkerType(MarkerType::SEGNO);
2230 0 : m->resetProperty(Pid::LABEL);
2231 0 : e = m;
2232 0 : break;
2233 : }
2234 0 : case ovebase::RepeatType::Coda: {
2235 0 : Marker* m = Factory::createMarker(measure);
2236 0 : m->setMarkerType(MarkerType::CODA);
2237 0 : m->resetProperty(Pid::LABEL);
2238 0 : e = m;
2239 0 : break;
2240 : }
2241 0 : case ovebase::RepeatType::DSAlCoda: {
2242 0 : Jump* jp = Factory::createJump(measure);
2243 0 : jp->setJumpType(JumpType::DS_AL_CODA);
2244 0 : e = jp;
2245 0 : break;
2246 : }
2247 0 : case ovebase::RepeatType::DSAlFine: {
2248 0 : Jump* jp = Factory::createJump(measure);
2249 0 : jp->setJumpType(JumpType::DS_AL_FINE);
2250 0 : e = jp;
2251 0 : break;
2252 : }
2253 0 : case ovebase::RepeatType::DCAlCoda: {
2254 0 : Jump* jp = Factory::createJump(measure);
2255 0 : jp->setJumpType(JumpType::DC_AL_CODA);
2256 0 : e = jp;
2257 0 : break;
2258 : }
2259 0 : case ovebase::RepeatType::DCAlFine: {
2260 0 : Jump* jp = Factory::createJump(measure);
2261 0 : jp->setJumpType(JumpType::DC_AL_FINE);
2262 0 : e = jp;
2263 0 : break;
2264 : }
2265 0 : case ovebase::RepeatType::ToCoda: {
2266 0 : Marker* m = Factory::createMarker(measure);
2267 0 : m->setMarkerType(MarkerType::TOCODA);
2268 0 : m->resetProperty(Pid::LABEL);
2269 0 : e = m;
2270 0 : break;
2271 : }
2272 0 : case ovebase::RepeatType::Fine: {
2273 0 : Marker* m = Factory::createMarker(measure);
2274 0 : m->setMarkerType(MarkerType::FINE);
2275 0 : m->resetProperty(Pid::LABEL);
2276 0 : e = m;
2277 0 : break;
2278 : }
2279 0 : default:
2280 0 : break;
2281 : }
2282 :
2283 0 : if (e != 0) {
2284 0 : e->setTrack(track);
2285 0 : measure->add(e);
2286 : }
2287 : }
2288 :
2289 : QList<ovebase::MusicData*> endings = measureData->getCrossMeasureElements(
2290 : ovebase::MusicDataType::Numeric_Ending,
2291 18 : ovebase::MeasureData::PairType::Start);
2292 :
2293 12 : for (i = 0; i < endings.size(); ++i) {
2294 3 : ovebase::NumericEnding* ending = static_cast<ovebase::NumericEnding*>(endings[i]);
2295 3 : int absTick1 = m_mtt->getTick(measure->measureNumber(), 0);
2296 3 : int absTick2 = m_mtt->getTick(measure->measureNumber() + ending->stop()->getMeasure(), 0);
2297 :
2298 3 : if (absTick1 < absTick2) {
2299 3 : Volta* volta = Factory::createVolta(m_score->dummy());
2300 3 : volta->setTrack(track);
2301 3 : volta->setTick(Fraction::fromTicks(absTick1));
2302 3 : volta->setTick2(Fraction::fromTicks(absTick2));
2303 3 : m_score->addElement(volta);
2304 3 : volta->setVoltaType(Volta::Type::CLOSED);
2305 3 : volta->setText(ending->getText());
2306 :
2307 3 : volta->endings().clear();
2308 3 : QList<int> numbers = ending->getNumbers();
2309 8 : for (int j = 0; j < numbers.size(); ++j) {
2310 5 : volta->endings().push_back(numbers[j]);
2311 : }
2312 3 : }
2313 : }
2314 9 : }
2315 :
2316 9 : void OveToMScore::convertSlurs(Measure* measure, int part, int staff, int track)
2317 : {
2318 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2319 9 : if (measureData == 0) {
2320 0 : return;
2321 : }
2322 :
2323 : QList<ovebase::MusicData*> slurs = measureData->getCrossMeasureElements(ovebase::MusicDataType::Slur,
2324 9 : ovebase::MeasureData::PairType::Start);
2325 :
2326 9 : for (int i = 0; i < slurs.size(); ++i) {
2327 0 : ovebase::Slur* slurPtr = static_cast<ovebase::Slur*>(slurs[i]);
2328 :
2329 0 : ovebase::NoteContainer* startContainer = getContainerByPos(part, staff, slurPtr->start()->shiftMeasure(0));
2330 0 : ovebase::NoteContainer* endContainer = getContainerByPos(
2331 : part,
2332 : staff,
2333 0 : slurPtr->stop()->shiftMeasure(slurPtr->start()->getMeasure()));
2334 :
2335 0 : if (startContainer != 0 && endContainer != 0) {
2336 0 : int absStartTick = m_mtt->getTick(slurPtr->start()->getMeasure(), startContainer->getTick());
2337 0 : int absEndTick = m_mtt->getTick(
2338 0 : slurPtr->start()->getMeasure() + slurPtr->stop()->getMeasure(), endContainer->getTick());
2339 :
2340 0 : Slur* slur = Factory::createSlur(m_score->dummy());
2341 0 : slur->setSlurDirection(slurPtr->getShowOnTop() ? DirectionV::UP : DirectionV::DOWN);
2342 0 : slur->setTick(Fraction::fromTicks(absStartTick));
2343 0 : slur->setTick2(Fraction::fromTicks(absEndTick));
2344 0 : slur->setTrack(track);
2345 0 : slur->setTrack2(track + endContainer->getOffsetStaff());
2346 :
2347 0 : m_score->addSpanner(slur);
2348 : }
2349 : }
2350 9 : }
2351 :
2352 0 : QString OveDynamics_To_Dynamics(ovebase::DynamicsType type)
2353 : {
2354 0 : QString dynamic = "other-dynamics";
2355 :
2356 0 : switch (type) {
2357 0 : case ovebase::DynamicsType::PPPP:
2358 0 : dynamic = "pppp";
2359 0 : break;
2360 0 : case ovebase::DynamicsType::PPP:
2361 0 : dynamic = "ppp";
2362 0 : break;
2363 0 : case ovebase::DynamicsType::PP:
2364 0 : dynamic = "pp";
2365 0 : break;
2366 0 : case ovebase::DynamicsType::P:
2367 0 : dynamic = "p";
2368 0 : break;
2369 0 : case ovebase::DynamicsType::MP:
2370 0 : dynamic = "mp";
2371 0 : break;
2372 0 : case ovebase::DynamicsType::MF:
2373 0 : dynamic = "mf";
2374 0 : break;
2375 0 : case ovebase::DynamicsType::F:
2376 0 : dynamic = "f";
2377 0 : break;
2378 0 : case ovebase::DynamicsType::FF:
2379 0 : dynamic = "ff";
2380 0 : break;
2381 0 : case ovebase::DynamicsType::FFF:
2382 0 : dynamic = "fff";
2383 0 : break;
2384 0 : case ovebase::DynamicsType::FFFF:
2385 0 : dynamic = "ffff";
2386 0 : break;
2387 0 : case ovebase::DynamicsType::SF:
2388 0 : dynamic = "sf";
2389 0 : break;
2390 0 : case ovebase::DynamicsType::FZ:
2391 0 : dynamic = "fz";
2392 0 : break;
2393 0 : case ovebase::DynamicsType::SFZ:
2394 0 : dynamic = "sfz";
2395 0 : break;
2396 0 : case ovebase::DynamicsType::SFFZ:
2397 0 : dynamic = "sffz";
2398 0 : break;
2399 0 : case ovebase::DynamicsType::FP:
2400 0 : dynamic = "fp";
2401 0 : break;
2402 0 : case ovebase::DynamicsType::SFP:
2403 0 : dynamic = "sfp";
2404 0 : break;
2405 0 : default:
2406 0 : break;
2407 : }
2408 :
2409 0 : return dynamic;
2410 0 : }
2411 :
2412 9 : void OveToMScore::convertDynamics(Measure* measure, int part, int staff, int track)
2413 : {
2414 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2415 9 : if (measureData == 0) {
2416 0 : return;
2417 : }
2418 :
2419 9 : QList<ovebase::MusicData*> dynamics = measureData->getMusicDatas(ovebase::MusicDataType::Dynamics);
2420 :
2421 9 : for (int i = 0; i < dynamics.size(); ++i) {
2422 0 : ovebase::Dynamics* dynamicPtr = static_cast<ovebase::Dynamics*>(dynamics[i]);
2423 0 : int absTick = m_mtt->getTick(measure->measureNumber(), dynamicPtr->getTick());
2424 0 : Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2425 0 : Dynamic* dynamic = Factory::createDynamic(s);
2426 :
2427 0 : dynamic->setDynamicType(OveDynamics_To_Dynamics(dynamicPtr->getDynamicsType()));
2428 0 : dynamic->setTrack(track);
2429 :
2430 0 : s->add(dynamic);
2431 : }
2432 9 : }
2433 :
2434 9 : void OveToMScore::convertExpressions(Measure* measure, int part, int staff, int track)
2435 : {
2436 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2437 9 : if (measureData == 0) {
2438 0 : return;
2439 : }
2440 :
2441 9 : QList<ovebase::MusicData*> expressions = measureData->getMusicDatas(ovebase::MusicDataType::Expressions);
2442 :
2443 9 : for (int i = 0; i < expressions.size(); ++i) {
2444 0 : ovebase::Expressions* expressionPtr = static_cast<ovebase::Expressions*>(expressions[i]);
2445 0 : int absTick = m_mtt->getTick(measure->measureNumber(), expressionPtr->getTick());
2446 0 : Segment* s = measure->getSegment(SegmentType::ChordRest, Fraction::fromTicks(absTick));
2447 0 : Text* t = Factory::createText(s, TextStyleType::EXPRESSION);
2448 0 : t->setPlainText(expressionPtr->getText());
2449 0 : t->setTrack(track);
2450 :
2451 0 : s->add(t);
2452 : }
2453 9 : }
2454 :
2455 9 : void OveToMScore::convertGlissandos(Measure* measure, int part, int staff, int track)
2456 : {
2457 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2458 9 : if (measureData == 0) {
2459 0 : return;
2460 : }
2461 :
2462 : QList<ovebase::MusicData*> glissandos = measureData->getCrossMeasureElements(ovebase::MusicDataType::Glissando,
2463 9 : ovebase::MeasureData::PairType::All);
2464 :
2465 9 : for (int i = 0; i < glissandos.size(); ++i) {
2466 0 : ovebase::Glissando* glissandoPtr = static_cast<ovebase::Glissando*>(glissandos[i]);
2467 0 : ovebase::NoteContainer* startContainer = getContainerByPos(part, staff, glissandoPtr->start()->shiftMeasure(0));
2468 0 : ovebase::NoteContainer* endContainer = getContainerByPos(
2469 : part,
2470 : staff,
2471 0 : glissandoPtr->stop()->shiftMeasure(glissandoPtr->start()->getMeasure()));
2472 :
2473 0 : if (startContainer != 0 && endContainer != 0) {
2474 0 : int absTick = m_mtt->getTick(measure->measureNumber(), glissandoPtr->getTick());
2475 0 : ChordRest* cr = measure->findChordRest(Fraction::fromTicks(absTick), track);
2476 0 : if (cr != 0) {
2477 0 : Glissando* g = Factory::createGlissando(cr);
2478 0 : g->setGlissandoType(GlissandoType::WAVY);
2479 0 : g->setGlissandoStyle(cr->part()->instrument(cr->tick())->glissandoStyle());
2480 0 : cr->add(g);
2481 : }
2482 : }
2483 : }
2484 9 : }
2485 :
2486 0 : static HairpinType OveWedgeType_To_Type(ovebase::WedgeType type)
2487 : {
2488 0 : HairpinType subtype = HairpinType::CRESC_HAIRPIN;
2489 0 : switch (type) {
2490 0 : case ovebase::WedgeType::Cresc_Line: {
2491 0 : subtype = HairpinType::CRESC_HAIRPIN;
2492 0 : break;
2493 : }
2494 0 : case ovebase::WedgeType::Double_Line: {
2495 0 : subtype = HairpinType::CRESC_HAIRPIN;
2496 0 : break;
2497 : }
2498 0 : case ovebase::WedgeType::Dim_Line: {
2499 0 : subtype = HairpinType::DIM_HAIRPIN;
2500 0 : break;
2501 : }
2502 0 : case ovebase::WedgeType::Cresc: {
2503 0 : subtype = HairpinType::CRESC_HAIRPIN;
2504 0 : break;
2505 : }
2506 0 : case ovebase::WedgeType::Dim: {
2507 0 : subtype = HairpinType::DIM_HAIRPIN;
2508 0 : break;
2509 : }
2510 0 : default:
2511 0 : break;
2512 : }
2513 :
2514 0 : return subtype;
2515 : }
2516 :
2517 9 : void OveToMScore::convertWedges(Measure* measure, int part, int staff, int track)
2518 : {
2519 9 : ovebase::MeasureData* measureData = m_ove->getMeasureData(part, staff, measure->measureNumber());
2520 9 : if (measureData == 0) {
2521 0 : return;
2522 : }
2523 :
2524 : QList<ovebase::MusicData*> wedges = measureData->getCrossMeasureElements(ovebase::MusicDataType::Wedge,
2525 9 : ovebase::MeasureData::PairType::All);
2526 :
2527 9 : for (int i = 0; i < wedges.size(); ++i) {
2528 0 : ovebase::Wedge* wedgePtr = static_cast<ovebase::Wedge*>(wedges[i]);
2529 0 : int absTick = m_mtt->getTick(
2530 : measure->measureNumber(),
2531 0 : MeasureToTick::unitToTick(wedgePtr->start()->getOffset(), m_ove->getQuarter()));
2532 0 : int absTick2 = m_mtt->getTick(
2533 0 : measure->measureNumber() + wedgePtr->stop()->getMeasure(),
2534 0 : MeasureToTick::unitToTick(wedgePtr->stop()->getOffset(), m_ove->getQuarter()));
2535 :
2536 0 : if (absTick2 > absTick) {
2537 0 : Hairpin* hp = Factory::createHairpin(m_score->dummy());
2538 :
2539 0 : hp->setHairpinType(OveWedgeType_To_Type(wedgePtr->getWedgeType()));
2540 : // hp->setYoff(wedgePtr->getYOffset());
2541 0 : hp->setTrack(track);
2542 :
2543 0 : hp->setTick(Fraction::fromTicks(absTick));
2544 0 : hp->setTick2(Fraction::fromTicks(absTick2));
2545 0 : m_score->addSpanner(hp);
2546 : }
2547 : }
2548 9 : }
2549 :
2550 4 : Err importOve(MasterScore* score, const QString& name)
2551 : {
2552 4 : ovebase::IOVEStreamLoader* oveLoader = ovebase::createOveStreamLoader();
2553 4 : ovebase::OveSong oveSong;
2554 :
2555 4 : QFile oveFile(name);
2556 4 : if (!oveFile.exists()) {
2557 0 : return Err::FileNotFound;
2558 : }
2559 4 : if (!oveFile.open(QFile::ReadOnly)) {
2560 : // messageOutString(QString("can't read file!"));
2561 0 : return Err::FileOpenError;
2562 : }
2563 :
2564 4 : QByteArray buffer = oveFile.readAll();
2565 :
2566 4 : oveFile.close();
2567 :
2568 4 : oveSong.setTextCodecName(QString::fromStdString(ove::configuration()->importOvertureCharset()));
2569 4 : oveLoader->setOve(&oveSong);
2570 4 : oveLoader->setFileStream((unsigned char*)buffer.data(), buffer.size());
2571 4 : bool result = oveLoader->load();
2572 4 : oveLoader->release();
2573 :
2574 4 : if (result) {
2575 2 : OveToMScore otm;
2576 2 : otm.convert(&oveSong, score);
2577 :
2578 : // score->connectSlurs();
2579 2 : }
2580 :
2581 4 : return result ? Err::NoError : Err::FileUnknownError;
2582 4 : }
|
