comparison at/ofai/music/worm/WormFile.java @ 2:4c3f5bc01c97

* Import BeatRoot v0.5.7

+/*  Performance Worm: Visualisation of Expressive Musical Performance
+	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 at.ofai.music.worm;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+import java.io.FileReader;
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.StringTokenizer;
+import java.util.Iterator;
+import java.awt.Frame;
+import at.ofai.music.util.Event;
+import at.ofai.music.util.EventList;
+import at.ofai.music.util.Format;
+import at.ofai.music.util.MatchTempoMap;
+
+// Read/write performance worm data
+public class WormFile {
+
+	Worm worm;
+	double outFramePeriod, inFramePeriod;
+	int length;
+	double[] time;
+	double[] inTempo, outTempo;
+	double[] inIntensity, outIntensity;
+	int[] inFlags, outFlags;
+	String[] label;
+	public static final int
+		TRACK=1, BEAT=2, BAR=4, SEG1=8, SEG2=16, SEG3=32, SEG4=64;
+	public static final double defaultFramePeriod = 0.1;	// 10 FPS
+	WormParameters info;
+
+	private WormFile(Frame f) {
+		info = new WormParameters(f);
+		inFramePeriod = defaultFramePeriod;
+		outFramePeriod = defaultFramePeriod;
+	} // shared constructor
+
+	public WormFile(int size) {
+		this(null);
+		length = size;
+		init();
+	} // constructor
+
+	public WormFile(int size, double step) {
+		this(size);
+		inFramePeriod = step;
+	} // constructor
+
+	public WormFile(EventList el, double step) {
+		this(null);
+		inFramePeriod = step;
+		convertList(el);
+	} // constructor
+
+	public WormFile(Worm w, EventList el) {
+		this(w == null? null: w.theFrame);
+		worm = w;
+		convertList(el);
+	} // constructor
+
+	public WormFile(Worm w, String fileName) {
+		this(w.theFrame);
+		worm = w;
+		read(fileName);
+	} // constructor
+
+	public void init() {
+		inTempo = new double[length];
+		inIntensity = new double[length];
+		inFlags = new int[length];
+		time = new double[length];
+	} // init()
+
+	public void smooth(int mode, double left, double right, int smoothLevel) {
+		if (worm != null)
+			worm.setSmoothMode(Worm.NONE);
+		info.smoothing = "None";
+		if ((outFramePeriod == 0) || ((inFramePeriod == 0) && (time == null))) {
+			System.err.println("Error: smooth() frameLength unspecified");
+			return;
+		}
+		if (inFramePeriod != 0) {
+			for (int i = 0; i < length; i++)
+				time[i] = inFramePeriod * i;
+		}
+		int outLength = 1+(int) Math.ceil(time[time.length-1] / outFramePeriod);
+		if ((outTempo == null) || (outTempo.length != outLength)) {
+			outTempo = new double[outLength];
+			outIntensity = new double[outLength];
+			outFlags = new int[outLength];
+			label = new String[outLength];
+		}
+		if (mode == Worm.NONE) {
+			int i = 0, o = 0;
+			while (o * outFramePeriod < time[0]) {
+				outTempo[o] = inTempo[0];
+				outIntensity[o] = inIntensity[0];
+				o++;
+			}
+			for ( ; i < time.length - 1; i++) {
+				while (o * outFramePeriod < time[i+1]) {
+					outTempo[o] = inTempo[i];
+					outIntensity[o] = inIntensity[i];
+					o++;
+				}
+			}
+			while (o < outLength) {
+				outTempo[o] = inTempo[i];
+				outIntensity[o] = inIntensity[i];
+				o++;
+			}
+		} else {
+			info.smoothing = "Gaussian" + "\t" + Format.d(left, 4) +
+									 "\t" + Format.d(right, 4);
+			if (smoothLevel != 0) {
+				int count = 0;
+				double first = 0, last = 0;
+				for (int i = 0; i < time.length; i++)
+					if ((inFlags[i] & smoothLevel) != 0) {
+						if (count == 0)
+							first = time[i];
+						else
+							last = time[i];
+						count++;
+					}
+				if (count < 2)
+					System.err.println("Warning: Beat data not available");
+				else {
+					double IBI = (last - first) / (count - 1); 
+					left *= IBI;
+					right *= IBI;
+					info.smoothing += "\t" +Format.d(IBI,4) + "\t" +smoothLevel;
+					System.out.println("Smoothing parameters (seconds): pre=" +
+							Format.d(left,3) + " post=" + Format.d(right,3));
+				}
+			}
+			int start = 0;
+			for (int o = 0; o < outLength; o++) {
+				double sum = 0, val = 0, tempo = 0, intensity = 0;
+				for (int i = start; i < time.length; i++) {
+					double d = o * outFramePeriod - time[i];
+					if (d > 4 * left) {	// average over 4 stddevs
+						start++;
+						continue;
+					}
+					if (d < -4 * right)
+						break;
+					if (d < 0)
+						val = Math.exp(-d*d/(left*left*2));
+					else
+						val = Math.exp(-d*d/(right*right*2));
+					sum += val;
+					tempo += val * inTempo[i];
+					intensity += val * inIntensity[i];
+				}
+				if (sum == 0) {		// assume this only occurs at beginning
+					outTempo[o] = inTempo[0];
+					outIntensity[o] = inIntensity[0];
+				} else {
+					outTempo[o] = tempo / sum;
+					outIntensity[o] = intensity / sum;
+				}
+			}
+		}
+		for (int i = 0; i < outFlags.length; i++)
+			outFlags[i] = 0;
+		for (int i = 0; i < inFlags.length; i++)
+			outFlags[(int)Math.round(time[i] / outFramePeriod)] |= inFlags[i];
+		int bar = 0;
+		int beat = 0;
+		int track = 0;
+		for (int i = 0; i < outFlags.length; i++) {
+			if ((outFlags[i] & BAR) != 0)
+				bar++;
+			if ((outFlags[i] & BEAT) != 0)
+				beat++;
+			if ((outFlags[i] & TRACK) != 0)
+				track++;
+			label[i] = bar + ":" + beat + ":" + track + ":" +
+						Format.d(i * outFramePeriod, 1);
+		}
+	} // smooth()
+	
+	public void editParameters() {
+		info.editParameters();
+		update();
+	} // editParameters()
+
+	public void update() {
+		length = info.length;
+		inFramePeriod = info.framePeriod;
+		worm.setTitle(info.composer + ", " + info.piece +
+						", played by " + info.performer);
+		// not used (?) : beatLevel trackLevel upbeat beatsPerBar
+		if ((inTempo == null) || (inTempo.length != length))
+			init();
+		worm.setInputFile(info.audioPath, info.audioFile);
+		worm.setSmoothMode(Worm.NONE);
+		if (info.axis.length() > 0)
+			worm.setAxis(info.axis);
+		worm.setFramePeriod(outFramePeriod);
+		worm.setLoudnessUnits(info.loudnessUnits);
+	} // update()
+
+	public void convertList(EventList el) {
+		double tMax = 0;
+		int count = 0;
+		for (Iterator<Event> i = el.iterator(); i.hasNext(); ) {
+			double pedalUpTime = i.next().pedalUp;
+			if (pedalUpTime > tMax)
+				tMax = pedalUpTime;
+			count++;
+		}
+		length = (int)Math.ceil(tMax / inFramePeriod);
+		init();
+		// double[] decayFactor = new double[128];
+		// for (int i = 0; i < 128; i++)
+		// 	decayFactor[i] = Math.max(5.0, (i - 6.0) / 3.0) * inFramePeriod;
+		// 	// was Math.pow(0.1, inFramePeriod);	// modify for pitch?
+		for (Iterator<Event> i = el.l.iterator(); i.hasNext(); ) {
+			Event e = i.next();
+			double loudness = 30.29 * Math.pow(e.midiVelocity, 0.2609);
+			loudness += (e.midiPitch - 66.0) / 12.0; // +1dB / oct
+			int start = (int)Math.floor(e.keyDown / inFramePeriod);
+			if (start < 0)
+				start = 0;
+			int stop = (int)Math.ceil((e.pedalUp + 0.5) / inFramePeriod);
+			if (stop > inIntensity.length)
+				stop = inIntensity.length;
+			for (int t = start; t < stop; t++) {
+				if (loudness > inIntensity[t])
+					inIntensity[t] = loudness;
+				loudness -= Math.max(5.0, (e.midiPitch - 6.0) / 3.0) *
+											inFramePeriod;
+				// was: mult by decay factor. But since vals are dB, we subtract
+			}
+		}
+		MatchTempoMap tMap = new MatchTempoMap(count);
+		for (Iterator<Event> i = el.l.iterator(); i.hasNext(); ) {
+			Event e = i.next();
+			tMap.add(e.keyDown, e.scoreBeat);
+		}
+		// el.print();
+		// tMap.print();	// for debugging
+		tMap.dump(inTempo, inFramePeriod);
+	} // convertList()
+
+	public void write(String fileName) {
+		PrintStream out;
+		try {
+			out = new PrintStream(new FileOutputStream(fileName));
+		} catch (FileNotFoundException e) {
+			System.err.println("Unable to open output file " + fileName);
+			return;
+		}
+		info.write(out, outTempo.length, outFramePeriod);
+		for (int i = 0; i < outTempo.length; i++) {
+			if (outFramePeriod == 0)
+				out.print(Format.d(time[i],3) + " ");
+			out.println(Format.d(outTempo[i],4) +" "+
+						Format.d(outIntensity[i],4) +" "+outFlags[i]);
+		}
+		out.close();
+	} // write()
+
+	public void read(String fileName) {
+		try {
+			File f = new File(fileName);
+			if (!f.isFile())	// a local hack for UNC file names under Windows
+				f = new File("//fichte" + fileName);
+			if (!f.isFile())
+				throw(new FileNotFoundException("Could not open " + fileName));
+			BufferedReader in = new BufferedReader(new FileReader(f));
+			String input = info.read(in);
+			update();
+			int index = 0;
+			int bar = 0;
+			while ((input != null) && (index < length)) {
+				StringTokenizer tk = new StringTokenizer(input);
+				if (inFramePeriod != 0)
+					time[index] = Double.parseDouble(tk.nextToken());
+				inTempo[index] = Double.parseDouble(tk.nextToken());
+				inIntensity[index] = Double.parseDouble(tk.nextToken());
+				if (tk.hasMoreTokens())
+					inFlags[index] = Integer.parseInt(tk.nextToken());
+				else
+					inFlags[index] = 0;
+				input = in.readLine();
+				index++;
+			}
+			in.close();
+			smooth(Worm.NONE, 0, 0, 0);
+		} catch (FileNotFoundException e) {
+			System.err.println(e);
+		} catch (IOException e) {
+			System.err.println("IOException reading " + fileName);
+		} catch (Exception e) {
+			System.err.println("Error parsing file " + fileName + ": " + e);
+			e.printStackTrace();
+		}
+	} // read()
+
+} // class WormFile