abcjs 6.3.0 → 6.4.1

package/src/synth/abc_midi_flattener.js

@@ -5,7 +5,7 @@
 // It also extracts guitar chords to a separate voice and resolves their rhythm.
 
 var flatten;
-var parseCommon = require("../parse/abc_common");
+var ChordTrack = require("./chord-track");
 var pitchesToPerc = require('./pitches-to-perc');
 
 (function() {
@@ -26,23 +26,11 @@ var pitchesToPerc = require('./pitches-to-perc');
 	var lastNoteDurationPosition;
 	var currentTrackName;
 	var lastEventTime;
+	var chordTrack;
 
 	var meter = { num: 4, den: 4 };
-	var chordTrack;
-	var chordSourceTrack;
-	var chordTrackFinished;
-	var chordChannel;
-	var bassInstrument = 0;
-	var chordInstrument = 0;
 	var drumInstrument = 128;
-	var boomVolume = 64;
-	var chickVolume = 48;
-	var currentChords;
-	var lastChord;
-	var chordLastBar;
 	var lastBarTime;
-	var gChordTacet = false;
-	var hasRhythmHead = false;
 	var doBeatAccents = true;
 	var stressBeat1 = 105;
 	var stressBeatDown = 95;
@@ -83,21 +71,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 		lastEventTime = 0;
 		percmap = percmap_;
 
-		// For resolving chords.
 		meter = { num: 4, den: 4 };
-		chordTrack = [];
-		chordSourceTrack = false;
-		chordChannel = voices.length; // first free channel for chords
-		chordTrackFinished = false;
-		currentChords = [];
-		bassInstrument = midiOptions.bassprog && midiOptions.bassprog.length === 1 ? midiOptions.bassprog[0] : 0;
-		chordInstrument = midiOptions.chordprog && midiOptions.chordprog.length === 1 ? midiOptions.chordprog[0] : 0;
-		boomVolume = midiOptions.bassvol && midiOptions.bassvol.length === 1 ? midiOptions.bassvol[0] : 64;
-		chickVolume = midiOptions.chordvol && midiOptions.chordvol.length === 1 ? midiOptions.chordvol[0] : 48;
-		lastChord = undefined;
-		chordLastBar = undefined;
-		gChordTacet = options.chordsOff ? true : false;
-		hasRhythmHead = false;
 
 		doBeatAccents = true;
 		stressBeat1 = 105;
@@ -117,16 +91,31 @@ var pitchesToPerc = require('./pitches-to-perc');
 		if (voices.length > 0 && voices[0].length > 0)
 			pickupLength = voices[0][0].pickupLength;
 
+		// For resolving chords.
+		if (options.bassprog !== undefined && !midiOptions.bassprog)
+			midiOptions.bassprog = [options.bassprog]
+		if (options.bassvol !== undefined && !midiOptions.bassvol)
+			midiOptions.bassvol = [options.bassvol]
+		if (options.chordprog !== undefined && !midiOptions.chordprog)
+			midiOptions.chordprog = [options.chordprog]
+		if (options.chordvol !== undefined && !midiOptions.chordvol)
+			midiOptions.chordvol = [options.chordvol]
+		if (options.gchord !== undefined && !midiOptions.gchord)
+			midiOptions.gchord = [options.gchord]
+		chordTrack = new ChordTrack(voices.length, options.chordsOff, midiOptions, meter)
+
 		// First adjust the input to resolve ties, set the starting time for each note, etc. That will make the rest of the logic easier
 		preProcess(voices, options);
 
 		for (var i = 0; i < voices.length; i++) {
 			transpose = 0;
+			chordTrack.setTranspose(transpose)
 			lastNoteDurationPosition = -1;
 			var voice = voices[i];
 			currentTrack = [{ cmd: 'program', channel: i, instrument: instrument }];
 			currentTrackName = undefined;
 			lastBarTime = 0;
+			chordTrack.setLastBarTime(0)
 			var voiceOff = false;
 			if (options.voicesOff === true)
 				voiceOff = true;
@@ -139,9 +128,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 						currentTrackName = {cmd: 'text', type: "name", text: element.trackName };
 						break;
 					case "note":
-						var setChordTrack = writeNote(element, voiceOff);
-						if (setChordTrack)
-							chordSourceTrack = i;
+						writeNote(element, voiceOff);
 						break;
 					case "key":
 						accidentals = setKeySignature(element);
@@ -150,6 +137,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 						if (!startingMeter)
 							startingMeter = element;
 						meter = element;
+						chordTrack.setMeter(meter)
 						beatFraction = getBeatFraction(meter);
 						alignDrumToMeter();
 						break;
@@ -158,21 +146,21 @@ var pitchesToPerc = require('./pitches-to-perc');
 							startingTempo = element.qpm;
 						else
 							tempoChangeFactor = element.qpm ? startingTempo / element.qpm : 1;
+						chordTrack.setTempoChangeFactor(tempoChangeFactor)
 						break;
 					case "transpose":
 						transpose = element.transpose;
+						chordTrack.setTranspose(transpose)
 						break;
 					case "bar":
-						if (chordTrack.length > 0 && (chordSourceTrack === false || i === chordSourceTrack)) {
-							resolveChords(lastBarTime, timeToRealTime(element.time));
-							currentChords = [];
-						}
+						chordTrack.barEnd(element)
+
 						barAccidentals = [];
 						if (i === 0) // Only write the drum part on the first voice so that it is not duplicated.
 							writeDrum(voices.length+1);
-						hasRhythmHead = false; // decide whether there are rhythm heads each measure.
-						chordLastBar = lastChord;
+							chordTrack.setRhythmHead(false) // decide whether there are rhythm heads each measure.
 						lastBarTime = timeToRealTime(element.time);
+						chordTrack.setLastBarTime(lastBarTime)
 						break;
 					case "bagpipes":
 						bagpipes = true;
@@ -198,9 +186,8 @@ var pitchesToPerc = require('./pitches-to-perc');
 						drumDefinition = normalizeDrumDefinition(element.params);
 						alignDrumToMeter();
 						break;
-					case "gchord":
-						if (!options.chordsOff)
-							gChordTacet = element.tacet;
+					case "gchordOn":
+						chordTrack.gChordOn(element)
 						break;
 					case "beat":
 						stressBeat1 = element.beats[0];
@@ -217,6 +204,13 @@ var pitchesToPerc = require('./pitches-to-perc');
 					case "beataccents":
 						doBeatAccents = element.value;
 						break;
+					case "gchord":
+					case "bassprog":
+					case "chordprog":
+					case "bassvol":
+					case "chordvol":
+						chordTrack.paramChange(element)
+						break
 					default:
 						// This should never happen
 						console.log("MIDI creation. Unknown el_type: " + element.el_type + "\n");// jshint ignore:line
@@ -228,8 +222,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 			if (currentTrackName)
 				currentTrack.unshift(currentTrackName);
 			tracks.push(currentTrack);
-			if (!chordTrackEmpty()) // Don't do chords on more than one track, so turn off chord detection after we create it.
-				chordTrackFinished = true;
+			chordTrack.finish()
 			if (drumTrack.length > 0) // Don't do drums on more than one track, so turn off drum after we create it.
 				drumTrackFinished = true;
 		}
@@ -237,8 +230,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 		if (options.detuneOctave)
 			findOctaves(tracks, parseInt(options.detuneOctave, 10));
 
-		if (!chordTrackEmpty())
-			tracks.push(chordTrack);
+		chordTrack.addTrack(tracks)
 		if (drumTrack.length > 0)
 			tracks.push(drumTrack);
 
@@ -254,15 +246,6 @@ var pitchesToPerc = require('./pitches-to-perc');
 		}
 	}
 
