Recall that our goal is to create a Yamaha Genos™ custom voice with an overlapping split zone between upper and lower instruments. The first step started with factory preset voices to build a split voice using Yamaha Expansion Manager (YEM). The second step used XML Notepad to change the high and low note limits. These steps are demonstrated in the third article in this tutorial series.

The next and final step in our project goes way beyond “extra credit.” The split voice that I created has hard cut-off points for the lower and upper voices. I wanted to take things further and produce a smooth blend across the key range where the upper and lower voices overlap. This problem proved to be more involved than I first thought! Solving this problem turned into a learning experience. 🙂

If you want to experiment on your own, download the ZIP file with the PPF file, UVF files and Java code (SplitVoices_v1.0.zip).

Many synthesis engines implement a form of key scaling in which a parameter (e.g., amplitude, filter cut-off frequency, etc.) changes across the notes of the keyboard. Key scaling allows subtle effects like making higher notes brighter than lower notes. Amplitude key scaling changes volume level across the keyboard. My plan is to use AWM2 amplitude key scaling to make a smooth cross-blend of the upper and lower split voices.

The example voice that we are creating consists of a bassoon in the left hand and two layered oboes in the right hand. I call this voice “2 Oboes & Bassoon” because it is very similar to an MOX patch that gets a lot of play. The table below summarizes the voice design.

Sharp-eyed readers will notice that the velocity ranges are slightly different than the ranges in the third article. I found that the ranges used in the original MOX patch design made a more playable, easier to control voice.

At this point, I must caution the reader that I’m about to dive into the guts of an AWM2 voice. I assume that you’re familiar with AWM2 synthesis and its voice architecture. If not, I recommend reading the Yamaha Synthesizer Parameter Manual and the introductory sections about voice architecture in either the Montage, Motif or MOX reference manuals.

I suggest exploring a few Genos factory voices using XML Notepad or Notepad++ in order to see how the voices are structured and organized. Drill down into the XML voiceEelement entities. You will see several elementBank entities which are the individual key banks within the voice element.

You should see a blockComposition entity, too. This entity has parameters for the oscillator, pan, LFO, pitch, filter and amplitude synthesis blocks. For our purposes, we need the amplitudeBlock because the amplitude key scaling table is located within this block. The table is located within the levelScalingTable entity. See the example screenshot below. [Click screenshots to enlarge.]

An amplitudeBlock may be located in either of two places within the XML tree:

• It may be part of the blockComposition belonging to the voiceEelement, or
• It may be part of the blockComposition belonging to each elementBank entity.

In the first case, the parameter amplitudeBankEnable is OFF. In the second case, the the parameter amplitudeBankEnable is ON. Please remember this setting because it was a hard-won discovery. If it seems like the amplitude scaling is not taking effect, check amplitudeBankEnable and make sure it is consistent with the XML structure! The voice definition is flexible enough to allow block parameter specification at the voiceEelement level and, optionally, for each key bank at the elementBank level.

Knowledge of the XML structure is important here. I found that the bassoon voice elements defined the amplitudeBlock at the elementBank level. That meant an instance of the levelScalingTable for each of the seventeen (!) elementBank entities. Since the table contents are the same in every element bank, I did major surgery on the XML tree. I created a single amplitudeBlock at the voiceEelement level and deleted all of the amplitudeBlock entities at the element bank level. Fortunately, XML Notepad has tree cut and paste. I also set amplitudeBankEnable to OFF. (Eventually.)

Once the XML tree is in the desired form, it becomes a matter of setting each levelScalingTable to the appropriate values. A scaling table consists of 128 integer values between -127 and +127. It is stored as one long text string. Each value is the amplitude level offset associated with its corresponding MIDI note. MIDI note numbers run from 0 to 127.

At first, I used the level scaling tables from the “SeattleStrings p” voice as source material. This voice is a nice blend of the five string sections: contrabass, celli, violas, second violins and first violins. Each level scaling table emphasizes its section in the blend. Here are two screen snaps plotting the level scaling tables for the celli and first violins.

