abcjs 6.0.0-beta.35 → 6.0.0-beta.39

package/src/synth/place-note.js

@@ -17,74 +17,78 @@ function placeNote(outputAudioBuffer, sampleRate, sound, startArray, volumeMulti
 		len = 0.005; // Have some small audible length no matter how short the note is.
 	var offlineCtx = new OfflineAC(2,Math.floor((len+fadeTimeSec)*sampleRate),sampleRate);
 	var noteName = pitchToNoteName[sound.pitch];
-	var noteBuffer = soundsCache[sound.instrument][noteName];
-	if (noteBuffer === "error" || noteBuffer === "pending") { // If the note isn't available, just leave a blank spot
-		// If the note is still pending by now that means an error happened when loading. There was probably a timeout.
-		console.log("Didn't load note", sound.instrument, noteName, noteBuffer);
-		return;
+	var noteBufferPromise = soundsCache[sound.instrument][noteName];
+
+	if (!noteBufferPromise) {
+		// if the note isn't present then just skip it - it will leave a blank spot in the audio.
+		return Promise.resolve();
 	}
 
-	// create audio buffer
-	var source = offlineCtx.createBufferSource();
-	source.buffer = noteBuffer;
+	return noteBufferPromise
+		.then(function (response) {
+			// create audio buffer
+			var source = offlineCtx.createBufferSource();
+			source.buffer = response.audioBuffer;
 
-	// add gain
-	// volume can be between 1 to 127. This translation to gain is just trial and error.
-	// The smaller the first number, the more dynamic range between the quietest to loudest.
-	// The larger the second number, the louder it will be in general.
-	var volume = (sound.volume / 96) * volumeMultiplier;
-	source.gainNode = offlineCtx.createGain();
+			// add gain
+			// volume can be between 1 to 127. This translation to gain is just trial and error.
+			// The smaller the first number, the more dynamic range between the quietest to loudest.
+			// The larger the second number, the louder it will be in general.
+			var volume = (sound.volume / 96) * volumeMultiplier;
+			source.gainNode = offlineCtx.createGain();
 
-	// add pan if supported and present
-	if (sound.pan && offlineCtx.createStereoPanner) {
-		source.panNode = offlineCtx.createStereoPanner();
-		source.panNode.pan.setValueAtTime(sound.pan, 0);
-	}
-	source.gainNode.gain.value = volume; // Math.min(2, Math.max(0, volume));
-	source.gainNode.gain.linearRampToValueAtTime(source.gainNode.gain.value, len);
-	source.gainNode.gain.linearRampToValueAtTime(0.0, len + fadeTimeSec);
+			// add pan if supported and present
+			if (sound.pan && offlineCtx.createStereoPanner) {
+				source.panNode = offlineCtx.createStereoPanner();
+				source.panNode.pan.setValueAtTime(sound.pan, 0);
+			}
+			source.gainNode.gain.value = volume; // Math.min(2, Math.max(0, volume));
+			source.gainNode.gain.linearRampToValueAtTime(source.gainNode.gain.value, len);
+			source.gainNode.gain.linearRampToValueAtTime(0.0, len + fadeTimeSec);
 
-	if (sound.cents) {
-		source.playbackRate.value = centsToFactor(sound.cents);
-	}
+			if (sound.cents) {
+				source.playbackRate.value = centsToFactor(sound.cents);
+			}
 
-	// connect all the nodes
-	if (source.panNode) {
-		source.panNode.connect(offlineCtx.destination);
-		source.gainNode.connect(source.panNode);
-	} else {
-		source.gainNode.connect(offlineCtx.destination);
-	}
-	source.connect(source.gainNode);
+			// connect all the nodes
+			if (source.panNode) {
+				source.panNode.connect(offlineCtx.destination);
+				source.gainNode.connect(source.panNode);
+			} else {
+				source.gainNode.connect(offlineCtx.destination);
+			}
+			source.connect(source.gainNode);
 
-	// Do the process of creating the sound and placing it in the buffer
-	source.start(0);
+			// Do the process of creating the sound and placing it in the buffer
+			source.start(0);
 
-	if (source.noteOff) {
-		source.noteOff(len + fadeTimeSec);
-	} else {
-		source.stop(len + fadeTimeSec);
-	}
-	var fnResolve;
-	offlineCtx.oncomplete = function(e) {
-		if (e.renderedBuffer) { // If the system gets overloaded then this can start failing. Just drop the note if so.
-			for (var i = 0; i < startArray.length; i++) {
-				//Math.floor(startArray[i] * sound.tempoMultiplier * sampleRate)
-				var start = startArray[i] * sound.tempoMultiplier;
-				if (ofsMs)
-					start -=ofsMs/1000;
-				if (start < 0)
-					start = 0; // If the item that is moved back is at the very beginning of the buffer then don't move it back. To do that would be to push everything else forward. TODO-PER: this should probably be done at some point but then it would change timing in existing apps.
-				start = Math.floor(start*sampleRate);
-				copyToChannel(outputAudioBuffer, e.renderedBuffer, start);
+			if (source.noteOff) {
+				source.noteOff(len + fadeTimeSec);
+			} else {
+				source.stop(len + fadeTimeSec);
 			}
-		}
-		fnResolve();
-	};
-	offlineCtx.startRendering();
-	return new Promise(function(resolve, reject) {
-		fnResolve = resolve;
-	});
+			var fnResolve;
+			offlineCtx.oncomplete = function(e) {
+				if (e.renderedBuffer) { // If the system gets overloaded then this can start failing. Just drop the note if so.
+					for (var i = 0; i < startArray.length; i++) {
+						//Math.floor(startArray[i] * sound.tempoMultiplier * sampleRate)
+						var start = startArray[i] * sound.tempoMultiplier;
+						if (ofsMs)
+							start -=ofsMs/1000;
+						if (start < 0)
+							start = 0; // If the item that is moved back is at the very beginning of the buffer then don't move it back. To do that would be to push everything else forward. TODO-PER: this should probably be done at some point but then it would change timing in existing apps.
+						start = Math.floor(start*sampleRate);
+						copyToChannel(outputAudioBuffer, e.renderedBuffer, start);
+					}
+				}
+				fnResolve();
+			};
+			offlineCtx.startRendering();
+			return new Promise(function(resolve) {
+				fnResolve = resolve;
+			});
+		})
+		.catch(function () {});
 }
 
 var copyToChannel = function(toBuffer, fromBuffer, start) {

package/src/tablatures/instruments/guitar/guitar-fonts.js

@@ -0,0 +1,19 @@
+
+/**
+ * Dedicated fonts for violin tabs
+ */
+
+/**
+ * Set here the fonts used by renderer/drawer 
+ * for the violin plugin
+ * @param {} tune 
+ */
+// eslint-disable-next-line no-unused-vars
+function setGuitarFonts(tune) {
+  /* enhance or change instrument fonts here */
+  // tune.formatting.tabnumberfont = { face: "\"Times New Roman\"", size: 9, weight: "normal", style: "normal", decoration: "none" };
+  // tune.formatting.tabgracefont = { face: "\"Times New Roman\"", size: 7, weight: "normal", style: "normal", decoration: "none" };
+}
+
+module.exports = setGuitarFonts;
+

package/src/tablatures/instruments/guitar/guitar-patterns.js

@@ -0,0 +1,23 @@
+var StringPatterns = require('../string-patterns');
+
+function GuitarPatterns(plugin) {
+  this.tuning = plugin._super.params.tuning;
+  if (!this.tuning) {
+    this.tuning = ['E,', 'A', 'D', 'G' , 'B' , 'e'];
+  }
+  plugin.tuning = this.tuning;
+  this.strings = new StringPatterns(plugin);
+}
+
+GuitarPatterns.prototype.notesToNumber = function (notes, graces) {
+  var converter = this.strings;
+  return converter.notesToNumber(notes, graces);
+};
+
+GuitarPatterns.prototype.stringToPitch = function (stringNumber) {
+  var converter = this.strings;
+  return converter.stringToPitch(stringNumber);
+};
+
+
+module.exports = GuitarPatterns;

package/src/tablatures/instruments/guitar/tab-guitar.js

@@ -0,0 +1,50 @@
+/*
+Emit tab for Guitar staff
+*/
+var StringTablature = require('../string-tablature');
+var TabCommon = require('../../tab-common');
+var TabRenderer = require('../../tab-renderer');
+var GuitarPatterns = require('./guitar-patterns');
+var setGuitarFonts = require('./guitar-fonts');
+
+/**
+* upon init mainly store provided instances for later usage
+* @param {*} abcTune  the parsed tune AST tree
+*  @param {*} tuneNumber  the parsed tune AST tree
+* @param {*} params  complementary args provided to Tablature Plugin
+*/
+Plugin.prototype.init = function (abcTune, tuneNumber, params) {
+  var _super = new TabCommon(abcTune, tuneNumber, params);
+  this._super = _super;
+  this.abcTune = abcTune;
+  this.linePitch = 3;
+  this.nbLines = 6;
+  this.isTabBig = true;
+  this.capo = params.capo;
+  this.transpose = params.visualTranspose;
+  this.tablature = new StringTablature(this.nbLines,
+    this.linePitch);
+
+  var semantics = new GuitarPatterns(this);
+  this.semantics = semantics;
+};
+
+Plugin.prototype.render = function (renderer, line, staffIndex) {
+  if (this._super.inError) return;
+  if (this.tablature.bypass(line)) return;
+  setGuitarFonts(this.abcTune);
+  var rndrer = new TabRenderer(this, renderer, line, staffIndex);
+  rndrer.doLayout();
+};
+
+function Plugin() {}
+
+//
+// Tablature plugin definition
+//
+var AbcGuitarTab = function () {
+  return { name: 'GuitarTab', tablature: Plugin };
+};
+
+
+module.exports = AbcGuitarTab;

package/src/tablatures/instruments/string-patterns.js

@@ -0,0 +1,277 @@
+var TabNote = require('./tab-note');
+var TabNotes = require('./tab-notes');
+
+
+function buildCapo(self) {
+  var capoTuning = null;
+  var tuning = self.tuning;
+  if (self.capo > 0) {
+    capoTuning = [];
+    for (var iii = 0; iii < tuning.length; iii++) {
+      var curNote = new TabNote.TabNote(tuning[iii]);
+      for (var jjj = 0; jjj < self.capo; jjj++) {
+        curNote = curNote.nextNote();
+      }
+      capoTuning[iii] = curNote.emit();
+    }
+  }
+  return capoTuning;
+}
+
+function buildPatterns(self) {
+  var strings = [];
+  var tuning = self.tuning;
+  if (self.capo > 0) {
+    tuning = self.capoTuning;
+  }
+  var pos = tuning.length - 1;
+  for (var iii = 0; iii < tuning.length; iii++) {
+    var nextNote = self.highestNote; // highest handled note
+    if (iii != tuning.length - 1) {
+      nextNote = tuning[iii + 1];
+    }
+    var tabNotes = new TabNotes(tuning[iii],nextNote);
+    var stringNotes = tabNotes.build();
+    if (stringNotes.error) {
+      return stringNotes;
+    }
+    strings[pos--] = stringNotes;
+  }
+  return strings;
+}
+
+
+function buildSecond(first) {
+  var seconds = [];
+  seconds[0] = [];
+  var strings = first.strings;
+  for (var iii = 1; iii < strings.length; iii++) {
+    seconds[iii] = strings[iii - 1];
+  }
+  return seconds;
+}
+
+function sameString(self, chord) {
+  for (var jjjj = 0; jjjj < chord.length - 1; jjjj++) {
+    var curPos = chord[jjjj];
+    var nextPos = chord[jjjj + 1];
+    if (curPos.str == nextPos.str) {
+      // same String
+      // => change lower pos 
+      if (curPos.str == self.strings.length - 1) {
+        // Invalid tab Chord position for instrument
+        curPos.num = "?";
+        nextPos.num = "?"; 
+        return; 
+      }
+      // change lower pitch on lowest string
+      if (nextPos.num < curPos.num) {
+        nextPos.str++;
+        nextPos = noteToNumber(self,
+          nextPos.note,
+          nextPos.str,
+          self.secondPos,
+          self.strings[nextPos.str].length
+        );
+      } else {
+        curPos.str++;
+        curPos = noteToNumber(self,
+          curPos.note,
+          curPos.str,
+          self.secondPos,
+          self.strings[curPos.str].length
+        );
+      }
+      // update table
+      chord[jjjj] = curPos;
+      chord[jjjj + 1] = nextPos;
+    }
+  }
+  return null;
+}
+
+function handleChordNotes(self, notes) {
+  var retNotes = [];
+  for (var iiii = 0; iiii < notes.length; iiii++) {
+    var note = new TabNote.TabNote(notes[iiii].name);
+    var curPos = toNumber(self, note);
+    retNotes.push(curPos);
+  }
+  sameString(self, retNotes);
+  return retNotes;
+}
+
+function noteToNumber(self, note, stringNumber, secondPosition , firstSize) {
+  var strings = self.strings;
+  note.checkKeyAccidentals(self.accidentals) ;
+  if (secondPosition) {
+    strings = secondPosition;
+  }
+  var noteName = note.emitNoAccidentals();
+  var num = strings[stringNumber].indexOf(noteName);
+  var acc = note.acc;
+  if (num != -1) {
+    if (secondPosition) {
+      num += firstSize;
+    }
+    if ( (note.isFlat || note.acc == -1) && (num == 0)) {
+      // flat on 0 pos => previous string 7th position
+      var noteEquiv = note.getAccidentalEquiv();
+      stringNumber++;
+      num = strings[stringNumber].indexOf(noteEquiv.emit());
+      acc = 0;
+    }
+    return {
+      num: (num + acc),
+      str: stringNumber,
+      note: note
+    };
+  }
+  return null;
+}
+
+function toNumber(self, note) {
+  var num = null;
+  var str = 0;
+  var lowestString = self.strings[self.strings.length - 1];
+  var lowestNote = new TabNote.TabNote(lowestString[0]);
+  if (note.isLowerThan(lowestNote) ) {
+    return {
+      num: "?",
+      str: self.strings.length - 1,
+      note: note,
+      error: note.emit() + ': unexpected note for instrument' 
+    };
+  }
+  while (str < self.strings.length) {
+    num = noteToNumber(self, note, str);
+    if (num) {
+      return num;
+    }
+    str++;
+  }
+  return null; // not found
+}
+
+StringPatterns.prototype.stringToPitch = function (stringNumber) {
+  var startingPitch = 5.3;
+  var bottom = this.strings.length - 1;
+  return startingPitch + ((bottom - stringNumber) * this.linePitch);
+};
+
+function invalidNumber( retNotes , note ) {
+  var number = {
+    num: "?",
+    str: 0,
+    note: note
+  };
+  retNotes.push(number);
+  retNotes.error = note.emit() + ': unexpected note for instrument' ;
+} 
+
+StringPatterns.prototype.notesToNumber = function (notes, graces) {
+  var note;
+  var number;
+  var error = null; 
+  var retNotes = null;
+  if (notes) {
+    retNotes = [];
+    if (notes.length > 1) {
+      retNotes = handleChordNotes(this, notes);
+      if (retNotes.error) {
+        error = retNotes.error;
+      }
+    } else {
+      note = new TabNote.TabNote(notes[0].name);
+      number = toNumber(this, note);
+      if (number) {
+        retNotes.push(number);
+      } else {
+        invalidNumber(retNotes, note);
+        error = retNotes.error;
+      }
+    }
+  }  
+  if (error) return retNotes;
+  var retGraces = null;
+  if (graces) {
+    retGraces = [];
+    for (var iiii = 0; iiii < graces.length; iiii++) {
+      note = new TabNote.TabNote(graces[iiii].name);
+      number = toNumber(this, note);
+      if (number) {
+        retGraces.push(number);
+      } else {
+        invalidNumber(retGraces, note);
+        error = retNotes.error;
+      }
+    }
+  }
+    
+  return {
+    notes: retNotes,
+    graces: retGraces,
+    error: error
+  };
+};
+
+StringPatterns.prototype.toString = function () {
+  return this.tuning.join('').replaceAll(',', '').toUpperCase();
+};
+
+StringPatterns.prototype.tabInfos = function (plugin) {
+  var _super = plugin._super;
+  var name = _super.params.label;
+  if (name) {
+    var tunePos = name.indexOf('%T');
+    var tuning = "";
+    if (tunePos != -1) {
+      tuning = this.toString();
+      if (plugin.capo > 0) {
+        tuning += ' capo:' + plugin.capo;
+      }
+      name = name.replace('%T', tuning);
+    }
+    return name;
+  }
+  return '';
+};
+
+/**
+ * Common patterns for all string instruments
+ * @param {} plugin
+ * @param {} tuning
+ * @param {*} capo
+ * @param {*} highestNote 
+ */
+function StringPatterns(plugin) {
+  var tuning = plugin.tuning;
+  var capo = plugin.capo;
+  var highestNote = plugin._super.params.highestNote;
+  this.linePitch = plugin.linePitch;
+  this.highestNote = "a'";
+  if (highestNote) {
+    // override default
+    this.highestNote = highestNote;
+  }
+  this.capo = 0;
+  if (capo) {
+    this.capo = capo;
+  }
+  this.tuning = tuning;
+  if (this.capo > 0) {
+    this.capoTuning = buildCapo(this);
+  }
+  this.strings = buildPatterns(this);
+  if (this.strings.error) {
+    plugin._super.setError(this.strings.error);
+    plugin.inError = true;
+    return;
+  }
+  // second position pattern per string
+  this.secondPos = buildSecond(this);
+}
+
+
+
+module.exports = StringPatterns;

package/src/tablatures/instruments/string-tablature.js

@@ -0,0 +1,56 @@
+
+/**
+ * Layout tablature informations for draw
+ * @param {*} numLines 
+ * @param {*} lineSpace 
+ */
+
+function StringTablature(numLines, lineSpace) {
+  this.numLines = numLines;
+  this.lineSpace = lineSpace;
+  this.verticalSize = this.numLines * this.lineSpace;
+  var pitch = 3;
+  this.bar = {
+    pitch: pitch,
+    pitch2: lineSpace * numLines,
+    height: 5,
+  };
+}
+
+/**
+ * return true if current line should not produce a tab
+ * @param {} line 
+ */
+StringTablature.prototype.bypass = function (line) {
+  var voices = line.staffGroup.voices;
+  if (voices.length > 0) {
+    if (voices[0].isPercussion) return true;
+  }
+  return false;
+};  
+
+
+StringTablature.prototype.setRelative = function (child, relative, first) {
+  switch (child.type) {
+    case 'bar':
+      relative.pitch = this.bar.pitch;
+      relative.pitch2 = this.bar.pitch2;
+      relative.height = this.height;
+      break;
+    case 'symbol':
+      var top = this.bar.pitch2 / 2;
+      if (child.name == 'dots.dot') {
+        if (first) {
+          relative.pitch = top;
+          return false;
+        } else {
+          relative.pitch = top + this.lineSpace;
+          return true;
+        }
+      }
+      break;
+  }
+  return first;
+};
+
+module.exports = StringTablature;