-	function chordTrackEmpty() {
-		var isEmpty = true;
-		for (var i = 0; i < chordTrack.length && isEmpty; i++) {
-			if (chordTrack[i].cmd === 'note')
-				isEmpty = false
-		}
-		return isEmpty;
-	}
-
 	function timeToRealTime(time) {
 		return time/1000000;
 	}
@@ -353,53 +336,6 @@ var pitchesToPerc = require('./pitches-to-perc');
 		}
 		return 0.25;
 	}
-	//
-	// The algorithm for chords is:
-	// - The chords are done in a separate track.
-	// - If there are notes before the first chord, then put that much silence to start the track.
-	// - The pattern of chord expression depends on the meter, and how many chords are in a measure.
-	// - There is a possibility that a measure will have an incorrect number of beats, if that is the case, then
-	// start the pattern anew on the next measure number.
-	// - If a chord root is not A-G, then ignore it as if the chord wasn't there at all.
-	// - If a chord modification isn't in our supported list, change it to a major triad.
-	//
-	// - If there is only one chord in a measure:
-	//		- If 2/4, play root chord
-	//		- If cut time, play root(1) chord(3)
-	//		- If 3/4, play root chord chord
-	//		- If 4/4 or common time, play root chord fifth chord
-	//		- If 6/8, play root(1) chord(3) fifth(4) chord(6)
-	//		- For any other meter, play the full chord on each beat. (TODO-PER: expand this as more support is added.)
-	//
-	//	- If there is a chord specified that is not on a beat, move it earlier to the previous beat, unless there is already a chord on that beat.
-	//	- Otherwise, move it later, unless there is already a chord on that beat.
-	// 	- Otherwise, ignore it. (TODO-PER: expand this as more support is added.)
-	//
-	// - If there is a chord on the second beat, play a chord for the first beat instead of a bass note.
-	// - Likewise, if there is a chord on the fourth beat of 4/4, play a chord on the third beat instead of a bass note.
-	//
-	// If there is any note in the melody that has a rhythm head, then assume the melody controls the rhythm, so that is
-	// the same as a break.
-	var breakSynonyms = [ 'break', '(break)', 'no chord', 'n.c.', 'tacet'];
-
-	function findChord(elem) {
-		if (gChordTacet)
-			return 'break';
-
-		// TODO-PER: Just using the first chord if there are more than one.
-		if (chordTrackFinished || !elem.chord || elem.chord.length === 0)
-			return null;
-
-		// Return the first annotation that is a regular chord: that is, it is in the default place or is a recognized "tacet" phrase.
-		for (var i = 0; i < elem.chord.length; i++) {
-			var ch = elem.chord[i];
-			if (ch.position === 'default')
-				return ch.name;
-			if (breakSynonyms.indexOf(ch.name.toLowerCase()) >= 0)
-				return 'break';
-		}
-		return null;
-	}
 
 	function calcBeat(measureStart, beatLength, currTime) {
 		var distanceFromStart = currTime - measureStart;
@@ -419,7 +355,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 		} else if (pickupLength > beat) {
 			volume = stressBeatUp;
 		} else {
-			var barLength = meter.num / meter.den;
+			//var barLength = meter.num / meter.den;
 			var barBeat = calcBeat(lastBarTime, getBeatFraction(meter), beat);
 			if (barBeat === 0)
 				volume = stressBeat1;
@@ -439,28 +375,6 @@ var pitchesToPerc = require('./pitches-to-perc');
 		return voiceOff ? 0 : volume;
 	}
 
