/*
* _______ _____ _____ _____
* |__ __| | __ \ / ____| __ \
* | | __ _ _ __ ___ ___ ___| | | | (___ | |__) |
* | |/ _` | '__/ __|/ _ \/ __| | | |\___ \| ___/
* | | (_| | | \__ \ (_) \__ \ |__| |____) | |
* |_|\__,_|_| |___/\___/|___/_____/|_____/|_|
*
* -------------------------------------------------------------
*
* TarsosDSP is developed by Joren Six at IPEM, University Ghent
*
* -------------------------------------------------------------
*
* Info: http://0110.be/tag/TarsosDSP
* Github: https://github.com/JorenSix/TarsosDSP
* Releases: http://0110.be/releases/TarsosDSP/
*
* TarsosDSP includes modified source code by various authors,
* for credits and info, see README.
*
*/
/*
Copyright (C) 2001, 2006 by Simon Dixon
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
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 (the file gpl.txt); if not, download it from
http://www.gnu.org/licenses/gpl.txt or write to the
Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
package be.tarsos.dsp.beatroot;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
// Adapted from eventList::readMatchFile in beatroot/src/eventMidi.cpp
// Reads in a Prolog score+performance (.match) file; returns it as an eventList
// Lines in the match file can be of the form:
// hammer_bounce-PlayedNote.
// info(Attribute, Value).
// insertion-PlayedNote.
// ornament(Anchor)-PlayedNote.
// ScoreNote-deletion.
// ScoreNote-PlayedNote.
// ScoreNote-trailing_score_note.
// trailing_played_note-PlayedNote.
// trill(Anchor)-PlayedNote.
// where ScoreNote is of the form
// snote(Anchor,[NoteName,Modifier],Octave,Bar:Beat,Offset,Duration,
// BeatNumber,DurationInBeats,ScoreAttributesList)
// e.g. snote(n1,[b,b],5,1:1,0,3/16,0,0.75,[s])
// and PlayedNote is of the form
// note(Number,[NoteName,Modifier],Octave,Onset,Offset,AdjOffset,Velocity)
// e.g. note(1,[a,#],5,5054,6362,6768,53)
class WormFileParseException extends RuntimeException {
static final long serialVersionUID = 0;
public WormFileParseException(String s) {
super(s);
} // constructor
} // class WormFileParseException
class MatchFileParseException extends RuntimeException {
static final long serialVersionUID = 0;
public MatchFileParseException(String s) {
super(s);
} // constructor
} // class MatchFileParseException
class BTFileParseException extends RuntimeException {
static final long serialVersionUID = 0;
public BTFileParseException(String s) {
super(s);
} // constructor
} // class BTFileParseException
// Process the strings which label extra features of notes in match files.
// We assume no more than 32 distinct labels in a file.
class Flags {
String[] labels = new String[32];
int size = 0;
int getFlag(String s) {
if ((s == null) || s.equals(""))
return 0;
//int val = 1;
for (int i = 0; i < size; i++)
if (s.equals(labels[i]))
return 1 << i;
if (size == 32) {
System.err.println("Overflow: Too many flags: " + s);
size--;
}
labels[size] = s;
return 1 << size++;
} // getFlag()
String getLabel(int i) {
if (i >= size)
return "ERROR: Unknown flag";
return labels[i];
} // getLabel()
} // class Flags
// A score/match/midi file is represented as an EventList object,
// which contains pointers to the head and tail links, and some
// class-wide parameters. Parameters are class-wide, as it is
// assumed that the Worm has only one input file at a time.
public class EventList {
public LinkedList<Event> l;
protected static boolean timingCorrection = false;
protected static double timingDisplacement = 0;
protected static int clockUnits = 480;
protected static int clockRate = 500000;
protected static double metricalLevel = 0;
public static final double UNKNOWN = Double.NaN;
protected static boolean noMelody = false;
protected static boolean onlyMelody = false;
protected static Flags flags = new Flags();
public EventList() {
l = new LinkedList<Event>();
} // constructor
public EventList(EventList e) {
this();
ListIterator<Event> it = e.listIterator();
while (it.hasNext())
add(it.next());
} // constructor
public EventList(Event[] e) {
this();
for (int i=0; i < e.length; i++)
add(e[i]);
} // constructor
public void add(Event e) {
l.add(e);
} // add()
public void add(EventList ev) {
l.addAll(ev.l);
} // add()
public void insert(Event newEvent, boolean uniqueTimes) {
ListIterator<Event> li = l.listIterator();
while (li.hasNext()) {
int sgn = newEvent.compareTo(li.next());
if (sgn < 0) {
li.previous();
break;
} else if (uniqueTimes && (sgn == 0)) {
li.remove();
break;
}
}
li.add(newEvent);
} // insert()
public ListIterator<Event> listIterator() {
return l.listIterator();
} // listIterator()
public Iterator<Event> iterator() {
return l.iterator();
} // iterator()
public int size() {
return l.size();
} // size()
public Event[] toArray() {
return toArray(0);
} // toArray()
public double[] toOnsetArray() {
double[] d = new double[l.size()];
int i = 0;
for (Iterator<Event> it = l.iterator(); it.hasNext(); i++)
d[i] = it.next().keyDown;
return d;
} // toOnsetArray()
public Event[] toArray(int match) {
int count = 0;
for (Event e : l)
if ((match == 0) || (e.midiCommand == match))
count++;
Event[] a = new Event[count];
int i = 0;
for (Event e : l)
if ((match == 0) || (e.midiCommand == match))
a[i++] = e;
return a;
} // toArray()
public void writeBinary(String fileName) {
try {
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(fileName));
oos.writeObject(this);
oos.close();
} catch (IOException e) {
System.err.println(e);
}
} // writeBinary()
public static EventList readBinary(String fileName) {
try {
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream(fileName));
EventList e = (EventList) ois.readObject();
ois.close();
return e;
} catch (IOException e) {
System.err.println(e);
return null;
} catch (ClassNotFoundException e) {
System.err.println(e);
return null;
}
} // readBinary()
/*
public void writeMIDI(String fileName) {
writeMIDI(fileName, null);
} // writeMIDI()
public void writeMIDI(String fileName, EventList pedal) {
try {
MidiSystem.write(toMIDI(pedal), 1, new File(fileName));
} catch (Exception e) {
System.err.println("Error: Unable to write MIDI file " + fileName);
e.printStackTrace();
}
} // writeMIDI()
public Sequence toMIDI(EventList pedal) throws InvalidMidiDataException {
final int midiTempo = 1000000;
Sequence s = new Sequence(Sequence.PPQ, 1000);
Track[] tr = new Track[16];
tr[0] = s.createTrack();
MetaMessage mm = new MetaMessage();
byte[] b = new byte[3];
b[0] = (byte)((midiTempo >> 16) & 0xFF);
b[1] = (byte)((midiTempo >> 8) & 0xFF);
b[2] = (byte)(midiTempo & 0xFF);
mm.setMessage(0x51, b, 3);
tr[0].add(new MidiEvent(mm, 0L));
for (Event e : l) { // from match or beatTrack file
if (e.midiCommand == 0) // skip beatTrack file
break;
if (tr[e.midiTrack] == null)
tr[e.midiTrack] = s.createTrack();
//switch (e.midiCommand)
//case ShortMessage.NOTE_ON:
//case ShortMessage.POLY_PRESSURE:
//case ShortMessage.CONTROL_CHANGE:
//case ShortMessage.PROGRAM_CHANGE:
//case ShortMessage.CHANNEL_PRESSURE:
//case ShortMessage.PITCH_BEND:
ShortMessage sm = new ShortMessage();
sm.setMessage(e.midiCommand, e.midiChannel,
e.midiPitch, e.midiVelocity);
tr[e.midiTrack].add(new MidiEvent(sm,
(long)Math.round(1000 * e.keyDown)));
if (e.midiCommand == ShortMessage.NOTE_ON) {
sm = new ShortMessage();
sm.setMessage(ShortMessage.NOTE_OFF, e.midiChannel, e.midiPitch, 0);
tr[e.midiTrack].add(new MidiEvent(sm, (long)Math.round(1000 * e.keyUp)));
}
}
if (pedal != null) { // from MIDI file
// if (t.size() > 0) // otherwise beatTrack files leave an empty trk
// t = s.createTrack();
for (Event e : pedal.l) {
if (tr[e.midiTrack] == null)
tr[e.midiTrack] = s.createTrack();
ShortMessage sm = new ShortMessage();
sm.setMessage(e.midiCommand, e.midiChannel,
e.midiPitch, e.midiVelocity);
tr[e.midiTrack].add(new MidiEvent(sm,
(long)Math.round(1000 * e.keyDown)));
if (e.midiCommand == ShortMessage.NOTE_ON) {
sm = new ShortMessage();
sm.setMessage(ShortMessage.NOTE_OFF, e.midiChannel,
e.midiPitch,e.midiVelocity);
tr[e.midiTrack].add(new MidiEvent(sm,
(long)Math.round(1000 * e.keyUp)));
}
//catch (InvalidMidiDataException exception) {}
}
}
return s;
} // toMIDI()
public static EventList readMidiFile(String fileName) {
return readMidiFile(fileName, 0);
} // readMidiFile()
public static EventList readMidiFile(String fileName, int skipTrackFlag) {
EventList list = new EventList();
Sequence s;
try {
s = MidiSystem.getSequence(new File(fileName));
} catch (Exception e) {
e.printStackTrace();
return list;
}
double midiTempo = 500000;
double tempoFactor = midiTempo / s.getResolution() / 1000000.0;
// System.err.println(tempoFactor);
Event[][] noteOns = new Event[128][16];
Track[] tracks = s.getTracks();
for (int t = 0; t < tracks.length; t++, skipTrackFlag >>= 1) {
if ((skipTrackFlag & 1) == 1)
continue;
for (int e = 0; e < tracks[t].size(); e++) {
MidiEvent me = tracks[t].get(e);
MidiMessage mm = me.getMessage();
double time = me.getTick() * tempoFactor;
byte[] mesg = mm.getMessage();
int channel = mesg[0] & 0x0F;
int command = mesg[0] & 0xF0;
if (command == ShortMessage.NOTE_ON) {
int pitch = mesg[1] & 0x7F;
int velocity = mesg[2] & 0x7F;
if (noteOns[pitch][channel] != null) {
if (velocity == 0) { // NOTE_OFF in disguise :(
noteOns[pitch][channel].keyUp = time;
noteOns[pitch][channel].pedalUp = time;
noteOns[pitch][channel] = null;
} else
System.err.println("Double note on: n=" + pitch +
" c=" + channel +
" t1=" + noteOns[pitch][channel] +
" t2=" + time);
} else {
Event n = new Event(time, 0, 0, pitch, velocity, -1, -1,
0, ShortMessage.NOTE_ON, channel, t);
noteOns[pitch][channel] = n;
list.add(n);
}
} else if (command == ShortMessage.NOTE_OFF) {
int pitch = mesg[1] & 0x7F;
noteOns[pitch][channel].keyUp = time;
noteOns[pitch][channel].pedalUp = time;
noteOns[pitch][channel] = null;
} else if (command == 0xF0) {
if ((channel == 0x0F) && (mesg[1] == 0x51)) {
midiTempo = (mesg[5] & 0xFF) |
((mesg[4] & 0xFF) << 8) |
((mesg[3] & 0xFF) << 16);
tempoFactor = midiTempo / s.getResolution() / 1000000.0;
// System.err.println("Info: Tempo change: " + midiTempo +
// " tf=" + tempoFactor);
}
} else if (mesg.length > 3) {
System.err.println("midi message too long: " + mesg.length);
System.err.println("\tFirst byte: " + mesg[0]);
} else {
int b0 = mesg[0] & 0xFF;
int b1 = -1;
int b2 = -1;
if (mesg.length > 1)
b1 = mesg[1] & 0xFF;
if (mesg.length > 2)
b2 = mesg[2] & 0xFF;
list.add(new Event(time, time, -1, b1, b2, -1, -1, 0,
b0 & 0xF0, b0 & 0x0F, t));
}
}
}
for (int pitch = 0; pitch < 128; pitch++)
for (int channel = 0; channel < 16; channel++)
if (noteOns[pitch][channel] != null)
System.err.println("Missing note off: n=" +
noteOns[pitch][channel].midiPitch + " t=" +
noteOns[pitch][channel].keyDown);
return list;
} // readMidiFile()
*/
public void print() {
for (Iterator<Event> i = l.iterator(); i.hasNext(); )
i.next().print(flags);
} // print()
public static void setTimingCorrection(double corr) {
timingCorrection = corr >= 0;
timingDisplacement = corr;
} // setTimingCorrection()
} // class EventList