Although I abandoned this approach, in retrospect, I think it’s viable. I abandoned ship before I understood the purpose of amplitudeBankEnable. Also, I had not yet developed enough confidence to shift the table up (or down) 12 values in order to compensate for the octave position of the waveforms.

Instead, I decided to control the table contents and to make the tables myself. The MOX (Motif and Montage) define amplitude level scaling using four “break points.” Each break point consists of a MIDI note and level offset. The offset is added to the overall voice volume level and defines the desired level at the corresponding MIDI note. The offset (and resulting volume level) is interpolated between break points. (See the Yamaha Synthesizer Parameter Manual for details.) I wrote a Java program to generate a level scaling table given four break points. The program source code appears at the end of this article (bugs and all).

Here are the break points that I used. I took inspiration from the MOX break points for its “2 Oboes & Bassoon” patch.

                      BP1      BP2      BP3      BP4
                   --------  -------  -------  -------
    Bassoon Med    A#-1 -75  A#0  +0  A#2  +0  E3 -103
    Bassoom Hard   C-1  -75  A#0  +8  A#2  +0  E3 -103
    Oboe Med       A#2  -85  E3   +0  F#5  +0  C7 -103
    Oboe Hard      A#2  -63  E3  +14  C5   +4  C7 -103

I ran the program for each set of break points, generating four tables. Table plots are shown below. [Click to enlarge.]

Each table file contains one long line of 128 integer values. In order to change a level scaling table, first open a table file with a text editor (e.g., notepad, emacs, etc.), select the entire line, and copy it to the clipboard. Then, using XML Notepad, navigate to the appropriate levelScalingTable in the XML and replace the content of the #text attribute with the line in the clipboard. Save the UVF (XML) voice file. Save early, save often.

Copy the UVF file to the correct YEM pack directory as demonstrated in the third article. It’s important to be careful at every step in the process because we are making changes directly to YEM’s internal database. We don’t want to introduce any errors into YEM’s pack representation and cause a malfunction that needs to be backed out. Be sure to keep plenty of back-up copies of your work just in case.

Fire up YEM, open the “2 Oboes & Bassoon” voice for editing, and test. Enable each voice element one at a time and play the keys in the overlapping zone. You should hear the instrument fade-in or fade-out as you play through the zone.

With the offsets given above, I needed to shift each of the tables either “up” (bassoon) or “down” (oboes) to get a better blend. If you take a little off the front of a table (say, 4 values) be sure to add the same number of values to the end of the table. The table must be 128 values in length.

The blending issue is best resolved up front by defining different break points. Of course, the table files must be regenerated, but this is a little bit safer than trimming and lengthening the tables in-place within the XML. Laziness has its advantages and dangers.

If you require background information about YEM, the first article in this series discusses Yamaha Expansion Manager. The second article covers XML Notepad and how it can be used to work around limitations in YEM. The third article, mentioned earlier, demonstrates creation of the basic “2 Oboes & Bassoon” voice.

There are a few other posts related to voice editing with YEM. Check out this short article about creating a PSR/Tyros Mega Voice using YEM. Take a peek at the article about the design and implementation of my jazz scat voices. Then, download the scat expansion pack for PSR-S770/S970 and Tyros 5, import it into YEM, and take things apart.

One final note, I produced the plots shown in this article with the GNU open source GNUPLOT package. Visualization is essential to getting things right. There are other tools to visualize level scaling tables such as spreadsheet charting.

Copyright © 2018 Paul J. Drongowski

Source code: GenScalingTable.java

//
// GenScalingTable: Generate level scaling table from break points
//

import java.io.* ;