-	function processChord(elem) {
-
-		var firstChord = false;
-		var chord = findChord(elem);
-		if (chord) {
-			var c = interpretChord(chord);
-			// If this isn't a recognized chord, just completely ignore it.
-			if (c) {
-				// If we ever have a chord in this voice, then we add the chord track.
-				// However, if there are chords on more than one voice, then just use the first voice.
-				if (chordTrack.length === 0) {
-					firstChord = true;
-					chordTrack.push({cmd: 'program', channel: chordChannel, instrument: chordInstrument});
-				}
-
-				lastChord = c;
-				var barBeat = calcBeat(lastBarTime, getBeatFraction(meter), timeToRealTime(elem.time));
-				currentChords.push({chord: lastChord, beat: barBeat, start: timeToRealTime(elem.time)});
-			}
-		}
-		return firstChord;
-	}
 
 	function findNoteModifications(elem, velocity) {
 		var ret = { };
@@ -552,10 +466,10 @@ var pitchesToPerc = require('./pitches-to-perc');
 		// If there are guitar chords, then they are put in a separate track, but they have the same format.
 		//
 
-		var trackStartingIndex = currentTrack.length;
+		//var trackStartingIndex = currentTrack.length;
 
 		var velocity = processVolume(timeToRealTime(elem.time), voiceOff);
-		var setChordTrack = processChord(elem);
+		chordTrack.processChord(elem)
 
 		// if there are grace notes, then also play them.
 		// I'm not sure there is an exact rule for the length of the notes. My rule, unless I find
@@ -611,15 +525,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 			// TODO-PER: Can also make a different sound on style=x and style=harmonic
 			var ePitches = elem.pitches;
 			if (elem.style === "rhythm") {
-				hasRhythmHead = true;
-				if (lastChord && lastChord.chick) {
-					ePitches = [];
-					for (var i2 = 0; i2 < lastChord.chick.length; i2++) {
-						var note2 = parseCommon.clone(elem.pitches[0]);
-						note2.actualPitch = lastChord.chick[i2];
-						ePitches.push(note2);
-					}
-				}
+				ePitches = chordTrack.setRhythmHead(true, elem)
 			}
 
 			if (elem.elem)
@@ -674,8 +580,6 @@ var pitchesToPerc = require('./pitches-to-perc');
 		}
 		var realDur = getRealDuration(elem);
 		lastEventTime = Math.max(lastEventTime, timeToRealTime(elem.time)+durationRounded(realDur));
