ChordPro auto-accompaniment: Implementation notes

I’m prep’ing my ChordPro to Yamaha accompaniment program (cp2mid) for distribution. Please check out the demo. In the meantime, here are a few comments about the implementation.

Command line interface

cp2mid doesn’t have a fancy graphical user interface (GUI). A GUI is too much for a simple tool that translates an extended ChordPro file into a Standard MIDI File (Type 0).

I’m distributing both Java source code and a JAR file. The JAR file contains the compiled Java — the Java executable, if you will. “JAR” is an acronym for “Java Archive” and is produced by the Java archive program (jar), which is part of the Java development environment (JDK). JAR is a way to package up a compiled Java program, hiding all of the interior classes, etc. An end user doesn’t really need to know about JAR.

Given the JAR file, enter the following command line to run cp2mid:

    java -jar cp2mid.jar AFile.cho

“AFile.cho” is the name of an extended ChordPro file to be translated. You can hide the cp2mid.jar file within a Windows BAT file or shell file. Here is cp2mid.bat:

    java -jar cp2mid.jar %1

Nothing complicated, here.

cp2mid recognizes the “.cho” file name extension. It does not recognize any other extensions. If you snag a ChordPro file from the Web, you may need to change its extension to “.cho”. cp2mid replaces “.cho” with “.mid” in order to make the MIDI file name. Thus, “AFile.cho” is translated to “AFile.mid”.

During development and testing, you can run cp2mid starting with the compiled classes, e.g., cp2mid.class. Enter the command line:

    java cp2mid AFile.cho

to run cp2mid. The Java interpreter will look for “cp2mid.class” and the rest of the compiled classes needed by cp2mid. These compiled classes must be available in the same directory as cp2mid.class. “cp2mid”, by the way, is the main class in the application. You’ll need to specify the main class when creating a JAR file. Again, these steps are relevant only to developers.

Java classes

cp2mid has five Java classes:

  • cp2mid (cp2mid.java) Main class and driver
  • SongElement (SongElement.java) Basic element (parts) of a Song
  • Song (Song.java) Represents a ChordPro song in terms of SongElements
  • Song2mid (Song2mid.java) Translates the internal song representation to MIDI
  • MidiFile (MidiFile.java) Represents and manipulates a standard MIDI File (SMF)

The MidiFile class was used in an earlier prototype and still contains a bit of unused legacy code. This may change in future versions. The MidiFile class exploits the standard Java MIDI packages and classes. It creates a MIDI file and inserts MIDI messages (meta, SysEx and otherwise) into a MIDI file.

cp2mid is the boss. It calls on the other classes to do their jobs. Processing is broken into five phases:

  1. Check and manipulate file names.
  2. Read the ChordPro file into a String array, one line per array element.
  3. Translate each line into one or more SongElements.
  4. Translate the SongElements into MIDI.
  5. Write the internal MIDI representation to a Type 0 SMF.

The translation phases do the heavy lifting.

Song and song elements

A Song is a list of SongElements. A SongElement represents one of several ChordPro song constituents:

  • Directive
  • Chord
  • Lyric
  • Line
  • Annotation
  • Comment
  • Tab

All SongElements have the same data members. Each SongElement has a tag which identifies its type. The type determines the validity and interpretation of the other data members.

The Song class translates extended ChordPro to a list of SongElements. This is, effectively, the intermediate, internal representation of a ChordPro song.

ChordPro directives begin with ‘{‘ and end with ‘}’. Usually ChordPro directives control song formating. Extended ChordPro uses key, tempo, time signature, style code, start accompaniment and stop accompaniment directives to issue MIDI messages that will control the accompaniment engine when the MIDI file is played back.

ChordPro chords and lyrics are what it’s all about. Chords begin with ‘[‘ and end with ‘]’. Chords are extended by an optional beat count which specifies how long the chord is held. A lyric is text and may be multiple syllables long (i.e., anything up to the next chord, annotation, or end of line.)

A line element is a marker for important end-of-lines. Line elements affect lyric formating.

Normally, a ChordPro annotation is text added to a song when it is displayed. Annotations begin with ‘*[‘ and end with ‘]’. Certain predefined annotations, e.g., [*MA], [*FA], etc. change the accompaniment section during play-back.

Comments are just that. cp2mid saves the text, but doesn’t do anything with it.

A ChordPro song may contain guitar tablature (tab). Right now, cp2mid ignores tablature. This has not been tested. I’m not sure how to handle or translate tablature as yet.

Song to MIDI

The Song2mid class translates the internal intermediate song representation to MIDI messages and adds the MIDI messages to a MIDI sequence. The MidiFile class helper functions create specific types of messages. Base MIDI message and sequence classes belong to the standard Java MIDI package.

The Song2mid class walks the SongElement list from front to back. Based on element type, it dispatches to an element type-specific handler. The handler adds one or more MIDI messages to the sequence.

A separate blog post describes the MIDI messages.

I tried to encapsulate most of the “Yamaha-ness” in the Song2mid and MidiFile classes. ChordPro is very loose and forgiving when it comes to chord syntax. Song2mid recognizes only the 33 or so Yamaha chord types as defined in the Genos Data List PDF. If Song2mid doesn’t recognize a chord, it issues either a major or minor triad.

Example songs

I will distribute 15 example songs in extended ChordPro and MIDI format. Even if you don’t run cp2mid (or look at its implementation), please take a look at the extended ChordPro songs and try the MIDI files on your arranger. All sorts of fun and crazy things happen in real music (key changes, time signature changes, anticipation) and the examples demonstrate how to handle many exceptional situations. I chose certain songs as examples for testing because they are weird. 🙂

I tested the MIDI files on Genos and I’m curious about their behavior on other arranger keyboards. The MIDI files are similar to those generated by Yamaha ChordTracker. If your arranger plays ChordTracker MIDI files, it should play cp2mid MIDI files.

I don’t want to lead you on — it takes a fair bit of effort to take an Internet ChordPro file and whip it into shape. ChordPro as a formating tool is very lenient and forgiving. Accompaniment requires tighter semantics and precision like most “executable” computer stuff. It’s fun to whip a song into shape, but it requires work.

Copyright © 2022 Paul J. Drongowski

Hidden arranger smarts: file system SysEx

What to do with the ennui that sets in on New Years Day? Explore unexamined territory!

Yamaha Musicsoft Downloader is a valuable tool for Yamaha arranger keyboardists. Downloader lets you transfer MIDI song files, registrations file, text files, etc. between a Windows PC and a compatible Yamaha arranger keyboard. It even works with digital home pianos, too.

Most folks transfer their files using a USB jump drive. This isn’t a big deal when moving a few files maybe once or twice a day. When I’m developing a new style, however, I swap a drive quite frequently — dozens of times a day. All that physical swapping causes wear and tear on USB ports. I often use a short USB extender to reduce wear on the computer and/or instrument USB ports. I’d rather have a cheap cable fail than a USB port on a motherboard.

Downloader saves a lot of that wear and tear by copying data over a cable instead of a USB drive. Downloader supports both USB and good ole 5-pin MIDI transfers. Thus, folks who own older pre-USB keyboards can use Downloader, too.

Downloader has been around a while — one reason why it’s backward compatible. The user interface is a little bit dated, but it works and who cares? To move a file, you add the file to the holding area at the top of the screen, then move the file to its final destination by pressing one of the big arrow buttons. Classic.

