abcjs-rails 2.1 → 2.3

data/app/assets/javascripts/abcjs/midi/abc_midi_renderer.js

@@ -0,0 +1,426 @@
+//    abc_midi_renderer.js: Create the actual format for the midi.
+//    Copyright (C) 2010,2015 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
+//
+//    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 3 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.  If not, see <http://www.gnu.org/licenses/>.
+
+if (!window.ABCJS)
+	window.ABCJS = {};
+
+if (!window.ABCJS.midi)
+	window.ABCJS.midi = {};
+
+(function() {
+	"use strict";
+	function setAttributes(elm, attrs) {
+		for (var attr in attrs)
+			if (attrs.hasOwnProperty(attr))
+				elm.setAttribute(attr, attrs[attr]);
+		return elm;
+	}
+
+	var MIDIPlugin;
+	//TODO-PER: put this back in when the MIDIPlugin works again.
+	//window.oldunload = window.onbeforeunload;
+	//window.onbeforeunload = function() {
+	//    if (window.oldunload)
+	//        window.oldunload();
+	//  if (typeof(MIDIPlugin) !== "undefined" && MIDIPlugin) { // PER: take care of crash in IE 8
+	//    MIDIPlugin.closePlugin();
+	//  }
+	//};
+
+
+	function MidiProxy(javamidi, qtmidi) {
+		this.javamidi = javamidi;
+		this.qtmidi = qtmidi;
+	}
+
+	MidiProxy.prototype.setTempo = function(qpm) {
+		this.javamidi.setTempo(qpm);
+		this.qtmidi.setTempo(qpm);
+	};
+
+	MidiProxy.prototype.startTrack = function() {
+		this.javamidi.startTrack();
+		this.qtmidi.startTrack();
+	};
+
+	MidiProxy.prototype.endTrack = function() {
+		this.javamidi.endTrack();
+		this.qtmidi.endTrack();
+	};
+
+	MidiProxy.prototype.setInstrument = function(number) {
+		this.javamidi.setInstrument(number);
+		this.qtmidi.setInstrument(number);
+	};
+
+	MidiProxy.prototype.startNote = function(pitch, loudness, abcelem) {
+		this.javamidi.startNote(pitch, loudness, abcelem);
+		this.qtmidi.startNote(pitch, loudness, abcelem);
+	};
+
+	MidiProxy.prototype.endNote = function(pitch, length) {
+		this.javamidi.endNote(pitch, length);
+		this.qtmidi.endNote(pitch, length);
+	};
+
+	MidiProxy.prototype.addRest = function(length) {
+		this.javamidi.addRest(length);
+		this.qtmidi.addRest(length);
+	};
+
+	MidiProxy.prototype.embed = function(parent) {
+		this.javamidi.embed(parent);
+		this.qtmidi.embed(parent, true);
+	};
+
+	function JavaMidi(midiwriter) {
+		this.playlist = []; // contains {time:t,funct:f} pairs
+		this.trackcount = 0;
+		this.timecount = 0;
+		this.tempo = 60;
+		this.midiapi = MIDIPlugin;
+		this.midiwriter = midiwriter;
+		this.noteOnAndChannel = "%90";
+	}
+
+	JavaMidi.prototype.setTempo = function(qpm) {
+		this.tempo = qpm;
+	};
+
+	JavaMidi.prototype.startTrack = function() {
+		this.silencelength = 0;
+		this.trackcount++;
+		this.timecount = 0;
+		this.playlistpos = 0;
+		this.first = true;
+		if (this.instrument) {
+			this.setInstrument(this.instrument);
+		}
+		if (this.channel) {
+			this.setChannel(this.channel);
+		}
+	};
+
+	JavaMidi.prototype.endTrack = function() {
+		// need to do anything?
+	};
+
+	JavaMidi.prototype.setInstrument = function(number) {
+		this.instrument = number;
+		this.midiapi.setInstrument(number);
+		//TODO push this into the playlist?
+	};
+
+	JavaMidi.prototype.setChannel = function(number) {
+		this.channel = number;
+		this.midiapi.setChannel(number);
+	};
+
+	JavaMidi.prototype.updatePos = function() {
+		while (this.playlist[this.playlistpos] &&
+		this.playlist[this.playlistpos].time < this.timecount) {
+			this.playlistpos++;
+		}
+	};
+
+	JavaMidi.prototype.startNote = function(pitch, loudness, abcelem) {
+		this.timecount += this.silencelength;
+		this.silencelength = 0;
+		if (this.first) {
+			//nothing special if first?
+		}
+		this.updatePos();
+		var self = this;
+		this.playlist.splice(this.playlistpos, 0, {
+			time: this.timecount,
+			funct: function() {
+				self.midiapi.playNote(pitch);
+				self.midiwriter.notifySelect(abcelem);
+			}
+		});
+	};
+
+	JavaMidi.prototype.endNote = function(pitch, length) {
+		this.timecount += length;
+		this.updatePos();
+		var self = this;
+		this.playlist.splice(this.playlistpos, 0, {
+			time: this.timecount,
+			funct: function() {
+				self.midiapi.stopNote(pitch);
+			}
+		});
+	};
+
+	JavaMidi.prototype.addRest = function(length) {
+		this.silencelength += length;
+	};
+
+	JavaMidi.prototype.embed = function(parent) {
+
+
+		this.playlink = setAttributes(document.createElement('a'), {
+			style: "border:1px solid black; margin:3px;"
+		});
+		this.playlink.innerHTML = "play";
+		var self = this;
+		this.playlink.onmousedown = function() {
+			if (self.playing) {
+				this.innerHTML = "play";
+				self.pausePlay();
+			} else {
+				this.innerHTML = "pause";
+				self.startPlay();
+			}
+		};
+		parent.appendChild(this.playlink);
+
+		var stoplink = setAttributes(document.createElement('a'), {
+			style: "border:1px solid black; margin:3px;"
+		});
+		stoplink.innerHTML = "stop";
+		//var self = this;
+		stoplink.onmousedown = function() {
+			self.stopPlay();
+		};
+		parent.appendChild(stoplink);
+		this.i = 0;
+		this.currenttime = 0;
+		this.playing = false;
+	};
+
+	JavaMidi.prototype.stopPlay = function() {
+		this.i = 0;
+		this.currenttime = 0;
+		this.pausePlay();
+		this.playlink.innerHTML = "play";
+	};
+
+	JavaMidi.prototype.startPlay = function() {
+		this.playing = true;
+		var self = this;
+		// repeat every 16th note TODO see the min in the piece
+		this.ticksperinterval = 480 / 4;
+		this.doPlay();
+		this.playinterval = window.setInterval(function() {self.doPlay(); },
+			(60000 / (this.tempo * 4)));
+	};
+
+	JavaMidi.prototype.pausePlay = function() {
+		this.playing = false;
+		window.clearInterval(this.playinterval);
+		this.midiapi.stopAllNotes();
+	};
+
+	JavaMidi.prototype.doPlay = function() {
+		while (this.playlist[this.i] &&
+		this.playlist[this.i].time <= this.currenttime) {
+			this.playlist[this.i].funct();
+			this.i++;
+		}
+		if (this.playlist[this.i]) {
+			this.currenttime += this.ticksperinterval;
+		} else {
+			this.stopPlay();
+		}
+	};
+
+	function Midi() {
+		this.trackstrings = "";
+		this.trackcount = 0;
+		this.noteOnAndChannel = "%90";
+	}
+
+	Midi.prototype.setTempo = function(qpm) {
+		//console.log("setTempo",qpm);
+		if (this.trackcount === 0) {
+			this.startTrack();
+			this.track += "%00%FF%51%03" + toHex(Math.round(60000000 / qpm), 6);
+			this.endTrack();
+		}
+	};
+
+	Midi.prototype.setGlobalInfo = function(qpm, name) {
+		//console.log("setGlobalInfo",qpm, key, time, name);
+		if (this.trackcount === 0) {
+			this.startTrack();
+			this.track += "%00%FF%51%03" + toHex(Math.round(60000000 / qpm), 6);
+			// TODO-PER: we could also store the key and time signatures, something like:
+			//00 FF 5902 03 00 - key signature
+			//00 FF 5804 04 02 30 08 - time signature
+			if (name) {
+				this.track += "%00%FF%03" + toHex(name.length, 2);
+				for (var i = 0; i < name.length; i++)
+					this.track += toHex(name.charCodeAt(i), 2);
+			}
+			this.endTrack();
+		}
+	};
+
+	Midi.prototype.startTrack = function() {
+		//console.log("startTrack");
+		this.track = "";
+		this.silencelength = 0;
+		this.trackcount++;
+		this.first = true;
+		if (this.instrument) {
+			this.setInstrument(this.instrument);
+		}
+	};
+
+	Midi.prototype.endTrack = function() {
+		//console.log("endTrack");
+		var tracklength = toHex(this.track.length / 3 + 4, 8);
+		this.track = "MTrk" + tracklength + // track header
+			this.track +
+			'%00%FF%2F%00'; // track end
+		this.trackstrings += this.track;
+	};
+
+	Midi.prototype.setInstrument = function(number) {
+		//console.log("setInstrument", number);
+		if (this.track)
+			this.track = "%00%C0" + toHex(number, 2) + this.track;
+		else
+			this.track = "%00%C0" + toHex(number, 2);
+		this.instrument = number;
+	};
+
+	Midi.prototype.setChannel = function(number) {
+		//console.log("setChannel", number);
+		this.channel = number - 1;
+		this.noteOnAndChannel = "%9" + this.channel.toString(16);
+	};
+
+	Midi.prototype.startNote = function(pitch, loudness) {
+		//console.log("startNote", pitch, loudness);
+		this.track += toDurationHex(this.silencelength); // only need to shift by amount of silence (if there is any)
+		this.silencelength = 0;
+		if (this.first) {
+			this.first = false;
+			this.track += this.noteOnAndChannel;
+		}
+		this.track += "%" + pitch.toString(16) + toHex(loudness, 2); //note
+	};
+
+	Midi.prototype.endNote = function(pitch, length) {
+		//console.log("endNote", pitch, length);
+		this.track += toDurationHex(this.silencelength+length); // only need to shift by amount of silence (if there is any)
+		this.silencelength = 0;
+//		this.track += toDurationHex(length); //duration
+		this.track += "%" + pitch.toString(16) + "%00";//end note
+	};
+
+	Midi.prototype.addRest = function(length) {
+		//console.log("addRest", length);
+		this.silencelength += length;
+	};
+
+	Midi.prototype.getData = function() {
+		return "data:audio/midi," +
+			"MThd%00%00%00%06%00%01" + toHex(this.trackcount, 4) + "%01%e0" + // header
+			this.trackstrings;
+	};
+
+	Midi.prototype.embed = function(parent, noplayer) {
+
+		var data = this.getData();
+
+		var link = setAttributes(document.createElement('a'), {
+			href: data
+		});
+		link.innerHTML = "download midi";
+		parent.insertBefore(link, parent.firstChild);
+
+		if (noplayer) return;
+
+		var embed = setAttributes(document.createElement('embed'), {
+			src: data,
+			type: 'video/quicktime',
+			controller: 'true',
+			autoplay: 'false',
+			loop: 'false',
+			enablejavascript: 'true',
+			style: 'display:block; height: 20px;'
+		});
+		parent.insertBefore(embed, parent.firstChild);
+	};
+
+	// s is assumed to be of even length
+	function encodeHex(s) {
+		var ret = "";
+		for (var i = 0; i < s.length; i += 2) {
+			ret += "%";
+			ret += s.substr(i, 2);
+		}
+		return ret;
+	}
+
+	function toHex(n, padding) {
+		var s = n.toString(16);
+		while (s.length < padding) {
+			s = "0" + s;
+		}
+		return encodeHex(s);
+	}
+
+	function toDurationHex(n) {
+		var res = 0;
+		var a = [];
+
+		// cut up into 7 bit chunks;
+		while (n !== 0) {
+			a.push(n & 0x7F);
+			n = n >> 7;
+		}
+
+		// join the 7 bit chunks together, all but last chunk get leading 1
+		for (var i = a.length - 1; i >= 0; i--) {
+			res = res << 8;
+			var bits = a[i];
+			if (i !== 0) {
+				bits = bits | 0x80;
+			}
+			res = res | bits;
+		}
+
+		var padding = res.toString(16).length;
+		padding += padding % 2;
+
+		return toHex(res, padding);
+	}
+
+	window.ABCJS.midi.rendererFactory = function(isJava) {
+		return (isJava) ? new MidiProxy(new JavaMidi(this), new Midi()) : new Midi();
+	};
+
+	window.ABCJS.midi.initializeJava = function() {
+		MIDIPlugin = document.MIDIPlugin;
+		setTimeout(function() { // run on next event loop (once MIDIPlugin is loaded)
+			try { // activate MIDIPlugin
+				MIDIPlugin.openPlugin();
+
+			} catch(e) { // plugin not supported (download externals)
+				var a = document.createElement("a");
+				a.href = "http://java.sun.com/products/java-media/sound/soundbanks.html";
+				a.target = "_blank";
+				a.appendChild(document.createTextNode("Download Soundbank"));
+				parent.appendChild(a);
+			}
+		}, 0);
+	};
+
+})();