/*
 * Author:   P.J. Drongowski
 * Web site: http://sandsoftwaresound.net/
 * Version:  1.0
 * Date:     15 February 2018
 *
 * Copyright (c) 2018 Paul J. Drongowski
 *               Permission granted to modify and distribute
 *
 * The program reads a file named "breakpoints.txt" and generates 
 * a Yamaha  * amplitude level scaling table. The table is written 
 * to standard out. The table is one long string (line) containing 
 * 128 integer values ranging from -127 to +128.
 *
 * The breakpoint file contains four break points, one break point
 * per line. A breakpoint is a MIDI note name and an offset. 
 * Collectively, the break points form a curve that controls 
 * how the Genos (synth) voice level varies across the MIDI note
 * range (from 0 to 127). The curve extends to MIDI notes C-2
 * and G8.
 *
 * Exampe "breakpoints.txt" file:
 * A#2 -85
 * E3 +0
 * F#5 +0
 * C7 -103
 *
 * The file syntax is somewhat brittle: use only a single space 
 * character to separate fields and do not leave extraneous 
 * blank lines at the end of the file.
 */

public class GenScalingTable {
    static String[] bpNotes = new String[4] ;
    static int[] bpOffsets = new int[4] ;
    static int[] bpNumber = new int[4] ;
    final static boolean debug_flag = false ;

    final static String[] noteNames = {
	"C-2","C#-2","D-2","D#-2","E-2","F-2","F#-2","G-2","G#-2","A-2","A#-2","B-2",
	"C-1","C#-1","D-1","D#-1","E-1","F-1","F#-1","G-1","G#-1","A-1","A#-1","B-1",
	"C0","C#0","D0","D#0","E0","F0","F#0","G0","G#0","A0","A#0","B0",
	"C1","C#1","D1","D#1","E1","F1","F#1","G1","G#1","A1","A#1","B1",
	"C2","C#2","D2","D#2","E2","F2","F#2","G2","G#2","A2","A#2","B2",
	"C3","C#3","D3","D#3","E3","F3","F#3","G3","G#3","A3","A#3","B3",
	"C4","C#4","D4","D#4","E4","F4","F#4","G4","G#4","A4","A#4","B4",
	"C5","C#5","D5","D#5","E5","F5","F#5","G5","G#5","A5","A#5","B5",
	"C6","C#6","D6","D#6","E6","F6","F#6","G6","G#6","A6","A#6","B6",
	"C7","C#7","D7","D#7","E7","F7","F#7","G7","G#7","A7","A#7","B7",
	"C8","C#8","D8","D#8","E8","F8","F#8","G8"
    } ;

    public static int findNoteName(String note) {
	for (int i = 0 ; i < noteNames.length ; i++) {
	    if (note.equals(noteNames[i])) return( i ) ;
	}
	System.err.println("Unknown note name: '" + note + "'") ;
	return( 0 ) ;
    }

    // Put scaling values for a segment of the scaling "graph"
    public static void putTableValues(int startNote, int startOffset,
				      int endNote, int endOffset) {
	// Don't put any values if (startNote == endNote)
	if (startNote != endNote) {
	    int numberOfValues = Math.abs(endNote - startNote) ;
	    double foffset = (double) startOffset ;
	    double difference = (double)(endOffset - startOffset) ;
	    double delta = difference / (double)numberOfValues ;
	    for (int i = 0 ; i < numberOfValues ; i++) {
		System.out.print(Math.round(foffset) + " ") ;
		foffset = foffset + delta ;
	    }
	}
    }

