public override void WriteSong(Song song)
{
if (song.IsEmpty)
{
throw new ArgumentException("Empty song");
}
MeasureHeader header = song.MeasureHeaders[0];
WriteStringByte(Gp5Version, 30);
WriteInfo(song);
WriteLyrics(song);
WritePageSetup();
WriteInt(header.Tempo.Value);
WriteInt(0);
WriteByte((byte)0);
WriteChannels(song);
for (int i = 0; i < 42; i++)
{
WriteByte(0xff);
}
WriteInt(song.MeasureHeaders.Count);
WriteInt(song.Tracks.Count);
WriteMeasureHeaders(song);
WriteTracks(song);
SkipBytes(2);
WriteMeasures(song, header.Tempo);
Close();
}
private Measure ParseMeasure(JObject jMeasure)
{
if (jMeasure["numerator"] != null)
{
_currentTimeSignature = new TimeSignature
{
Numerator = jMeasure["numerator"].SafeValue <int>(),
Denominator = new Duration {
Value = jMeasure["denominator"].SafeValue <int>(),
}
}
}
;
_tempo = jMeasure["tempo"].SafeValue(_tempo);
MeasureHeader header = new MeasureHeader
{
IsRepeatOpen = jMeasure["repeatopen"].SafeValue <bool>(),
RepeatClose = jMeasure["repeatcount"].SafeValue <int>(),
Tempo = new Tempo {
Value = _tempo,
},
TimeSignature = _currentTimeSignature
};
Measure measure = new Measure(header)
{
Beats = ParseBeats(jMeasure["beats"].Value <JArray>())
};
return(measure);
}
public void AddMeasureHeader(MeasureHeader header)
{
//header.Song = this;
MeasureHeaders.Add(header);
if (header.IsRepeatOpen || (header.RepeatAlternatives.Count > 0 && CurrentRepeatGroup.IsClosed && header.RepeatAlternatives[0] <= 0))
{
CurrentRepeatGroup = new RepeatGroup();
}
CurrentRepeatGroup.AddMeasureHeader(header);
}
private Marker ReadMarker(MeasureHeader header)
{
Marker marker = new Marker();
marker.Title = GpBase.ReadIntByteSizeString();
marker.Color = ReadColor();
marker.MeasureHeader = header;
return(marker);
}
public void addMeasureHeader(MeasureHeader header)
{
header.song = this;
measureHeaders.Add(header);
if (header.isRepeatOpen || (header.repeatAlternatives.Count > 0 && _currentRepeatGroup.isClosed && header.repeatAlternatives[0] <= 0))
{
_currentRepeatGroup = new RepeatGroup();
}
_currentRepeatGroup.addMeasureHeader(header);
}
private Marker readMarker(MeasureHeader header)
{
Marker marker = new Marker();
marker.title = GPBase.readIntByteSizeString();
marker.color = readColor();
marker.measureHeader = header;
return(marker);
}
public Measure(Track track = null, MeasureHeader header = null)
{
if (voices.Count == 0)
{
for (int x = 0; x < maxVoices; x++)
{
voices.Add(new Voice(this));
}
}
this.header = header;
this.track = track;
}
private void WriteMeasures(Song song, Tempo tempo)
{
for (int i = 0; i < song.MeasureHeaders.Count; i++)
{
MeasureHeader header = song.MeasureHeaders[i];
for (int j = 0; j < song.Tracks.Count; j++)
{
Track track = song.Tracks[j];
Measure measure = track.Measures[i];
WriteMeasure(measure, (header.Tempo.Value != tempo.Value));
SkipBytes(1);
}
header.Tempo = tempo;
}
}
private void ReadMeasureHeaders(int measureCount)
{
/*Read measure headers.
*
* The *measures* are written one after another, their number have
* been specified previously.
*
* :param measureCount: number of measures to expect.*/
MeasureHeader previous = null;
for (int number = 1; number < measureCount + 1; number++)
{
var header = ReadMeasureHeader(number, previous);
this.AddMeasureHeader(header);
previous = header;
}
}
public void addMeasureHeader(MeasureHeader h)
{
if (!(openings.Count > 0))
{
openings.Add(h);
}
measureHeaders.Add(h);
h.repeatGroup = this;
if (h.repeatClose > 0)
{
closings.Add(h);
isClosed = true;
}
else if (isClosed)
{
isClosed = false;
openings.Add(h);
}
}
private void WriteMeasureHeaders(Song song)
{
TimeSignature timeSignature = new TimeSignature();
if (song.MeasureHeaders.Count > 0)
{
for (int i = 0; i < song.MeasureHeaders.Count; i++)
{
if (i > 0)
{
SkipBytes(1);
}
MeasureHeader measure = song.MeasureHeaders[i];
WriteMeasureHeader(measure, timeSignature);
timeSignature.Numerator = measure.TimeSignature.Numerator;
timeSignature.Denominator.Value = measure.TimeSignature.Denominator.Value;
}
}
}
private MeasureHeader ReadMeasureHeader(int number, MeasureHeader previous = null)
{
/*Read measure header.
*
* The first byte is the measure's flags. It lists the data given in the
* current measure.
*
* - *0x01*: numerator of the key signature
* - *0x02*: denominator of the key signature
* - *0x04*: beginning of repeat
* - *0x08*: end of repeat
* - *0x10*: number of alternate ending
* - *0x20*: presence of a marker
* - *0x40*: tonality of the measure
* - *0x80*: presence of a double bar
*
* Each of these elements is present only if the corresponding bit
* is a 1.
*
* The different elements are written (if they are present) from
* lowest to highest bit.
*
* Exceptions are made for the double bar and the beginning of
* repeat whose sole presence is enough, complementary data is not
* necessary.
*
* - Numerator of the key signature: :ref:`byte`.
*
* - Denominator of the key signature: :ref:`byte`.
*
* - End of repeat: :ref:`byte`.
* Number of repeats until the previous beginning of repeat.
*
* - Number of alternate ending: :ref:`byte`.
*
* - Marker: see :meth:`GP3File.readMarker`.
*
* - Tonality of the measure: 2 :ref:`Bytes <byte>`. These values
* encode a key signature change on the current piece. First byte
* is key signature root, second is key signature type.
*/
byte flags = GpBase.ReadByte()[0];
MeasureHeader header = new MeasureHeader();
header.Number = number;
header.Start = 0;
header.Tempo.Value = Tempo;
header.TripletFeel = TripletFeel;
if ((flags & 0x01) != 0)
{
header.TimeSignature.Numerator = GpBase.ReadSignedByte()[0];
}
else
{
header.TimeSignature.Numerator = previous.TimeSignature.Numerator;
}
if ((flags & 0x02) != 0)
{
header.TimeSignature.Denominator.Value = GpBase.ReadSignedByte()[0];
}
else
{
header.TimeSignature.Denominator.Value = previous.TimeSignature.Denominator.Value;
}
header.IsRepeatOpen = (bool)((flags & 0x04) != 0);
if ((flags & 0x08) != 0)
{
header.RepeatClose = GpBase.ReadSignedByte()[0];
}
if ((flags & 0x10) != 0)
{
header.RepeatAlternatives.Add(ReadRepeatAlternative(MeasureHeaders));
}
if ((flags & 0x20) != 0)
{
header.Marker = ReadMarker(header);
}
if ((flags & 0x40) != 0)
{
sbyte root = GpBase.ReadSignedByte()[0];
sbyte type = GpBase.ReadSignedByte()[0];
int dir = (root < 0) ? -1 : 1;
header.KeySignature = (KeySignatures)((int)root * 10 + dir * type);
}
else if (header.Number > 1)
{
header.KeySignature = previous.KeySignature;
}
header.HasDoubleBar = ((flags & 0x80) != 0);
return(header);
}
private void WriteMeasureHeader(MeasureHeader measure, TimeSignature timeSignature)
{
sbyte flags = 0;
if (measure.Number == 0)
{
flags |= 0x40;
}
if (measure.Number == 0 ||
!(measure.TimeSignature.Denominator.Value == timeSignature.Denominator.Value &&
measure.TimeSignature.Numerator == timeSignature.Numerator))
{
flags |= 0x01;
flags |= 0x02;
}
if (measure.IsRepeatOpen)
{
flags |= 0x04;
}
if (measure.RepeatClose > 0)
{
flags |= 0x08;
}
if (measure.RepeatAlternative > 0)
{
flags |= 0x10;
}
if (measure.Marker != null)
{
flags |= 0x20;
}
WriteUnsignedByte(flags);
if ((flags & 0x01) != 0)
{
WriteByte((byte)measure.TimeSignature.Numerator);
}
if ((flags & 0x02) != 0)
{
WriteByte((byte)measure.TimeSignature.Denominator.Value);
}
if ((flags & 0x08) != 0)
{
WriteByte((byte)(measure.RepeatClose + 1));
}
if ((flags & 0x20) != 0)
{
WriteMarker(measure.Marker);
}
if ((flags & 0x10) != 0)
{
WriteByte((byte)measure.RepeatAlternative);
}
if ((flags & 0x40) != 0)
{
SkipBytes(2);
}
if ((flags & 0x01) != 0)
{
WriteBytes(MakeBeamEighthNoteBytes(measure.TimeSignature));
}
if ((flags & 0x10) == 0)
{
WriteByte((byte)0);
}
if (measure.TripletFeel == MeasureHeader.TripletFeelNone)
{
WriteByte((byte)0);
}
else if (measure.TripletFeel == MeasureHeader.TripletFeelEighth)
{
WriteByte((byte)1);
}
else if (measure.TripletFeel == MeasureHeader.TripletFeelSixteenth)
{
WriteByte((byte)2);
}
}
