1 //=============================================================================
2 // MuseScore
3 // Music Composition & Notation
4 //
5 // Copyright (C) 2011 Werner Schweer
6 //
7 // This program is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License version 2
9 // as published by the Free Software Foundation and appearing in
10 // the file LICENCE.GPL
11 //=============================================================================
12
13 #include "importgtp.h"
14
15 #include "importptb.h"
16
17 #include "mscore/preferences.h"
18
19 #include <libmscore/measurebase.h>
20 #include <libmscore/text.h>
21 #include <libmscore/box.h>
22 #include <libmscore/staff.h>
23 #include <libmscore/part.h>
24 #include <libmscore/measure.h>
25 #include <libmscore/timesig.h>
26 #include <libmscore/tremolo.h>
27 #include <libmscore/rest.h>
28 #include <libmscore/chord.h>
29 #include <libmscore/note.h>
30 #include <libmscore/stringdata.h>
31 #include <libmscore/clef.h>
32 #include <libmscore/lyrics.h>
33 #include <libmscore/tempotext.h>
34 #include <libmscore/slur.h>
35 #include <libmscore/tie.h>
36 #include <libmscore/tuplet.h>
37 #include <libmscore/barline.h>
38 #include <libmscore/excerpt.h>
39 #include <libmscore/stafftype.h>
40 #include <libmscore/bracket.h>
41 #include <libmscore/articulation.h>
42 #include <libmscore/keysig.h>
43 #include <libmscore/harmony.h>
44 #include <libmscore/bend.h>
45 #include <libmscore/tremolobar.h>
46 #include <libmscore/segment.h>
47 #include <libmscore/rehearsalmark.h>
48 #include <libmscore/dynamic.h>
49 #include <libmscore/arpeggio.h>
50 #include <libmscore/volta.h>
51 #include <libmscore/fret.h>
52 #include <libmscore/instrtemplate.h>
53 #include <libmscore/glissando.h>
54 #include <libmscore/chordline.h>
55 #include <libmscore/instrtemplate.h>
56 #include <libmscore/hairpin.h>
57 #include <libmscore/ottava.h>
58 #include <libmscore/notedot.h>
59 #include <libmscore/stafftext.h>
60 #include <libmscore/sym.h>
61 #include <libmscore/textline.h>
62 #include <libmscore/letring.h>
63 #include <libmscore/palmmute.h>
64 #include <libmscore/vibrato.h>
65
66 namespace Ms {
67
68 //---------------------------------------------------------
69 // errmsg
70 //---------------------------------------------------------
71
72 const char* const GuitarPro::errmsg[] = {
73 "no error",
74 "unknown file format",
75 "unexpected end of file",
76 "bad number of strings",
77 };
78
79 #ifdef _MSC_VER
80 #pragma optimize("", off)
81 #endif
82
83 //---------------------------------------------------------
84 // GpBar
85 //---------------------------------------------------------
86
GpBar()87 GpBar::GpBar()
88 {
89 barLine = BarLineType::NORMAL;
90 keysig = GP_INVALID_KEYSIG;
91 timesig = Fraction(4,4);
92 repeatFlags = Repeat::NONE;
93 repeats = 2;
94 }
95
96 //---------------------------------------------------------
97 // GuitarPro
98 //---------------------------------------------------------
99
GuitarPro(MasterScore * s,int v)100 GuitarPro::GuitarPro(MasterScore* s, int v)
101 {
102 score = s;
103 version = v;
104 _codec = QTextCodec::codecForName(preferences.getString(PREF_IMPORT_GUITARPRO_CHARSET).toLatin1());
105 voltaSequence = 1;
106 tempo = -1;
107 }
108
~GuitarPro()109 GuitarPro::~GuitarPro()
110 {
111 delete[] slurs;
112 }
113
114 //---------------------------------------------------------
115 // skip
116 //---------------------------------------------------------
117
skip(qint64 len)118 void GuitarPro::skip(qint64 len)
119 {
120 f->seek(f->pos() + len);
121 /*char c;
122 while (len--)
123 read(&c, 1);*/
124 }
125
126 //---------------------------------------------------------
127 // createTuningString
128 //---------------------------------------------------------
129
createTuningString(int strings,int tuning[])130 void GuitarPro::createTuningString(int strings, int tuning[])
131 {
132 const char* tune[] = { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};
133 //TODO-ws score->tuning.clear();
134 std::vector<int> pitch;
135 for (int i = 0; i < strings; ++i) {
136 pitch.push_back(tuning[i]);
137 //score->tuning += tune[tuning[i] % 12];
138 }
139 std::string t;
140 for (auto i : pitch) {
141 t += tune[i % 12];
142 t += " ";
143 }
144 tunings.push_back(t);
145 }
146
147 //---------------------------------------------------------
148 // read
149 //---------------------------------------------------------
150
read(void * p,qint64 len)151 void GuitarPro::read(void* p, qint64 len)
152 {
153 if (len == 0)
154 return;
155 qint64 rv = f->read((char*)p, len);
156 if (rv != len) {
157 Q_ASSERT(rv == len); //to have assert in debug and no warnings from AppVeyor in release
158 }
159 curPos += len;
160 }
161
162 //---------------------------------------------------------
163 // readChar
164 //---------------------------------------------------------
165
readChar()166 int GuitarPro::readChar()
167 {
168 signed char c;
169 read(&c, 1);
170 return c;
171 }
172
173 //---------------------------------------------------------
174 // readUChar
175 //---------------------------------------------------------
176
readUChar()177 int GuitarPro::readUChar()
178 {
179 uchar c;
180 read(&c, 1);
181 return c;
182 }
183
184 //---------------------------------------------------------
185 // readPascalString
186 //---------------------------------------------------------
187
readPascalString(int n)188 QString GuitarPro::readPascalString(int n)
189 {
190 uchar l = readUChar();
191 std::vector<char> s(l + 1);
192 //char s[l + 1];
193 read(&s[0], l);
194 s[l] = 0;
195 if (n - l > 0)
196 skip(n - l);
197 if (_codec)
198 return _codec->toUnicode(&s[0]);
199 else
200 return QString(&s[0]);
201 }
202
203 //---------------------------------------------------------
204 // readWordPascalString
205 //---------------------------------------------------------
206
readWordPascalString()207 QString GuitarPro::readWordPascalString()
208 {
209 int l = readInt();
210 std::vector<char> c(l + 1);
211 //char c[l+1];
212 read(&c[0], l);
213 c[l] = 0;
214 if (_codec)
215 return _codec->toUnicode(&c[0]);
216 else
217 return QString::fromLocal8Bit(&c[0]);
218 }
219
220 //---------------------------------------------------------
221 // readBytePascalString
222 //---------------------------------------------------------
223
readBytePascalString()224 QString GuitarPro::readBytePascalString()
225 {
226 int l = readUChar();
227 std::vector<char> c(l + 1);
228 //char c[l+1];
229 read(&c[0], l);
230 c[l] = 0;
231 if(_codec)
232 return _codec->toUnicode(&c[0]);
233 else
234 return QString::fromLocal8Bit(&c[0]);
235 }
236
237 //---------------------------------------------------------
238 // readDelphiString
239 //---------------------------------------------------------
240
readDelphiString()241 QString GuitarPro::readDelphiString()
242 {
243 int maxl = readInt();
244 int l = readUChar();
245 if (maxl != l + 1 && maxl > 255) {
246 qFatal("readDelphiString: first word doesn't match second byte");
247 l = maxl - 1;
248 }
249 std::vector<char> c(l + 1);
250 //char c[l + 1];
251 read(&c[0], l);
252 c[l] = 0;
253 std::string g(&c[0]);
254 if (g.find("2nd ") == 0) {
255 ; //?? int k = 1;
256 }
257 if (_codec)
258 return _codec->toUnicode(&c[0]);
259 else
260 return QString::fromLatin1(&c[0]);
261 }
262
263 //---------------------------------------------------------
264 // readInt
265 //---------------------------------------------------------
266
readInt()267 int GuitarPro::readInt()
268 {
269 uchar x;
270 read(&x, 1);
271 int r = x;
272 read(&x, 1);
273 r += x << 8;
274 read(&x, 1);
275 r += x << 16;
276 read(&x, 1);
277 r += x << 24;
278 return r;
279 }
280
281 //---------------------------------------------------------
282 // initGuitarProDrumset
283 //---------------------------------------------------------
284
initGuitarProDrumset()285 void GuitarPro::initGuitarProDrumset()
286 {
287 gpDrumset = new Drumset;
288 for (int i = 0; i < 128; ++i) {
289 gpDrumset->drum(i).notehead = NoteHead::Group::HEAD_INVALID;
290 gpDrumset->drum(i).line = 0;
291 gpDrumset->drum(i).shortcut = 0;
292 gpDrumset->drum(i).voice = 0;
293 gpDrumset->drum(i).stemDirection = Direction::UP;
294 }
295 // new drumset determined via guitar pro (third argument specifies position on staff, 10 = C3, 9 = D3, 8 = E3,...)
296 gpDrumset->drum(27) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Q"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
297 gpDrumset->drum(28) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Slap"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
298 gpDrumset->drum(29) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Scratch Push"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
299 gpDrumset->drum(30) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Scratch Pull"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
300 gpDrumset->drum(31) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Sticks"), NoteHead::Group::HEAD_CROSS, 3, Direction::UP);
301 gpDrumset->drum(32) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Square Click"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
302 gpDrumset->drum(33) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Metronome Click"), NoteHead::Group::HEAD_CROSS, 3, Direction::UP);
303 gpDrumset->drum(34) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Metronome Bell"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
304 gpDrumset->drum(35) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Acoustic Bass Drum"), NoteHead::Group::HEAD_NORMAL, 7, Direction::UP);
305 gpDrumset->drum(36) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Bass Drum 1"), NoteHead::Group::HEAD_NORMAL, 7, Direction::UP);
306 gpDrumset->drum(37) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Side Stick"), NoteHead::Group::HEAD_CROSS, 3, Direction::UP);
307 gpDrumset->drum(38) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Acoustic Snare"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
308 gpDrumset->drum(39) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hand Clap"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
309 gpDrumset->drum(40) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Electric Snare"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
310 gpDrumset->drum(41) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Floor Tom"), NoteHead::Group::HEAD_NORMAL, 6, Direction::UP);
311 gpDrumset->drum(42) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Closed Hi-Hat"), NoteHead::Group::HEAD_CROSS, -1, Direction::UP);
312 gpDrumset->drum(43) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Floor Tom"), NoteHead::Group::HEAD_NORMAL, 6, Direction::UP);
313 gpDrumset->drum(44) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Pedal Hi-Hat"), NoteHead::Group::HEAD_CROSS, 9, Direction::UP);
314 gpDrumset->drum(45) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Tom"), NoteHead::Group::HEAD_NORMAL, 5, Direction::UP);
315 gpDrumset->drum(46) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Hi-Hat"), NoteHead::Group::HEAD_XCIRCLE, -1, Direction::UP);
316 gpDrumset->drum(47) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low-Mid Tom"), NoteHead::Group::HEAD_NORMAL, 4, Direction::UP);
317 gpDrumset->drum(48) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hi-Mid Tom"), NoteHead::Group::HEAD_NORMAL, 2, Direction::UP);
318 gpDrumset->drum(49) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Crash Cymbal 1"), NoteHead::Group::HEAD_CROSS, -1, Direction::UP);
319 gpDrumset->drum(50) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Tom"), NoteHead::Group::HEAD_NORMAL, 1, Direction::UP);
320 gpDrumset->drum(51) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride Cymbal 1"), NoteHead::Group::HEAD_CROSS, 0, Direction::UP);
321 gpDrumset->drum(52) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Chinese Cymbal"), NoteHead::Group::HEAD_CROSS, -3, Direction::UP);
322 gpDrumset->drum(53) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride Bell"), NoteHead::Group::HEAD_DIAMOND, 0, Direction::UP);
323 gpDrumset->drum(54) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Tambourine"), NoteHead::Group::HEAD_CROSS, 2, Direction::UP);
324 gpDrumset->drum(55) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Splash Cymbal"), NoteHead::Group::HEAD_CROSS, -2, Direction::UP);
325 gpDrumset->drum(56) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cowbell Medium"), NoteHead::Group::HEAD_NORMAL, 0, Direction::UP);
326 gpDrumset->drum(57) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Crash Cymbal 2"), NoteHead::Group::HEAD_CROSS, -2, Direction::UP);
327 gpDrumset->drum(58) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Vibraslap"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
328 gpDrumset->drum(59) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride Cymbal 2"), NoteHead::Group::HEAD_DIAMOND, 0, Direction::UP);
329 gpDrumset->drum(60) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hi Bongo"), NoteHead::Group::HEAD_NORMAL, 8, Direction::UP);
330 gpDrumset->drum(61) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Bongo"), NoteHead::Group::HEAD_NORMAL, 9, Direction::UP);
331 gpDrumset->drum(62) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Hi Conga"), NoteHead::Group::HEAD_CROSS, 5, Direction::UP);
332 gpDrumset->drum(63) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Hi Conga"), NoteHead::Group::HEAD_CROSS, 4, Direction::UP);
333 gpDrumset->drum(64) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Conga"), NoteHead::Group::HEAD_CROSS, 6, Direction::UP);
334 gpDrumset->drum(65) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Timbale"), NoteHead::Group::HEAD_CROSS, 8, Direction::UP);
335 gpDrumset->drum(66) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Timbale"), NoteHead::Group::HEAD_CROSS, 9, Direction::UP);
336 gpDrumset->drum(67) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Agogo"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
337 gpDrumset->drum(68) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Agogo"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
338 gpDrumset->drum(69) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cabasa"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
339 gpDrumset->drum(70) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Maracas"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
340 gpDrumset->drum(71) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Short Whistle"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
341 gpDrumset->drum(72) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Long Whistle"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
342 gpDrumset->drum(73) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Short Güiro"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
343 gpDrumset->drum(74) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Long Güiro"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
344 gpDrumset->drum(75) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Claves"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
345 gpDrumset->drum(76) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hi Wood Block"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
346 gpDrumset->drum(77) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Wood Block"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
347 gpDrumset->drum(78) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Cuica"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
348 gpDrumset->drum(79) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Cuica"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
349 gpDrumset->drum(80) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Triangle"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
350 gpDrumset->drum(81) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Triangle"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
351 gpDrumset->drum(82) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Shaker"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
352 gpDrumset->drum(83) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Sleigh Bell"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
353 gpDrumset->drum(84) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Bell Tree"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
354 gpDrumset->drum(85) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Castanets"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
355 gpDrumset->drum(86) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Surdo"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
356 gpDrumset->drum(87) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Surdo"), NoteHead::Group::HEAD_NORMAL, 3, Direction::UP);
357
358 gpDrumset->drum(91) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Snare (Rim shot)"), NoteHead::Group::HEAD_DIAMOND, 3, Direction::UP);
359 gpDrumset->drum(93) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride (Edge)"), NoteHead::Group::HEAD_CROSS, 0, Direction::UP);
360
361 //Additional clutch presets (midi by default can't play this)
362 gpDrumset->drum(99) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cowbell Low"), NoteHead::Group::HEAD_TRIANGLE_UP, 1, Direction::UP);
363 gpDrumset->drum(102) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cowbell High"), NoteHead::Group::HEAD_TRIANGLE_UP, -1, Direction::UP);
364 }
365
366 //---------------------------------------------------------
367 // addPalmMate
368 //---------------------------------------------------------
369
addPalmMute(Note * note)370 void GuitarPro::addPalmMute(Note* note)
371 {
372 int track = note->track();
373 while (int(_palmMutes.size()) < track + 1)
374 _palmMutes.push_back(0);
375
376 Chord* chord = note->chord();
377 if (_palmMutes[track]) {
378 PalmMute* pm = _palmMutes[track];
379 Chord* lastChord = toChord(pm->endCR());
380 if (lastChord == note->chord())
381 return;
382 //
383 // extend the current palm mute or start a new one
384 //
385 Fraction tick = note->chord()->segment()->tick();
386 if (pm->tick2() < tick)
387 _palmMutes[track] = 0;
388 else {
389 pm->setTick2(chord->tick() + chord->actualTicks());
390 pm->setEndElement(chord);
391 }
392
393 }
394 if (!_palmMutes[track]) {
395 PalmMute* pm = new PalmMute(score);
396 _palmMutes[track] = pm;
397 Segment* segment = chord->segment();
398 Fraction tick = segment->tick();
399
400 pm->setTick(tick);
401 pm->setTick2(tick + chord->actualTicks());
402 pm->setTrack(track);
403 pm->setTrack2(track);
404 pm->setStartElement(chord);
405 pm->setEndElement(chord);
406 score->addElement(pm);
407 }
408 }
409
410 //---------------------------------------------------------
411 // addLetRing
412 //---------------------------------------------------------
413
addLetRing(Note * note)414 void GuitarPro::addLetRing(Note* note)
415 {
416 int track = note->track();
417 while (int(_letRings.size()) < track + 1)
418 _letRings.push_back(0);
419
420 Chord* chord = note->chord();
421 if (_letRings[track]) {
422 LetRing* lr = _letRings[track];
423 Chord* lastChord = toChord(lr->endCR());
424 if (lastChord == note->chord())
425 return;
426 //
427 // extend the current "let ring" or start a new one
428 //
429 Fraction tick = note->chord()->segment()->tick();
430 if (lr->tick2() < tick)
431 _letRings[track] = 0;
432 else {
433 lr->setTick2(chord->tick() + chord->actualTicks());
434 lr->setEndElement(chord);
435 }
436 }
437 if (!_letRings[track]) {
438 LetRing* lr = new LetRing(score);
439 _letRings[track] = lr;
440 Segment* segment = chord->segment();
441 Fraction tick = segment->tick();
442
443 lr->setTick(tick);
444 lr->setTick2(tick + chord->actualTicks());
445 lr->setTrack(track);
446 lr->setTrack2(track);
447 lr->setStartElement(chord);
448 lr->setEndElement(chord);
449 score->addElement(lr);
450 }
451 }
452
453 //---------------------------------------------------------
454 // addVibrato
455 //---------------------------------------------------------
456
addVibrato(Note * note,Vibrato::Type type)457 void GuitarPro::addVibrato(Note* note, Vibrato::Type type)
458 {
459 int track = note->track();
460 while (int(_vibratos.size()) < track + 1)
461 _vibratos.push_back(0);
462
463 Chord* chord = note->chord();
464 if (_vibratos[track]) {
465 Vibrato* v = _vibratos[track];
466 if (v->vibratoType() == type) {
467 Chord* lastChord = toChord(v->endCR());
468 if (lastChord == note->chord())
469 return;
470 //
471 // extend the current "vibrato" or start a new one
472 //
473 Fraction tick = note->chord()->segment()->tick();
474 if (v->tick2() < tick)
475 _vibratos[track] = 0;
476 else {
477 v->setTick2(chord->tick() + chord->actualTicks());
478 v->setEndElement(chord);
479 }
480 }
481 else
482 _vibratos[track] = 0;
483 }
484 if (!_vibratos[track]) {
485 Vibrato* v = new Vibrato(score);
486 v->setVibratoType(type);
487 _vibratos[track] = v;
488 Segment* segment = chord->segment();
489 Fraction tick = segment->tick();
490
491 v->setTick(tick);
492 v->setTick2(tick + chord->actualTicks());
493 v->setTrack(track);
494 v->setTrack2(track);
495 v->setStartElement(chord);
496 v->setEndElement(chord);
497 score->addElement(v);
498 }
499 }
500
501 //---------------------------------------------------------
502 // addTap
503 //---------------------------------------------------------
504
addTap(Note * note)505 void GuitarPro::addTap(Note* note)
506 {
507 addTextToNote("T", Align::CENTER, note);
508 }
509
510 //---------------------------------------------------------
511 // addSlap
512 //---------------------------------------------------------
513
addSlap(Note * note)514 void GuitarPro::addSlap(Note* note)
515 {
516 addTextToNote("S", Align::CENTER, note);
517 }
518
519 //---------------------------------------------------------
520 // addPop
521 //---------------------------------------------------------
522
addPop(Note * note)523 void GuitarPro::addPop(Note* note)
524 {
525 addTextToNote("P", Align::CENTER, note);
526 }
527
528 //---------------------------------------------------------
529 // addTextToNote
530 //---------------------------------------------------------
531
addTextToNote(QString string,Align a,Note * note)532 Text* GuitarPro::addTextToNote(QString string, Align a, Note* note)
533 {
534 Text* text = new Text(score);
535 //TODO-ws if (textStyle.underline())
536 // text->setFramed(true);
537 text->setAlign(a);
538 bool use_harmony = string[string.size() - 1] == '\\';
539 if (use_harmony)
540 string.resize(string.size() - 1);
541 text->setPlainText(string);
542 // text->setTextStyleType(use_harmony ? TextStyleType::HARMONY : TextStyleType::TECHNIQUE);
543 note->add(text);
544 return text;
545 }
546
setupTupletStyle(Tuplet * tuplet)547 void GuitarPro::setupTupletStyle(Tuplet* tuplet)
548 {
549 bool real;
550 switch (tuplet->ratio().numerator()) {
551 case 2: real = (tuplet->ratio().denominator() == 3); break;
552 case 3:
553 case 4: real = (tuplet->ratio().denominator() == 2); break;
554 case 5:
555 case 6:
556 case 7: real = (tuplet->ratio().denominator() == 4); break;
557 case 9:
558 case 10:
559 case 11:
560 case 12:
561 case 13: real = (tuplet->ratio().denominator() == 8); break;
562 default: real = false;
563 }
564 if (!real) {
565 tuplet->setNumberType(TupletNumberType::SHOW_RELATION);
566 tuplet->setPropertyFlags(Pid::NUMBER_TYPE, PropertyFlags::UNSTYLED);
567 }
568 }
569
570 //---------------------------------------------------------
571 // setTuplet
572 //---------------------------------------------------------
573
setTuplet(Tuplet * tuplet,int tuple)574 void GuitarPro::setTuplet(Tuplet* tuplet, int tuple)
575 {
576 switch (tuple) {
577 case 3:
578 tuplet->setRatio(Fraction(3,2));
579 break;
580 case 5:
581 tuplet->setRatio(Fraction(5,4));
582 break;
583 case 6:
584 tuplet->setRatio(Fraction(6,4));
585 break;
586 case 7:
587 tuplet->setRatio(Fraction(7,4));
588 break;
589 case 9:
590 tuplet->setRatio(Fraction(9,8));
591 break;
592 case 10:
593 tuplet->setRatio(Fraction(10,8));
594 break;
595 case 11:
596 tuplet->setRatio(Fraction(11,8));
597 break;
598 case 12:
599 tuplet->setRatio(Fraction(12,8));
600 break;
601 case 13:
602 tuplet->setRatio(Fraction(13,8));
603 break;
604 default:
605 qFatal("unsupported tuplet %d\n", tuple);
606 }
607 }
608
609 //---------------------------------------------------------
610 // addDynamic
611 //---------------------------------------------------------
612
addDynamic(Note * note,int d)613 void GuitarPro::addDynamic(Note* note, int d)
614 {
615 if (d < 0)
616 return;
617 if (!note->chord()){
618 qDebug() << "addDynamics: No chord associated with this note";
619 return;
620 }
621 Segment* s = nullptr;
622 if (note->chord()->isGrace()) {
623 Chord* parent = static_cast<Chord*>(note->chord()->parent());
624 s = parent->segment();
625 }
626 else
627 s = note->chord()->segment();
628 if (!s->findAnnotation(ElementType::DYNAMIC, note->staffIdx() * VOICES, note->staffIdx() * VOICES + VOICES - 1)) {
629 Dynamic* dyn = new Dynamic(score);
630 // guitar pro only allows their users to go from ppp to fff
631 QString map_dyn[] = {"f","ppp","pp","p","mp","mf","f","ff","fff"};
632 dyn->setDynamicType(map_dyn[d]);
633 dyn->setTrack(note->track());
634 s->add(dyn);
635 }
636 }
637
638 //---------------------------------------------------------
639 // readVolta
640 //---------------------------------------------------------
641
readVolta(GPVolta * gpVolta,Measure * m)642 void GuitarPro::readVolta(GPVolta* gpVolta, Measure* m)
643 {
644 /* Volta information is at most eight bits
645 * signifying which numbers should appear in the
646 * volta. A single bit 1 represents we should show
647 * 1, 100 represents 3, 10000 represents 6, 10101
648 * represents 1,3,5 etc. */
649 if (gpVolta->voltaInfo.length() != 0) {
650 // we have volta information - set up a volta
651 Ms::Volta* volta = new Ms::Volta(score);
652 volta->endings().clear();
653 QString voltaTextString = "";
654 // initialise count to 1 as the first bit processed with represesnt first time volta
655 int count = 0;
656 int binaryNumber = 0;
657 // iterate through the volta information and determine the decimal numbers for voltas
658 auto iter = gpVolta->voltaInfo.begin();
659 while (iter != gpVolta->voltaInfo.end()) {
660 switch (gpVolta->voltaType) {
661 case GP_VOLTA_FLAGS:
662 count++;
663 if (*iter == 1) { // we want this number to be displayed in the volta
664 if (voltaTextString == "")
665 voltaTextString += QString::number(count);
666 else
667 voltaTextString += "," + QString::number(count);
668 // add the decimal number to the endings field of voltas as well as the text
669 volta->endings().append(count);
670 }
671 ++iter;
672 break;
673 case GP_VOLTA_BINARY:
674 // find the binary number in decimal
675 if (*iter == 1) {
676 binaryNumber += pow(2,count);
677 }
678 ++iter;
679 if (iter == gpVolta->voltaInfo.end()) {
680 // display all numbers in the volta from voltaSequence to the decimal
681 while (voltaSequence <= binaryNumber) {
682 if (voltaTextString == "")
683 voltaTextString = QString::number(voltaSequence);
684 else
685 voltaTextString += "," + QString::number(voltaSequence);
686 volta->endings().append(voltaSequence);
687 voltaSequence++;
688 }
689 }
690 count++;
691 break;
692 }
693 }
694 volta->setText(XmlWriter::xmlString(voltaTextString));
695 volta->setTick(m->tick());
696 volta->setTick2(m->tick() + m->ticks());
697 score->addElement(volta);
698 }
699 }
700
701 //---------------------------------------------------------
702 // readBend
703 // bend graph
704 //---------------------------------------------------------
705
readBend(Note * note)706 void GuitarPro::readBend(Note* note)
707 {
708 readUChar(); // icon
709 /*int amplitude =*/ readInt(); // shown aplitude
710 int numPoints = readInt(); // the number of points in the bend
711
712 // there are no notes in the bend, exit the function
713 if (numPoints == 0)
714 return;
715 Bend* bend = new Bend(note->score());
716 //TODO-ws bend->setNote(note);
717 for (int i = 0; i < numPoints; ++i) {
718 int bendTime = readInt();
719 int bendPitch = readInt();
720 int bendVibrato = readUChar();
721 bend->points().append(PitchValue(bendTime, bendPitch, bendVibrato));
722 }
723 //TODO-ws bend->setAmplitude(amplitude);
724 bend->setTrack(note->track());
725 note->add(bend);
726 }
727
728 //---------------------------------------------------------
729 // readLyrics
730 //---------------------------------------------------------
731
readLyrics()732 void GuitarPro::readLyrics()
733 {
734 gpLyrics.lyricTrack = readInt(); // lyric track
735 gpLyrics.fromBeat = readInt();
736 gpLyrics.beatCounter = 0;
737
738 QString lyrics = readWordPascalString();
739 lyrics.replace(QRegExp("\n"), " ");
740 lyrics.replace(QRegExp("\r"), " ");
741 auto sl = lyrics.split(" ", QString::KeepEmptyParts);
742 //gpLyrics.lyrics = lyrics.split(" ", QString::KeepEmptyParts);
743 for (auto& str : sl) {
744 /*while (str[0] == '-')
745 {
746 gpLyrics.lyrics.push_back("aa");
747 str = str.substr(1);
748 }*/
749 gpLyrics.lyrics.push_back(str);
750 }
751
752 for (int i = 0; i < 4; ++i) {
753 readInt();
754 readWordPascalString();
755 }
756 }
757
758 //---------------------------------------------------------
759 // createSlide
760 //---------------------------------------------------------
761
createSlide(int sl,ChordRest * cr,int staffIdx,Note *)762 void GuitarPro::createSlide(int sl, ChordRest* cr, int staffIdx, Note* /*note*/)
763 {
764 // shift / legato slide
765 if (sl == SHIFT_SLIDE || sl == LEGATO_SLIDE) {
766 Glissando* s = new Glissando(score);
767 //s->setXmlText("");
768 s->setGlissandoType(GlissandoType::STRAIGHT);
769 cr->add(s);
770 s->setAnchor(Spanner::Anchor::NOTE);
771 Segment* prevSeg = cr->segment()->prev1(SegmentType::ChordRest);
772 Element* prevElem = prevSeg->element(staffIdx);
773 if (prevElem) {
774 if (prevElem->type() == ElementType::CHORD) {
775 Chord* prevChord = static_cast<Chord*>(prevElem);
776 /** TODO we should not just take the top note here
777 * but the /correct/ note need to check whether GP
778 * supports multi-note gliss. I think it can in modern
779 * versions */
780 s->setStartElement(prevChord->upNote());
781 s->setTick(prevSeg->tick());
782 s->setTrack(staffIdx);
783 s->setParent(prevChord->upNote());
784 s->setText("");
785 s->setGlissandoType(GlissandoType::STRAIGHT);
786 if (sl == LEGATO_SLIDE)
787 createSlur(true, staffIdx, prevChord);
788 }
789 }
790
791 Chord* chord = (Chord*) cr;
792 /* TODO again here, we should not just set the up note but the
793 * /correct/ note need to check whether GP supports
794 * multi-note gliss. I think it can in modern versions */
795 s->setEndElement(chord->upNote());
796 s->setTick2(chord->segment()->tick());
797 s->setTrack2(staffIdx);
798 score->addElement(s);
799 if (sl == LEGATO_SLIDE)
800 createSlur(false, staffIdx, cr);
801 }
802 // slide out downwards (fall)
803 if (sl & SLIDE_OUT_DOWN) {
804 ChordLine* cl = new ChordLine(score);
805 cl->setChordLineType(ChordLineType::FALL);
806 cl->setStraight(true);
807 //TODO-ws cl->setNote(note);
808 cr->add(cl);
809 }
810 // slide out upwards (doit)
811 if (sl & SLIDE_OUT_UP) {
812 ChordLine* cl = new ChordLine(score);
813 cl->setChordLineType(ChordLineType::DOIT);
814 cl->setStraight(true);
815 //TODO-ws cl->setNote(note);
816 cr->add(cl);
817 }
818 // slide in from below (plop)
819 if (sl & SLIDE_IN_BELOW) {
820 ChordLine* cl = new ChordLine(score);
821 cl->setChordLineType(ChordLineType::PLOP);
822 cl->setStraight(true);
823 //TODO-ws cl->setNote(note);
824 cr->add(cl);
825 }
826 // slide in from above (scoop)
827 if (sl & SLIDE_IN_ABOVE) {
828 ChordLine* cl = new ChordLine(score);
829 cl->setChordLineType(ChordLineType::SCOOP);
830 cl->setStraight(true);
831 //TODO-ws cl->setNote(note);
832 cr->add(cl);
833 }
834 }
835
836 //---------------------------------------------------------
837 // readChannels
838 //---------------------------------------------------------
839
readChannels()840 void GuitarPro::readChannels()
841 {
842 for (int i = 0; i < GP_MAX_TRACK_NUMBER * 2; ++i) {
843 channelDefaults[i].patch = readInt();
844 channelDefaults[i].volume = readUChar() * 8 - 1;
845 channelDefaults[i].pan = readUChar() * 8 - 1;
846 channelDefaults[i].chorus = readUChar() * 8 - 1;
847 channelDefaults[i].reverb = readUChar() * 8 - 1;
848 channelDefaults[i].phase = readUChar() * 8 - 1;
849 channelDefaults[i].tremolo = readUChar() * 8 - 1;
850
851 // defaults of 255, or any value above 127, are set to 0 (Musescore range is 0-127)
852 if (channelDefaults[i].patch > 127) { channelDefaults[i].patch = 0; }
853 if (channelDefaults[i].volume > 127) { channelDefaults[i].volume = 0; }
854 if (channelDefaults[i].pan > 127) { channelDefaults[i].pan = 0; }
855 if (channelDefaults[i].chorus > 127) { channelDefaults[i].chorus = 0; }
856 if (channelDefaults[i].reverb > 127) { channelDefaults[i].reverb = 0; }
857 if (channelDefaults[i].phase > 127) { channelDefaults[i].phase = 0; }
858 if (channelDefaults[i].tremolo > 127) { channelDefaults[i].tremolo = 0; }
859
860 // skip over blank information included for backwards compatibility with 3.0
861 skip(2);
862 }
863 }
864
865 //---------------------------------------------------------
866 // len2fraction
867 //---------------------------------------------------------
868
len2fraction(int len)869 Fraction GuitarPro::len2fraction(int len)
870 {
871 Fraction l;
872 switch(len) {
873 case -2: l.set(1, 1); break;
874 case -1: l.set(1, 2); break;
875 case 0: l.set(1, 4); break;
876 case 1: l.set(1, 8); break;
877 case 2: l.set(1, 16); break;
878 case 3: l.set(1, 32); break;
879 case 4: l.set(1, 64); break;
880 case 5: l.set(1, 128); break;
881 // set to len - in some cases we get whacky numbers for this (40, 28...)
882 default:
883 l.set(1,len);
884 }
885 return l;
886 }
887
888 //---------------------------------------------------------
889 // readMixChange
890 //---------------------------------------------------------
891
readMixChange(Measure * measure)892 bool GuitarPro::readMixChange(Measure* measure)
893 {
894 /*char patch =*/ readChar();
895 signed char volume = readChar();
896 signed char pan = readChar();
897 signed char chorus = readChar();
898 signed char reverb = readChar();
899 signed char phase = readChar();
900 signed char tremolo = readChar();
901 int temp = readInt();
902
903 if (volume >= 0)
904 readChar();
905 if (pan >= 0)
906 readChar();
907 if (chorus >= 0)
908 readChar();
909 if (reverb >= 0)
910 readChar();
911 if (phase >= 0)
912 readChar();
913 if (tremolo >= 0)
914 readChar();
915 if (temp >= 0) {
916 if (temp != previousTempo) {
917 previousTempo = temp;
918 setTempo(temp, measure);
919 }
920 readChar();
921 }
922 return true;
923 }
924
925 //---------------------------------------------------------
926 // createMeasures
927 //---------------------------------------------------------
928
createMeasures()929 void GuitarPro::createMeasures()
930 {
931 Fraction tick = Fraction(0,1);
932 Fraction ts;
933 qDebug("measures %d bars.size %d", measures, bars.size());
934
935 // for (int i = 0; i < measures; ++i) {
936 for (int i = 0; i < bars.size(); ++i) { // ?? (ws)
937 Fraction nts = bars[i].timesig;
938 Measure* m = new Measure(score);
939 m->setTick(tick);
940 m->setTimesig(nts);
941 m->setTicks(nts);
942
943 if (i == 0 || ts != nts) {
944 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
945 const Staff* staff = score->staff(staffIdx);
946 const StaffType* staffType = staff->staffType(Fraction(0,1)); // at tick 0
947 if (staffType->genTimesig()) {
948 TimeSig* t = new TimeSig(score);
949 t->setTrack(staffIdx * VOICES);
950 t->setSig(nts);
951 Segment* s = m->getSegment(SegmentType::TimeSig, tick);
952 s->add(t);
953 }
954 }
955 }
956 if (i == 0 || (bars[i].keysig != GP_INVALID_KEYSIG)) {
957 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
958 int keysig = bars[i].keysig != GP_INVALID_KEYSIG ? bars[i].keysig : key;
959 if (tick.isZero() || (int)score->staff(staffIdx)->key(tick) != (int)Key(keysig)) {
960 KeySig* t = new KeySig(score);
961 t->setKey(Key(keysig));
962 t->setTrack(staffIdx * VOICES);
963 Segment* s = m->getSegment(SegmentType::KeySig, tick);
964 s->add(t);
965 }
966 }
967 }
968 readVolta(&bars[i].volta, m);
969 m->setRepeatEnd(bars[i].repeatFlags == Repeat::END);
970 m->setRepeatStart(bars[i].repeatFlags == Repeat::START);
971 m->setRepeatJump(bars[i].repeatFlags == Repeat::JUMP);
972 // m->setRepeatFlags(bars[i].repeatFlags);
973 m->setRepeatCount(bars[i].repeats); // supported in gp5
974
975 // reset the volta sequence if we have an opening repeat
976 if (bars[i].repeatFlags == Repeat::START)
977 voltaSequence = 1;
978 // otherwise, if we see an end repeat symbol, only reset if the bar after it does not contain a volta
979 else if (bars[i].repeatFlags == Repeat::END && i < bars.length() - 1) {
980 if (bars[i+1].volta.voltaInfo.length() == 0) {
981 voltaSequence = 1; // reset the volta count
982 }
983 }
984
985 score->measures()->add(m);
986 tick += nts;
987 ts = nts;
988 }
989 }
990
991 //---------------------------------------------------------
992 // applyBeatEffects
993 //---------------------------------------------------------
994
applyBeatEffects(Chord * chord,int beatEffect)995 void GuitarPro::applyBeatEffects(Chord* chord, int beatEffect)
996 {
997 /* tap/slap/pop implemented as text until SMuFL has
998 * specifications and we can add them to fonts. Note that
999 * tap/slap/pop are just added to the top note in the chord,
1000 * technically these can be applied to individual notes on the
1001 * UI, but Guitar Pro has no way to express that on the
1002 * score. To get the same result, we should just add the marking
1003 * to above the top note.
1004 */
1005 if (beatEffect == 1) {
1006 if (version > 300)
1007 addTap(chord->upNote());
1008 else
1009 addVibrato(chord->upNote());
1010 }
1011 else if (beatEffect == 2)
1012 addSlap(chord->upNote());
1013 else if (beatEffect == 3)
1014 addPop(chord->upNote());
1015 else if (beatEffect == 4) {
1016 if (version >= 400) {
1017 Articulation* a = new Articulation(chord->score());
1018 a->setSymId(SymId::guitarFadeIn);
1019 a->setAnchor(ArticulationAnchor::TOP_STAFF);
1020 a->setPropertyFlags(Pid::ARTICULATION_ANCHOR, PropertyFlags::UNSTYLED);
1021 chord->add(a);
1022 }
1023 //TODO-ws else for (auto n : chord->notes())
1024 // n->setHarmonic(true);
1025 }
1026 else if (beatEffect == 5) {
1027 Articulation* a = new Articulation(chord->score());
1028 a->setSymId(SymId::stringsUpBow);
1029 chord->add(a);
1030 }
1031 else if (beatEffect == 6) {
1032 Articulation* art = new Articulation(chord->score());
1033 art->setSymId(SymId::stringsDownBow);
1034 chord->add(art);
1035 }
1036 else if (beatEffect == 7) {
1037 addVibrato(chord->upNote(), Vibrato::Type::VIBRATO_SAWTOOTH);
1038 }
1039 }
1040
1041 #ifdef _MSC_VER
1042 #pragma optimize("", on)
1043 #endif
1044
1045 //---------------------------------------------------------
1046 // read
1047 //---------------------------------------------------------
1048
read(QFile * fp)1049 bool GuitarPro1::read(QFile* fp)
1050 {
1051 f = fp;
1052 curPos = 30;
1053
1054 title = readDelphiString();
1055 artist = readDelphiString();
1056 readDelphiString();
1057
1058 int temp = readInt();
1059 /*uchar num =*/ readUChar(); // Shuffle rhythm feel
1060
1061 // int octave = 0;
1062 key = 0;
1063 if (version > 102)
1064 key = readInt(); // key
1065
1066 staves = version > 102 ? 8 : 1;
1067
1068 slurs = new Slur*[staves];
1069 for (int i = 0; i < staves; ++i)
1070 slurs[i] = nullptr;
1071
1072 //int tnumerator = 4;
1073 //int tdenominator = 4;
1074
1075 //
1076 // create a part for every staff
1077 //
1078 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
1079 Part* part = new Part(score);
1080 Staff* s = new Staff(score);
1081 s->setPart(part);
1082 part->insertStaff(s, 0);
1083 score->staves().push_back(s);
1084 score->appendPart(part);
1085 }
1086
1087
1088 for (int i = 0; i < staves; ++i) {
1089 int tuning[GP_MAX_STRING_NUMBER];
1090
1091 int strings = version > 101 ? readInt() : 6;
1092 for (int j = 0; j < strings; ++j)
1093 tuning[j] = readInt();
1094 std::vector<int> tuning2(strings);
1095 //int tuning2[strings];
1096 for (int k = 0; k < strings; ++k)
1097 tuning2[strings-k-1] = tuning[k];
1098
1099 int frets = 32; // TODO
1100 StringData stringData(frets, strings, &tuning2[0]);
1101 createTuningString(strings, &tuning2[0]);
1102 Part* part = score->staff(i)->part();
1103 Instrument* instr = part->instrument();
1104 instr->setStringData(stringData);
1105 instr->setSingleNoteDynamics(false);
1106 }
1107
1108 measures = readInt();
1109
1110 Fraction ts;
1111 Fraction tick = {0,1};
1112 for (int i = 0; i < measures; ++i) {
1113 Fraction nts = bars[i].timesig;
1114 Measure* m = new Measure(score);
1115 m->setTick(tick);
1116 m->setTimesig(nts);
1117 m->setTicks(nts);
1118
1119 if (i == 0 || ts != nts) {
1120 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
1121 TimeSig* t = new TimeSig(score);
1122 t->setTrack(staffIdx * VOICES);
1123 t->setSig(nts);
1124 Segment* s = m->getSegment(SegmentType::TimeSig, tick);
1125 s->add(t);
1126 }
1127 }
1128
1129 score->measures()->add(m);
1130 tick += nts;
1131 ts = nts;
1132 }
1133
1134 previousTempo = temp;
1135 Measure* measure = score->firstMeasure();
1136 bool mixChange = false;
1137 for (int bar = 0; bar < measures; ++bar, measure = measure->nextMeasure()) {
1138 const GpBar& gpbar = bars[bar];
1139
1140 if (!gpbar.marker.isEmpty()) {
1141 RehearsalMark* s = new RehearsalMark(score);
1142 s->setPlainText(gpbar.marker.trimmed());
1143 s->setTrack(0);
1144 Segment* segment = measure->getSegment(SegmentType::ChordRest, measure->tick());
1145 segment->add(s);
1146 }
1147 std::vector<Tuplet*> tuplets(staves);
1148 //Tuplet* tuplets[staves];
1149 for (int staffIdx = 0; staffIdx < staves; ++staffIdx)
1150 tuplets[staffIdx] = 0;
1151
1152 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
1153 Fraction measureLen = {0,1};
1154 int track = staffIdx * VOICES;
1155 Fraction fraction = measure->tick();
1156 int beats = readInt();
1157 for (int beat = 0; beat < beats; ++beat) {
1158 // int pause = 0;
1159 uchar beatBits = readUChar();
1160 bool dotted = beatBits & BEAT_DOTTED;
1161 if (beatBits & BEAT_PAUSE)
1162 /*pause =*/ readUChar();
1163 int len = readChar();
1164 int tuple = 0;
1165 if (beatBits & BEAT_TUPLET)
1166 tuple = readInt();
1167 Segment* segment = measure->getSegment(SegmentType::ChordRest, fraction);
1168 if (beatBits & BEAT_CHORD) {
1169 int numStrings = score->staff(staffIdx)->part()->instrument()->stringData()->strings();
1170 int header = readUChar();
1171 QString name;
1172 if ((header & 1) == 0) {
1173 name = readDelphiString();
1174 readChord(segment, track, numStrings, name, false);
1175 }
1176 else {
1177 skip(25);
1178 name = readPascalString(34);
1179 readChord(segment, track, numStrings, name, true);
1180 skip(36);
1181 }
1182 }
1183 Lyrics* lyrics = 0;
1184 if (beatBits & BEAT_LYRICS) {
1185 lyrics = new Lyrics(score);
1186 lyrics->setPlainText(readDelphiString());
1187 }
1188 if (beatBits & BEAT_EFFECTS)
1189 readBeatEffects(track, segment);
1190
1191 if (beatBits & BEAT_MIX_CHANGE) {
1192 readMixChange(measure);
1193 mixChange = true;
1194 }
1195
1196 int strings = readUChar(); // used strings mask
1197
1198 Fraction l = len2fraction(len);
1199 ChordRest* cr;
1200 if (strings)
1201 cr = new Chord(score);
1202 else
1203 cr = new Rest(score);
1204 cr->setTrack(track);
1205 if (lyrics)
1206 cr->add(lyrics);
1207
1208 TDuration d(l);
1209 d.setDots(dotted ? 1 : 0);
1210
1211 if (dotted)
1212 l = l + (l * Fraction(1,2));
1213
1214 if (tuple) {
1215 Tuplet* tuplet = tuplets[staffIdx];
1216 if ((tuplet == 0) || (tuplet->elementsDuration() == tuplet->baseLen().fraction() * tuplet->ratio().numerator())) {
1217 tuplet = new Tuplet(score);
1218 tuplet->setTick(fraction);
1219 tuplet->setTrack(cr->track());
1220 tuplets[staffIdx] = tuplet;
1221 setTuplet(tuplet, tuple);
1222 tuplet->setParent(measure);
1223 }
1224 tuplet->setTrack(track);
1225 tuplet->setBaseLen(l);
1226 tuplet->setTicks(l * tuplet->ratio().denominator());
1227 cr->setTuplet(tuplet);
1228 tuplet->add(cr); //TODOxxx
1229 }
1230
1231 cr->setTicks(l);
1232 cr->setDurationType(d);
1233 segment->add(cr);
1234 Staff* staff = cr->staff();
1235 int numStrings = staff->part()->instrument()->stringData()->strings();
1236 for (int i = 6; i >= 0; --i) {
1237 if (strings & (1 << i) && ((6-i) < numStrings)) {
1238 Note* note = new Note(score);
1239 static_cast<Chord*>(cr)->add(note);
1240 readNote(6-i, note);
1241 note->setTpcFromPitch();
1242 }
1243 }
1244 restsForEmptyBeats(segment, measure, cr, l, track, fraction);
1245 fraction += cr->actualTicks();
1246 measureLen += cr->actualTicks();
1247 }
1248 if (measureLen < measure->ticks()) {
1249 score->setRest(fraction, track, measure->ticks() - measureLen, false, nullptr, false);
1250 }
1251 }
1252 if (bar == 1 && !mixChange)
1253 setTempo(temp, score->firstMeasure());
1254 }
1255
1256 return true;
1257 }
1258
1259 //---------------------------------------------------------
1260 // setTempo
1261 //---------------------------------------------------------
1262
setTempo(int temp,Measure * measure)1263 void GuitarPro::setTempo(int temp, Measure* measure)
1264 {
1265 if (!last_measure) {
1266 last_measure = measure;
1267 last_tempo = temp;
1268 }
1269 else if (last_measure == measure) {
1270 last_tempo = temp;
1271 }
1272 else {
1273 std::swap(last_tempo, temp);
1274 std::swap(last_measure, measure);
1275
1276 Segment* segment = measure->getSegment(SegmentType::ChordRest, measure->tick());
1277 for (Element* e : segment->annotations()) {
1278 if (e->isTempoText()) {
1279 qDebug("already there");
1280 return;
1281 }
1282 }
1283
1284 TempoText* tt = new TempoText(score);
1285 tt->setTempo(double(temp) / 60.0);
1286 tt->setXmlText(QString("<sym>metNoteQuarterUp</sym> = %1").arg(temp));
1287 tt->setTrack(0);
1288
1289 segment->add(tt);
1290 score->setTempo(measure->tick(), tt->tempo());
1291 previousTempo = temp;
1292 }
1293 }
1294
1295 //---------------------------------------------------------
1296 // readChord
1297 //---------------------------------------------------------
1298
readChord(Segment * seg,int track,int numStrings,QString name,bool gpHeader)1299 void GuitarPro::readChord(Segment* seg, int track, int numStrings, QString name, bool gpHeader)
1300 {
1301 int firstFret = readInt();
1302 if (firstFret || gpHeader) {
1303 FretDiagram* fret = new FretDiagram(score);
1304 fret->setTrack(track);
1305 fret->setStrings(numStrings);
1306 fret->setFretOffset(firstFret-1);
1307 for (int i = 0; i < (gpHeader ? 7 : 6); ++i) {
1308 int currentFret = readInt();
1309 // read the frets and add them to the fretboard
1310 // subtract 1 extra from numStrings as we count from 0
1311 if (i > numStrings - 1) {
1312 }
1313 else if (currentFret > 0) {
1314 fret->setDot(numStrings - 1 - i, currentFret - firstFret + 1, true);
1315 }
1316 else if (currentFret == 0) {
1317 fret->setDot(numStrings - 1 - i, 0, true);
1318 fret->setMarker(numStrings - 1 - i, FretMarkerType::CIRCLE);
1319 }
1320 else if (currentFret == -1) {
1321 fret->setDot(numStrings - 1 - i, 0, true);
1322 fret->setMarker(numStrings - 1 - i, FretMarkerType::CROSS);
1323 }
1324 }
1325 seg->add(fret);
1326 if (!name.isEmpty()) {
1327 Harmony* harmony = new Harmony(seg->score());
1328 harmony->setHarmony(name);
1329 harmony->setTrack(track);
1330 fret->add(harmony);
1331 }
1332 }
1333 else if (!name.isEmpty()) {
1334 Harmony* harmony = new Harmony(seg->score());
1335 harmony->setHarmony(name);
1336 harmony->setTrack(track);
1337 seg->add(harmony);
1338 }
1339 }
1340
1341 //---------------------------------------------------------
1342 // restsForEmptyBeats
1343 //---------------------------------------------------------
1344
restsForEmptyBeats(Segment * seg,Measure * measure,ChordRest * cr,Fraction & l,int track,const Fraction & tick)1345 void GuitarPro::restsForEmptyBeats(Segment* seg, Measure* measure, ChordRest* cr, Fraction& l, int track, const Fraction& tick)
1346 {
1347 /* this can happen as Guitar Pro versions 5 and below allows
1348 * users to create empty segments. Here, we create rests and
1349 * make them invisible so users get the same visual if they are
1350 * at a valid tick of the score. */
1351 if (seg->empty()) {
1352 if (tick < measure->first()->tick() + measure->ticks()) {
1353 cr = new Rest(score);
1354 cr->setTrack(track);
1355 TDuration d(l);
1356 cr->setDurationType(d);
1357 cr->setVisible(false);
1358 seg->add(cr);
1359 }
1360 else
1361 measure->remove(seg);
1362 }
1363 }
1364
1365 //---------------------------------------------------------
1366 // createSlur
1367 //---------------------------------------------------------
1368
createSlur(bool hasSlur,int staffIdx,ChordRest * cr)1369 void GuitarPro::createSlur(bool hasSlur, int staffIdx, ChordRest* cr)
1370 {
1371 if (hasSlur && (slurs[staffIdx] == 0)) {
1372 Slur* slur = new Slur(score);
1373 slur->setParent(0);
1374 slur->setTrack(cr->track());
1375 slur->setTrack2(cr->track());
1376 slur->setTick(cr->tick());
1377 slur->setTick2(cr->tick());
1378 slurs[staffIdx] = slur;
1379 score->addElement(slur);
1380 }
1381 else if (slurs[staffIdx] && !hasSlur) {
1382 Slur* s = slurs[staffIdx];
1383 slurs[staffIdx] = 0;
1384 s->setTick2(cr->tick());
1385 s->setTrack2(cr->track());
1386 }
1387 }
1388
1389 //---------------------------------------------------------
1390 // createOttava
1391 //---------------------------------------------------------
1392
createOttava(bool hasOttava,int track,ChordRest * cr,QString value)1393 void GuitarPro::createOttava(bool hasOttava, int track, ChordRest* cr, QString value)
1394 {
1395 if (hasOttava && (ottava.at(track) == 0)) {
1396 Ottava* newOttava = new Ottava(score);
1397 newOttava->setTrack(track);
1398 if (!value.compare("8va"))
1399 newOttava->setOttavaType(OttavaType::OTTAVA_8VA);
1400 else if (!value.compare("8vb"))
1401 newOttava->setOttavaType(OttavaType::OTTAVA_8VB);
1402 else if (!value.compare("15ma"))
1403 newOttava->setOttavaType(OttavaType::OTTAVA_15MA);
1404 else if (!value.compare("15mb"))
1405 newOttava->setOttavaType(OttavaType::OTTAVA_15MB);
1406 newOttava->setTick(cr->tick());
1407 /* we set the second tick when we encounter the next note
1408 without an ottava. We also allow the ottava to continue
1409 over rests, as that's what Guitar Pro does. */
1410 newOttava->setTick2(cr->tick());
1411 ottava.at(track) = newOttava;
1412 score->addElement(newOttava);
1413 }
1414 else if (ottava.at(track) && !hasOttava) {
1415 Ottava* currentOttava = ottava.at(track);
1416 ottava.at(track) = 0;
1417 currentOttava->setTick2(cr->tick());
1418 //ottava.at(track)->staff()->updateOttava(ottava.at(track));
1419 }
1420 }
1421
1422 //---------------------------------------------------------
1423 // read
1424 //---------------------------------------------------------
1425
read(QFile * fp)1426 bool GuitarPro2::read(QFile* fp)
1427 {
1428 f = fp;
1429 curPos = 30;
1430
1431 title = readDelphiString();
1432 subtitle = readDelphiString();
1433 artist = readDelphiString();
1434 album = readDelphiString();
1435 composer = readDelphiString();
1436 QString copyright = readDelphiString();
1437 if (!copyright.isEmpty())
1438 score->setMetaTag("copyright", QString("%1").arg(copyright));
1439
1440 transcriber = readDelphiString();
1441 instructions = readDelphiString();
1442 int n = readInt();
1443 for (int i = 0; i < n; ++i)
1444 comments.append(readDelphiString());
1445
1446 /*uchar num =*/ readUChar(); // Shuffle rhythm feel
1447
1448 int temp = readInt();
1449
1450 // int octave = 0;
1451 /*int key =*/ readInt(); // key
1452
1453 for (int i = 0; i < GP_MAX_TRACK_NUMBER * 2; ++i) {
1454 channelDefaults[i].patch = readInt();
1455 channelDefaults[i].volume = readUChar() * 8 - 1;
1456 channelDefaults[i].pan = readUChar() * 8 - 1;
1457 channelDefaults[i].chorus = readUChar() * 8 - 1;
1458 channelDefaults[i].reverb = readUChar() * 8 - 1;
1459 channelDefaults[i].phase = readUChar() * 8 - 1;
1460 channelDefaults[i].tremolo = readUChar() * 8 - 1;
1461 readUChar(); // padding
1462 readUChar();
1463 }
1464 measures = readInt();
1465 staves = readInt();
1466
1467 int tnumerator = 4;
1468 int tdenominator = 4;
1469 for (int i = 0; i < measures; ++i) {
1470 GpBar bar;
1471 uchar barBits = readUChar();
1472 if (barBits & SCORE_TIMESIG_NUMERATOR)
1473 tnumerator = readUChar();
1474 if (barBits & SCORE_TIMESIG_DENOMINATOR)
1475 tdenominator = readUChar();
1476 if (barBits & SCORE_REPEAT_START)
1477 bar.repeatFlags = bar.repeatFlags | Repeat::START;
1478 if (barBits & SCORE_REPEAT_END) {
1479 bar.repeatFlags = bar.repeatFlags | Repeat::END;
1480 bar.repeats = readUChar() + 1;
1481 }
1482 if (barBits & SCORE_VOLTA) {
1483 uchar voltaNumber = readUChar();
1484 while (voltaNumber > 0) {
1485 // volta information is represented as a binary number
1486 bar.volta.voltaType = GP_VOLTA_BINARY;
1487 bar.volta.voltaInfo.append(voltaNumber & 1);
1488 voltaNumber >>= 1;
1489 }
1490 }
1491 if (barBits & SCORE_MARKER) {
1492 bar.marker = readDelphiString(); // new section?
1493 /*int color =*/ readInt(); // color?
1494 }
1495 if (barBits & SCORE_KEYSIG) {
1496 bar.keysig = readUChar();
1497 /*uchar c =*/ readUChar(); // minor
1498 }
1499 if (barBits & SCORE_DOUBLE_BAR)
1500 bar.barLine = BarLineType::DOUBLE;
1501 bar.timesig = Fraction(tnumerator, tdenominator);
1502 bars.append(bar);
1503 }
1504
1505 //
1506 // create a part for every staff
1507 //
1508 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
1509 Part* part = new Part(score);
1510 Staff* s = new Staff(score);
1511 s->setPart(part);
1512 part->insertStaff(s, 0);
1513 score->staves().push_back(s);
1514 score->appendPart(part);
1515 }
1516
1517 Fraction ts;
1518 Fraction tick = {0, 1};
1519 for (int i = 0; i < measures; ++i) {
1520 Fraction nts = bars[i].timesig;
1521 Measure* m = new Measure(score);
1522 m->setTick(tick);
1523 m->setTimesig(nts);
1524 m->setTicks(nts);
1525
1526 if (i == 0 || ts != nts) {
1527 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
1528 TimeSig* t = new TimeSig(score);
1529 t->setTrack(staffIdx * VOICES);
1530 t->setSig(nts);
1531 Segment* s = m->getSegment(SegmentType::TimeSig, tick);
1532 s->add(t);
1533 }
1534 }
1535
1536 score->measures()->add(m);
1537 tick += nts;
1538 ts = nts;
1539 }
1540
1541 for (int i = 0; i < staves; ++i) {
1542 int tuning[GP_MAX_STRING_NUMBER];
1543
1544 uchar c = readUChar(); // simulations bitmask
1545 if (c & 0x2) { // 12 stringed guitar
1546 }
1547 if (c & 0x4) { // banjo track
1548 }
1549 QString name = readPascalString(40);
1550 int strings = readInt();
1551 if (strings <= 0 || strings > GP_MAX_STRING_NUMBER)
1552 return false;
1553 for (int j = 0; j < strings; ++j)
1554 tuning[j] = readInt();
1555 for (int j = strings; j < GP_MAX_STRING_NUMBER; ++j)
1556 readInt();
1557 /*int midiPort =*/ readInt(); // - 1;
1558 int midiChannel = readInt() - 1;
1559 /*int midiChannel2 =*/ readInt(); // - 1;
1560 int frets = readInt();
1561 int capo = readInt();
1562 /*int color =*/ readInt();
1563
1564 std::vector<int> tuning2(strings);
1565 //int tuning2[strings];
1566 for (int k = 0; k < strings; ++k)
1567 tuning2[strings-k-1] = tuning[k];
1568 StringData stringData(frets, strings, &tuning2[0]);
1569 Part* part = score->staff(i)->part();
1570 Instrument* instr = part->instrument();
1571 instr->setStringData(stringData);
1572 instr->setSingleNoteDynamics(false);
1573 part->setPartName(name);
1574 part->setPlainLongName(name);
1575 createTuningString(strings, &tuning2[0]);
1576
1577 //
1578 // determine clef
1579 //
1580 Staff* staff = score->staff(i);
1581 int patch = channelDefaults[midiChannel].patch;
1582 ClefType clefId = ClefType::G;
1583 if (midiChannel == GP_DEFAULT_PERCUSSION_CHANNEL) {
1584 clefId = ClefType::PERC;
1585 // instr->setUseDrumset(DrumsetKind::GUITAR_PRO);
1586 instr->setDrumset(gpDrumset);
1587 staff->setStaffType(Fraction(0,1), *StaffType::preset(StaffTypes::PERC_DEFAULT));
1588 }
1589 else
1590 clefId = defaultClef(patch);
1591 Measure* measure = score->firstMeasure();
1592 Clef* clef = new Clef(score);
1593 clef->setClefType(clefId);
1594 clef->setTrack(i * VOICES);
1595 Segment* segment = measure->getSegment(SegmentType::HeaderClef, Fraction(0,1));
1596 segment->add(clef);
1597
1598 if (capo > 0) {
1599 Segment* s = measure->getSegment(SegmentType::ChordRest, measure->tick());
1600 StaffText* st = new StaffText(score);
1601 // st->setTextStyleType(TextStyleType::STAFF);
1602 st->setPlainText(QString("Capo. fret ") + QString::number(capo));
1603 st->setTrack(i * VOICES);
1604 s->add(st);
1605 }
1606
1607 Channel* ch = instr->channel(0);
1608 if (midiChannel == int(StaffTypes::PERC_DEFAULT)) {
1609 ch->setProgram(0);
1610 ch->setBank(128);
1611 }
1612 else {
1613 ch->setProgram(patch);
1614 ch->setBank(0);
1615 }
1616 ch->setVolume(channelDefaults[midiChannel].volume);
1617 ch->setPan(channelDefaults[midiChannel].pan);
1618 ch->setChorus(channelDefaults[midiChannel].chorus);
1619 ch->setReverb(channelDefaults[midiChannel].reverb);
1620 // missing: phase, tremolo
1621 }
1622
1623 previousTempo = temp;
1624 Measure* measure = score->firstMeasure();
1625 bool mixChange = false;
1626 for (int bar = 0; bar < measures; ++bar, measure = measure->nextMeasure()) {
1627 const GpBar& gpbar = bars[bar];
1628
1629 if (!gpbar.marker.isEmpty()) {
1630 RehearsalMark* s = new RehearsalMark(score);
1631 s->setPlainText(gpbar.marker.trimmed());
1632 s->setTrack(0);
1633 Segment* segment = measure->getSegment(SegmentType::ChordRest, measure->tick());
1634 segment->add(s);
1635 }
1636
1637 std::vector<Tuplet*> tuplets(staves);
1638 // Tuplet* tuplets[staves];
1639 for (int staffIdx = 0; staffIdx < staves; ++staffIdx)
1640 tuplets[staffIdx] = 0;
1641
1642 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
1643 Fraction measureLen = {0,1};
1644 int track = staffIdx * VOICES;
1645 Fraction fraction = measure->tick();
1646 int beats = readInt();
1647 for (int beat = 0; beat < beats; ++beat) {
1648 // int pause = 0;
1649 uchar beatBits = readUChar();
1650 bool dotted = beatBits & BEAT_DOTTED;
1651 if (beatBits & BEAT_PAUSE)
1652 /*pause =*/ readUChar();
1653 int len = readChar();
1654 int tuple = 0;
1655 if (beatBits & BEAT_TUPLET)
1656 tuple = readInt();
1657 Segment* segment = measure->getSegment(SegmentType::ChordRest, fraction);
1658 if (beatBits & BEAT_CHORD) {
1659 int numStrings = score->staff(staffIdx)->part()->instrument()->stringData()->strings();
1660 int header = readUChar();
1661 QString name;
1662 if ((header & 1) == 0) {
1663 name = readDelphiString();
1664 readChord(segment, track, numStrings, name, false);
1665 }
1666 else {
1667 skip(25);
1668 name = readPascalString(34);
1669 readChord(segment, track, numStrings, name, true);
1670 skip(36);
1671 }
1672 }
1673 Lyrics* lyrics = 0;
1674 if (beatBits & BEAT_LYRICS) {
1675 QString txt = readDelphiString();
1676 lyrics = new Lyrics(score);
1677 lyrics->setPlainText(txt);
1678 }
1679 if (beatBits & BEAT_EFFECTS)
1680 readBeatEffects(track, segment);
1681
1682 if (beatBits & BEAT_MIX_CHANGE) {
1683 readMixChange(measure);
1684 mixChange = true;
1685 }
1686
1687 int strings = readUChar(); // used strings mask
1688
1689 Fraction l = len2fraction(len);
1690 ChordRest* cr;
1691 if (strings)
1692 cr = new Chord(score);
1693 else
1694 cr = new Rest(score);
1695 cr->setTrack(track);
1696 if (lyrics)
1697 cr->add(lyrics);
1698
1699 TDuration d(l);
1700 d.setDots(dotted ? 1 : 0);
1701
1702 if (dotted)
1703 l = l + (l * Fraction(1,2));
1704
1705 if (tuple) {
1706 Tuplet* tuplet = tuplets[staffIdx];
1707 if ((tuplet == 0) || (tuplet->elementsDuration() == tuplet->baseLen().fraction() * tuplet->ratio().numerator())) {
1708 tuplet = new Tuplet(score);
1709 tuplet->setTick(fraction);
1710 tuplet->setTrack(cr->track());
1711 tuplets[staffIdx] = tuplet;
1712 setTuplet(tuplet, tuple);
1713 tuplet->setParent(measure);
1714 }
1715 tuplet->setTrack(track);
1716 tuplet->setBaseLen(l);
1717 tuplet->setTicks(l * tuplet->ratio().denominator());
1718 cr->setTuplet(tuplet);
1719 tuplet->add(cr);
1720 }
1721
1722 cr->setTicks(l);
1723 cr->setDurationType(d);
1724 segment->add(cr);
1725 Staff* staff = cr->staff();
1726 int numStrings = staff->part()->instrument()->stringData()->strings();
1727 for (int i = 6; i >= 0; --i) {
1728 if (strings & (1 << i) && ((6-i) < numStrings)) {
1729 Note* note = new Note(score);
1730 static_cast<Chord*>(cr)->add(note);
1731 readNote(6-i, note);
1732 note->setTpcFromPitch();
1733 }
1734 }
1735 restsForEmptyBeats(segment, measure, cr, l, track, fraction);
1736 fraction += cr->actualTicks();
1737 measureLen += cr->actualTicks();
1738 }
1739 if (measureLen < measure->ticks()) {
1740 score->setRest(fraction, track, measure->ticks() - measureLen, false, nullptr, false);
1741 }
1742 }
1743 if (bar == 1 && !mixChange)
1744 setTempo(temp, score->firstMeasure());
1745 }
1746
1747 return true;
1748 }
1749
1750 //---------------------------------------------------------
1751 // readNote
1752 //---------------------------------------------------------
1753
readNote(int string,Note * note)1754 bool GuitarPro1::readNote(int string, Note* note)
1755 {
1756 bool slur = false;
1757 uchar noteBits = readUChar();
1758 if (noteBits & NOTE_GHOST) {
1759 if (version == 300)
1760 note->setGhost(true);
1761 else {
1762 note->setHeadGroup(NoteHead::Group::HEAD_CROSS);
1763 note->setGhost(true);
1764 }
1765 }
1766
1767 bool tieNote = false;
1768 uchar variant = 1;
1769 if (noteBits & NOTE_DEAD) {
1770 variant = readUChar();
1771 if (variant == 1) { // normal note
1772 }
1773 else if (variant == 2) {
1774 tieNote = true;
1775 }
1776 else if (variant == 3) { // dead notes
1777 note->setHeadGroup(NoteHead::Group::HEAD_CROSS);
1778 note->setGhost(true);
1779 }
1780 else
1781 qDebug("unknown note variant: %d", variant);
1782 }
1783
1784 //
1785 // noteBits:
1786 // 7 - Right hand or left hand fingering;
1787 // 6 - Accentuated note
1788 // 5 - Note type (rest, empty note, normal note);
1789 // 4 - note dynamic;
1790 // 3 - Presence of effects linked to the note;
1791 // 2 - Ghost note;
1792 // 1 - Dotted note; ?
1793 // 0 - Time-independent duration
1794
1795 if (noteBits & 0x1) { // note != beat
1796 int a = readUChar(); // length
1797 int b = readUChar(); // t
1798 qDebug("Time independent note len, len %d t %d", a, b);
1799 }
1800 if (noteBits & 0x2) { // note is dotted
1801 //readUChar();
1802 }
1803
1804 // set dynamic information on note if different from previous note
1805 if (noteBits & NOTE_DYNAMIC) {
1806 int d = readChar();
1807 if (previousDynamic != d) {
1808 previousDynamic = d;
1809 addDynamic(note, d);
1810 }
1811 }
1812
1813 int fretNumber = -1;
1814 if (noteBits & NOTE_FRET)
1815 fretNumber = readUChar();
1816
1817 if (noteBits & NOTE_FINGERING) { // fingering
1818 int a = readUChar();
1819 int b = readUChar();
1820 qDebug("Fingering=========%d %d", a, b);
1821 }
1822 if (noteBits & BEAT_EFFECTS) {
1823 uchar modMask1 = readUChar();
1824 uchar modMask2 = 0;
1825 if (version >= 400)
1826 modMask2 = readUChar();
1827 if (modMask1 & EFFECT_BEND)
1828 readBend(note);
1829 if (modMask1 & EFFECT_GRACE) {
1830 // GP3 grace note
1831 int fret = readUChar(); // grace fret
1832 int dynamic = readUChar(); // grace dynamic
1833 int transition = readUChar(); // grace transition
1834 int duration = readUChar(); // grace duration
1835
1836 int grace_len = MScore::division/8;
1837 if (duration == 1)
1838 grace_len = MScore::division/8; //32th
1839 else if (duration == 2)
1840 grace_len = MScore::division/6; //24th
1841 else if (duration == 3)
1842 grace_len = MScore::division/4; //16th
1843 Note* gn = new Note(score);
1844
1845 if (fret == 255) {
1846 gn->setHeadGroup(NoteHead::Group::HEAD_CROSS);
1847 gn->setGhost(true);
1848 }
1849 if (fret == 255)
1850 fret = 0;
1851 gn->setFret(fret);
1852 gn->setString(string);
1853 int grace_pitch = note->staff()->part()->instrument()->stringData()->getPitch(string, fret, nullptr, Fraction(0,1));
1854 gn->setPitch(grace_pitch);
1855 gn->setTpcFromPitch();
1856
1857 Chord* gc = nullptr;
1858 if (note->chord()->graceNotes().size())
1859 {
1860 gc = note->chord()->graceNotes().first();
1861 }
1862 if (!gc)
1863 {
1864 gc = new Chord(score);
1865 TDuration d;
1866 d.setVal(grace_len);
1867 if (grace_len == MScore::division / 6)
1868 d.setDots(1);
1869 gc->setDurationType(d);
1870 gc->setTicks(d.fraction());
1871 gc->setNoteType(NoteType::ACCIACCATURA);
1872 gc->setMag(note->chord()->staff()->mag(Fraction(0,1)) * score->styleD(Sid::graceNoteMag));
1873 note->chord()->add(gc); // sets parent + track
1874 addDynamic(gn, dynamic);
1875 }
1876
1877 gc->add(gn);
1878
1879 if (transition == 0) {
1880 // no transition
1881 }
1882 else if(transition == 1){
1883 //note->setSlideNote(gn);
1884 Glissando* glis = new Glissando(score);
1885 glis->setGlissandoType(GlissandoType::STRAIGHT);
1886 gn->chord()->add(glis);
1887 glis->setAnchor(Spanner::Anchor::NOTE);
1888 glis->setStartElement(gn);
1889 glis->setTick(gn->chord()->tick());
1890 glis->setTrack(gn->track());
1891 glis->setParent(gn);
1892 glis->setEndElement(note);
1893 glis->setTick2(note->chord()->tick());
1894 glis->setTrack2(note->track());
1895 score->addElement(glis);
1896 //HammerOn here??? Maybe version...
1897
1898 Slur* slur1 = new Slur(score);
1899 slur1->setStartElement(gc);
1900 slur1->setEndElement(note->chord());
1901 slur1->setTick(gc->tick());
1902 slur1->setTick2(note->chord()->tick());
1903 slur1->setTrack(gc->track());
1904 slur1->setTrack2(note->track());
1905 score->addElement(slur1);
1906
1907 //TODO: Add a 'slide' guitar effect when implemented
1908 }
1909 else if (transition == 2 && fretNumber>=0 && fretNumber<=255 && fretNumber!=gn->fret()) {
1910 /*QList<PitchValue> points;
1911 points.append(PitchValue(0,0, false));
1912 points.append(PitchValue(60,(fretNumber-gn->fret())*100, false));
1913
1914 Bend* b = new Bend(note->score());
1915 b->setPoints(points);
1916 b->setTrack(gn->track());
1917 gn->add(b);*/
1918 }
1919 else if (transition == 3) {
1920 // TODO:
1921 // major: replace with a 'hammer-on' guitar effect when implemented
1922 // minor: make slurs for parts
1923
1924 ChordRest* cr1 = static_cast<Chord*>(gc);
1925 ChordRest* cr2 = static_cast<Chord*>(note->chord());
1926
1927 Slur* slur1 = new Slur(score);
1928 slur1->setStartElement(cr1);
1929 slur1->setEndElement(cr2);
1930 slur1->setTick(cr1->tick());
1931 slur1->setTick2(cr2->tick());
1932 slur1->setTrack(cr1->track());
1933 slur1->setTrack2(cr2->track());
1934 score->addElement(slur1);
1935 }
1936 }
1937 if (modMask1 & EFFECT_HAMMER) // hammer on / pull off
1938 slur = true;
1939 if (modMask1 & EFFECT_LET_RING) // let ring
1940 addLetRing(note);
1941 if (modMask1 & EFFECT_SLIDE_OLD)
1942 slideList.push_back(note);
1943
1944 if (version >= 400) {
1945 if (modMask2 & EFFECT_STACATTO) {
1946 }
1947 if (modMask2 & EFFECT_PALM_MUTE) {
1948 //note->setPalmMute(true);
1949 addPalmMute(note);
1950 }
1951 if (modMask2 & EFFECT_TREMOLO) {
1952 readUChar();
1953 }
1954 if (modMask2 & EFFECT_ARTIFICIAL_HARMONIC) {
1955 /*int type =*/ readUChar();
1956 //TODO-ws if (type == 1 || type == 4 || type == 5)
1957 // note->setHarmonic(true);
1958 }
1959 if (modMask2 & EFFECT_TRILL) {
1960 //TODO-ws note->setTrillFret(readUChar()); // trill fret
1961 readUChar(); // trill length
1962 }
1963 }
1964 }
1965 if (fretNumber == -1) {
1966 qDebug("Note: no fret number, tie %d", tieNote);
1967 }
1968 Staff* staff = note->staff();
1969 if (fretNumber == 255) {
1970 fretNumber = 0;
1971 note->setHeadGroup(NoteHead::Group::HEAD_CROSS);
1972 note->setGhost(true);
1973 }
1974 // dead note represented as high numbers - fix to zero
1975 if (fretNumber > 99 || fretNumber == -1)
1976 fretNumber = 0;
1977 int pitch = staff->part()->instrument()->stringData()->getPitch(string, fretNumber, nullptr, Fraction(0,1));
1978
1979 /* it's possible to specify extraordinarily high pitches by
1980 specifying fret numbers that don't exist. This is an issue that
1981 comes from tuxguitar. Just set to maximum pitch. GP6 actually
1982 sets the fret number to 0 also, so that's what I've opted to do
1983 here. */
1984 if (pitch > MAX_PITCH) {
1985 fretNumber = 0;
1986 pitch = MAX_PITCH;
1987 }
1988
1989 note->setFret(fretNumber);
1990 note->setString(string);
1991 note->setPitch(pitch);
1992
1993 if (tieNote) {
1994 bool found = false;
1995 Chord* chord = note->chord();
1996 Segment* segment = chord->segment()->prev1(SegmentType::ChordRest);
1997 int track = note->track();
1998 std::vector<Chord*> chords;
1999 Note* true_note = nullptr;
2000 while (segment) {
2001 Element* e = segment->element(track);
2002 if (e) {
2003 if (e->isChord()) {
2004 Chord* chord2 = toChord(e);
2005 foreach (Note* note2, chord2->notes()) {
2006 if (note2->string() == string) {
2007 if (chords.empty()) {
2008 Tie* tie = new Tie(score);
2009 tie->setEndNote(note);
2010 note2->add(tie);
2011 }
2012 note->setFret(note2->fret());
2013 note->setPitch(note2->pitch());
2014 found = true;
2015 true_note = note2;
2016 break;
2017 }
2018 }
2019 if (!found)
2020 chords.push_back(chord2);
2021 }
2022 if (found)
2023 break;
2024 }
2025 segment = segment->prev1(SegmentType::ChordRest);
2026 }
2027
2028 if (chords.size() && true_note) {
2029 Note* end_note = note;
2030 for (unsigned int i = 0; i < chords.size(); ++i) {
2031 Note* note2 = new Note(score);
2032 note2->setString(true_note->string());
2033 note2->setFret(true_note->fret());
2034 note2->setPitch(true_note->pitch());
2035 note2->setTpcFromPitch();
2036 chords[i]->add(note2);
2037 Tie* tie = new Tie(score);
2038 tie->setEndNote(end_note);
2039 end_note = note2;
2040 note2->add(tie);
2041 }
2042 Tie* tie = new Tie(score);
2043 tie->setEndNote(end_note);
2044 true_note->add(tie);
2045 }
2046 }
2047 return slur;
2048 }
2049
2050 //---------------------------------------------------------
2051 // readBeatEffects
2052 //---------------------------------------------------------
2053
readBeatEffects(int,Segment *)2054 int GuitarPro1::readBeatEffects(int, Segment*)
2055 {
2056 uchar fxBits1 = readUChar();
2057 if (fxBits1 & BEAT_EFFECT) {
2058 uchar num = readUChar();
2059 switch(num) {
2060 case 0: // tremolo bar
2061 readInt();
2062 break;
2063 default:
2064 readInt();
2065 break;
2066 }
2067 }
2068 if (fxBits1 & BEAT_ARPEGGIO) {
2069 readUChar(); // down stroke length
2070 readUChar(); // up stroke length
2071 }
2072 return 0;
2073 }
2074
2075 //---------------------------------------------------------
2076 // read
2077 //---------------------------------------------------------
2078
read(QFile * fp)2079 bool GuitarPro3::read(QFile* fp)
2080 {
2081 f = fp;
2082 curPos = 30;
2083
2084 title = readDelphiString();
2085 subtitle = readDelphiString();
2086 artist = readDelphiString();
2087 album = readDelphiString();
2088 composer = readDelphiString();
2089 QString copyright = readDelphiString();
2090 if (!copyright.isEmpty())
2091 score->setMetaTag("copyright", QString("%1").arg(copyright));
2092
2093 transcriber = readDelphiString();
2094 instructions = readDelphiString();
2095 for (int i = 0, n = readInt(); i < n; ++i)
2096 comments.append(readDelphiString());
2097
2098 /*uchar num =*/ readUChar(); // Shuffle rhythm feel
2099
2100 int temp = readInt();
2101
2102 // int octave = 0;
2103 key = readInt(); // key
2104
2105 for (int i = 0; i < GP_MAX_TRACK_NUMBER * 2; ++i) {
2106 channelDefaults[i].patch = readInt();
2107 channelDefaults[i].volume = readUChar() * 8 - 1;
2108 channelDefaults[i].pan = readUChar() * 8 - 1;
2109 channelDefaults[i].chorus = readUChar() * 8 - 1;
2110 channelDefaults[i].reverb = readUChar() * 8 - 1;
2111 channelDefaults[i].phase = readUChar() * 8 - 1;
2112 channelDefaults[i].tremolo = readUChar() * 8 - 1;
2113 readUChar(); // padding
2114 readUChar();
2115 }
2116 measures = readInt();
2117 staves = readInt();
2118
2119 slurs = new Slur*[staves];
2120 for (int i = 0; i < staves; ++i)
2121 slurs[i] = nullptr;
2122
2123 //previousDynamic = new int [staves * VOICES];
2124 // initialise the dynamics to 0
2125 //for (int i = 0; i < staves * VOICES; i++)
2126 // previousDynamic[i] = 0;
2127 previousDynamic = -1;
2128
2129 int tnumerator = 4;
2130 int tdenominator = 4;
2131 for (int i = 0; i < measures; ++i) {
2132 GpBar bar;
2133 uchar barBits = readUChar();
2134 if (barBits & SCORE_TIMESIG_NUMERATOR)
2135 tnumerator = readUChar();
2136 if (barBits & SCORE_TIMESIG_DENOMINATOR)
2137 tdenominator = readUChar();
2138 if (barBits & SCORE_REPEAT_START)
2139 bar.repeatFlags = bar.repeatFlags | Repeat::START;
2140 if (barBits & SCORE_REPEAT_END) { // number of repeats
2141 bar.repeatFlags = bar.repeatFlags | Repeat::END;
2142 bar.repeats = readUChar() + 1;
2143 }
2144 if (barBits & SCORE_VOLTA) { // a volta
2145 uchar voltaNumber = readUChar();
2146 // voltas are represented as a binary number
2147 bar.volta.voltaType = GP_VOLTA_BINARY;
2148 while (voltaNumber > 0) {
2149 bar.volta.voltaInfo.append(voltaNumber & 1);
2150 voltaNumber >>= 1;
2151 }
2152 }
2153 if (barBits & SCORE_MARKER) {
2154 bar.marker = readDelphiString(); // new section?
2155 /*int color =*/ readInt(); // color?
2156 }
2157 if (barBits & SCORE_KEYSIG) {
2158 int currentKey = readUChar();
2159 /* key signatures are specified as
2160 * 1# = 1, 2# = 2, ..., 7# = 7
2161 * 1b = 255, 2b = 254, ... 7b = 249 */
2162 bar.keysig = currentKey <= 7 ? currentKey : -256+currentKey;
2163 readUChar(); // specifies major/minor mode
2164 }
2165
2166 if (barBits & SCORE_DOUBLE_BAR)
2167 bar.barLine = BarLineType::DOUBLE;
2168 bar.timesig = Fraction(tnumerator, tdenominator);
2169 bars.append(bar);
2170 }
2171
2172 //
2173 // create a part for every staff
2174 //
2175 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
2176 Part* part = new Part(score);
2177 Staff* s = new Staff(score);
2178 s->setPart(part);
2179 part->insertStaff(s, 0);
2180 score->staves().push_back(s);
2181 score->appendPart(part);
2182 }
2183
2184 Fraction ts;
2185 Fraction tick = {0,1};
2186 for (int i = 0; i < measures; ++i) {
2187 Fraction nts = bars[i].timesig;
2188 Measure* m = new Measure(score);
2189 m->setTick(tick);
2190 m->setTimesig(nts);
2191 m->setTicks(nts);
2192
2193 if (i == 0 || ts != nts) {
2194 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
2195 TimeSig* t = new TimeSig(score);
2196 t->setTrack(staffIdx * VOICES);
2197 t->setSig(nts);
2198 Segment* s = m->getSegment(SegmentType::TimeSig, tick);
2199 s->add(t);
2200 }
2201 }
2202 if (i == 0 && key) {
2203 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
2204 KeySig* t = new KeySig(score);
2205 t->setKey(Key(key));
2206 t->setTrack(staffIdx * VOICES);
2207 Segment* s = m->getSegment(SegmentType::KeySig, tick);
2208 s->add(t);
2209 }
2210 }
2211
2212 readVolta(&bars[i].volta, m);
2213 m->setRepeatEnd(bars[i].repeatFlags == Repeat::END);
2214 m->setRepeatStart(bars[i].repeatFlags == Repeat::START);
2215 m->setRepeatJump(bars[i].repeatFlags == Repeat::JUMP);
2216 // m->setRepeatFlags(bars[i].repeatFlags);
2217 m->setRepeatCount(bars[i].repeats);
2218
2219 // reset the volta sequence if we have an opening repeat
2220 if (bars[i].repeatFlags == Repeat::START)
2221 voltaSequence = 1;
2222 // otherwise, if we see an end repeat symbol, only reset if the bar after it does not contain a volta
2223 else if (bars[i].repeatFlags == Repeat::END && i < bars.length() - 1) {
2224 if (bars[i+1].volta.voltaInfo.length() == 0) {
2225 voltaSequence = 1;
2226 }
2227 }
2228
2229 score->measures()->add(m);
2230 tick += nts;
2231 ts = nts;
2232 }
2233
2234 for (int i = 0; i < staves; ++i) {
2235 int tuning[GP_MAX_STRING_NUMBER];
2236
2237 uchar c = readUChar(); // simulations bitmask
2238 if (c & 0x2) { // 12 stringed guitar
2239 }
2240 if (c & 0x4) { // banjo track
2241 }
2242 QString name = readPascalString(40);
2243 int strings = readInt();
2244 if (strings <= 0 || strings > GP_MAX_STRING_NUMBER)
2245 return false;
2246 for (int j = 0; j < strings; ++j)
2247 tuning[j] = readInt();
2248 for (int j = strings; j < GP_MAX_STRING_NUMBER; ++j)
2249 readInt();
2250 /*int midiPort =*/ readInt(); // - 1;
2251 int midiChannel = readInt() - 1;
2252 /*int midiChannel2 =*/ readInt(); // - 1;
2253 int frets = readInt();
2254 int capo = readInt();
2255 /*int color =*/ readInt();
2256
2257 std::vector<int> tuning2(strings);
2258 //int tuning2[strings];
2259 for (int k = 0; k < strings; ++k)
2260 tuning2[strings-k-1] = tuning[k];
2261 StringData stringData(frets, strings, &tuning2[0]);
2262 Part* part = score->staff(i)->part();
2263 Instrument* instr = part->instrument();
2264 instr->setStringData(stringData);
2265 instr->setSingleNoteDynamics(false);
2266 part->setPartName(name);
2267 part->setPlainLongName(name);
2268 createTuningString(strings, &tuning2[0]);
2269 //
2270 // determine clef
2271 //
2272 Staff* staff = score->staff(i);
2273 int patch = channelDefaults[midiChannel].patch;
2274 ClefType clefId = ClefType::G;
2275 if (midiChannel == GP_DEFAULT_PERCUSSION_CHANNEL) {
2276 clefId = ClefType::PERC;
2277 // instr->setUseDrumset(DrumsetKind::GUITAR_PRO);
2278 instr->setDrumset(gpDrumset);
2279 staff->setStaffType(Fraction(0,1), *StaffType::preset(StaffTypes::PERC_DEFAULT));
2280 }
2281 else
2282 clefId = defaultClef(patch);
2283 Measure* measure = score->firstMeasure();
2284 Clef* clef = new Clef(score);
2285 clef->setClefType(clefId);
2286 clef->setTrack(i * VOICES);
2287 Segment* segment = measure->getSegment(SegmentType::HeaderClef, Fraction(0,1));
2288 segment->add(clef);
2289
2290 if (capo > 0) {
2291 Segment* s = measure->getSegment(SegmentType::ChordRest, measure->tick());
2292 StaffText* st = new StaffText(score);
2293 // st->setTextStyleType(TextStyleType::STAFF);
2294 st->setPlainText(QString("Capo. fret ") + QString::number(capo));
2295 st->setTrack(i * VOICES);
2296 s->add(st);
2297 }
2298
2299 Channel* ch = instr->channel(0);
2300 if (midiChannel == GP_DEFAULT_PERCUSSION_CHANNEL) {
2301 ch->setProgram(0);
2302 ch->setBank(128);
2303 }
2304 else {
2305 ch->setProgram(patch);
2306 ch->setBank(0);
2307 }
2308 ch->setVolume(channelDefaults[midiChannel].volume);
2309 ch->setPan(channelDefaults[midiChannel].pan);
2310 ch->setChorus(channelDefaults[midiChannel].chorus);
2311 ch->setReverb(channelDefaults[midiChannel].reverb);
2312 // missing: phase, tremolo
2313 }
2314
2315 previousTempo = temp;
2316 Measure* measure = score->firstMeasure();
2317 bool mixChange = false;
2318 for (int bar = 0; bar < measures; ++bar, measure = measure->nextMeasure()) {
2319 const GpBar& gpbar = bars[bar];
2320
2321 if (!gpbar.marker.isEmpty()) {
2322 RehearsalMark* s = new RehearsalMark(score);
2323 s->setPlainText(gpbar.marker.trimmed());
2324 s->setTrack(0);
2325 Segment* segment = measure->getSegment(SegmentType::ChordRest, measure->tick());
2326 segment->add(s);
2327 }
2328
2329 std::vector<Tuplet*> tuplets(staves);
2330 //Tuplet* tuplets[staves];
2331 for (int staffIdx = 0; staffIdx < staves; ++staffIdx)
2332 tuplets[staffIdx] = 0;
2333
2334 for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
2335 Fraction measureLen = {0,1};
2336 int track = staffIdx * VOICES;
2337 Fraction fraction = measure->tick();
2338 int beats = readInt();
2339 if (beats > 200)
2340 return false;
2341 for (int beat = 0; beat < beats; ++beat) {
2342 // int pause = 0;
2343 uchar beatBits = readUChar();
2344 bool dotted = beatBits & BEAT_DOTTED;
2345 if (beatBits & BEAT_PAUSE)
2346 /*pause =*/ readUChar();
2347
2348 slide = -1;
2349 if (slides.contains(track))
2350 slide = slides.take(track);
2351
2352 int len = readChar();
2353 int tuple = 0;
2354 if (beatBits & BEAT_TUPLET)
2355 tuple = readInt();
2356
2357 Segment* segment = measure->getSegment(SegmentType::ChordRest, fraction);
2358 if (beatBits & BEAT_CHORD) {
2359 int numStrings = score->staff(staffIdx)->part()->instrument()->stringData()->strings();
2360 int header = readUChar();
2361 QString name;
2362 if ((header & 1) == 0) {
2363 name = readDelphiString();
2364 readChord(segment, track, numStrings, name, false);
2365 }
2366 else {
2367 skip(25);
2368 name = readPascalString(34);
2369 readChord(segment, track, numStrings, name, false);
2370 skip(36);
2371 }
2372 }
2373 Lyrics* lyrics = 0;
2374 if (beatBits & BEAT_LYRICS) {
2375 QString txt = readDelphiString();
2376 lyrics = new Lyrics(score);
2377 lyrics->setPlainText(txt);
2378 }
2379 int beatEffects = 0;
2380
2381 if (beatBits & BEAT_EFFECTS) {
2382 beatEffects = readBeatEffects(track, segment);
2383 }
2384 bool vibrato = beatEffects & 0x1 || beatEffects & 0x2;
2385
2386 if (beatBits & BEAT_MIX_CHANGE) {
2387 readMixChange(measure);
2388 mixChange = true;
2389 }
2390
2391 int strings = readUChar(); // used strings mask
2392
2393 Fraction l = len2fraction(len);
2394
2395 // Some beat effects could add a Chord before this
2396 ChordRest* cr = segment->cr(track);
2397 // if (!pause || strings)
2398 if (strings) {
2399 if(!segment->cr(track))
2400 cr = new Chord(score);
2401 }
2402 else
2403 {
2404 if(segment->cr(track)){
2405 segment->remove(segment->cr(track));
2406 delete cr;
2407 cr = 0;
2408 }
2409 cr = new Rest(score);
2410 }
2411
2412 cr->setTrack(track);
2413 if (lyrics)
2414 cr->add(lyrics);
2415
2416 TDuration d(l);
2417 d.setDots(dotted ? 1 : 0);
2418
2419 if (dotted)
2420 l = l + (l * Fraction(1,2));
2421
2422 if (tuple) {
2423 Tuplet* tuplet = tuplets[staffIdx];
2424 if ((tuplet == 0) || (tuplet->elementsDuration() == tuplet->baseLen().fraction() * tuplet->ratio().numerator())) {
2425 tuplet = new Tuplet(score);
2426 tuplet->setTick(fraction);
2427 tuplet->setTrack(cr->track());
2428 tuplets[staffIdx] = tuplet;
2429 setTuplet(tuplet, tuple);
2430 tuplet->setParent(measure);
2431 }
2432 tuplet->setTrack(track);
2433 tuplet->setBaseLen(l);
2434 tuplet->setTicks(l * tuplet->ratio().denominator());
2435 cr->setTuplet(tuplet);
2436 tuplet->add(cr);
2437 }
2438
2439 cr->setTicks(l);
2440
2441 if (cr->type() == ElementType::REST && l >= measure->ticks()) {
2442 cr->setDurationType(TDuration::DurationType::V_MEASURE);
2443 cr->setTicks(measure->ticks());
2444 }
2445 else
2446 cr->setDurationType(d);
2447
2448 if(!segment->cr(track))
2449 segment->add(cr);
2450
2451 Staff* staff = cr->staff();
2452 int numStrings = staff->part()->instrument()->stringData()->strings();
2453 bool hasSlur = false;
2454 for (int i = 6; i >= 0; --i) {
2455 if (strings & (1 << i) && ((6-i) < numStrings)) {
2456 Note* note = new Note(score);
2457 toChord(cr)->add(note);
2458 if (vibrato)
2459 addVibrato(note);
2460 if (dotted) {
2461 NoteDot* dot = new NoteDot(score);
2462 // there is at most one dotted note in this guitar pro version - set 0 index
2463 dot->setParent(note);
2464 dot->setTrack(track); // needed to know the staff it belongs to (and detect tablature)
2465 dot->setVisible(true);
2466 note->add(dot);
2467 }
2468 hasSlur = (readNote(6-i, note) || hasSlur);
2469 note->setTpcFromPitch();
2470 }
2471 }
2472 if (cr && cr->type() == ElementType::CHORD && static_cast<Chord*>(cr)->notes().empty()) {
2473 if (segment->cr(track))
2474 segment->remove(cr);
2475 delete cr;
2476 cr = new Rest(score);
2477 cr->setTicks(l);
2478 cr->setTrack(track);
2479 cr->setDurationType(d);
2480 segment->add(cr);
2481 }
2482 createSlur(hasSlur, staffIdx, cr);
2483 if (cr && (cr->isChord())) {
2484 if (beatEffects >= 200) {
2485 beatEffects -= 200;
2486 Articulation* art = new Articulation(score);
2487 art->setSymId(SymId::guitarFadeOut);
2488 art->setAnchor(ArticulationAnchor::TOP_STAFF);
2489 art->setPropertyFlags(Pid::ARTICULATION_ANCHOR, PropertyFlags::UNSTYLED);
2490 if (!score->addArticulation(cr, art)) {
2491 delete art;
2492 }
2493 }
2494
2495 applyBeatEffects(static_cast<Chord*>(cr), beatEffects);
2496 if (slide > 0)
2497 createSlide(slide, cr, staffIdx);
2498 }
2499
2500 restsForEmptyBeats(segment, measure, cr, l, track, fraction);
2501 fraction += cr->actualTicks();
2502 measureLen += cr->actualTicks();
2503 }
2504 if (measureLen < measure->ticks()) {
2505 score->setRest(fraction, track, measure->ticks() - measureLen, false, nullptr, false);
2506 }
2507 bool removeRests = true;
2508 int counter = 0;
2509 Rest* lastRest = nullptr;
2510 for (auto seg = measure->first(); seg; seg = seg->next())
2511 {
2512 if (seg->segmentType() == SegmentType::ChordRest)
2513 {
2514 auto cr = seg->cr(track);
2515 if (cr && cr->type() == ElementType::CHORD)
2516 {
2517 removeRests = false;
2518 break;
2519 }
2520 else if (cr) {
2521 ++counter;
2522 lastRest = static_cast<Rest*>(cr);
2523 }
2524 }
2525 }
2526 if (removeRests && counter < 2) {
2527 removeRests = false;
2528 if (counter == 1)
2529 {
2530 lastRest->setTicks(measure->timesig());
2531 lastRest->setDurationType(TDuration::DurationType::V_MEASURE);
2532 }
2533 }
2534 if (removeRests)
2535 {
2536 auto seg = measure->first();
2537 while (seg && seg != measure->last())
2538 {
2539 if (seg->segmentType() == SegmentType::ChordRest)
2540 {
2541 auto cr = seg->cr(track);
2542 if (cr) {
2543 seg->remove(cr);
2544 delete cr;
2545 }
2546 }
2547 seg = seg->next();
2548 }
2549 auto cr = new Rest(score);
2550 cr->setTicks(measure->timesig());
2551 cr->setDurationType(TDuration::DurationType::V_MEASURE);
2552 cr->setTrack(track);
2553 seg->add(cr);
2554 }
2555 }
2556 if (bar == 1 && !mixChange)
2557 setTempo(temp, score->firstMeasure());
2558 }
2559 for (auto n : slideList) {
2560 auto segment = n->chord()->segment();
2561 auto measure1 = segment->measure();
2562 while ((segment = segment->next1(SegmentType::ChordRest)) || ((measure1 = measure1->nextMeasure()) && (segment = measure1->first()))) {
2563 // bool br = false;
2564 auto crest = segment->cr(n->track());
2565 if (!crest)
2566 continue;
2567 if (crest->type() == Ms::ElementType::REST)
2568 break;
2569 auto cr = static_cast<Chord*>(crest);
2570 if (!cr)
2571 continue;
2572 if (cr->graceNotes().size())
2573 cr = cr->graceNotes().first();
2574 if (cr) {
2575 for (auto nt : cr->notes()) {
2576 if (nt->string() == n->string()) {
2577 // auto mg = nt->magS();
2578 Glissando* s = new Glissando(score);
2579 s->setAnchor(Spanner::Anchor::NOTE);
2580 s->setStartElement(n);
2581 s->setTick(n->chord()->segment()->tick());
2582 s->setTrack(n->track());
2583 s->setParent(n);
2584 s->setGlissandoType(GlissandoType::STRAIGHT);
2585 s->setEndElement(nt);
2586 s->setTick2(cr->segment()->tick());
2587 s->setTrack2(n->track());
2588 score->addElement(s);
2589 break;
2590 }
2591 }
2592 }
2593 break;
2594 }
2595 }
2596 return true;
2597 }
2598
2599 //---------------------------------------------------------
2600 // readBeatEffects
2601 //---------------------------------------------------------
2602
readBeatEffects(int track,Segment * segment)2603 int GuitarPro3::readBeatEffects(int track, Segment* segment)
2604 {
2605 int effects = 0;
2606 uchar fxBits = readUChar();
2607
2608 if (fxBits & BEAT_EFFECT) {
2609 effects = readUChar(); // effect 1-tapping, 2-slapping, 3-popping
2610 readInt(); // we don't need this integer
2611 }
2612
2613 if (fxBits & BEAT_ARPEGGIO) {
2614 int strokeup = readUChar(); // up stroke length
2615 int strokedown = readUChar(); // down stroke length
2616
2617 Arpeggio* a = new Arpeggio(score);
2618 if ( strokeup > 0 ) {
2619 a->setArpeggioType(ArpeggioType::UP_STRAIGHT);
2620 }
2621 else if( strokedown > 0 ) {
2622 a->setArpeggioType(ArpeggioType::DOWN_STRAIGHT);
2623 }
2624 else {
2625 delete a;
2626 a = 0;
2627 }
2628
2629 if(a) {
2630 ChordRest* cr = new Chord(score);
2631 cr->setTrack(track);
2632 cr->add(a);
2633 segment->add(cr);
2634 }
2635 }
2636 if (fxBits & BEAT_TREMOLO) {
2637 }
2638 if (fxBits & BEAT_FADE) {
2639 #if 0
2640 Articulation* art = new Articulation(score);
2641 // art->setArticulationType(ArticulationType::FadeOut);
2642 art->setSym(SymId::guitarFadeOut);
2643 art->setAnchor(ArticulationAnchor::TOP_STAFF);
2644 art->setPropertyFlags(Pid::ARTICULATION_ANCHOR, PropertyFlags::UNSTYLED);
2645 if (!score->addArticulation(segment->cr(track), art)) {
2646 delete art;
2647 }
2648 #endif
2649 effects += 200;
2650 }
2651 if (fxBits & BEAT_DOTTED) {
2652 }
2653 if (fxBits & BEAT_CHORD) {
2654 }
2655 if (effects == 0)
2656 return fxBits;
2657 return effects;
2658 }
2659
2660 //---------------------------------------------------------
2661 // readTremoloBar
2662 //---------------------------------------------------------
2663
readTremoloBar(int,Segment *)2664 void GuitarPro::readTremoloBar(int /*track*/, Segment* /*segment*/)
2665 {
2666 /*int a1 =*/ readChar();
2667 /*int a2 =*/ readChar();
2668 /*int a3 =*/ readChar();
2669 /*int a4 =*/ readChar();
2670 /*int a5 =*/ readChar();
2671 int n = readInt();
2672 QList<PitchValue> points;
2673 for (int i = 0; i < n; ++i) {
2674 int time = readInt();
2675 int pitch = readInt();
2676 int vibrato = readUChar();
2677 points.append(PitchValue(time, pitch, vibrato));
2678 }
2679 #if 0
2680 //TODO
2681 TremoloBar* b = new TremoloBar(segment->score());
2682 b->setPoints(points);
2683 b->setTrack(track);
2684 segment->add(b);
2685 #endif
2686 }
2687
2688 //---------------------------------------------------------
2689 // createCrecDim
2690 //---------------------------------------------------------
2691
createCrecDim(int staffIdx,int track,const Fraction & tick,bool crec)2692 void GuitarPro::createCrecDim(int staffIdx, int track, const Fraction& tick, bool crec)
2693 {
2694 hairpins[staffIdx] = new Hairpin(score);
2695 if (crec)
2696 hairpins[staffIdx]->setHairpinType(HairpinType::CRESC_HAIRPIN);
2697 else
2698 hairpins[staffIdx]->setHairpinType(HairpinType::DECRESC_HAIRPIN);
2699 hairpins[staffIdx]->setTick(tick);
2700 hairpins[staffIdx]->setTick2(tick);
2701 hairpins[staffIdx]->setTrack(track);
2702 hairpins[staffIdx]->setTrack(track);
2703 score->undoAddElement(hairpins[staffIdx]);
2704 }
2705
2706 //---------------------------------------------------------
2707 // importGTP
2708 //---------------------------------------------------------
2709
importGTP(MasterScore * score,const QString & name)2710 Score::FileError importGTP(MasterScore* score, const QString& name)
2711 {
2712 QFile fp(name);
2713 if (!fp.exists())
2714 return Score::FileError::FILE_NOT_FOUND;
2715 if (!fp.open(QIODevice::ReadOnly))
2716 return Score::FileError::FILE_OPEN_ERROR;
2717
2718 char header[5];
2719 fp.read(header, 4);
2720 header[4] = 0;
2721 fp.seek(0);
2722 if (name.endsWith(".ptb", Qt::CaseInsensitive) || strcmp(header, "ptab") == 0) {
2723 PowerTab ptb(&fp, score);
2724 return ptb.read();
2725 }
2726
2727 GuitarPro* gp;
2728 bool readResult = false;
2729 // check to see if we are dealing with a GP file via the extension
2730 if (name.endsWith(".gp", Qt::CaseInsensitive)) {
2731 gp = new GuitarPro7(score);
2732 gp->initGuitarProDrumset();
2733 readResult = gp->read(&fp);
2734 gp->setTempo(0, 0);
2735 }
2736 // check to see if we are dealing with a GPX file via the extension
2737 else if (name.endsWith(".gpx", Qt::CaseInsensitive) || strcmp(header, "BCFZ") == 0) {
2738 gp = new GuitarPro6(score);
2739 gp->initGuitarProDrumset();
2740 readResult = gp->read(&fp);
2741 gp->setTempo(0, 0);
2742 }
2743 // otherwise it's an older version - check the header
2744 else if (strcmp(&header[1], "FIC") == 0) {
2745 uchar l;
2746 fp.read((char*)&l, 1);
2747 char ss[30];
2748 fp.read(ss, 30);
2749 ss[l] = 0;
2750 QString s(ss);
2751 if (s.startsWith("FICHIER GUITAR PRO "))
2752 s = s.mid(20);
2753 else if (s.startsWith("FICHIER GUITARE PRO "))
2754 s = s.mid(21);
2755 else {
2756 qDebug("unknown gtp format <%s>", ss);
2757 return Score::FileError::FILE_BAD_FORMAT;
2758 }
2759 int a = s.left(1).toInt();
2760 int b = s.mid(2).toInt();
2761 int version = a * 100 + b;
2762 if (a == 1)
2763 gp = new GuitarPro1(score, version);
2764 else if (a == 2)
2765 gp = new GuitarPro2(score, version);
2766 else if (a == 3)
2767 gp = new GuitarPro3(score, version);
2768 else if (a == 4)
2769 gp = new GuitarPro4(score, version);
2770 else if (a == 5)
2771 gp = new GuitarPro5(score, version);
2772 else {
2773 qDebug("unknown gtp format %d", version);
2774 return Score::FileError::FILE_BAD_FORMAT;
2775 }
2776 gp->initGuitarProDrumset();
2777 readResult = gp->read(&fp);
2778 gp->setTempo(0, 0);
2779 }
2780 else {
2781 return Score::FileError::FILE_BAD_FORMAT;
2782 }
2783 if (readResult == false) {
2784 /*if (!MScore::noGui) {
2785 QMessageBox::warning(0,
2786 QWidget::tr("Import Guitar Pro"),
2787 QWidget::tr("Load failed: %1").arg(gp->error(errNo)),
2788 QString::null, QWidget::tr("Quit"), QString::null, 0, 1);
2789 }*/
2790 qDebug("guitar pro import error====");
2791 // avoid another error message box
2792 return Score::FileError::FILE_NO_ERROR;
2793 }
2794
2795 score->style().set(Sid::ArpeggioHiddenInStdIfTab, true);
2796
2797 MeasureBase* m;
2798 if (!score->measures()->first()) {
2799 m = new VBox(score);
2800 m->setTick(Fraction(0,1));
2801 score->addMeasure(m, 0);
2802 }
2803 else {
2804 m = score->measures()->first();
2805 if (!m->isVBox()) {
2806 MeasureBase* mb = new VBox(score);
2807 mb->setTick(Fraction(0,1));
2808 score->addMeasure(mb, m);
2809 m = mb;
2810 }
2811 }
2812 if (!gp->title.isEmpty()) {
2813 Text* s = new Text(score, Tid::TITLE);
2814 s->setPlainText(gp->title);
2815 m->add(s);
2816 }
2817 if (!gp->subtitle.isEmpty()|| !gp->artist.isEmpty() || !gp->album.isEmpty()) {
2818 Text* s = new Text(score, Tid::SUBTITLE);
2819 QString str;
2820 if (!gp->subtitle.isEmpty())
2821 str.append(gp->subtitle);
2822 if (!gp->artist.isEmpty()) {
2823 if (!str.isEmpty())
2824 str.append("\n");
2825 str.append(gp->artist);
2826 }
2827 if (!gp->album.isEmpty()) {
2828 if (!str.isEmpty())
2829 str.append("\n");
2830 str.append(gp->album);
2831 }
2832 s->setPlainText(str);
2833 m->add(s);
2834 }
2835 if (!gp->composer.isEmpty()) {
2836 Text* s = new Text(score, Tid::COMPOSER);
2837 s->setPlainText(gp->composer);
2838 m->add(s);
2839 }
2840 int idx = 0;
2841
2842 for (Measure* m1 = score->firstMeasure(); m1; m1 = m1->nextMeasure(), ++idx) {
2843 const GpBar& bar = gp->bars[idx];
2844 if (bar.barLine != BarLineType::NORMAL && bar.barLine != BarLineType::END_REPEAT && bar.barLine != BarLineType::START_REPEAT && bar.barLine != BarLineType::END_START_REPEAT)
2845 m1->setEndBarLineType(bar.barLine, 0);
2846 }
2847 if (score->lastMeasure() && score->lastMeasure()->endBarLineType() != BarLineType::NORMAL)
2848 score->lastMeasure()->setEndBarLineType(BarLineType::END, false);
2849
2850 //
2851 // create parts (excerpts)
2852 //
2853 std::vector<Part*> infoParts;
2854 for (Part* part : score->parts()) {
2855 const QString& longName = part->longName();
2856 if (!longName.isEmpty() && longName[0] == '@') {
2857 infoParts.push_back(part);
2858 continue;
2859 }
2860 QMultiMap<int, int> tracks;
2861 Score* pscore = new Score(score);
2862 //TODO-ws pscore->showLyrics = score->showLyrics;
2863 pscore->style().set(Sid::createMultiMeasureRests, false);
2864 pscore->style().set(Sid::ArpeggioHiddenInStdIfTab, true);
2865
2866 QList<int> stavesMap;
2867 Part* p = new Part(pscore);
2868 p->setInstrument(*part->instrument());
2869 //TODO-ws pscore->tuning = gp->tunings[counter++];
2870
2871 Staff* staff = part->staves()->front();
2872
2873 Staff* s = new Staff(pscore);
2874 s->setPart(p);
2875 const StaffType* st = staff->constStaffType(Fraction(0,1));
2876 s->setStaffType(Fraction(0,1), *st);
2877
2878 s->linkTo(staff);
2879 p->staves()->append(s);
2880 pscore->staves().append(s);
2881 stavesMap.append(staff->idx());
2882
2883 for (int i = staff->idx() * VOICES, j = 0; i < staff->idx() * VOICES + VOICES; i++, j++)
2884 tracks.insert(i, j);
2885
2886 Excerpt* excerpt = new Excerpt(score);
2887 excerpt->setTracks(tracks);
2888 excerpt->setPartScore(pscore);
2889 pscore->setExcerpt(excerpt);
2890 excerpt->setTitle(part->partName());
2891 excerpt->parts().append(part);
2892 score->excerpts().append(excerpt);
2893
2894 Excerpt::cloneStaves(score, pscore, stavesMap, tracks);
2895
2896 if (staff->part()->instrument()->stringData()->strings() > 0
2897 && part->staves()->front()->constStaffType(Fraction(0,1))->group() == StaffGroup::STANDARD) {
2898 p->setStaves(2);
2899 Staff* s1 = p->staff(1);
2900
2901 int lines = staff->part()->instrument()->stringData()->strings();
2902 StaffTypes sts = StaffTypes::TAB_DEFAULT;
2903 if (lines == 4)
2904 sts = StaffTypes::TAB_4COMMON;
2905 StaffType st1 = *StaffType::preset(sts);
2906 s1->setStaffType(Fraction(0,1), st1);
2907 s1->setLines(Fraction(0,1), lines);
2908 Excerpt::cloneStaff(s,s1);
2909 p->staves()->front()->addBracket(new BracketItem(pscore, BracketType::NORMAL, 2));
2910 }
2911 pscore->appendPart(p);
2912
2913 //
2914 // create excerpt title
2915 //
2916 MeasureBase* measure = pscore->first();
2917 if (!measure || (measure->type() != ElementType::VBOX)) {
2918 MeasureBase* mb = new VBox(pscore);
2919 mb->setTick(Fraction(0,1));
2920 pscore->addMeasure(mb, measure);
2921 measure = mb;
2922 }
2923 Text* txt = new Text(pscore, Tid::INSTRUMENT_EXCERPT);
2924 txt->setPlainText(part->longName());
2925 measure->add(txt);
2926
2927 //
2928 // layout score
2929 //
2930 pscore->setPlaylistDirty();
2931 pscore->setLayoutAll();
2932 pscore->addLayoutFlags(LayoutFlag::FIX_PITCH_VELO);
2933 // pscore->doLayout();
2934 }
2935
2936 for (auto p : infoParts) {
2937 auto staff = p->staves()->back();
2938 score->removeStaff(staff);
2939 score->removePart(p);
2940 delete staff;
2941 delete p;
2942 }
2943 // score->rebuildMidiMapping();
2944 // score->updateChannel();
2945 // album
2946 // copyright
2947
2948 score->setCreated(true);
2949 delete gp;
2950
2951 return Score::FileError::FILE_NO_ERROR;
2952 }
2953 }
2954
2955