    public static void main(String argv[]) {
	int bpIndex = 0 ;

	// Read break points (note+offset), one per line
        try {
	    FileInputStream fstream = new FileInputStream("breakpoints.txt") ;
	    DataInputStream in = new DataInputStream(fstream) ;
	    BufferedReader br = new BufferedReader(new InputStreamReader(in)) ;
	    String strLine ;
	    while ((strLine = br.readLine()) != null) {
		String[] tokens = strLine.split(" ") ;
		if (bpIndex < 4) {
		    bpNotes[bpIndex] = tokens[0] ;
		    bpOffsets[bpIndex] = Integer.parseInt(tokens[1]) ;
		    bpNumber[bpIndex] = findNoteName(tokens[0]) ;
		    bpIndex = bpIndex + 1 ;
		}
	    }
	    in.close() ;
	} catch (Exception e) {
	    System.err.println("Error: " + e.getMessage()) ;
            e.printStackTrace() ;
        }

	// Display the break point values
	if (debug_flag) {
	    for (int i = 0 ; i < 4 ; i++) {
		System.err.println(bpNotes[i] + " " + bpNumber[i]
				   + " " + bpOffsets[i]) ;
	    }
	}

	// Generate the key scaling table to the standard output
	putTableValues(0, bpOffsets[0], bpNumber[0], bpOffsets[0]) ;
	putTableValues(bpNumber[0], bpOffsets[0], bpNumber[1], bpOffsets[1]) ;
	putTableValues(bpNumber[1], bpOffsets[1], bpNumber[2], bpOffsets[2]) ;
	putTableValues(bpNumber[2], bpOffsets[2], bpNumber[3], bpOffsets[3]) ;
	putTableValues(bpNumber[3], bpOffsets[3], 128, bpOffsets[3]) ;
    }
}

Welcome to the third article in a short series about Yamaha Genos™ voice editing with Yamaha Expansion Manager (YEM). The first article introduces YEM and the second article discusses work arounds for a few shortcomings in YEM.

Time for an example! Let’s create a voice similar to the “2 Oboes & Bassoon” voice on the Yamaha MOX. This voice gets a lot of use in situations calling for a delicate solo voice balanced by a heavier single voice in the left hand. The table below summarizes the basic voice design on the MOX:

This voice is not a straight split. The bassoon and the oboes overlap in the key range from A#2 to E3, so there isn’t a sharp sonic break when the melody moves into bassoon range or vice versa. All three independent voices implement two velocity layers: hard (101 to 127) and soft (1 to 100).

The best way to start out is to create a Genos custom regular voice from an existing factory bassoon voice. Earlier, I had browse the Genos factory preset UVF files with XML Notepad as described in the second article. I decided to start with the Genos “OrchestralBassoon” voice because its programming is similar to what we need. In case you want to browse its UVF file with XML Notepad, the full path to the file is:

C:\Program Files (x86)\YAMAHA\Expansion Manager\voices\genos\EKB_LEGACY\Legacy\Woodwind\OrchestralBassoon.uvf

Here is a table summarizing the four elements which make up the “OrchestralBassoon” voice:

The lower and upper bassoon elements are split at C3. There are two velocity levels: hard (86 to 127) and soft (1 to 85). We will need to extend the lower bassoon elements to E3. Much later in the process, we might want to change the velocity layers to match after we hear how everything sounds and plays.

Here are ten steps to the finished result. This scenario assumes that you have YEM installed and your personal computer is connected to Genos with a USB cable. The best way to test is to actually play the voice while editing! When YEM is launched and Genos is connected, Genos enters a voice editing mode with the new voice in the RIGHT1 part.

1. Create a new pack “SplitVoices”. [Click on screenshots to enlarge.]

2. Create a new Genos custom normal voice starting with “OrchestralBassoon”.

3. Rename the new voice to “2 Oboes & Bassoon”.

4. Edit the new voice.

Copy “OrchestralOboe” element 1 (upper) to element 1 of the new voice.

5. Copy OrchestralOboe element 2 (upper) to element 2 of the new voice.

The new voice contains the following elements at this point in the process:

This leaves a silent gap between C3 and C#4. Eventually, we need to change bassoon’s note high to E4 and change oboe’s note low to G#2 using XML Notepad. The lower note limit is slightly out of the oboe’s real world range. The overlap is for blending purposes and the bassoon should hide this musical faux pas.

6. Copy “ClassicalOboe” element 1 to element 5 of the new voice.