data/app/assets/javascripts/abcjs/midi/abc_midi_sequencer.js

@@ -0,0 +1,207 @@
+//    abc_midi_sequencer.js: Turn parsed abc into a linear series of events.
+//    Copyright (C) 2010,2015 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
+//
+//    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 3 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.  If not, see <http://www.gnu.org/licenses/>.
+
+if (!window.ABCJS)
+	window.ABCJS = {};
+
+if (!window.ABCJS.midi)
+	window.ABCJS.midi = {};
+
+(function() {
+	"use strict";
+
+	// The abc is provided to us line by line. It might have repeats in it. We want to re arrange the elements to
+	// be an array of voices with all the repeats embedded, and no lines. Then it is trivial to go through the events
+	// one at a time and turn it into midi.
+
+	window.ABCJS.midi.sequence = function(abctune, options) {
+		// Global options
+		options = options || {};
+		var qpm = options.qpm || 180;	// The tempo if there isn't a tempo specified.
+		var program = options.program || 2;	// The program if there isn't a program specified.
+		var transpose = options.transpose || 0;
+		var channel = options.channel || 0;
+
+		var bagpipes = abctune.formatting.bagpipes; // If it is bagpipes, then the gracenotes are played on top of the main note.
+		if (bagpipes)
+			program = 71;
+
+		// %%MIDI formatting options
+		if (abctune.formatting.midi) {
+			if (abctune.formatting.midi.transpose)
+				transpose = abctune.formatting.midi.transpose;
+
+			// PER: changed format of the global midi commands from the parser. Using the new definition here.
+			if (abctune.formatting.midi.program && abctune.formatting.midi.program.program)
+				program = abctune.formatting.midi.program.program;
+			if (abctune.formatting.midi.channel)
+				channel = abctune.formatting.midi.channel;
+		}
+
+		// Specified options in abc string.
+
+		if (abctune.metaText.tempo)
+			qpm = interpretTempo(abctune.metaText.tempo);
+
+		var startVoice = [];
+		if (bagpipes)
+			startVoice.push({ el_type: 'bagpipes' });
+		startVoice.push({ el_type: 'instrument', program: program });
+		if (channel)
+			startVoice.push({ el_type: 'channel', channel: channel });
+		if (transpose)
+			startVoice.push({ el_type: 'transpose', transpose: transpose });
+		startVoice.push({ el_type: 'tempo', qpm: qpm });
+
+		// the relevant part of the input structure is:
+		// abctune
+		//		array lines
+		//			array staff
+		//				object key
+		//				object meter
+		//				array voices
+		//					array abcelem
+
+		// visit each voice completely in turn
+		var voices = [];
+		var startRepeatPlaceholder = []; // There is a place holder for each voice.
+		var skipEndingPlaceholder = []; // This is the place where the first ending starts.
+		for (var i = 0; i < abctune.lines.length; i++) {
+			// For each group of staff lines in the tune.
+			var line = abctune.lines[i];
+			if (line.staff) {
+				var staves = line.staff;
+				var voiceNumber = 0;
+				for (var j = 0; j < staves.length; j++) {
+					var staff = staves[j];
+					// For each staff line
+					for (var k = 0; k < staff.voices.length; k++) {
+						// For each voice in a staff line
+						var voice = staff.voices[k];
+						if (!voices[voiceNumber])
+							voices[voiceNumber] = [].concat(startVoice);
+						if (staff.key) {
+							if (staff.key.root === 'HP')
+								voices[voiceNumber].push({el_type: 'key', accidentals: [{acc: 'natural', note: 'g'}, {acc: 'sharp', note: 'f'}, {acc: 'sharp', note: 'c'}]});
+							else
+								voices[voiceNumber].push({el_type: 'key', accidentals: staff.key.accidentals });
+						}
+						if (staff.meter) {
+							voices[voiceNumber].push(interpretMeter(staff.meter));
+						}
+						if (staff.clef && staff.clef.transpose) {
+							staff.clef.el_type = 'clef';
+							voices[voiceNumber].push({ el_type: 'transpose', transpose: staff.clef.transpose });
+						}
+						var noteEventsInBar = 0;
+						for (var v = 0; v < voice.length; v++) {
+							// For each element in a voice
+							var elem = voice[v];
+							switch (elem.el_type) {
+								case "note":
+									// regular items are just pushed.
+									if (!elem.rest || elem.rest.type !== 'spacer') {
+										voices[voiceNumber].push(elem);
+										noteEventsInBar++;
+									}
+									break;
+								case "key":
+									if (elem.root === 'HP')
+										voices[voiceNumber].push({el_type: 'key', accidentals: [{acc: 'natural', note: 'g'}, {acc: 'sharp', note: 'f'}, {acc: 'sharp', note: 'c'}]});
+									else
+										voices[voiceNumber].push({el_type: 'key', accidentals: elem.accidentals });
+									break;
+								case "meter":
+									voices[voiceNumber].push(interpretMeter(elem));
+									break;
+								case "clef": // need to keep this to catch the "transpose" element.
+									if (elem.transpose)
+										voices[voiceNumber].push({ el_type: 'transpose', transpose: elem.transpose });
+									break;
+								case "tempo":
+									qpm = interpretTempo(elem);
+									voices[voiceNumber].push({ el_type: 'tempo', qpm: qpm });
+									break;
+								case "bar":
+									if (noteEventsInBar > 0) // don't add two bars in a row.
+										voices[voiceNumber].push({ el_type: 'bar' }); // We need the bar marking to reset the accidentals.
+									noteEventsInBar = 0;
+									// figure out repeats and endings --
+									// The important part is where there is a start repeat, and end repeat, or a first ending.
+									var endRepeat = (elem.type === "bar_right_repeat" || elem.type === "bar_dbl_repeat");
+									var startEnding = (elem.startEnding) ? true : false;
+									var startRepeat = (elem.type === "bar_left_repeat" || elem.type === "bar_dbl_repeat" || elem.type === "bar_thick_thin" || elem.type === "bar_thin_thick" || elem.type === "bar_thin_thin" || elem.type === "bar_right_repeat");
+									if (endRepeat) {
+										var s = startRepeatPlaceholder[voiceNumber];
+										if (!s) s = 0; // If there wasn't a left repeat, then we repeat from the beginning.
+										var e = skipEndingPlaceholder[voiceNumber];
+										if (!e) e = voices[voiceNumber].length; // If there wasn't a first ending marker, then we copy everything.
+										voices[voiceNumber] = voices[voiceNumber].concat(voices[voiceNumber].slice(s, e));
+									}
+									if (startEnding)
+										skipEndingPlaceholder[voiceNumber] = voices[voiceNumber].length;
+									if (startRepeat)
+										startRepeatPlaceholder[voiceNumber] = voices[voiceNumber].length;
+									break;
+								case 'style':
+									// TODO-PER: If this is set to rhythm heads, then it should use the percussion channel.
+									break;
+								case 'part':
+									// TODO-PER: If there is a part section in the header, then this should probably affect the repeats.
+									break;
+								case 'stem':
+								case 'scale':
+									// These elements don't affect sound
+									break;
+								default:
+									console.log("MIDI: element type " + elem.el_type + " not handled.");
+							}
+						}
+						voiceNumber++;
+					}
+				}
+			}
+		}
+		return voices;
+	};
+
+	function interpretTempo(element) {
+		var duration = 1/4;
+		if (element.duration) {
+			duration = element.duration[0];
+		}
+		var bpm = 60;
+		if (element.bpm) {
+			bpm = element.bpm;
+		}
+		return bpm*duration*4;
+	}
+
+	function interpretMeter(element) {
+		switch (element.type) {
+			case "common_time":
+				return { el_type: 'meter', num: 4, den: 4 };
+			case "cut_time":
+				return { el_type: 'meter', num: 2, den: 2 };
+			case "specified":
+				// TODO-PER: only taking the first meter, so the complex meters are not handled.
+				return { el_type: 'meter', num: element.value[0].num, den: element.value[0].den };
+			default:
+				// This should never happen.
+				return { el_type: 'meter' };
+		}
+	}
+})();