-
-		return setChordTrack;
 	}
 	function getRealDuration(elem) {
 		if (elem.pitches && elem.pitches.length > 0 && elem.pitches[0])
@@ -810,332 +714,6 @@ var pitchesToPerc = require('./pitches-to-perc');
 		return pitch;
 	}
 
-	var basses = {
-		'A': 33, 'B': 35, 'C': 36, 'D': 38, 'E': 40, 'F': 41, 'G': 43
-	};
-	function interpretChord(name) {
-		// chords have the format:
-		// [root][acc][modifier][/][bass][acc]
-		// (The chord might be surrounded by parens. Just ignore them.)
-		// root must be present and must be from A-G.
-		// acc is optional and can be # or b
-		// The modifier can be a wide variety of things, like "maj7". As they are discovered, more are supported here.
-		// If there is a slash, then there is a bass note, which can be from A-G, with an optional acc.
-		// If the root is unrecognized, then "undefined" is returned and there is no chord.
-		// If the modifier is unrecognized, a major triad is returned.
-		// If the bass notes is unrecognized, it is ignored.
-		if (name.length === 0)
-			return undefined;
-		if (name === 'break')
-			return { chick: []};
-		var root = name.substring(0,1);
-		if (root === '(') {
-			name = name.substring(1,name.length-2);
-			if (name.length === 0)
-				return undefined;
-			root = name.substring(0,1);
-		}
-		var bass = basses[root];
-		if (!bass)	// If the bass note isn't listed, then this was an unknown root. Only A-G are accepted.
-			return undefined;
-		// Don't transpose the chords more than an octave.
-		var chordTranspose = transpose;
-		while (chordTranspose < -8)
-			chordTranspose += 12;
-		while (chordTranspose > 8)
-			chordTranspose -= 12;
-		bass  += chordTranspose;
-		var bass2 = bass - 5;	// The alternating bass is a 4th below
-		var chick;
-		if (name.length === 1)
-			chick = chordNotes(bass, '');
-		var remaining = name.substring(1);
-		var acc = remaining.substring(0,1);
-		if (acc === 'b' || acc === '♭') {
-			bass--;
-			bass2--;
-			remaining = remaining.substring(1);
-		} else if (acc === '#' || acc === '♯') {
-			bass++;
-			bass2++;
-			remaining = remaining.substring(1);
-		}
-		var arr = remaining.split('/');
-		chick = chordNotes(bass, arr[0]);
-		// If the 5th is altered then the bass is altered. Normally the bass is 7 from the root, so adjust if it isn't.
-		if (chick.length >= 3) {
-			var fifth = chick[2] - chick[0];
-			bass2 = bass2 + fifth - 7;
-		}
-
-		if (arr.length === 2) {
-			var explicitBass = basses[arr[1].substring(0,1)];
-			if (explicitBass) {
-				var bassAcc = arr[1].substring(1);
-				var bassShift = {'#': 1, '♯': 1, 'b': -1, '♭': -1}[bassAcc] || 0;
-				bass = basses[arr[1].substring(0,1)] + bassShift + chordTranspose;
-				bass2 = bass;
-			}
-		}
-		return { boom: bass, boom2: bass2, chick: chick };
-	}
-
-	var chordIntervals = {
-		// diminished (all flat 5 chords)
-		'dim': [ 0, 3, 6 ],
-		'°': [ 0, 3, 6 ],
-		'˚': [ 0, 3, 6 ],
-
-		'dim7': [ 0, 3, 6, 9 ],
-		'°7': [ 0, 3, 6, 9 ],
-		'˚7': [ 0, 3, 6, 9 ],
-
-		'ø7': [ 0, 3, 6, 10 ],
-		'm7(b5)': [ 0, 3, 6, 10 ],
-		'm7b5': [ 0, 3, 6, 10 ],
-		'm7♭5': [ 0, 3, 6, 10 ],
-		'-7(b5)': [ 0, 3, 6, 10 ],
-		'-7b5': [ 0, 3, 6, 10 ],
-
-		'7b5': [ 0, 4, 6, 10 ],
-		'7(b5)': [ 0, 4, 6, 10 ],
-		'7♭5': [ 0, 4, 6, 10 ],
-
-		'7(b9,b5)': [ 0, 4, 6, 10, 13 ],
-		'7b9,b5': [ 0, 4, 6, 10, 13 ],
-		'7(#9,b5)': [ 0, 4, 6, 10, 15 ],
-		'7#9b5': [ 0, 4, 6, 10, 15 ],
-		'maj7(b5)': [ 0, 4, 6, 11 ],
-		'maj7b5': [ 0, 4, 6, 11 ],
-		'13(b5)': [ 0, 4, 6, 10, 14, 21 ],
-		'13b5': [ 0, 4, 6, 10, 14, 21 ],
-
-		// minor (all normal 5, minor 3 chords)
-		'm': [ 0, 3, 7 ],
-		'-': [ 0, 3, 7 ],
-		'm6': [ 0, 3, 7, 9 ],
-		'-6': [ 0, 3, 7, 9 ],
-		'm7': [ 0, 3, 7, 10 ],
-		'-7': [ 0, 3, 7, 10 ],
-
-		'-(b6)': [ 0, 3, 7, 8 ],
-		'-b6': [ 0, 3, 7, 8 ],
-		'-6/9': [ 0, 3, 7, 9, 14 ],
-		'-7(b9)': [ 0, 3, 7, 10, 13 ],
-		'-7b9': [ 0, 3, 7, 10, 13 ],
-		'-maj7': [ 0, 3, 7, 11 ],
-		'-9+7': [ 0, 3, 7, 11, 13 ],
-		'-11': [  0, 3, 7, 11, 14, 17 ],
-		'm11': [  0, 3, 7, 11, 14, 17 ],
-		'-maj9': [ 0, 3, 7, 11, 14 ],
-		'-∆9': [ 0, 3, 7, 11, 14 ],
-		'mM9': [ 0, 3, 7, 11, 14 ],
-
-		// major (all normal 5, major 3 chords)
-		'M': [ 0, 4, 7 ],
-		'6': [ 0, 4, 7, 9 ],
-		'6/9': [ 0, 4, 7, 9, 14 ],
-		'6add9': [ 0, 4, 7, 9, 14 ],
-		'69': [ 0, 4, 7, 9, 14 ],
-
-		'7': [ 0, 4, 7, 10 ],
-		'9': [ 0, 4, 7, 10, 14 ],
-		'11': [ 0, 7, 10, 14, 17 ],
-		'13': [ 0, 4, 7, 10, 14, 21 ],
-		'7b9': [ 0, 4, 7, 10, 13 ],
-		'7♭9': [ 0, 4, 7, 10, 13 ],
-		'7(b9)': [ 0, 4, 7, 10, 13 ],
-		'7(#9)': [ 0, 4, 7, 10, 15 ],
-		'7#9': [ 0, 4, 7, 10, 15 ],
-		'(13)': [ 0, 4, 7, 10, 14, 21 ],
-		'7(9,13)': [ 0, 4, 7, 10, 14, 21 ],
-		'7(#9,b13)': [ 0, 4, 7, 10, 15, 20 ],
-		'7(#11)': [ 0, 4, 7, 10, 14, 18 ],
-		'7#11': [ 0, 4, 7, 10, 14, 18 ],
-		'7(b13)': [ 0, 4, 7, 10, 20 ],
-		'7b13': [ 0, 4, 7, 10, 20 ],
-		'9(#11)': [ 0, 4, 7, 10, 14, 18 ],
-		'9#11': [ 0, 4, 7, 10, 14, 18 ],
-		'13(#11)': [ 0, 4, 7, 10, 18, 21 ],
-		'13#11': [ 0, 4, 7, 10, 18, 21 ],
-
-		'maj7': [ 0, 4, 7, 11 ],
-		'∆7': [ 0, 4, 7, 11 ],
-		'Δ7': [ 0, 4, 7, 11 ],
-		'maj9': [ 0, 4, 7, 11, 14 ],
-		'maj7(9)': [ 0, 4, 7, 11, 14 ],
-		'maj7(11)': [ 0, 4, 7, 11, 17 ],
-		'maj7(#11)': [ 0, 4, 7, 11, 18 ],
-		'maj7(13)': [ 0, 4, 7, 14, 21 ],
-		'maj7(9,13)': [ 0, 4, 7, 11, 14, 21 ],
-
-		'7sus4': [ 0, 5, 7, 10 ],
-		'm7sus4': [ 0, 3, 7, 10, 17 ],
-		'sus4': [ 0, 5, 7 ],
-		'sus2': [ 0, 2, 7 ],
-		'7sus2': [ 0, 2, 7, 10 ],
-		'9sus4': [ 0, 5, 7, 10, 14 ],
-		'13sus4': [ 0, 5, 7, 10, 14, 21 ],
-
-		// augmented (all sharp 5 chords)
-		'aug7': [ 0, 4, 8, 10 ],
-		'+7': [ 0, 4, 8, 10 ],
-		'+': [ 0, 4, 8 ],
-		'7#5': [ 0, 4, 8, 10 ],
-		'7♯5': [ 0, 4, 8, 10 ],
-		'7+5': [ 0, 4, 8, 10 ],
-		'9#5': [ 0, 4, 8, 10, 14 ],
-		'9♯5': [ 0, 4, 8, 10, 14 ],
-		'9+5': [ 0, 4, 8, 10, 14 ],
-		'-7(#5)': [ 0, 3, 8, 10 ],
-		'-7#5': [ 0, 3, 8, 10 ],
-		'7(#5)': [ 0, 4, 8, 10 ],
-		'7(b9,#5)': [ 0, 4, 8, 10, 13 ],
-		'7b9#5': [ 0, 4, 8, 10, 13 ],
-		'maj7(#5)': [ 0, 4, 8, 11 ],
-		'maj7#5': [ 0, 4, 8, 11 ],
-		'maj7(#5,#11)': [ 0, 4, 8, 11, 18 ],
-		'maj7#5#11': [ 0, 4, 8, 11, 18 ],
-		'9(#5)': [ 0, 4, 8, 10, 14 ],
-		'13(#5)': [ 0, 4, 8, 10, 14, 21 ],
-		'13#5': [ 0, 4, 8, 10, 14, 21 ]
-};
-	function chordNotes(bass, modifier) {
-		var intervals = chordIntervals[modifier];
-		if (!intervals) {
-			if (modifier.slice(0,2).toLowerCase() === 'ma' || modifier[0] === 'M')
-				intervals = chordIntervals.M;
-			else if (modifier[0] === 'm' || modifier[0] === '-')
-				intervals = chordIntervals.m;
-			else
-				intervals = chordIntervals.M;
-		}
-		bass += 12;	// the chord is an octave above the bass note.
-		var notes = [ ];
-		for (var i = 0; i < intervals.length; i++) {
-			notes.push(bass + intervals[i]);
-		}
-		return notes;
-	}
-
-	function writeBoom(boom, beatLength, volume, beat, noteLength) {
-		// undefined means there is a stop time.
-		if (boom !== undefined)
-			chordTrack.push({cmd: 'note', pitch: boom, volume: volume, start: lastBarTime+beat*durationRounded(beatLength), duration: durationRounded(noteLength), gap: 0, instrument: bassInstrument});
-	}
-
-	function writeChick(chick, beatLength, volume, beat, noteLength) {
-		for (var c = 0; c < chick.length; c++)
-			chordTrack.push({cmd: 'note', pitch: chick[c], volume: volume, start: lastBarTime+beat*durationRounded(beatLength), duration: durationRounded(noteLength), gap: 0, instrument: chordInstrument});
-	}
-
-	var rhythmPatterns = { "2/2": [ 'boom', 'chick' ],
-		"2/4": [ 'boom', 'chick' ],
-		"3/4": [ 'boom', 'chick', 'chick' ],
-		"4/4": [ 'boom', 'chick', 'boom2', 'chick' ],
-		"5/4": [ 'boom', 'chick', 'chick', 'boom2', 'chick' ],
-		"6/8": [ 'boom', '', 'chick', 'boom2', '', 'chick' ],
-		"9/8": [ 'boom', '', 'chick', 'boom2', '', 'chick', 'boom2', '', 'chick' ],
-		"12/8": [ 'boom', '', 'chick', 'boom2', '', 'chick', 'boom', '', 'chick', 'boom2', '', 'chick' ],
-	};
-
-	function resolveChords(startTime, endTime) {
-		var num = meter.num;
-		var den = meter.den;
-		var beatLength = 1/den;
-		var noteLength = beatLength/2;
-		var pattern = rhythmPatterns[num+'/'+den];
-		var thisMeasureLength = parseInt(num,10)/parseInt(den,10);
-		var portionOfAMeasure = thisMeasureLength - (endTime-startTime)/tempoChangeFactor;
-		if (Math.abs(portionOfAMeasure) < 0.00001)
-			portionOfAMeasure = false;
-		if (!pattern || portionOfAMeasure) { // If it is an unsupported meter, or this isn't a full bar, just chick on each beat.
-			pattern = [];
-			var beatsPresent = ((endTime-startTime)/tempoChangeFactor) / beatLength;
-			for (var p = 0; p < beatsPresent; p++)
-				pattern.push("chick");
-		}
-		//console.log(startTime, pattern, currentChords, lastChord, portionOfAMeasure)
-
-		if (currentChords.length === 0) { // there wasn't a new chord this measure, so use the last chord declared.
-			currentChords.push({ beat: 0, chord: lastChord});
-		}
-		if (currentChords[0].beat !== 0 && lastChord) { // this is the case where there is a chord declared in the measure, but not on its first beat.
-			if (chordLastBar)
-				currentChords.unshift({ beat: 0, chord: chordLastBar});
-		}
-		if (currentChords.length === 1) {
-			for (var m = currentChords[0].beat; m < pattern.length; m++) {
-				if (!hasRhythmHead) {
-					switch (pattern[m]) {
-						case 'boom':
-							writeBoom(currentChords[0].chord.boom, beatLength, boomVolume, m, noteLength);
-							break;
-						case 'boom2':
-							writeBoom(currentChords[0].chord.boom2, beatLength, boomVolume, m, noteLength);
-							break;
-						case 'chick':
-							writeChick(currentChords[0].chord.chick, beatLength, chickVolume, m, noteLength);
-							break;
-					}
-				}
-			}
-			return;
-		}
-
-		// If we are here it is because more than one chord was declared in the measure, so we have to sort out what chord goes where.
-
-		// First, normalize the chords on beats.
-		var mult = beatLength === 0.125 ? 3 : 1; // If this is a compound meter then the beats in the currentChords is 1/3 of the true beat
-		var beats = {};
-		for (var i = 0; i < currentChords.length; i++) {
-			var cc = currentChords[i];
-			var b = Math.round(cc.beat*mult);
-			beats[''+b] = cc;
-		}
-
-		// - If there is a chord on the second beat, play a chord for the first beat instead of a bass note.
-		// - Likewise, if there is a chord on the fourth beat of 4/4, play a chord on the third beat instead of a bass note.
-		for (var m2 = 0; m2 < pattern.length; m2++) {
-			var thisChord;
-			if (beats[''+m2])
-				thisChord = beats[''+m2];
-			var lastBoom;
-			if (!hasRhythmHead && thisChord) {
-				switch (pattern[m2]) {
-					case 'boom':
-						if (beats['' + (m2 + 1)]) // If there is not a chord change on the next beat, play a bass note.
-							writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);
-						else {
-							writeBoom(thisChord.chord.boom, beatLength, boomVolume, m2, noteLength);
-							lastBoom = thisChord.chord.boom;
-						}
-						break;
-					case 'boom2':
-						if (beats['' + (m2 + 1)])
-							writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);
-						else {
-							// If there is the same root as the last chord, use the alternating bass, otherwise play the root.
-							if (lastBoom === thisChord.chord.boom) {
-								writeBoom(thisChord.chord.boom2, beatLength, boomVolume, m2, noteLength);
-								lastBoom = undefined;
-							} else {
-								writeBoom(thisChord.chord.boom, beatLength, boomVolume, m2, noteLength);
-								lastBoom = thisChord.chord.boom;
-							}
-						}
-						break;
-					case 'chick':
-						writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);
-						break;
-					case '':
-						if (beats['' + m2])	// If there is an explicit chord on this beat, play it.
-							writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);
-						break;
-				}
-			}
-		}
-	}
 
 	function normalizeDrumDefinition(params) {
 		// Be very strict with the drum definition. If anything is not perfect,