The new voice contains the following elements at this point in the process:

We need to change element 5’s note low to G#2 eventually. We’ll make all of these note changes with XML Notepad.

Save your work by clicking the small file (disk) icon in the upper right corner of the editing window.

7. Exit YEM. Find the new pack and voice file using the file browser. Look in the directory:

    C:\Users\XXX\AppData\Local\Yamaha\Expansion Manager\Packs\

Substitute your user name, e.g., “pjd”, where “XXX” appears in the file path. Identify the new pack by its modification date and time, i.e., the date and time when you saved the new voice in YEM. As seen in the screenshot, YEM stores its packs with very cryptic names. Programmers call this kind of name, a “Global Unique Identifier” or “GUID”. The directory named “{1c2a0107-db86-4600-8e0a-b95993120573}” is the example “SplitVoices” pack.

Click to drill down into the pack directory. Copy the UVF file for the new voice to your own working directory. Launch XML Notepad and open your copy of the UVF file. (Save the original to be extra safe!)

Voice file names are also GUIDs. In the example, the file named “{2a6409fa-77b0-41b1-a374-71d1f4524386}” is the new “2 Oboes & Bassoon” voice.

8. Use XML Notepad to change the note limits as required. The “voiceElement” entities are listed in order and you’ll find the note high and low limit parameters within the fifth “voiceElement”.

The final result is:

We could also change the velocity limits to make them consistent. Save the UVF file. Copy the working file to the pack’s directory, overwriting the original UVF file for the new voice.

9. Launch YEM and open the voice for editing. Play the keyboard and test the new voice where the instruments overlap. We need to set mix levels for both both oboes (elements 1, 2 and 5) and the bassoon (elements 3 and 4). Change the volume level for each element using YEM. Be sure to save your edits when you’re done!

10. Now that the basic voice is finished, feel free to experiment. Try detuning the oboes to get a fatter sound. Let your imagination run free.

In the next article, we will edit the UVF file to get a better blend across the overlapping note region.

Commentary

I hope to attract Yamaha’s attention to the limitations in Yamaha Expansion Manager which are exposed by this scenario. YEM should display all basic information about a factory voice including the element waveform name, low and high note limits, and low and high velocity limits. We should also be able to change these vital parameters for each element. We should not have to reach for a tool like XML Notepad nor should we have to edit parameters behind YEM’s back by changing files in its database. Yamaha must remove these limitations, otherwise users cannot build split and layered voices of moderate complexity.

Copyright © 2018 Paul J. Drongowski

To date, my experience with Yamaha Genos™ has been generally positive. I’ve got a basic set of registrations set up for church tunes and I just converted the PSR-S950 registrations for rock, pop, jazz, funk tunes. Everything — customized styles, WAV files, and registrations — reside in the Genos’ internal memory.

Although some Genos players are reporting divots and a few serious bugs, my use has been quite reliable and error free. The shortcomings which affect me the most are related to drawbar organ (AKA “Organ Flutes”) functionality. I’ll cover that subject in a separate post.

The church registrations make use of left/right voice splits and layers. The Genos, like Tyros 5, breaks the keyboard into four zones/layers: LEFT, RIGHT1, RIGHT2, and RIGHT3. The RIGHTx parts allow two or three voice layers. If the LEFT part is turned off, the RIGHTx voices extend across the full keyboard. If the LEFT part is turned on, the keyboard is divided into LEFT and RIGHTx zones. The LEFT part plays only one voice (no layering).

The Genos allows considerable flexibility within this model. Please see the Owner’s Manual for details and configuration.

By and large, the LEFT/RIGHTx paradigm is sufficient to cover 90% of my needs. However, sometimes the hard split between LEFT and RIGHTx sounds unnatural. Consider a split with strings in the LEFT and oboe in the RIGHT. If the melody line crosses the split point, uh-oh, the melody shifts to the strings.

