Quick note entry feature

• Dec 1, 2013 - 18:06
Reported version
2.2
Type
Functional
Severity
S5 - Suggestion
Status
closed
Project

Back in the late 1970s I interfaced my first computer (Processor Technology Sol-20, 32 kbytes RAM) to my 10 rank pipe organ. I also hooked up an organ keyboard to the parallel port through which I entered the scores I wanted the computer to play on the organ (remember that this was before MIDI). In effect I turned it into a player organ. Although I am an amateur organist, I wanted to hear my organ play the great works of Bach which were (and still are) beyond my skill level. What I needed was an input program that let me enter complex music a note or a chord at a time.

The input program I developed (using 8080 assembler) worked much like a primitive version of MuseScore in that I could enter single notes, or chords, through the organ keyboard by pressing the appropriate key(s) and thus build up the polyphonic layers one bar at a time. As with MuseScore, the note length was selected via the computer keyboard. But what really speeded up the process was a technique that removed the necessity of going back to the computer keyboard every time the note length change. Here is how it worked:

Select any basic note length (an eighth, say).

Play a note, a beep sounds to indicate that the (eighth) note has been entered. The key is released.
Up to this point, (except for the beep sound), this is in effect how MuseScore works.

If, however, the key is not released, about half a second after the first beep sounds, a second beep is sounded, and then a third and a fourth, etc., all half a second apart until the key is released.

If the key is released after the second beep, the note is entered as a quarter note.
If the key is released after the third beep, the note is entered as a dotted quarter note.
If the key is released after the fourth beep, the note is entered as a half note.
Etc.

Rests were entered the same way by holding the computer's space bar for the appropriate number of beeps.

When using this program, it immediately felt very natural and intuitive to hold a note that was twice as long for two beeps, three times as long for three beeps and so on. This is not to be confused with real-time entry since between notes you have all the time in the world to ponder your next move. My wife and I used it successfully to enter many a Bach Toccata and Fugue and even Soler's music for two organs.

The only change to the MuseScore interface would be a menu item that would turn this feature on and off and provide a way for the user to select the interval between beeps. It could work equally well for MIDI input, input through the computer's keyboard, or input via the mouse.

My programming skills go back to Fortran, Pascal and ObjectLOGO and are horribly out of date, so it would be a very steep learning curve for me to implement this. I would be interested as to the merits of pursuing this idea. John Coenraads


Comments

For me, I don't this would be useful for me as I am quite quick and familiar with notation in general, and, on first thought, I suspect I would soon be annoyed with the wait. However, I think some might find it useful, perhaps very useful. I'll be interested to see other responses.

This is why I want to see a more complete OSC interface in MuseScore. If we could define a simple interface to navigate a score and say "enter a C E G chords (giving midi pitches), quarter note", we could define any type of note entry by creating an external program, and it would make anyone happy. I would prefer to put effort in this OSC API and not in yet another MIDI note entry method.

For that matter, plugins could possibly be used to implement custom note entry methods as well.

Fwiw, I've seen a note entry system not unlike the one described here, except as I recall it was a bit more manual. I think you held a key down then pulsed the pedal to indicate how many "beeps" long it should be. I can't remember if this was in an older version of Finale, in Notator, or something else.

As it is, I believe. ersion 2.0 already will provide the ability to change durations and perform other tasks by mapping seldom-used keys on your MIDI keyboard to various actions. I haven't tried this yet, but assuming it works, it should go a long way toward simplifying and speeding up MIDI entry. So having a feature such as the one being discussed here will seem less relevant - although it could of course still male an interesting OSC or plugin programming project.

The area where I think this method of note entry would shine is for entry by touchscreen.

At present trying to use my Iconia Tablet to edit scores with the touch screen is a highly frustrating process involving far too many "key" presses.

This method of note entry would be ideal for a touchscreen interface though IMO.

I don't know too much about OSC but presumably it must be a protocol similar to MIDI??

I will endeavour to learn something about it before Christmas :)

With regard to comment #1, you may very well be right that this method would not benefit an experienced user, but I have the new and occasional user in mind, like myself. In my experience, a person using the quick note entry method "gets it" almost immediately and there is almost no learning curve. As far as the wait goes, their is no delay for the first beep, and the interval between subsequent beeps is user adjustable. With just a little practice, I was able to get this down to about 3/10 second and note entry was plenty fast.

I think that rather than program this into musescore, we should just make sure than the plugin system can make this possible, so that the feature can be made available through a separate plugin.

I was thinking of this note entry method again. But how does it work for chords?
Let's say I press C and hold it, beep, then press E, beep then press G, beep and now unpress C, E, G. What would you expect? A CEG quarter dotted (if the base time is a 8th note) or a 8th CEG chord? something more complicated?

Back in the mid 1970s, with only 32 kbytes of RAM (for both program and data file) and using 8080 assembler, I kept things simple. The rule was that any and all overlapping notes were treated as part of one chord which was assigned a length determined by the number of beeps that transpired between the press of the first key and the release of the last key. To use your example: a CEG quarter dotted. I did consider more complicated interpretations but the parsing quickly got complicated and this simple approach satisfied our needs at the time.