abcjs 6.4.1 → 6.4.2

package/src/synth/abc_midi_flattener.js

@@ -209,6 +209,7 @@ var pitchesToPerc = require('./pitches-to-perc');
 					case "chordprog":
 					case "bassvol":
 					case "chordvol":
+					case "gchordbars":
 						chordTrack.paramChange(element)
 						break
 					default:
@@ -347,7 +348,8 @@ var pitchesToPerc = require('./pitches-to-perc');
 			return 0;
 
 		var volume;
-		if (nextVolume) {
+    	// MAE 21 Jun 2024 - This previously wasn't allowing zero volume to be applied
+		if (nextVolume != undefined) {
 			volume = nextVolume;
 			nextVolume = undefined;
 		} else if (!doBeatAccents) {

package/src/synth/abc_midi_sequencer.js

@@ -315,7 +315,7 @@ var parseCommon = require("../parse/abc_common");
 										if (!e) e = voices[voiceNumber].length; // If there wasn't a first ending marker, then we copy everything.
 										// duplicate each of the elements - this has to be a deep copy.
 										for (var z = s; z < e; z++) {
-											var item = parseCommon.clone(voices[voiceNumber][z]);
+											var item = Object.assign({},voices[voiceNumber][z]);
 											if (item.pitches)
 												item.pitches = parseCommon.cloneArray(item.pitches);
 											voices[voiceNumber].push(item);
@@ -389,12 +389,27 @@ var parseCommon = require("../parse/abc_common");
 											break;
 										case "swing":
 										case "gchord":
-										case "bassprog":
-										case "chordprog":
 										case "bassvol":
 										case "chordvol":
 											voices[voiceNumber].push({ el_type: elem.cmd, param: elem.params[0] });
 											break;
+
+										case "bassprog": // MAE 22 May 2024
+										case "chordprog": // MAE 22 May 2024
+					                      voices[voiceNumber].push({
+					                        el_type: elem.cmd,
+					                        value: elem.params[0],
+					                        octaveShift: elem.params[1]
+					                      });
+					                      break;
+
+					                    // MAE 23 Jun 2024
+					                    case "gchordbars":
+					                        voices[voiceNumber].push({
+					                          el_type: elem.cmd,
+					                          param: elem.params[0]
+					                        });
+					                    break;
 										default:
 											console.log("MIDI seq: midi cmd not handled: ", elem.cmd, elem);
 									}

package/src/synth/chord-track.js

@@ -17,8 +17,6 @@
 //
 // If there is any note in the melody that has a rhythm head, then assume the melody controls the rhythm, so there is no chord added for that entire measure.
 
-var parseCommon = require("../parse/abc_common");
-
 var ChordTrack = function ChordTrack(numVoices, chordsOff, midiOptions, meter) {
 	this.chordTrack = [];
 	this.chordTrackFinished = false;
@@ -34,12 +32,24 @@ var ChordTrack = function ChordTrack(numVoices, chordsOff, midiOptions, meter) {
 	this.meter = meter;
 	this.tempoChangeFactor = 1;
 
-	this.bassInstrument = midiOptions.bassprog && midiOptions.bassprog.length === 1 ? midiOptions.bassprog[0] : 0;
-	this.chordInstrument = midiOptions.chordprog && midiOptions.chordprog.length === 1 ? midiOptions.chordprog[0] : 0;
+	// MAE 17 Jun 2024 - To allow for bass and chord instrument octave shifts
+	this.bassInstrument = midiOptions.bassprog && midiOptions.bassprog.length >= 1 ? midiOptions.bassprog[0] : 0;
+	this.chordInstrument = midiOptions.chordprog && midiOptions.chordprog.length >= 1 ? midiOptions.chordprog[0] : 0;
+
+	// MAE For octave shifted bass and chords
+	this.bassOctaveShift = midiOptions.bassprog && midiOptions.bassprog.length === 2 ? midiOptions.bassprog[1] : 0;
+	this.chordOctaveShift = midiOptions.chordprog && midiOptions.chordprog.length === 2 ? midiOptions.chordprog[1] : 0;
+
 	this.boomVolume = midiOptions.bassvol && midiOptions.bassvol.length === 1 ? midiOptions.bassvol[0] : 64;
 	this.chickVolume = midiOptions.chordvol && midiOptions.chordvol.length === 1 ? midiOptions.chordvol[0] : 48;
 
-	this.overridePattern = midiOptions.gchord ? parseGChord(midiOptions.gchord[0]) : undefined
+	// This allows for an initial %%MIDI gchord with no string
+	if (midiOptions.gchord && (midiOptions.gchord.length > 0)) {
+		this.overridePattern = parseGChord(midiOptions.gchord[0])
+	}
+	else {
+		this.overridePattern = undefined;
+	}
 };
 
 ChordTrack.prototype.setMeter = function (meter) {
@@ -64,7 +74,7 @@ ChordTrack.prototype.setRhythmHead = function (isRhythmHead, elem) {
 	if (isRhythmHead) {
 		if (this.lastChord && this.lastChord.chick) {
 			for (var i2 = 0; i2 < this.lastChord.chick.length; i2++) {
-				var note2 = parseCommon.clone(elem.pitches[0]);
+				var note2 = Object.assign({},elem.pitches[0]);
 				note2.actualPitch = this.lastChord.chick[i2];
 				ePitches.push(note2);
 			}
@@ -89,13 +99,32 @@ ChordTrack.prototype.gChordOn = function (element) {
 ChordTrack.prototype.paramChange = function (element) {
 	switch (element.el_type) {
 		case "gchord":
-			this.overridePattern = parseGChord(element.param);
+			// Skips gchord elements that don't have pattern strings
+			if (element.param && element.param.length > 0) {
+				this.overridePattern = parseGChord(element.param);
+
+				// Generate a default duration scale based on the pattern
+				//this.gchordduration = generateDefaultDurationScale(element.param);
+			} else
+				this.overridePattern = undefined;
 			break;
 		case "bassprog":
-			this.bassInstrument = element.param;
+			this.bassInstrument = element.value;
+			if ((element.octaveShift != undefined) && (element.octaveShift != null)) {
+				this.bassOctaveShift = element.octaveShift;
+			}
+			else {
+				this.bassOctaveShift = 0;
+			}
 			break;
 		case "chordprog":
-			this.chordInstrument = element.param;
+			this.chordInstrument = element.value;
+			if ((element.octaveShift != undefined) && (element.octaveShift != null)) {
+				this.chordOctaveShift = element.octaveShift;
+			}
+			else {
+				this.chordOctaveShift = 0;
+			}
 			break;
 		case "bassvol":
 			this.boomVolume = element.param;
@@ -169,6 +198,12 @@ ChordTrack.prototype.interpretChord = function (name) {
 	while (chordTranspose > 8)
 		chordTranspose -= 12;
 	bass += chordTranspose;
+
+	// MAE 17 Jun 2024 - Supporting octave shifted bass and chords
+	var unshiftedBass = bass;
+
+	bass += this.bassOctaveShift * 12;
+
 	var bass2 = bass - 5;	// The alternating bass is a 4th below
 	var chick;
 	if (name.length === 1)
@@ -176,16 +211,18 @@ ChordTrack.prototype.interpretChord = function (name) {
 	var remaining = name.substring(1);
 	var acc = remaining.substring(0, 1);
 	if (acc === 'b' || acc === '♭') {
+		unshiftedBass--;
 		bass--;
 		bass2--;
 		remaining = remaining.substring(1);
 	} else if (acc === '#' || acc === '♯') {
+		unshiftedBass++;
 		bass++;
 		bass2++;
 		remaining = remaining.substring(1);
 	}
 	var arr = remaining.split('/');
-	chick = this.chordNotes(bass, arr[0]);
+	chick = this.chordNotes(unshiftedBass, 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];
@@ -198,6 +235,10 @@ ChordTrack.prototype.interpretChord = function (name) {
 			var bassAcc = arr[1].substring(1);
 			var bassShift = { '#': 1, '♯': 1, 'b': -1, '♭': -1 }[bassAcc] || 0;
 			bass = this.basses[arr[1].substring(0, 1)] + bassShift + chordTranspose;
+
+			// MAE 22 May 2024 - Supporting octave shifted bass and chords
+			bass += this.bassOctaveShift * 12;
+
 			bass2 = bass;
 		}
 	}
@@ -215,6 +256,10 @@ ChordTrack.prototype.chordNotes = function (bass, modifier) {
 			intervals = this.chordIntervals.M;
 	}
 	bass += 12;	// the chord is an octave above the bass note.
+
+	// MAE 22 May 2024 - For chick octave shift
+	bass += (this.chordOctaveShift * 12);
+
 	var notes = [];
 	for (var i = 0; i < intervals.length; i++) {
 		notes.push(bass + intervals[i]);
@@ -338,25 +383,34 @@ function resolvePitch(currentChord, type, firstBoom, newBass) {
 		ret.push(firstBoom ? currentChord.boom : currentChord.boom2)
 	else if (newBass)
 		ret.push(currentChord.boom)
+	var numChordNotes = currentChord.chick.length
 	if (type.indexOf('chick') >= 0) {
-		for (var i = 0; i < currentChord.chick.length; i++)
+		for (var i = 0; i < numChordNotes; i++)
 			ret.push(currentChord.chick[i])
 	}
 	switch (type) {
 		case 'DO': ret.push(currentChord.chick[0]); break;
 		case 'MI': ret.push(currentChord.chick[1]); break;
-		case 'SOL': ret.push(currentChord.chick[2]); break;
-		case 'TI': currentChord.chick.length > 3 ? ret.push(currentChord.chick[2]) : ret.push(currentChord.chick[0]+12); break;
-		case 'TOP': currentChord.chick.length > 4 ? ret.push(currentChord.chick[2]) : ret.push(currentChord.chick[1]+12); break;
+		case 'SOL': ret.push(extractNote(currentChord,2)); break;
+		case 'TI': ret.push(extractNote(currentChord,3)); break;
+		case 'TOP': ret.push(extractNote(currentChord,4)); break;
 		case 'do': ret.push(currentChord.chick[0]+12); break;
 		case 'mi': ret.push(currentChord.chick[1]+12); break;
-		case 'sol': ret.push(currentChord.chick[2]+12); break;
-		case 'ti': currentChord.chick.length > 3 ? ret.push(currentChord.chick[2]+12) : ret.push(currentChord.chick[0]+24); break;
-		case 'top': currentChord.chick.length > 4 ? ret.push(currentChord.chick[2]+12) : ret.push(currentChord.chick[1]+24); break;
+		case 'sol': ret.push(extractNote(currentChord,2)+12); break;
+		case 'ti': ret.push(extractNote(currentChord,3)+12); break;
+		case 'top': ret.push(extractNote(currentChord,4)+12); break;
 	}
 	return ret
 }
 
+function extractNote(chord, index) {
+	// This creates an arpeggio note no matter how many notes are in the chord - if it runs out of notes it continues in the next octave
+	var octave = Math.floor(index / chord.chick.length)
+	var note = chord.chick[index % chord.chick.length]
+	//console.log(chord.chick, {index, octave, note}, index % chord.chick.length)
+	return note + octave * 12
+}
+
 function parseGChord(gchord) {
 	// TODO-PER: The spec is more complicated than this but for now this will not try to do anything with error cases like the wrong number of beats.
 	var pattern = []
@@ -532,7 +586,12 @@ ChordTrack.prototype.chordIntervals = {
 	'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]
+	'13#5': [0, 4, 8, 10, 14, 21],
+	// MAE Power chords added 10 April 2024
+	'5': [0, 7],
+	'5(8)': [0, 7, 12],
+	'5add8': [0, 7, 12]
+
 };
 
 ChordTrack.prototype.rhythmPatterns = {
@@ -547,8 +606,12 @@ ChordTrack.prototype.rhythmPatterns = {
 	"6/4": ['boom', '', 'chick', '', 'boom', '', 'chick', '', 'boom', '', 'chick', ''],
 
 	"3/8": ['boom', '', 'chick'],
+	"5/8": ['boom', 'chick', 'chick', 'boom', 'chick'],
 	"6/8": ['boom', '', 'chick', 'boom', '', 'chick'],
+	"7/8": ['boom', 'chick', 'chick', 'boom', 'chick', 'boom', 'chick'],
 	"9/8": ['boom', '', 'chick', 'boom', '', 'chick', 'boom', '', 'chick'],
+	"10/8": ['boom', 'chick', 'chick', 'boom', 'chick', 'chick', 'boom', 'chick', 'boom', 'chick'],
+	"11/8": ['boom', 'chick', 'chick', 'boom', 'chick', 'chick', 'boom', 'chick', 'boom', 'chick', 'chick'],
 	"12/8": ['boom', '', 'chick', 'boom', '', 'chick', 'boom', '', 'chick', 'boom', '', 'chick'],
 };
 

package/src/synth/create-synth-control.js

@@ -1,7 +1,6 @@
 var supportsAudio = require('./supports-audio');
 var registerAudioContext = require('./register-audio-context');
 var activeAudioContext = require('./active-audio-context');
-var parseCommon = require('../parse/abc_common');
 
 var loopImage = require('./images/loop.svg.js');
 var playImage = require('./images/play.svg.js');
@@ -23,7 +22,7 @@ function CreateSynthControl(parent, options) {
 	self.parent = parent;
 	self.options = {};
 	if (options)
-		self.options = parseCommon.clone(options);
+		self.options = Object.assign({},options);
 
 	// This can be called in the following cases:
 	// AC already registered and not suspended

package/src/tablatures/abc_tablatures.js

@@ -0,0 +1,184 @@
+/*
+ * Tablature Plugins
+ * tablature are defined dynamically and registered inside abcjs
+ * by calling abcTablatures.register(plugin) 
+ * where plugin represents a plugin instance 
+ * 
+ */
+
+// This is the only entry point to the tablatures. It is called both after parsing a tune and just before engraving
+
+var TabString = require('./instruments/tab-string');
+
+/* extend the table below when adding a new instrument plugin */
+
+// Existing tab classes 
+var pluginTab = {
+	'violin': { name: 'StringTab', defaultTuning: ['G,', 'D', 'A', 'e'], isTabBig: false, tabSymbolOffset: 0 },
+	'fiddle': { name: 'StringTab', defaultTuning: ['G,', 'D', 'A', 'e'], isTabBig: false, tabSymbolOffset: 0 },
+	'mandolin': { name: 'StringTab', defaultTuning: ['G,', 'D', 'A', 'e'], isTabBig: false, tabSymbolOffset: 0 },
+	'guitar': { name: 'StringTab', defaultTuning: ['E,', 'A,', 'D', 'G', 'B', 'e'], isTabBig: true, tabSymbolOffset: 0 },
+	'fiveString': { name: 'StringTab', defaultTuning: ['C,', 'G,', 'D', 'A', 'e'], isTabBig: false, tabSymbolOffset: -.95 },
+};
+
+var abcTablatures = {
+
+	inited: false,
+	plugins: {},
+
+
+	/**
+	 * to be called once per plugin for registration 
+	 * @param {*} plugin 
+	 */
+	register: function (plugin) {
+		var name = plugin.name;
+		var tablature = plugin.tablature;
+		this.plugins[name] = tablature;
+	},
+
+	setError: function (tune, msg) {
+		if (tune.warnings) {
+			tune.warning.push(msg);
+		} else {
+			tune.warnings = [msg];
+		}
+	},
+
+	/**
+	 * handle params for current processed score
+	 * @param {*} tune current tune 
+	 * @param {*} tuneNumber number in tune list
+	 * @param {*} params params to be processed for tablature
+	 * @return prepared tablatures plugin instances for current tune
+	 */
+	preparePlugins: function (tune, tuneNumber, params) {
+		// Called after parsing a tune and before engraving it
+		if (!this.inited) {
+			// TODO-PER: I don't think this is needed - the plugin array can be hard coded, right?
+			this.register(new TabString());
+			this.inited = true;
+		}
+		var returned = null;
+		var nbPlugins = 0;
+		if (params.tablature) {
+			// validate requested plugins 
+			var tabs = params.tablature;
+			returned = [];
+			for (var ii = 0; ii < tabs.length; ii++) {
+				var args = tabs[ii];
+				var instrument = args['instrument'];
+				if (instrument == null) {
+					this.setError(tune, "tablature 'instrument' is missing");
+					return returned;
+				}
+				var tabName = pluginTab[instrument];
+				var plugin = null;
+				if (tabName) {
+					plugin = this.plugins[tabName.name];
+				}
+				if (plugin) {
+					if (params.visualTranspose != 0) {
+						// populate transposition request to tabs
+						args.visualTranspose = params.visualTranspose;
+					}
+					args.abcSrc = params.tablature.abcSrc;
+					var pluginInstance = {
+						classz: plugin,
+						tuneNumber: tuneNumber,
+						params: args,
+						instance: null,
+						tabType: tabName,
+					};
+					// proceed with tab plugin  init 
+					// plugin.init(tune, tuneNumber, args, ii);
+					returned.push(pluginInstance);
+					nbPlugins++;
+				} else if (instrument === '') {
+					// create a placeholder - there is no tab for this staff
+					returned.push(null)
+				} else {
+					// unknown tab plugin 
+					//this.emit_error('Undefined tablature plugin: ' + tabName)
+					this.setError(tune, 'Undefined tablature plugin: ' + instrument);
+					return returned;
+				}
+			}
+		}
+		return returned;
+	},
+
+	/**
+	 * Call requested plugin
+	 * @param {*} renderer 
+	 * @param {*} abcTune 
+	 */
+	layoutTablatures: function layoutTablatures(renderer, abcTune) {
+		var tabs = abcTune.tablatures;
+
+		// chack tabs request for each staffs
+		var staffLineCount = 0;
+
+		// Clear the suppression flag
+		if (tabs && (tabs.length > 0)) {
+			var nTabs = tabs.length;
+			for (var kk = 0; kk < nTabs; ++kk) {
+				if (tabs[kk] && tabs[kk].params.firstStaffOnly) {
+					tabs[kk].params.suppress = false;
+				}
+			}
+		}
+
+		for (var ii = 0; ii < abcTune.lines.length; ii++) {
+			var line = abcTune.lines[ii];
+
+			if (line.staff) {
+				staffLineCount++;
+			}
+
+			// MAE 27Nov2023
+			// If tab param "firstStaffOnly", remove the tab label after the first staff
+			if (staffLineCount > 1) {
+				if (tabs && (tabs.length > 0)) {
+					var nTabs = tabs.length;
+					for (var kk = 0; kk < nTabs; ++kk) {
+						if (tabs[kk].params.firstStaffOnly) {
+							// Set the staff draw suppression flag
+							tabs[kk].params.suppress = true;
+						}
+					}
+				}
+			}
+
+			var curStaff = line.staff;
+			if (curStaff) {
+				var maxStaves = curStaff.length
+				for (var jj = 0; jj < curStaff.length; jj++) {
+
+					if (tabs[jj] && jj < maxStaves) {
+						// tablature requested for staff
+						var tabPlugin = tabs[jj];
+						if (tabPlugin.instance == null) {
+							//console.log("★★★★ Tab Init line: " + ii + " staff: " + jj)
+							tabPlugin.instance = new tabPlugin.classz();
+							// plugin.init(tune, tuneNumber, args, ii);
+							// call initer first
+							tabPlugin.instance.init(abcTune,
+								tabPlugin.tuneNumber,
+								tabPlugin.params,
+								tabPlugin.tabType
+							);
+						}
+						// render next
+						//console.log("★★★★ Tab Render line: " + ii + " staff: " + jj)
+						tabPlugin.instance.render(renderer, line, jj);
+					}
+				}
+			}
+		}
+	},
+
+};
+
+
+module.exports = abcTablatures;