Now, it may be possible to avoid this issue through Genos ensemble voices, which are a big unexplored territory for me. I will look into ensemble voices eventually. As a synth guy, I’m used to addressing this issue through voice programming. In the synth world, one can have overlapping zones where both left and right voices are heard — usually good enough to fool the ear. Even better, features such as:

• Level Key Follow Sensitivity
• Amplitude Scaling

perform a blend across the split point. Think of this as a “horizontal cross-fade” similar to the “vertical cross-fade” which smooths the switch point between velocity levels.

None of these deep techniques is immediately available through the Genos user interface (UI). Genos voice editing reminds me of the TG-500 Quick Edit mode — a way to make fast voice-level changes (via “offsets”) which affect all of the underlying voice elements at once. Quick edit is not unique to Yamaha having seen and used a similar capability on Roland JV/XP gear.

Enter Yamaha Expansion Manager (YEM).

Having a PSR-S950, I nearly and dearly missed Yamaha Expansion Manager. YEM first supported the PSR-S970, S770 and Tyros 5 keyboards, now Genos. YEM is the means to make and install expansion packs. It also allows creation of new voices based on user waveforms (samples). On Tyros 5 and Genos, one can create new voices from preset voices of the “Regular,” “Sweet” or “Live” variety. Super Articulation voices cannot be edited or created via YEM.

My one brush with YEM was the implementation of the Scat Voice expansion pack for the PSR-S970, S770 and Tyros 5. YEM’s voice editing was sufficient to get the job done.

The screenshot below (click to enlarge) shows YEM’s Common voice parameters. YEM has all of the usual sliders and UI gizmos found in a typical computer-based synth voice editor. The Common parameters correspond to the Quick Edit parameters that are accessible through the Genos UI. These tweaks are also the high-level voice parameters found in Yamaha’s XG voice architecture.

The next deeper level of editing adheres to Yamaha’s AWM2 voice architecture. I recommend studying the Motif documentation to learn more about the AWM2 voice architecture, including the Yamaha Synthesizer Parameter Manual. (All manuals are available directly from the Yamaha Web site.) Concisely, a voice consists of one to eight elements. Each element is a mini sample-playback synthesizer with its own waveform, amplitude, pitch, filter and LFO blocks. Through YEM, you can tweak parameters within these blocks as shown in the screenshot below.

When working with user samples, YEM provides access to the key banks which make up an element waveform. In the screenshot above, you can see twelve key banks laid out across the middle of the MIDI keyboard. Velocity for each key bank ranges from 1 to 89. This is a velocity-switched voice, so other elements handle the rest of the full MIDI velocity range of 1 to 127.

I want to mention two major shortcomings of YEM at this point:

1. YEM does not provide vertical cross-fade to smooth the transition between velocity levels.
2. YEM does not provide control over velocity sensitivity at the element level.

Lack of vertical cross-fade means a hard sonic change across velocity split points. Inability to control element-level velocity sensitivity prohibits construction of well-behaved Megavoice voices. Yamaha need to add these capabilities to YEM.

As I mentioned earlier, YEM allows Tyros 5 and Genos users to edit preset voices. The screenshot below shows the YEM screen for element 1 in the “SeattleStrings p” voice.

Wow, a big blank where we expect to see the key banks. YEM does not provide access to the individual key banks for the factory waveform assigned to an element. To some extent, this is understandable as they would need to extract and distribute a lot more detail about the factory waveforms with YEM.

However, Yamaha omit vital information:

• What is the waveform name? A string section? A car horn? What?
• What range of the keyboard does the waveform cover?
• How is key amplitude scaling applied to the waveform?
• How is key velocity scaling applied to the waveform?

These omissions significantly reduce the effectiveness of YEM. Yamaha need to add these capababilities to YEM.

The missing information is available in the Genos voice definition files (UVF) that are distributed with YEM. In my next post on the topic of Genos voice editing, I will describe how to find, access and change the missing parameters.

Copyright © 2018 Paul J. Drongowski