Yamaha Musicsoft Downloader in action

The screenshot shows Downloader connected to Genos over 5-pin MIDI. The file “Downtown.mid” is in the temporary storage area. The lower left hand panel navigates instruments, drives and directories. The lower right hand panel selects files within a directory.

So, how does it do the actual transfer?

Because Downloader is old skool, it does it with MIDI. (Even over USB.) Downloader was written back in the day when MIDI was king and could do anything and everything. As another example, I give you the MIDI Sample Dump Standard (SDS) for representing and transferring samples to/from early-day samplers.

Downloader performs a dance with the target instrument. Like SDS, Downloader and the target instrument follow a set of rules — a protocol — for communication. To my knowledge, Yamaha has never published this protocol. It’s all done via MIDI System Exclusive (SysEx) messages although you won’t find these message types in the instrument’s reference manual or data list file. Nonetheless, your instrument is smarter than you think!

Of course, a lot depends upon the storage and capability of the target instrument. Entry-level instruments may be oblivious to Downloader or maybe just transfer back-up files. Mid- to higher-end arrangers are fully capable.

I decided to get a taste of this hidden protocol by monitoring the exchange of MIDI SysEx messages between Downloader and Genos. I split the MIDI stream and watched the dance as Downloader makes contact with Genos and acquires top-level directory information. After watching this process several times, I tried sending my own SysEx messages via MIDI-OX. (What a great tool!)

Here is a typical start-up sequence. It shows Genos’ response for each SysEx message that I sent.

F0 43 50 00 00 00 01 F7 
Genos responds: F0 43 50 00 00 00 02 01 01 F7
F0 43 50 00 00 02 01 F7
Genos responds: F0 43 50 00 00 02 02 33 00 01 00 00 01 00 01 00 00 1B
78 17 3F 01 00 00 00 00 00 00 01 7F 00 00 00 32 00 00
00 00 00 00 00 00 00 00 00 00 00 00 27 08 00 00 02 00
04 7F 7F 7F 7F F7
F0 43 50 00 00 01 01 F7
Genos responds: F0 43 50 00 00 01 02 00 F7
F0 7E 7F 06 01 F7 Identity request
Genos responds: F0 7E 7F 06 02 43 00 44 42 1C 0A 00 00 01 F7
F0 43 50 00 00 01 00 01 F7 Make connection (Genos is connected)
Genos responds: F0 43 50 00 00 01 02 01 F7

The first three out-bound messages test for a response. Downloader uses these messages as a connection check. The identity request message is a MIDI standard message for obtaining the identity of a musical device or instrument. Genos identifies itself as Yamaha (0x43) and model.

After getting the instrument identity, Downloader initiates the actual connection. When connected, the Genos display changes to a special background with the message: “Connected to the computer or smart device.” Genos is now listening for Downloader commands.

Thereafter, Downloader asks Genos for device, file and directory information. Here is the inquiry about top-level devices:

F0 43 50 00 05 0B 00 00 F7     Request drive 0 information 
Genos responds: F0 43 50 00 05 0B 01 42 00 00 05 00 55 53 45 52 F7
U S E R

Yamaha arranger people will recognize the USER drive where all user directories and files are kept. Genos returns the name for device 0: “USER”. If you have a USB jump drive attached, you will see:

F0 43 50 00 05 0B 00 01 F7     Request drive 1 information 
Genos responds: F0 43 50 00 05 0B 01 42 00 00 05 00 55 53 42 31 F7
U S B 1

Makes me think that Genos tells Downloader how many devices are available — maybe in response to the connection command?

Moving on, Downloader interrogates Genos about the directories and files at the next level down in the file hierarchy.

F0 43 50 00 05 04 00 3F 00 08 00 30 3A 5C 2A 2E 2A 00 F7    dir 0:\*.* 
? 0 : \ * . *
Genos responds: F0 43 50 00 05 04 01 10 31 39 38 30 20 31 20 31 20 30
1 9 8 0 1 1 0
20 30 20 30 03 01 00 00 00 03 00 2E 00 F7
0 0 .

You’ll notice that some command arguments and responses are ASCII characters, including the date and time stamps.

The number of subdirectories and files varies. So, Downloader and Genos go into a “loop” in which Downloader asks for the next entry (i.e., list item) and Genos responds with the entry’s information:

F0 43 50 00 05 05 00 F7        Request next dir list item 
Genos responds: F0 43 50 00 05 05 01 10 32 30 32 31 20 36 32 36 20 30
2 0 2 1 6 2 6 0
34 34 35 34 03 01 00 00 00 06 00 53 4F 4E 47 00 00 F7
4 4 5 4 S O N G

This loop continues until the list of available items is empty:

F0 43 50 00 05 05 00 F7        Request next dir list item 
Genos responds: F0 43 50 00 05 7F 01 01 01 42 00 00 F7 End of list

Genos responds with a unique message saying “no more” (0x7F).

Finally, it’s time to close the connection:

F0 43 50 00 00 01 00 00 F7     Disconnect command

Genos drops the connection and returns to normal operation, that is, it displays its usual main screen.

Sharp-eyed readers have noted the “ChordTracker” subdirectory in the “SONG” directory. ChordTracker created this subdirectory when I transfered an accompaniment from my iPad to Genos. How did ChordTracker create the subdirectory and perform the transfer? That’s new territory (more SysEx) to explore!

Well, that was one way to stave off the New Year’s blues. 🙂

Copyright © 2022 Paul J. Drongowski

ChordPro to MIDI accompaniment: Demo

Work continues on my Java program to translate ChordPro songs to Yamaha accompaniment (SMF). The code is fairly stable and mostly I’ve been writing example songs in ChordPro format for testing. The range and variety of musical craziness is amazing: weird chords (“Superstition”, “Michelle”), changing time signatures (“Two Of Us”), changing key signatures (“My Girl”), unusual time signature (“Everybody Wants To Rule The World”), and more.

Today, I want to give a taste of what to expect. I plan to distribute the Java executable as a “jar” file and will also make the source code available. To keep things simple, the program runs from a command line — no graphical user interface:

    java -jar cp2mid.jar ItsTooLate.cho

The program is named “cp2mid” and “cp2mid.jar” is the Java executable. We need to invoke java explicitly because it is an interpreted language and the executable consists of Java bytecodes.

The above command produces a Type 0 Standard MIDI File (SMF) named “ItsTooLate.mid”. This file must be sent to a Yamaha arranger like Genosâ„¢ by whatever means you have at your disposal, i.e., a USB flash drive or Yamaha Musicsoft Downloader.

Here is the first part of “ItsTooLate.cho”. The song begins with set-up directives including “{stylecode: }”, which selects the accompaniment style (“Cool8Beat”). You could leave out key, time, tempo, or stylecode and go with the current panel settings. This flexibility allows experiments with different tempos or different styles, including USER styles.

