abcjs 6.1.9 → 6.2.1

package/src/synth/create-synth.js

@@ -26,11 +26,13 @@ function CreateSynth() {
 	self.audioBuffers = []; // cache of the buffers so starting play can be fast.
 	self.duration = undefined; // the duration of the tune in seconds.
 	self.isRunning = false; // whether there is currently a sound buffer running.
+//	self.options = undefined
 
 	// Load and cache all needed sounds
 	self.init = function(options) {
 		if (!options)
 			options = {};
+//		self.options = options
 		registerAudioContext(options.audioContext); // This works no matter what - if there is already an ac it is a nop; if the context is not passed in, then it creates one.
 		var startTime = activeAudioContext().currentTime;
 		self.debugCallback = options.debugCallback;
@@ -163,6 +165,9 @@ function CreateSynth() {
 				notes.push({ instrument: instrument, note: note });
 			});
 		});
+		if (self.debugCallback)
+			self.debugCallback("notes "+JSON.stringify(notes));
+
 		// If there are lots of notes, load them in batches
 		var batches = [];
 		var CHUNK = 256;
@@ -179,8 +184,13 @@ function CreateSynth() {
 
 			var index = 0;
 			var next = function() {
+				if (self.debugCallback)
+					self.debugCallback("loadBatch idx="+index+ " len="+batches.length);
+	
 				if (index < batches.length) {
 					self._loadBatch(batches[index], self.soundFontUrl, startTime).then(function(data) {
+						if (self.debugCallback)
+							self.debugCallback("loadBatch then");
 						startTime = activeAudioContext().currentTime;
 						if (data) {
 							if (data.error)
@@ -192,6 +202,9 @@ function CreateSynth() {
 						next();
 					}, reject);
 				} else {
+					if (self.debugCallback)
+						self.debugCallback("resolve init");
+		
 					resolve(results);
 				}
 			};
@@ -203,6 +216,8 @@ function CreateSynth() {
 		// This is called recursively to see if the sounds have loaded. The "delay" parameter is how long it has been since the original call.
 		var promises = [];
 		batch.forEach(function(item) {
+			if (self.debugCallback)
+				self.debugCallback("getNote " + item.instrument+':'+item.note);
 			promises.push(getNote(soundFontUrl, item.instrument, item.note, activeAudioContext()));
 		});
 		return Promise.all(promises).then(function(response) {
@@ -225,6 +240,8 @@ function CreateSynth() {
 					error.push(which + ' ' + oneResponse.message);
 			}
 			if (pending.length > 0) {
+				if (self.debugCallback)
+					self.debugCallback("pending " + JSON.stringify(pending));
 				// There was probably a second call for notes before the first one finished, so just retry a few times to see if they stop being pending.
 				// Retry quickly at first so that there isn't an unnecessary delay, but increase the delay each time.
 				if (!delay)
@@ -239,7 +256,9 @@ function CreateSynth() {
 								which = pending[i].split(":");
 								newBatch.push({instrument: which[0], note: which[1]});
 							}
-							self._loadBatch(newBatch, soundFontUrl, startTime, delay).then(function (response) {
+							if (self.debugCallback)
+								self.debugCallback("retry " + JSON.stringify(newBatch));
+									self._loadBatch(newBatch, soundFontUrl, startTime, delay).then(function (response) {
 								resolve(response);
 							}).catch(function (error) {
 								reject(error);
@@ -250,11 +269,18 @@ function CreateSynth() {
 					var list = [];
 					for (var j = 0; j < batch.length; j++)
 						list.push(batch[j].instrument+'/'+batch[j].note)
-					return Promise.reject(new Error("timeout attempting to load: " + list.join(", ")));
+						if (self.debugCallback)
+							self.debugCallback("loadBatch timeout")
+						return Promise.reject(new Error("timeout attempting to load: " + list.join(", ")));
 				}
-			} else
+			} else {
+				if (self.debugCallback)
+					self.debugCallback("loadBatch resolve")
 				return Promise.resolve({loaded: loaded, cached: cached, error: error});
+			}
 		}).catch(function (error) {
+			if (self.debugCallback)
+				self.debugCallback("loadBatch catch "+error.message)
 		});
 	});
 
@@ -283,6 +309,8 @@ function CreateSynth() {
 			self.stop();
 
 			var noteMapTracks = createNoteMap(self.flattened);
+			// if (self.options.swing)
+			// 	addSwing(noteMapTracks, self.options.swing, self.beatsPerMeasure)
 			if (self.sequenceCallback)
 				self.sequenceCallback(noteMapTracks, self.callbackContext);
 
@@ -295,6 +323,8 @@ function CreateSynth() {
 				var panDistance = panDistances && panDistances.length > trackNumber ? panDistances[trackNumber] : 0;
 				noteMap.forEach(function(note) {
 					var key = note.instrument + ':' + note.pitch + ':' +note.volume + ':' + Math.round((note.end-note.start)*1000)/1000 + ':' + panDistance + ':' + tempoMultiplier + ':' + (note.cents ? note.cents : 0);
+					if (self.debugCallback)
+						self.debugCallback("noteMapTrack "+key)
 					if (!uniqueSounds[key])
 						uniqueSounds[key] = [];
 					uniqueSounds[key].push(note.start);
@@ -309,7 +339,7 @@ function CreateSynth() {
 				var parts = k.split(":");
 				var cents = parts[6] !== undefined ? parseFloat(parts[6]) : 0;
 				parts = {instrument: parts[0], pitch: parseInt(parts[1], 10), volume: parseInt(parts[2], 10), len: parseFloat(parts[3]), pan: parseFloat(parts[4]), tempoMultiplier: parseFloat(parts[5]), cents: cents};
-				allPromises.push(placeNote(audioBuffer, activeAudioContext().sampleRate, parts, uniqueSounds[k], self.soundFontVolumeMultiplier, self.programOffsets[parts.instrument], fadeTimeSec, self.noteEnd/1000));
+				allPromises.push(placeNote(audioBuffer, activeAudioContext().sampleRate, parts, uniqueSounds[k], self.soundFontVolumeMultiplier, self.programOffsets[parts.instrument], fadeTimeSec, self.noteEnd/1000, self.debugCallback));
 			}
 			self.audioBuffers = [audioBuffer];
 
@@ -477,6 +507,10 @@ function CreateSynth() {
 		return downloadBuffer(self);
 	};
 
+	self.getAudioBuffer = function() {
+		return self.audioBuffers[0];
+	};
+
 	/////////////// Private functions //////////////
 
 	self._deviceCapable = function() {
@@ -506,6 +540,39 @@ function CreateSynth() {
 			};
 		}
 	};
+
+	// // this is a first attempt at adding a little bit of swing to the output, but the algorithm isn't correct.
+	// function addSwing(noteMapTracks, swing, beatsPerMeasure) {
+	// 	console.log("addSwing", noteMapTracks, swing, beatsPerMeasure)
+	// 	// Swing should be between -0.9 and 0.9. Make sure the input is between them.
+	// 	// Then that is the percentage to add to the first beat, so a negative number moves the second beat earlier.
+	// 	// A value of zero is the same as no swing at all.
+	// 	// This only works when there are an even number of beats in a measure.
+	// 	if (beatsPerMeasure % 2 !== 0)
+	// 		return;
+	// 	swing = parseFloat(swing)
+	// 	if (isNaN(swing))
+	// 		return
+	// 	if (swing < -0.9)
+	// 		swing = -0.9
+	// 	if (swing > 0.9)
+	// 		swing = 0.9
+	// 	var beatLength = (1 / beatsPerMeasure)*2
+	// 	swing = beatLength * swing
+	// 	for (var t = 0; t < noteMapTracks.length; t++) {
+	// 		var track = noteMapTracks[t];
+	// 		for (var i = 0; i < track.length; i++) {
+	// 			var event = track[i];
+	// 			if (event.start % beatLength) {
+	// 				// This is the off beat
+	// 				event.start += swing;
+	// 			} else {
+	// 				// This is the beat
+	// 				event.end += swing;
+	// 			}
+	// 		}
+	// 	}
+	// }
 }
 
 module.exports = CreateSynth;

package/src/synth/load-note.js

@@ -16,7 +16,7 @@ var getNote = function (url, instrument, name, audioContext) {
 			xhr.responseType = "arraybuffer";
 			xhr.onload = function () {
 				if (xhr.status !== 200) {
-					reject(Error("Can't load sound at " + noteUrl));
+					reject(Error("Can't load sound at " + noteUrl + ' status=' + xhr.status));
 					return
 				}
 				var noteDecoded = function(audioBuffer) {

package/src/synth/note-to-midi.js

@@ -0,0 +1,50 @@
+var accidentals = {
+	"__": -2,
+	"_": -1,
+	"_/": -0.5,
+	"=": 0,
+	"": 0,
+	"^/": 0.5,
+	"^": 1,
+	"^^": 2
+}
+
+var notesInOrder = ['C', '-', 'D', '-', 'E', 'F', '-', 'G', '-', 'A', '-', 'B', 'c', '-', 'd', '-', 'e', 'f', '-', 'g', '-', 'a', '-', 'b']
+
+function noteToMidi(note) {
+	var reg = note.match(/([_^\/]*)([ABCDEFGabcdefg])(,*)('*)/)
+	if (reg && reg.length === 5) {
+		var acc = accidentals[reg[1]]
+		var pitch = notesInOrder.indexOf(reg[2])
+		var octave = reg[4].length - reg[3].length
+		return 48 + pitch + acc + octave * 12;
+	}
+	return 0;
+}
+
+function midiToNote(midi) {
+	midi = parseInt(midi, 10) // TODO-PER: not sure how to handle quarter sharps and flats, so strip them for now.
+	var octave = Math.floor(midi / 12)
+	var pitch = midi % 12
+	var name = notesInOrder[pitch]
+	if (name === '-') {
+		name = '^' + notesInOrder[pitch-1]
+	}
+	
+	if (octave > 4) {
+		name = name.toLowerCase()
+		octave -= 5
+		while (octave > 0) {
+			name += "'"
+			octave--
+		}
+	} else {
+		while (octave < 4) {
+			name += ','
+			octave++
+		}
+	}	
+	return name
+}
+
+module.exports = {noteToMidi: noteToMidi, midiToNote: midiToNote};

package/src/synth/place-note.js

@@ -2,7 +2,7 @@ var soundsCache = require('./sounds-cache');
 var pitchToNoteName = require('./pitch-to-note-name');
 var centsToFactor = require("./cents-to-factor");
 
-function placeNote(outputAudioBuffer, sampleRate, sound, startArray, volumeMultiplier, ofsMs, fadeTimeSec, noteEndSec) {
+function placeNote(outputAudioBuffer, sampleRate, sound, startArray, volumeMultiplier, ofsMs, fadeTimeSec, noteEndSec, debugCallback) {
 	// sound contains { instrument, pitch, volume, len, pan, tempoMultiplier
 	// len is in whole notes. Multiply by tempoMultiplier to get seconds.
 	// ofsMs is an offset to subtract from the note to line up programs that have different length onsets.
@@ -21,6 +21,8 @@ function placeNote(outputAudioBuffer, sampleRate, sound, startArray, volumeMulti
 
 	if (!noteBufferPromise) {
 		// if the note isn't present then just skip it - it will leave a blank spot in the audio.
+		if (debugCallback)
+			debugCallback('placeNote skipped: '+sound.instrument+':'+noteName)
 		return Promise.resolve();
 	}
 
@@ -81,6 +83,8 @@ function placeNote(outputAudioBuffer, sampleRate, sound, startArray, volumeMulti
 						copyToChannel(outputAudioBuffer, e.renderedBuffer, start);
 					}
 				}
+				if (debugCallback)
+					debugCallback('placeNote: '+sound.instrument+':'+noteName)
 				fnResolve();
 			};
 			offlineCtx.startRendering();
@@ -88,7 +92,11 @@ function placeNote(outputAudioBuffer, sampleRate, sound, startArray, volumeMulti
 				fnResolve = resolve;
 			});
 		})
-		.catch(function () {});
+		.catch(function (error) {
+			if (debugCallback)
+				debugCallback('placeNote catch: '+error.message)
+			return Promise.resolve()
+		});
 }
 
 var copyToChannel = function(toBuffer, fromBuffer, start) {

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

@@ -5,7 +5,6 @@ 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
@@ -32,7 +31,6 @@ Plugin.prototype.init = function (abcTune, tuneNumber, params) {
 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();
 };

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

@@ -1,3 +1,4 @@
+const {noteToMidi} = require('../../synth/note-to-midi');
 var TabNote = require('./tab-note');
 var TabNotes = require('./tab-notes');
 
@@ -93,7 +94,10 @@ function sameString(self, chord) {
 function handleChordNotes(self, notes) {
   var retNotes = [];
   for (var iiii = 0; iiii < notes.length; iiii++) {
-    var note = new TabNote.TabNote(notes[iiii].name);
+    if (notes[iiii].endTie)
+      continue;
+    var note = new TabNote.TabNote(notes[iiii].name, self.clefTranspose);
+    note.checkKeyAccidentals(self.accidentals, self.measureAccidentals)
     var curPos = toNumber(self, note);
     retNotes.push(curPos);
   }
@@ -147,26 +151,23 @@ function toNumber(self, note) {
       acc = "="
     self.measureAccidentals[note.name.toUpperCase()] = acc  
   }
-  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;
+  for (var i = self.stringPitches.length-1; i >= 0; i--) {
+    if (note.pitch + note.pitchAltered >= self.stringPitches[i]) {
+      var num = note.pitch + note.pitchAltered - self.stringPitches[i]
+      if (note.quarter === '^') num -= 0.5
+      else if (note.quarter === "v") num += 0.5
+      return {
+        num: Math.round(num),
+        str: self.stringPitches.length-1-i, // reverse the strings because string 0 is on the bottom
+        note: note
+      }
     }
-    str++;
   }
-  return null; // not found
+  return {
+    num: "?",
+    str: self.stringPitches.length-1,
+    note: note,
+  };
 }
 
 StringPatterns.prototype.stringToPitch = function (stringNumber) {
@@ -198,13 +199,16 @@ StringPatterns.prototype.notesToNumber = function (notes, graces) {
         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 (!notes[0].endTie) {
+        note = new TabNote.TabNote(notes[0].name, this.clefTranspose);
+        note.checkKeyAccidentals(this.accidentals, this.measureAccidentals)
+        number = toNumber(this, note);
+        if (number) {
+          retNotes.push(number);
+        } else {
+          invalidNumber(retNotes, note);
+          error = retNotes.error;
+        }
       }
     }
   }  
@@ -213,7 +217,8 @@ StringPatterns.prototype.notesToNumber = function (notes, graces) {
   if (graces) {
     retGraces = [];
     for (var iiii = 0; iiii < graces.length; iiii++) {
-      note = new TabNote.TabNote(graces[iiii].name);
+      note = new TabNote.TabNote(graces[iiii].name, this.clefTranspose);
+      note.checkKeyAccidentals(this.accidentals, this.measureAccidentals)
       number = toNumber(this, note);
       if (number) {
         retGraces.push(number);
@@ -232,7 +237,14 @@ StringPatterns.prototype.notesToNumber = function (notes, graces) {
 };
 
 StringPatterns.prototype.toString = function () {
-  return this.tuning.join('').replaceAll(',', '').toUpperCase();
+  var arr = []
+  for (var i = 0; i < this.tuning.length; i++) {
+    var str = this.tuning[i].replaceAll(',', '').replaceAll("'", '').toUpperCase();
+    if (str[0] === '_') str = str[1] + 'b '
+    else if (str[0] === '^') str = str[1] + "# "
+    arr.push(str)
+  }
+  return arr.join('');
 };
 
 StringPatterns.prototype.tabInfos = function (plugin) {
@@ -273,9 +285,15 @@ function StringPatterns(plugin) {
   this.measureAccidentals = {}
   this.capo = 0;
   if (capo) {
-    this.capo = capo;
+    this.capo = parseInt(capo,10);
   }
+  this.transpose = plugin.transpose ? plugin.transpose : 0
   this.tuning = tuning;
+  this.stringPitches = []
+  for (var i = 0; i < this.tuning.length; i++) {
+    var pitch = noteToMidi(this.tuning[i]) + this.capo
+    this.stringPitches.push(pitch)
+  }
   if (this.capo > 0) {
     this.capoTuning = buildCapo(this);
   }

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

@@ -1,3 +1,5 @@
+var {noteToMidi, midiToNote} = require('../../synth/note-to-midi');
+
 /**
  * 
  * Note structure for Tabs
@@ -6,9 +8,12 @@
 var notes = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
 
 
-function TabNote(note) {
+function TabNote(note, clefTranspose) {
+  var pitch = noteToMidi(note)
+  if (clefTranspose)
+    pitch += clefTranspose
+  var newNote = midiToNote(pitch);
   var isFlat = false;
-  var newNote = note;
   var isSharp = false;
   var isAltered = false;
   var natural = null;
@@ -54,9 +59,11 @@ function TabNote(note) {
       newNote = note.slice(1);
     }
   }
-  var hasComma = (note.match(/,/g) || []).length;
-  var hasQuote = (note.match(/'/g) || []).length;
+  var hasComma = (newNote.match(/,/g) || []).length;
+  var hasQuote = (newNote.match(/'/g) || []).length;
 
+  this.pitch = pitch
+  this.pitchAltered = 0
   this.name = newNote;
   this.acc = acc;
   this.isSharp = isSharp;
@@ -76,6 +83,7 @@ function TabNote(note) {
 function cloneNote(self) {
   var newNote = self.name;
   var newTabNote = new TabNote(newNote);
+  newTabNote.pitch = self.pitch;
   newTabNote.hasComma = self.hasComma;
   newTabNote.isLower = self.isLower;
   newTabNote.isQuoted = self.isQuoted;
@@ -86,33 +94,11 @@ function cloneNote(self) {
   return newTabNote;
 } 
 TabNote.prototype.sameNoteAs = function (note) {
-  if ((this.name == note.name) &&
-    (this.hasComma == note.hasComma) &&
-    (this.isLower == note.isLower) &&
-    (this.isQuoted == note.isQuoted) &&
-    (this.isSharp == note.isSharp) &&
-    (this.isFlat == note.isFlat)) {
-    return true;
-  } else {
-    return false;
-  }
+  return note.pitch === this.pitch
 };
 
 TabNote.prototype.isLowerThan = function (note) {
-  var noteComparator = ['C','D','E','F','G','A','B'];
-  if (this.hasComma > note.hasComma) return true;
-  if (note.hasComma > this.hasComma) return false;
-  if (this.isQuoted > note.isQuoted) return false;
-  if (note.isQuoted > this.isQuoted) return true;
-  if (this.isLower) {
-    if (!note.isLower) return false;
-  } else {
-    if (note.isLower) return true;
-  }
-  var noteName = note.name[0].toUpperCase();
-  var thisName = this.name[0].toUpperCase();
-  if (noteComparator.indexOf(thisName) < noteComparator.indexOf(noteName)) return true;
-  return false;
+  return note.pitch > this.pitch
 };
 
 TabNote.prototype.checkKeyAccidentals = function(accidentals, measureAccidentals) {
@@ -120,14 +106,13 @@ TabNote.prototype.checkKeyAccidentals = function(accidentals, measureAccidentals
     return
   if (measureAccidentals[this.name.toUpperCase()]) {
     switch (measureAccidentals[this.name.toUpperCase()]) {
-      case "__": this.acc = -2; return;
-      case "_": this.acc = -1; return;
-      case "=": this.acc = 0; return;
-      case "^": this.acc = 1; return;
-      case "^^": this.acc = 2; return;
+      case "__": this.acc = -2; this.pitchAltered = -2; return;
+      case "_": this.acc = -1; this.pitchAltered = -1; return;
+      case "=": this.acc = 0; this.pitchAltered = 0; return;
+      case "^": this.acc = 1; this.pitchAltered = 1; return;
+      case "^^": this.acc = 2; this.pitchAltered = 2; return;
     }
-  }  
-  if (accidentals) {
+  } else if (accidentals) {
     var curNote = this.name;
     for (var iii = 0; iii < accidentals.length; iii++) {
       var curAccidentals = accidentals[iii];
@@ -135,10 +120,12 @@ TabNote.prototype.checkKeyAccidentals = function(accidentals, measureAccidentals
         if (curAccidentals.acc == 'flat') {
           this.acc = -1;
           this.isKeyFlat = true;
+          this.pitchAltered = -1
         }
         if (curAccidentals.acc == 'sharp') {
           this.acc = +1;
           this.isKeySharp = true;
+          this.pitchAltered = 1
         }
       }
     }
@@ -163,77 +150,13 @@ TabNote.prototype.getAccidentalEquiv = function () {
 
 
 TabNote.prototype.nextNote = function () {
-  var newTabNote = cloneNote(this);
-
-  if (!this.isSharp && !this.isKeySharp ) {
-    if (this.name != 'E' && this.name != 'B') {
-      newTabNote.isSharp = true;
-      return newTabNote;
-    }
-  } else {
-    // cleanup
-    newTabNote.isSharp = false; 
-    newTabNote.isKeySharp = false; 
-  }
-  var noteIndex = notes.indexOf(this.name);
-  if (noteIndex == notes.length - 1) {
-    noteIndex = 0;
-  } else {
-    noteIndex++;
-  }
-  newTabNote.name = notes[noteIndex];
-  if (newTabNote.name == 'C') {
-    if (newTabNote.hasComma > 0) {
-      newTabNote.hasComma--;
-    } else {
-      if (!newTabNote.isLower) {
-        newTabNote.isLower = true;
-      } else {
-        newTabNote.isQuoted = true;
-      }
-    }
-  }
-  return newTabNote;
+  var note = midiToNote(this.pitch+1+this.pitchAltered)
+  return new TabNote(note)
 };
 
 TabNote.prototype.prevNote = function () {
-  var newTabNote = cloneNote(this);
-
-  if (this.isSharp) {
-    newTabNote.isSharp = false;
-    return newTabNote;
-  }
-  var noteIndex = notes.indexOf(this.name);
-  if (noteIndex == 0) {
-    noteIndex = notes.length - 1;
-  } else {
-    noteIndex--;
-  }
-  newTabNote.name = notes[noteIndex];
-  if (newTabNote.name == 'B') {
-    if (newTabNote.isLower) {
-      newTabNote.hasComma = 1;
-    } else {
-      if (newTabNote.hasComma > 0) {
-        newTabNote.hasComma++;
-      } else {
-        if (newTabNote.isQuoted > 0) {
-          newTabNote.isQuoted -= 1;
-        } else {
-          newTabNote.isLower = true;
-        }
-      }
-    }
-  }
-  if (this.isFlat) {
-    newTabNote.isFlat = false;
-    return newTabNote;
-  } else {
-    if (this.name != 'E' && this.name != 'B') {
-      newTabNote.isSharp = true;
-    }
-  }
-  return newTabNote;
+  var note = midiToNote(this.pitch-1+this.pitchAltered)
+  return new TabNote(note)
 };
 
 TabNote.prototype.emitNoAccidentals = function (  ) {

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

@@ -3,7 +3,6 @@ var StringTablature = require('../string-tablature');
 var TabCommon = require('../../tab-common');
 var TabRenderer = require('../../tab-renderer');
 var ViolinPatterns = require('./violin-patterns');
-var setViolinFonts = require('./violin-fonts');
 
 
 /**
@@ -30,7 +29,6 @@ Plugin.prototype.init = function (abcTune, tuneNumber, params) {
 Plugin.prototype.render = function (renderer, line, staffIndex) {
   if (this._super.inError) return;
   if (this.tablature.bypass(line)) return;
-  setViolinFonts(this.abcTune);
   var rndrer = new TabRenderer(this, renderer, line, staffIndex);
   rndrer.doLayout();
 };