324 lines
10 KiB
C++
324 lines
10 KiB
C++
//=============================================================================
|
|
// MusE Score
|
|
// Linux Music Score Editor
|
|
// $Id:$
|
|
//
|
|
// Copyright (C) 2010 Werner Schweer and others
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License version 2.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
//=============================================================================
|
|
|
|
#ifndef __IMPORTGTP_H__
|
|
#define __IMPORTGTP_H__
|
|
|
|
#include "libmscore/mscore.h"
|
|
#include "libmscore/fraction.h"
|
|
#include "libmscore/fret.h"
|
|
#include "libmscore/chordrest.h"
|
|
#include "libmscore/slur.h"
|
|
#include "libmscore/clef.h"
|
|
#include "libmscore/keysig.h"
|
|
#include "libmscore/chordrest.h"
|
|
#include "libmscore/clef.h"
|
|
#include "libmscore/keysig.h"
|
|
#include "libmscore/hairpin.h"
|
|
#include "libmscore/ottava.h"
|
|
#include "libmscore/drumset.h"
|
|
|
|
namespace Ms {
|
|
|
|
class Score;
|
|
class Chord;
|
|
class Note;
|
|
class Segment;
|
|
class Measure;
|
|
class Tuplet;
|
|
|
|
static const int GP_MAX_LYRIC_LINES = 5;
|
|
static const int GP_MAX_TRACK_NUMBER = 32;
|
|
static const int GP_MAX_STRING_NUMBER = 7;
|
|
static const int GP_DEFAULT_PERCUSSION_CHANNEL = 9;
|
|
|
|
static const int GP_INVALID_KEYSIG = 127;
|
|
|
|
static const int GP_VOLTA_BINARY = 1;
|
|
static const int GP_VOLTA_FLAGS = 2;
|
|
|
|
enum class Repeat : char;
|
|
|
|
struct GpTrack {
|
|
int patch;
|
|
uchar volume, pan, chorus, reverb, phase, tremolo;
|
|
};
|
|
|
|
struct GPVolta {
|
|
int voltaType;
|
|
QList<int> voltaInfo;
|
|
};
|
|
|
|
/* How the fermatas are represented in Guitar Pro is two integers, the
|
|
* first is an index value and the second is the time division that
|
|
* index value refers to, and they are givin with respect to a
|
|
* measure. Time division 0 means a minim, 1 is a crotchet, 2 is a
|
|
* quaver and so on, with the index (counting from 0) refering to how
|
|
* many time divisions occur before the fermata. These numbers are
|
|
* separated in GP6 with a '/' character. For example, a note
|
|
* occurring on the third beat of a measure in a 4/4 bar would be
|
|
* represented as 2/1.
|
|
*/
|
|
struct GPFermata {
|
|
int index;
|
|
int timeDivision;
|
|
};
|
|
|
|
struct GpBar {
|
|
Fraction timesig;
|
|
bool freeTime;
|
|
int keysig;
|
|
QString marker;
|
|
BarLineType barLine;
|
|
Repeat repeatFlags;
|
|
int repeats;
|
|
GPVolta volta;
|
|
QString direction;
|
|
QString directionStyle;
|
|
|
|
GpBar();
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// GuitarPro
|
|
//---------------------------------------------------------
|
|
|
|
class GuitarPro {
|
|
protected:
|
|
static const char* errmsg[];
|
|
int version;
|
|
int key;
|
|
|
|
QMap<int, QList<GPFermata>*> fermatas;
|
|
Ottava** ottava;
|
|
Hairpin** hairpins;
|
|
Score* score;
|
|
QFile* f;
|
|
int curPos;
|
|
int previousTempo;
|
|
int previousDynamic;
|
|
int ottavaFound;
|
|
QString ottavaValue;
|
|
int tempo;
|
|
QMap<int,int> slides;
|
|
|
|
int voltaSequence;
|
|
QTextCodec* _codec;
|
|
Slur** slurs;
|
|
|
|
void skip(qint64 len);
|
|
void read(void* p, qint64 len);
|
|
int readUChar();
|
|
int readChar();
|
|
QString readPascalString(int);
|
|
QString readWordPascalString();
|
|
QString readBytePascalString();
|
|
int readInt();
|
|
QString readDelphiString();
|
|
void readVolta(GPVolta*, Measure*);
|
|
virtual void readBend(Note*);
|
|
virtual bool readMixChange(Measure* measure);
|
|
virtual int readBeatEffects(int track, Segment*) = 0;
|
|
void readLyrics();
|
|
void readChannels();
|
|
void setTuplet(Tuplet* tuplet, int tuple);
|
|
Fraction len2fraction(int len);
|
|
void addDynamic(Note*, int d);
|
|
void setTempo(int n, Measure* measure);
|
|
void createMeasures();
|
|
void applyBeatEffects(Chord*, int beatEffects);
|
|
void readTremoloBar(int track, Segment*);
|
|
void readChord(Segment* seg, int track, int numStrings, QString name, bool gpHeader);
|
|
void restsForEmptyBeats(Segment* seg, Measure* measure, ChordRest* cr, Fraction& l, int track, int tick);
|
|
void createSlur(bool hasSlur, int staffIdx, ChordRest* cr);
|
|
void createOttava(bool hasOttava, int track, ChordRest* cr, QString value);
|
|
void createSlide(int slide, ChordRest* cr, int staffIdx);
|
|
void createCrecDim(int staffIdx, int track, int tick, bool crec);
|
|
void addTextToNote(QString string, TextStyle textStyle, Note* note);
|
|
void addPalmMute(Note* note);
|
|
void addLetRing(Note* note);
|
|
void addTap(Note* note);
|
|
void addSlap(Note* note);
|
|
void addPop(Note* note);
|
|
|
|
public:
|
|
void initGuitarProDrumset();
|
|
QString title, subtitle, artist, album, composer;
|
|
QString transcriber, instructions;
|
|
QStringList comments;
|
|
GpTrack channelDefaults[GP_MAX_TRACK_NUMBER * 2];
|
|
int staves;
|
|
int measures;
|
|
QList<GpBar> bars;
|
|
|
|
enum class GuitarProError : char { GP_NO_ERROR, GP_UNKNOWN_FORMAT,
|
|
GP_EOF, GP_BAD_NUMBER_OF_STRINGS
|
|
};
|
|
|
|
GuitarPro(Score*, int v);
|
|
virtual ~GuitarPro();
|
|
virtual void read(QFile*) = 0;
|
|
QString error(GuitarProError n) const { return QString(errmsg[int(n)]); }
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// GuitarPro1
|
|
//---------------------------------------------------------
|
|
|
|
class GuitarPro1 : public GuitarPro {
|
|
|
|
protected:
|
|
void readNote(int string, Note* note);
|
|
virtual int readBeatEffects(int track, Segment*);
|
|
|
|
public:
|
|
GuitarPro1(Score* s, int v) : GuitarPro(s, v) {}
|
|
virtual void read(QFile*);
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// GuitarPro2
|
|
//---------------------------------------------------------
|
|
|
|
class GuitarPro2 : public GuitarPro1 {
|
|
|
|
public:
|
|
GuitarPro2(Score* s, int v) : GuitarPro1(s, v) {}
|
|
virtual void read(QFile*);
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// GuitarPro3
|
|
//---------------------------------------------------------
|
|
|
|
class GuitarPro3 : public GuitarPro1 {
|
|
|
|
virtual int readBeatEffects(int track, Segment* segment);
|
|
public:
|
|
GuitarPro3(Score* s, int v) : GuitarPro1(s, v) {}
|
|
virtual void read(QFile*);
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// GuitarPro4
|
|
//---------------------------------------------------------
|
|
|
|
class GuitarPro4 : public GuitarPro {
|
|
|
|
int slide;
|
|
void readInfo();
|
|
bool readNote(int string, int staffIdx, Note* note);
|
|
virtual int readBeatEffects(int track, Segment* segment);
|
|
virtual bool readMixChange(Measure* measure);
|
|
int convertGP4SlideNum(int slide);
|
|
|
|
public:
|
|
GuitarPro4(Score* s, int v) : GuitarPro(s, v) {}
|
|
virtual void read(QFile*);
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// GuitarPro5
|
|
//---------------------------------------------------------
|
|
|
|
class GuitarPro5 : public GuitarPro {
|
|
|
|
int slide;
|
|
void readInfo();
|
|
void readPageSetup();
|
|
virtual int readBeatEffects(int track, Segment* segment);
|
|
bool readNote(int string, Note* note);
|
|
virtual bool readMixChange(Measure* measure);
|
|
void readMeasure(Measure* measure, int staffIdx, Tuplet*[], bool mixChange);
|
|
void readArtificialHarmonic();
|
|
void readTracks();
|
|
void readMeasures(int startingTempo);
|
|
int readBeat(int tick, int voice, Measure* measure, int staffIdx, Tuplet** tuplets, bool mixChange);
|
|
bool readNoteEffects(Note*);
|
|
|
|
public:
|
|
GuitarPro5(Score* s, int v) : GuitarPro(s, v) {}
|
|
virtual void read(QFile*);
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
// GuitarPro6
|
|
//---------------------------------------------------------
|
|
|
|
class GuitarPro6 : public GuitarPro {
|
|
|
|
private:
|
|
// an integer stored in the header indicating that the file is not compressed (BCFS).
|
|
const int GPX_HEADER_UNCOMPRESSED = 1397113666;
|
|
// an integer stored in the header indicating that the file is not compressed (BCFZ).
|
|
const int GPX_HEADER_COMPRESSED = 1514554178;
|
|
int position=0;
|
|
QMap<int, int>* slides;
|
|
QByteArray* buffer;
|
|
// a constant storing the amount of bits per byte
|
|
const int BITS_IN_BYTE = 8;
|
|
// contains all the information about notes that will go in the parts
|
|
struct GPPartInfo {
|
|
QDomNode masterBars;
|
|
QDomNode bars;
|
|
QDomNode voices;
|
|
QDomNode beats;
|
|
QDomNode notes;
|
|
QDomNode rhythms;
|
|
};
|
|
// a mapping from identifiers to fret diagrams
|
|
QMap<int, FretDiagram*> fretDiagrams;
|
|
void parseFile(char* filename, QByteArray* data);
|
|
int readBit();
|
|
QByteArray getBytes(QByteArray* buffer, int offset, int length);
|
|
void readGPX(QByteArray* buffer);
|
|
int readInteger(QByteArray* buffer, int offset);
|
|
QByteArray readString(QByteArray* buffer, int offset, int length);
|
|
int readBits(int bitsToRead);
|
|
int readBitsReversed(int bitsToRead);
|
|
void readGpif(QByteArray* data);
|
|
void readScore(QDomNode* metadata);
|
|
void readChord(QDomNode* diagram, int track);
|
|
int findNumMeasures(GPPartInfo* partInfo);
|
|
void readMasterTracks(QDomNode* masterTrack);
|
|
void readDrumNote(Note* note, int element, int variation);
|
|
int readBeats(QString beats, GPPartInfo* partInfo, Measure* measure, int tick, int staffIdx, int voiceNum, Tuplet* tuplets[], int measureCounter);
|
|
void readBars(QDomNode* barList, Measure* measure, ClefType oldClefId[], GPPartInfo* partInfo, int measureCounter);
|
|
void readTracks(QDomNode* tracks);
|
|
void readMasterBars(GPPartInfo* partInfo);
|
|
Fraction rhythmToDuration(QString value);
|
|
Fraction fermataToFraction(int numerator, int denominator);
|
|
QDomNode getNode(QString id, QDomNode nodes);
|
|
void unhandledNode(QString nodeName);
|
|
void makeTie(Note* note);
|
|
int* previousDynamic;
|
|
void addTremoloBar(Segment* segment, int track, int whammyOrigin, int whammyMiddle, int whammyEnd);
|
|
|
|
protected:
|
|
void readNote(int string, Note* note);
|
|
virtual int readBeatEffects(int track, Segment*);
|
|
|
|
public:
|
|
GuitarPro6(Score* s) : GuitarPro(s, 6) {}
|
|
virtual void read(QFile*);
|
|
};
|
|
|
|
} // namespace Ms
|
|
#endif
|