{t: It's Too Late }   
{key: Am}
{artist:Carole King}
{time: 4/4}
{tempo: 104}
# Style: Cool8Beat
{stylecode: 5635}

{start_accomp}
[Am7][*IA]

# Introduction (intro riff)
{start_of_instrumental}
[Am7][*MA] [D6] [Am7] [D6]
{end_of_instrumental}

{c: Verse 1}
[Am7] Stayed in bed all morning just to [D6] pass the time.
[Am7] There's something wrong here there can [D6] be no denying.
[Am7] One of us is changing
Or [Gm7] maybe we've just stopped [Fmaj7] trying. [Fmaj7][*FA]

{start_of_chorus}
And it's too [Bbmaj7][*MB] late baby now [Fmaj7] it's too late
Though we [Bbmaj7] really did try to [Fmaj7] make it.
[Bbmaj7] Something inside has [Fmaj7] died
And I can't hide [Dm7] and I just can't [Esus4:2][*FB] fake it. [E7#9:2]
{end_of_chorus}

The screenshot above shows the Genos song player with “ItsTooLate.mid” loaded and ready. Choose either the Lyrics or Score display (optional). Then hit play!

The next screenshot shows the Lyrics display. It should look familiar if you have played a Yamaha arranger. The arranger highlights the current lyric syllable or phrase in time with playback. Compare the screenshot with the ChordPro song and you’ll get an idea of what to expect for each ChordPro construct. A lyric phrase is not broken into syllables, but is associated with the chord preceding the phrase.

The following screenshot shows the Score display. It’s a different view of the same song. Lyrics appear below the staff and chords appear above. The time and key signature are displayed on the first page. Follow the bouncing ball during playback.

So, how does it sound? Listen to a quick demo (MP3) with me noodling on top.

That’s a taste of what’s ahead. I hope you will try cp2mid when it’s ready.

Copyright © 2021 Paul J. Drongowski

ChordPro auto-accompaniment: MIDI messages

I’ve made quite a bit of progress with my Java program that translates extended ChordPro songs into a Yamaha-compatible accompaniment MIDI file. This blog post describes the stuff inside the MIDI files produced by the program (cp2mid).

The MIDI file contains MIDI meta and SysEx (System Exclusive) messages which drive the Yamaha accompaniment engine. When the MIDI file is played back on a compatible Yamaha arranger keyboard (e.g., Genos), the keyboard generates an accompaniment as directed by the chord and section change messages in the MIDI file. It may sound odd to hear this, but the MIDI file doesn’t contain a single note ON or note OFF message! It’s all accomplished through control messages and the accompaniment is produced in real-time.

The MIDI file is a Type 0 Standard MIDI File. It starts with a bunch of set-up messages:

  F0 05 7E 7F 09 01 F7                           GM Reset 
F0 08 43 10 4C 00 00 7E 00 F7 XG System ON
FF 58 04 04 02 18 08 Time signature
FF 59 02 02 00 Key signature
FF 51 03 07 EF eb Tempo
F0 0D 43 73 01 51 05 00 03 04 00 00 2C 05 F7 Style code
F0 04 43 60 7A F7 Accompaniment Start

All of these message types are defined in the Yamaha Genosâ„¢ Data List PDF document. The messages beginning with “F0” are System Exclusive (SysEx) messages. Messages starting with “FF” are MIDI SMF meta messages. All messages are Yamaha proprietary (code “43”). The trick, of course, is filling in the correct values for the tempo, key, etc.

GM Reset and XG System ON initialize the tone generator. Time signature, key signature and tempo are SMF meta messages which control and arranger’s sequencing engine. The Style Code message selects one of the many built-in accompaniment styles. The Accompaniment Start message tells the accompaniment engine to get busy.

Once set-up is complete, the rest of the MIDI file consists of Chord, Lyric and Section Control messages. Again, these messages are all defined in the Genos Data List PDF document.

Here is a typical chord message:

    F0 08 43 7E 02 37 08 37 7F F7          Chord Bm/B

It tells the accompaniment engine to play a B minor chord (0x37 0x08) with a B bass note (0x37 0x7F). The neatest thing about the ChordPro conversion program? It makes it easy to play and hear difficult to finger chords like slash chords and unusual chord types like Cminmaj7-9.

Lyrics are inserted into the MIDI file using the SMF Lyric meta message:

    FF 05 len [Data]

For example, this Lyric meta message:

    FF 05 04 79 6F 75 20      0x79='y', 0x6F='o', 0x75='u', 0x20=' '

encodes the syllable text “you “.

No attempt is made to separate lyric text into syllables or to assign syllables to individual beats. When a lyric phrase is encountered in the ChordPro file, the phrase is inserted right after the preceding Chord message, i.e., it has the same MIDI timestamp as the preceding Chord message.

A Section Control message selects the current accompaniment section (pattern). The following message:

    F0 06 43 7E 00 09 7F F7               Section Control Main B: ON

selects the “MAIN B” section (0x09 0x7F). Because playback is fully automated, section changes are precise.

The penultimate message stops accompaniment:

    F0 04 43 60 7D F7                     Accompaniment Stop

The final SMF meta message ends the SMF sequencer track:

    FF 2F 00                              End Of Track (mandatory)

Overall, that’s a lot of power with just a few message types! Most of the Java code involves scanning the ChordPro input, book- and time-keeping. Java has a good MIDI library which makes coding easier.

As to time-keeping, all MIDI events (messages) have a timestamp. Messages issued from set-up directives before start_accomp occur in the first song measure. The start_accomp directive advances the MIDI clock to the first beat of the second measure. Thus, the first chord and lyric (if any) occurs at the beginning of the second measure. Thereafter, MIDI time advances in accord with each chord beat count (default: a full measure as determined by the current time signature).

Look here for more information about ChordPro format.

Copyright © 2021 Paul J. Drongowski

ChordPro for Yamaha accompaniment

Time to take the wrapping paper off my current development project.

It starts with ChordPro. ChordPro Format is perhaps the most popular notation for rock, pop, soul and folk tunes. A ChordPro format song contains lyrics and chords, usually formatted for easy display and reading. Strummers and plinkers everywhere use ChordPro songs as lead sheets.

It ends with Yamaha Genos, Tyros and PSR accompaniment. Genos — and other recent Yamaha arrangers — play MIDI files containing chords and lyrics. Genos displays either a running score or lyrics (plus chords) during playback.

What is missing is the bridge between ChordPro and Genos. My current project is the bridge. It translates an extended ChordPro file to a MIDI file which is compatible with Genos and other mid- to high-end Yamaha arranger keyboards. So far, I have a prototype up-and-running.

I emphasized the word “extended” because ChordPro format by itself is not sufficient for playback. The format does not have a precise notion of time. ChordPro relies on the musician to interpret the song on the fly. It assumes that the musician has heard the song before and knows when to change chords. As usual with computer stuff, playback needs more precise semantics. That’s where the extensions come into play.

Since there are a gazillion ChordPro songs on the Interwebs, I wanted to play back ChordPro files with as few modifications as possible. Thus, the first rule is “Each notated chord is held for one measure.” Of course, many songs change chords within a measure, too. (Even “Louie, Louie”!) Enter the first extension. A notated chord may have an optional beat count which specifies the number of beats to hold the chord, or more precisely, the number of time divisions (quarter notes or eigth notes) to hold the chord.

As I discovered during testing, existing ChordPro song files have a fair number of warts. Sometime the chord progressions are whack. The files often have random playing directions which ChordPro happily snarfs up as lyric text. ChordPro is very forgiving as it is primarily a formatting representation and tool. The initial goal — playing a ChordPro song with just a few additions — is unrealistic; expect to do some clean-ups.

Plain, unchanging accompaniment is pretty boring after a short while. Therefore, I added annotations for section changes, fills and breaks. Certain ChordPro directives are optional, but strongly recommended: key, tempo, and time signature. Tempo and time signature obviously guide playback speed and the interpretation of chord hold time. The key signature will set the arranger’s score display to the appropriate key.

Stylecode is an extension. It is a decimal number that selects the arranger accompaniment style, .e.g., 60sVintageRock, Oldies R&R, etc. A style name would be more convenient, but then I would need to develop a style name to code database for each arranger. Forget it; keep it simple. Besides, the PSR Tutorial site has such spreadsheets — just look up the style code yourself.

Start_accomp and stop_accomp are extensions, too. Start_accomp should (must) appear after all the basic playback settings are made. When the MIDI file is played back, the arranger will start or stop the accompaniment engine as directed. Start_accomp begins playback from the second measure; the first measure is reserved for set-up.

The translation program does not implement every and all ChordPro directive. It ignores formatting related directives and it doesn’t handle tablature (tab).

Let’s put all of this together and look at an example. Here is a snippet of “It’s Too Late” by Carole King.

{t: It's Too Late } 
{key: Am}
{artist:Carole King}
{time: 4/4}
{tempo: 104}
# Style: Cool8Beat
{stylecode: 5635}
{start_accomp}

[Am7][*IA]
# Introduction (intro riff)
[Am7][*MA] [D6] [Am7] [D6]

{c: Verse 1}
[Am7] Stayed in bed all morning just to [D6] pass the time.
[Am7] There's something wrong here there can [D6] be no denying.
[Am7] One of us is changing
Or [Gm7] maybe we've just stopped [Fmaj7] trying. [Fmaj7][*FA]

{start_of_chorus}
And it's too [Bbmaj7][*MB] late baby now [Fmaj7] it's too late
Though we [Bbmaj7] really did try to [Fmaj7] make it.
[Bbmaj7] Something inside has [Fmaj7] died
And I can't hide [Dm7] and I just can't [Esus4:2][*FB] fake it.[E7#9:2]
{end_of_chorus}

Lines beginning with ‘#’ are comments. Lines beginning with ‘{‘ are directives. Each directive must have a closing ‘}’ and consist of one line only. My translation tool supports the following simple directives:

  • title (or ‘t’): Song title
  • key: Song key
  • artist: Performing artist
  • composer: Song composer
  • copyright: Copyright information
  • comment (or ‘c’): Comment to be ignored
  • time: Time signature
  • tempo: Song tempo in BPM
  • stylecode: Yamaha style code (a decimal number)
  • start_accomp, stop_accomp: Starts and stops the accompaniment

As I mentioned, time, tempo and stylecode are optional, but necessary — unless you are willing to roll with the defaults. Start_accomp must be the final directive before the first chord and lyric in the song. Start_accomp generates the magic message needed to start accompaniment.

Chords look like regular ChordPro chords. Chord names are surrounded by square brackets, e.g., “[Am7]”. Nothing looks amiss until the end of the chorus, e.g., “[Esus4:2]” and “[E7#9:2]”. “:2” is a beat count. Each chord is held for two quarter notes — quarter notes because the number of divisions per bar (the “denominator”) of the time signature is four. It’s our job to make sure that the counts add up to a full measure in order to keep everything synchronized to measures.

The translation program (yet unnamed!) is very forgiving when it comes to chord spelling. However, it only recognizes and generates the 34 Yamaha chord types which are supported by Yamaha arrangers:

    Maj        7        min        minMaj      aug      dim 
Maj6 7sus4 min6 minMaj7 aug7 dim7
Maj7 7b5 min7 minMaj7-9
Maj7#11 7-9 min7b5
Maj9 7#11 min9
Maj7-9 7-13 min7-9
Maj6-9 7b9 min7-11
7aug 7aug
8
5
sus2
sus4

If the chord is not recognized, you will get a major or minor triad.

ChordPro allows annotations, that is, constructs beginning with “[*” and ending with “]”. Annotations ordinarily are playing instructions that are displayed in a pretty-printed ChordPro song. Annotations are extended with accompaniment section control commands:

  • Introduction: [*IA] [*IB] [*IC] [*ID]
  • Main section: [*MA] [*MB] [*MC] [*MD]
  • Fill in: [*FA] [*FB] [*FC] [*FD]
  • Break: [*BR]
  • Ending: [*EA] [*EB] [*EC] [*ED]

A section control command usually follows a chord and takes effect at the same time as the chord change.

ChordPro supports paired formatting directives like:

    {start_of_chorus} 
...
{end_of_chorus}

I am currently experimenting with these directives to control lyric and chord formatting. Yamaha’s lyric display allows line breaks and page breaks. Start of chorus (abbreviated “{soc}”) generates a page break. I added a new directive pair for handling long instrumental breaks, e.g.,

    {start_of_instrumental} 
[Cmaj7][*MC] [Fmaj7] [Fmaj7] [Am7] [Gm7] [Fmaj7]
[Dm7] [Esus4:2][*FC] [E7#9:2]
{end_of_instrumental}

Yamaha’s lyric display runs chords together when no lyric text is present. The new directive provides some separation between chords by generating filler lyric text (dashes, to be exact).

That’s the story. Testing continues. I will make the Java source code available as soon as possible. So far, so good. The concept works.

Copyright © 2021 Paul J. Drongowski

Critique: Genos™ drawbar organ

I like the Korg Module Pro “GospelOrgan” patch, so I tried to create a sound-alike voice on Yamaha Genos. Genos and MODX share the same waveforms and DSP effects, and I may port the result to MODX, too.

The experience recalled my previous misgivings about the rotary speaker simulation and limitations of the Genos DSP effect implementation. I will amplify those comments here.

Mid- to upper-level Yamaha arranger workstation have long had a drawbar organ feature which Yamaha calls “Organ Flutes.” This feature dates back to 1999, appearing in the PSR-9000 keyboard. Although a few details have changed over the years, Yamaha has not substantially overhauled Organ Flutes. It’s time, Yamaha — the world has moved on. I’d love to see the new YC organ technology in Genos. It’s the flagship of the arranger line and YC organs would definitely differentiate Genos from its lower-cost brethren.

Yamaha Organ Flutes main voice editing screen

The main, tweakable organ parameters are:

  • Nine drawbars
  • Percussion (first note/each note, length)
  • Percussion pitch (4′, 2-2/3′, 2′)
  • Response (onset delay of drawbar and percussion sounds)
  • Vibrato (on/off, depth, speed)
  • Rotary speaker speed (slow/fast)
  • Volume level (1 to 8)
  • DSP effect (e.g., rotary speaker)

For B-3’ers, the 4′ percussion pitch is the 2nd harmonic setting and the 2-2/3′ percussion pitch is the 3rd harmonic setting. The 2′ pitch supports non-Hammond organs which require it.

Compared with a contemporary clonewheel, one immediately notes a few missing features:

  • Vibrato only, no chorus
  • No key click
  • No rotor noise
  • No leakage

Overall, the Genos B-3 is super clean and polite — not vintage. MODX (Montage) provides key click, rotor noise (grit) and rotor whistle waveforms. Why does Genos lag behind? Although MODX is AWM2, not modeling, these extra waveforms are better than nothing at all.

The Genos synthesis engine is also AWM2 sample-playback and AWM2 provides the Organ Flutes vibrato. Organ Flutes does not simulate the one-of-a-kind Hammond vibrato/chorus scanner. The Korg Module “Gospel Organ” voice incorporates C-3 chorus and the AMW2 vibrato just doesn’t cut it (head-to-head comparison). I had to substitute Genos’ V-2 setting and move on.

Simplified, graphical rotary speaker interface

If you want to change the rotary speaker type, you need to dive through the effect setting button at the top of the Organ Flutes screen. After selecting the insertion effect, Genos displays a skeuomorphic (graphical) rotary speaker cabinet with a few knobs. In the screenshot above, we get rotary speed, horn and rotor balance, and microphone left/right angle. Like many (most?) rotary speaker simulations, the rotary effect emulates the sound of a mic’d up, stereo recording of a Leslie, not a horn and rotor moving air in a room.

Additional rotary speaker (DSP) parameters are changed by tapping the “Detail” button in the lower right corner. deep-diving reveals a few more deficiencies:

  • Missing parameters due to a limitation on the number of DSP effect parameters (16 parameters maximum)
  • Only one insert effect (typically the rotary speaker)
  • Volume control is post-effect and does not affect overdrive

Here is a little more information about each issue.

First page of rotary speaker parameters

At heart, the Genos (PSR, Tyros) sound engine implements the Yamaha XG synthesis and effects architecture. The XG architecture allows up to sixteen (!6) parameters per DSP effect unit. Unfortunately, Yamaha’s DSP engineers are creating effect algorithms (AKA “effect types”) with more than sixteen parameters! The MODX ROTARY SPEAKER 2 algorithm has eighteen (18) parameters. The Genos REAL ROTARY effect type is the same algorithm as MODX. However, only 16 parameters are accessible or stored on Genos. The two missing REAL ROTARY parameters are:

  • Slow-Fast Time of Rotor
  • Fast-Slow Time of Rotor

You cannot change these rotor ramp times on Genos, yet, you can change them on MODX.

This issues affects the Genos UNI COMP compressor algorithm (MODX: UNIVERSAL COMPRESSOR DOWN). Dare I mention the inability to specify a side-chain part, too? People are trying to create EDM on arrangers.

The XG architecture allows only one insert effect per part. The Organ Flutes insertion effect is typically a rotary speaker simulator. The MODX effect architecture, on the other hand, allows two insert effects per part. Yamaha synths take advantage of the second insert effect to add overdrive or vintage EQ:

  • Rotary speaker 1 → Multi FX (Distortion Solo)
  • Rotary speaker 2 → VCM 501 EQ (Flat)
  • Amp Simulator 3 (Tube) → VCM 501 (Flat)
  • Amp Simulator 1 (Stack 2) → Rotary Speaker 1
  • VCM 501 EQ (Flat) → Rotary Speaker 1

The rotary speaker drive alone is not enough to warm up the basic sound nor is it enough to get a sweet, realistic overdrive with guts. I experimented with the Genos REAL ROTARY effect and got some very squirelly results at high drive levels. The algorithm can be pushed in unexpected, undesirable ways while searching for true funk.

Unlike a real Hammond/Leslie combination, the Genos expression pedal controls post-effect part volume. This is like putting the volume control after the Leslie speaker. A Hammond B-3 pedal controls the level into the Leslie pre-amp. Thus, the pre-amp frequency characteristics and overdrive track the Hammond pedal. The Yamaha YC61 modeling gets this right. Putting the volume pedal before the pre-amp lets the player get clean or dirty in the same way a guitarist uses picking and/or the guitar volume knob to distort or clean up their tone.

If the Genos developers must work around the XG architecture, they should consider a new effect algorithm that combines overdrive with the rotary speaker simulation. The algorithm should allow foot pedal control over the Leslie pre-amp input level. Genos and other PSRs allow wah pedal control, so they obviously know how to achieve this capability within the current architecture.

Copyright © 2021 Paul J. Drongowski

Random answer day (1)

Maybe it’s the first day of the regular NFL season or the phase of the moon. Here’s a recap of a few questions that came into the forums.

How are arranger/synth preset voices stored? First, one may ask, “How is a preset represented?” Typically, a preset voice consists of waveforms (AKA “samples”) and voice (meta-)data. The voice data control how the sample-playback engine applies filtering, amplitude envelope, modulation and so forth. The waveforms, of course, provide the basic digital audio data.

There is such a broad range of arranger/synth products at different price points, that the amount of storage and the kind of storage varies quite a lot.

The lowest of the low in the Yamaha range: PSS-A50, -E30, -F30, PSR-F51. Presets are stored on a 2MByte serial flash ROM and are loaded into the processor (SWLL) at start-up. The 2MBytes include code, too! Tone generation is integrated into the SWLL. Insanely small, and very low cost.

The highest of the high in the Yamaha range: Genos. Factory presets are stored in four 1GByte ONFI NAND flash devices. Expansion memory consists of two 1GByte ONFI NAND flash devices. Wave memory connects directly to external tone generators (SWP70).

I’ve looked at the diagrams for Genos and I’m not sure about the size and function of those memory units, especially Genos USER memory and expansion memory.

Yamaha confuses people when they speak of “user memory,” “internal memory,” etc. They are usually referring to logical, user visible storage.

When getting down to the hardware level, there are many different physical memory units. since we’re not discussing fairy dust or magic, the logical storage must be assigned to one or more physical memory units. And, of course, the physical memory units themselves may be composed of multiple integrated circuits. The other dimension is “what communicates to what.” Memory is passive and needs a processor to initiate reads and writes and to do something with all that data. At the physical level, a memory unit essentially belongs to a single processing unit (host computer, tone generator) and directly communicate with it.

Sometimes I think of the SWP70 as a parallel processor just like a GPU. The CPU/SWP70 is not exactly analogous to host CPU plus GPU, however. Graphics memory is shared between CPU and GPU. The SWP70 does not share its waveform memory with anybody — it’s dedicated to the tone generator. That’s why installing an expansion pack (voice library) is kind of slow and technically complicated, and why a Genos reboot is required.

Yamaha Genos SWP70 tone generators

Staying with Genos, Genos has two SWP70 tone generators: one handles factory presets and the other handles user expansion voices. The factory SWP70 has 4GBytes of flash memory while the expansion flash memory has 1GB of flash memory. That’s physical memory. Yamaha boosted the effective capacity to 3GB expansion through compression.

The SWP70s also have DSP RAM. As a user, you never know about this memory. It’s scratchpad memory for DSP effects. Physically, the DSP RAM is completely separate and independent from the waveform memory, and communicates with only its parent SWP70.

Yamaha Genos Host CPU

The host CPU has two kinds of memory (as determined by its bus interfaces): 1GB of working RAM on the CPU memory bus (EMIF) and two embedded eMMC memory devices that act like solid state storage drives (MMC0 and MMC1). As far as a user is concerned, the user never sees the 4GB eMMC drive (MMC0) just like you don’t see the DSP RAM; it’s hidden. The MMC0 drive contains the Linux operating system kernel and the root file system.

The user sees only part of the second 64GB eMMC drive (MMC1). The user sees the logical storage which Yamaha calls “Internal memory” or “USER drive.” What’s in the remaining 6GB? I don’t know — Yamaha haven’t left any clues.

What about Montage and its 5.67GByte waveform memory? 5.67GB is the capacity when the waveforms (samples) are compressed. Again, this is logical storage capacity.

Yamaha Montage SWP70 tone generators

Montage has two SWP70s. One SWP70 is dedicated to FM-X and it does not have waveform memory. The second SWP70 handles AWM2 synthesis (sample playback) and has waveform memory connected to it. The waveform memory consists of four 1GByte devices totaling 4GBytes. Thanks to Yamaha’s proprietary compression, Montage stores 5.67GBytes-worth of data in the physical waveform memory. The remaining space, 1.75GB physical, is available for user samples.

How does sample capacity relate to price? It doesn’t. Component cost is outweighed by manufacturing costs, software development cost and sound design cost.

If the memory components are so cheap, why isn’t there more waveform memory? If there was more, then you wouldn’t buy the Mark II model, would you? 🙂

I understand that E30/F30 do NOT offer velocity sensitivity. My question is about the internals. Is it confirmed that it’s a keybed with two switches per key, that just aren’t supported in software?

Yes, you need to be careful here. There are hardware model differences: E30 and F30 are not velocity sensitive. A50 is velocity sensitive.

There are two different keybed printed circuit boards (PCB). Yamaha part number VAY27800 for F30/E30 and VAY28500 for A50. The A50 PCB has the necessary diodes installed for velocity sense. The F30/E30 PCB does not have the diodes. Further, the A50 board has a 12-pin connector while the F30/E30 board has an 11-pin connector — perhaps to avoid assembly mistakes.

Yamaha Reface key switch matrix schematic

Is velocity sense worth the extra bucks? There may be other differences, too, but these differences are plainly visible.

And the usual caution/disclaimer — kiss the warranty good-bye! For the money, the PSS should be good mod-fodder. Korg probably sold a mess o’monotron that way. 

Copyright © 2021 Paul J. Drongowski

Free DJX-II styles: Version 2

I’m happy to announce version 2 of my DJX-II styles for Yamaha Genos, Tyros and PSR arrangers.

These DJ styles are converted from the original Yamaha DJX-II patterns. If you would like to know more about the conversion process, please see: Mining the Yamaha DJX-II.

These are DJ styles, so they only respond to changes in the root note. The chord progressions are cooked into the patterns (just like intros and endings in regular PSR styles). I tried to find the best mapping from DJX-II patterns to style sections. Therefore, some of the DJXII styles have auto-fill, some do not. Longer “fill” patterns are assigned to the intro and ending sections which can play more than one measure.

Feel free to edit, rearrange and customize the styles in order to make them your own. I recommend Jørgen Sørensen’s excellent tools. Jørgen’s site also has documentation and tutorials about styles and style creation to help you along. Please check it out and support his work!

Click on this link to download the ZIP file.

Version 2 includes all of the files in the first collection. Version 2 adds Drum ‘n’ Bass, Disco, House and Trip Hop styles. The ZIP file includes a README.TXT file which should help you get started with the styles. I have also included PDF notation files for people who read music and want to know about the chord progressions, bass lines, and so forth.

Enjoy! The DJX-II style collection is free.

Copyright © 2021 Paul J. Drongowski

Arpeggio to style conversion

Let’s get one out of the vault… 🙂

The Motif XS/XF (MOX/MOXF) and Montage (MODX) arpeggios and performances are a great source of inspiration. Unlike Yamaha’s arranger series, the built-in phrase library is rich in urban and chill patterns. For some odd reason, one of the classic XS/MOX performances — “Dresden At Night” — never made the leap to Motif XF. And, it’s missing from Montage/MODX, too.

A PSR Tutorial forum member sought help resurrecting Dresden At Night, albeit a recreation for the PSR-SX700 arranger. I thought I would help out since I wrote a series of articles about MOX performance to style conversion:

The end result of that work is a small collection of PSR (Tyros, Genos) styles based on MOX (Motif XS) performances.

If you would like to try Dresden At Night or experiment with a conversion of your own, download the free ZIP file.

MOX performances have four parts (voices). Each part has up to six musical phrases (arpeggios) associated with it. Six front-panel buttons select the currently playing set of arpeggios, i.e., button one selects the first arpeggio for each set and so forth. To get the basic MIDI data, I played each arpeggio (group) for four measures while recording in MOX performance quick record mode. I wrote out the MIDI data as a Standard MIDI File (SMF), transfered the SMF to PC, and imported the SMF into a DAW (Sonar).

Dresden At Night is a downtempo (91 BPM), urban-ish chill performance. It has four parts:

Part# Voice    Name              NoteLo NoteHi VelLo VelHi Level Pan
----- -------- ---------------- ------ ------ ----- ----- ----- ---
1 PRE8:070 8Z Heavy Hearts C-2 G8 1 127 81 C
2 PRE3:053 Dark Bass C-2 G8 1 127 51 C
3 PRE7:110 Ibiza Groove C-2 G8 1 127 127 C
4 PRE5:121 Smooth BPF Sweep C-2 G8 1 127 73 C

The first part is the rhythm voice and the second part is the bass voice. As we’ll see below, arpegiation is turned for these two parts. The third and fourth voices are a play-along pad layer and arpeggiation is disabled. Thus, the rhythm and bass parts provide a looped backing while the pad voices provide an atmospheric you-steer-it, right hand part.

Here are the arpeggio assignments:

Arp#1 Tempo:91              Arp#2 
----- -----
1 MA_8Z HeavyHrt1 1 MA_8Z HeavyHrt3 ON
2 MB_WestCoastPop _XS 2 MA_WestCoastPop _XS ON
3 MA_Space Arp 3 MA_Space Arp OFF
4 MA_Up Oct1 4 MA_Up Oct2 OFF
Arp#3 Arp#4
----- -----
1 MA_8Z HeavyHrt4 1 MA_8Z GatedBt3 ON
2 BA_Jazz Pop _XS 2 FB_WestCoastPop _XS ON
3 MA_Space Arp 3 MA_Space Arp OFF
4 MA_Up Oct4 4 MA_Down Oct1 OFF
Arp#5 Arp#6
----- -----
1 MA_8Z ChillBrk4 1 BA_Sp SFX ON
2 MB_WestCoastPop _XS 2 MA_WestCoastPop _XS ON
3 MA_Space Arp 3 Off OFF
4 MA_Down Oct2 4 Off OFF

The Arpeggiator is turned ON for Parts 1 and 2 only.

A big factor is the “8Z Heavy Hearts” drum kit. The “8Z” in its name means “eight zone”. Eight zone (8Z) voices are a Motif innovation beginning with the XS (MOX) family. If you would like more information, check out these earlier posts about eight zone voices:

8Z voices aren’t drum kits. They are implemented as synth voices and are just a clever way of using the eight elements which make up a voice. The eight zones (8Z) are divided across specific note ranges. 8Z Heavy Hearts assigns waveforms (zone sounds) in the following way:

Element#  Note Low  Note High  Waveform 
-------- -------- --------- --------------
1 C0 F#0 Bd T9-1
2 G0 C1 Bd Hard Long
3 C#1 D1 Sd Elec12
4 D#1 F1 Sd HipHop6
5 F#1 A1 HH Closed D&B
6 A#1 C2 HH Open T9
7 C#2 C4 Clap AnSm
8 C#4 C6 Shaker Hip2

Yamaha messes with each of the zones in crazy ways and ties keyboard notes to voice parameters (AKA “key follow”). For 8Z Heavy Hearts, the most notable effect is how the Clap AnSm pitch follows the keyboard.

Arrangers (even Genos!) don’t have 8Z voices. They have standard drum kits where each MIDI note is a separate drum instrument. In order to make a PSR style using a DAW, one must translate the 8Z MIDI notes to standard drum kit notes. You need to assign appropriate drum kits (e.g., DrumMachine, Analog T9, House, Break or HipHop) to style parts 9 and 10 (MIDI channels 9 and 10) and copy the Heavy Hearts MIDI data to both Parts. Then, delete the notes that aren’t needed in a style part, compress each zone into a single drum instrument, and map the resulting “compressed” notes to the appropriate drum instrument(s). So, for example, all of the notes in C0 to F#0 might be compressed into the Kick T9 1 instrument (B0) in the Analog T9 Kit, which is one of the target drum kits.

I found two PSR drum parts to be enough. However, styles are flexible and you could assign a third (fourth, …) drum kit to one of the other style parts. There’s nothing in Yamaha styles that prevents this. It’s just that parts 9 and 10 (MIDI channels 9 and 10) are conventionally assigned to drum parts in a style.

I went with two PSR drum kits: Analog T9 kit and Drum Machine kit. Here is one possible assignment:

Note Low Note High Waveform       Instrument        Note#   Kit 
-------- --------- ------------- ---------------- ------ -----------
C0 24 F#0 30 Bd T9-1 Kick T9 1 35 B0 AnalogT9Kit
G0 31 C1 36 Bd Hard Long BD Hard Long 24 C0 DrumMachine
C#1 37 D1 38 Sd Elec12 Snare Analog CR 63 D#3 DrumMachine
D#1 39 F1 41 Sd HipHop6 Snare Hip 1 86 F#3 DrumMachine
F#1 42 A1 45 HH Closed D&B Hi-Hat Closed Syn 91 A4 DrumMachine
A#1 46 C2 48 HH Open T9 Hi-Hat Open T9 46 A#1 AnalogT9Kit
C#2 49 C4 72 Clap AnSm Clap Analog Sm 27 D#0 AnalogT9Kit
C#4 73 C6 96 Shaker Hip2 Analog Shaker 57 A2 DrumMachine

A lot of detail, huh? Nobody said style conversion was easy. 🙂 In the end, I spread each zone across multiple drum instruments of the same type, i.e., assigning the Shaker Hip2 zone to a few different Analog Shaker sounds in the Drum Machine kit. Part of 8Z Heavy Hearts’ charm is the subtle sonic variation provided by each zone.

Trying to keep this all straight in the DAW piano roll is cognitively challenging. Did I say, style conversion isn’t easy? 🙂

Fortunately, one can loop four bar sections and play the MIDI through the arranger (Genos, in this case) just like a MIDI song. Then, it’s the usual tweak, listen, rinse, repeat edit process. When the MIDI is tweezed to your liking, you need to add MIDI markers to delimit the style sections. (BTW, leave a one bar MIDI set-up measure at the beginning.) Style section markers are:

    Set-up measure 1: SFF1 
Set-up measure 1: SInt
Main sections: Main A, ...
Fill sections: Fill In AA, ...
Break section: Fill In BA, ...
Introduction: Intro A, ...
Ending: Ending A, ...

At a minimum, you need a few MIDI set-up System Exclusive (SysEx) messages at the beginning of the SMF (measure 1, beat 1):

    F0 7E 7F 09 01 F7                 GM Reset 
F0 43 10 4C 00 00 7E 00 F7 XG System ON
F0 43 10 4C 02 01 00 01 16 F7 Reverb type
F0 43 10 4C 02 01 20 16 00 F7 Chorus type

Reverb is the “Light Hall” preset and chorus is the “Tempo Cross 1” preset. The tempo cross delay is an 8-beat echo.

Which brings me to a necessary ingredient: crunch. 8Z Heavy Hearts gets a lot of its appeal from the Lo-Fi effect:

#  Parameter                   Val  Hex   Meaning 
-- -------------------------- --- ---- --------
1 Sampling Frequency Control 4 0x04 8.82kHz
2 Word Length 98 0x62
3 Output Gain 7 0x07 0dB
4 LPF Cutoff Frequency 56 0x38 12kHz
5 Filter Type 1 0x01 PowerBass
6 LPF Resonance 63 0x3F 6.3
7 Bit Assign 4 0x04
8 Emphasis 1 0x01 On
10 Dry/Wet 88 0x58 D<W24
15 Input Mode 1 0x01 Stereo

Since we need Lo-Fi on both style parts 9 and 10, I configured the variation effect as an XG SYSTEM effect. Parts 9 and 10 also require variation send (MIDI CC#94) set to 127. Add a CC#94 message to parts 9 and 10 in the set-up measure. Here are the MIDI System Exclusive messages to add to the set-up measure:

F0 43 10 4C 02 01 40 5E 13 F7       Variation type 
F0 43 10 4C 02 01 5A 01 F7 Variation SYSTEM
F0 43 10 4C 02 01 56 40 F7 Variation return
F0 43 10 4C 02 01 58 10 F7 Variation send to reverb
F0 43 10 4C 02 01 59 10 F7 Variation send to chorus
F0 43 10 4C 02 01 42 00 04 F7 Variation parameter 1
F0 43 10 4C 02 01 44 00 62 F7 Variation parameter 2
F0 43 10 4C 02 01 46 00 07 F7 Variation parameter 3
F0 43 10 4C 02 01 48 00 38 F7 Variation parameter 4
F0 43 10 4C 02 01 4A 00 01 F7 Variation parameter 5
F0 43 10 4C 02 01 4C 00 3F F7 Variation parameter 6
F0 43 10 4C 02 01 4E 00 04 F7 Variation parameter 7
F0 43 10 4C 02 01 50 00 01 F7 Variation parameter 8
F0 43 10 4C 02 01 54 00 58 F7 Variation parameter 10
F0 43 10 4C 02 01 75 01 F7 Variation parameter 15

At this point, you could save the MIDI to “DresdenAtNight.sty” and load it into your arranger as an SFF1 format style. The arranger should create the style CASM segment. As an alternative, you can add a CASM segment to the SMF with Jørgen Sørensen’s CASM editor. You might as well download his OTS editor, too, and use it to add OTS voice settings to the new style as well. Or, you can do this sort of work on your arranger itself. Mid- and high-end Yamaha arrangers save styles as SFF2 format, which is one way to convert from SFF1 to SFF2. I highly recommend Jørgen’s site, tools and style creation tutorial.

BTW, you can recreate Dresden At Night on MODX (Montage). Create a new MODX performance with 8Z Heavy Hearts and Dark Bass. 8Z Heavy Hearts has the appropriate arpeggios by default. You’ll need to assign different arpeggios to the Dark Bass part. Modify effects as needed. Choose and add pad or lead voices to give your right hand something to do. Done! Use the Scene buttons to switch arpeggio groups.

Copyright © 2021 Paul J. Drongowski


Combo organ: Montage, MODX, Genos

Contemporary workstation instruments offer several options for combo organ emulation. Every workstation has at least a few internal combo organ waveforms. Korg Kronos, for example, has two Vox organ waves built in. Even the lowly Korg microKorg XL+ has two Vox waveforms (DWGS single cycle).

Yamaha MODX and Montage — my focus in this article — have a good variety of Vox and Farfisa waveforms. Yamaha Genos has a lesser endowment as we’ll see. Yamaha Reface YC shares sonic DNA (AWM2 and effects) with the Motif XF and will be the subject of a future post.

Motif, Motif ES and Motif XS

Models in the early Motif series primarily base combo organ patches on two waveforms:

  • Portable Electronic: Vox-y tone
  • Compact Electronic: Farf-y tone

You can hear these waveforms at work in the Tiny Combo Bars 1 performance and the Tiny Combo Bar 2 performance. The patches layer three are more elements playing Portable Electronic or Compact Electronic (respectively). Each element is filtered differently: low pass, band pass and high pass. The net effect is like several distinctive tab stops or drawbars pulled at once.

These waveforms are very old, going back to the original Motif (maybe S80) in the early 2000s. I’ll bet dollars to donuts that the Portable Electronic waveform is the basis for the 60’sOrgan voice (MSB: 0, LSB: 116, PC: 18) in PSR and Tyros keyboards. The 60’sOrgan voice was the sole combo organ mainstay in the arranger line for a loooong time.

Motif XF, Montage, MODX

Motif XF got a big shot of combo juice. Motif XF added several combo organ waveforms:

  • Fr All Tabs
  • Fr Bright Boost
  • Fr Flute
  • Fr String Lo
  • Fr String Hi
  • Fr Trumpet
  • Fr Piccolo
  • Fr Pedal
  • Fr KeyOff
  • Vx Drawbar1-3
  • Vx DrawbarIV
  • Vx KeyOff

The Farfisa (Fr) waveforms support emulation of specific Farfisa features: individual voice tabs (flute, string, trumpet and piccolo), the wicked Bright Boost knee lever, bass keys (pedal), and key off sound. The Fr All Tabs waveform covers one of the most common use cases — all of the tab stops turned on. Subtlety was not a hallmark of sixties combo organ music. 🙂

The Vox (Vx) Vx Drawbar1-3 waveform covers the three Continentel footage drawbars while the mixture drawbar is handled by the Vx DrawbarIV waveform. The Vox waveforms include a Vox key-off noise.

In terms of voice programming, one uses note shift to achieve different footage ranks. Passive filtering is emulated through filter type (low pass, band pass, high pass) and cutoff frequency. Of course, everything can be routed into insert effects for distortion, amp simulation, and other grunge.

Since Montage and MODX inherit all things Motif, these waveforms and the Motif performances are there for you. The Montage and MODX sliders allow control over individual voice elements. For example, choose the Raspy Tabs performance and assign slider control to element level. The Fr Raspy Tabs waveform-to-element assignment is:

El# Waveform     KeyLo KeyHi VelLo VelHi Coarse Level Cutoff XA Ctrl 
--- ------------ ----- ----- ----- ----- ------ ----- ------ -------
1 Fr String Lo C2 G8 1 127 0 97 255 Normal
2 Fr Trumpet C2 G8 1 127 0 82 255 Normal
3 Fr Flute C2 G8 1 127 24 120 236 Normal
4 Fr Pedal C-2 B1 1 127 0 127 160 Normal
5 Fr String Hi C2 G8 1 127 19 24 236 A.SW2 On
6 Fr KeyOff C2 G8 1 127 6 87 80 Key Off

Different tabs are brought in and out by moving the corresponding slider. Assignable switch 2 turns on additional brightness. The low keyboard octaves play the bass (pedal) tones. Overall, this is a fairly controllable representation of a wheezy Farfisa Compact.

Because the sliders are not discrete, you can probably make up Farfisa tones which aren’t entirely authentic. But, really, should one care? 😉

Vox performances have similar control-ability. Here is the waveform-to-element assignment in the Vx Full Bars performance:

El# Waveform      KeyLo KeyHi VelLo VelHi Coarse Level Cutoff XA Ctrl 
--- ------------- ----- ----- ----- ----- ------ ----- ------ -------
1 Vx Drawbar1-3 C-2 G8 1 127 0 75 255 Normal
2 Vx Drawbar1-3 C-2 G8 1 127 12 77 255 Normal
3 Vx Drawbar1-3 C-2 G8 1 127 24 91 255 Normal
4 Vx DrawbarIV C-2 G8 1 127 0 127 250 Normal
5 Vx KeyOff C-2 G8 1 127 4 68 85 Key Off

The first three sliders control the 16′, 8′ and 4′ Vox drawbar settings and the fourth drawbar controls the Mixture (IV) tone. Go ahead, just everything to eleven. 🙂

Montage and MODX FM

But, wait, there’s more! Montage and MODX have two FM combo voices: BOX FM Combo Organ and FM YC Combo Organ. Although these performances don’t sound authentic to my ears, they provide starting points for further programming. I haven’t heard the YC61 as yet, but I wonder if the YC61 combo emulations can be ported to Montage and MODX?

Genos

As I mentioned earlier, the arranger series has been historically short on combo organ sounds, relying on the old 60’sOrgan voice. Wheezy, raspy Farfisa tones are noticably absent. The 60’sOrgan voice sounds like the Portable Electronic waveform on which the Motif 1967 Keys performance is based.

Tyros 4 and Motif XF were introduced at approximately the same time. They certainly were together in the development lab during late 2009. Tyros 4 added four combo organ voices:

  1. 60sComboOrgan1: VoxContiComb1_Full_NoVib waveform
  2. 60sComboOrgan2: VoxContiComb1_Full_VibOn waveform
  3. 60sComboOrgan3: VoxCombi4NoVib waveform
  4. 60sComboOrgan4: VoxCombi4NoVib091117 waveform

Voices 1 and 2 capture one Vox Continental drawbar combination (Comb1) and voices 3 and 4 capture a second combination (Combi4).

Voices 1 and 3 are without vibrato. Voices 2 and 4, unfortunately, have an excessive amount of vibrato — almost painfully so. When I use voices 2 and 4 in a MIDI sequence, I dial down the vibrato depth using MIDI CC#77 messages. Vibrato frequency is about 5Hz. I also remove touch sensitivity by setting:

  • Velocity sensitivity depth to zero, and
  • Velocity sensitivity offset to 114.

An organ voice should not respond to touch (key velocity) — ever.

PSR, Tyros and Genos players shouldn’t forget the “hidden” Italian 60s organ voice (It60’sOrgan) in the GM2 sound set. On PSR and Tyros, you’ll find It60’sOrgan within the Legacy voices Organ subfolder. On Genos, you need to download GM2 and XG user voices to the USER voice folder. (See this thread in the PSR Tutorial Forum.) Of course, you can select
It60’sOrgan from a DAW (MSB: 121, LSB: 2, PC: 17) .

All-in-all, you can get a nice Vox tone out of Genos. Farfisa is still missing in action, tho’. Kind of an odd shortcoming of a keyboard with styles and a user base that want to play popular hits from days past.

In the next post, I’ll compare Reface YC combo organs against Montage/MODX (Motif XF). The result may surprise you.

Copyright © 2021 Paul J. Drongowski