X-Git-Url: https://git.cworth.org/git?p=scherzo;a=blobdiff_plain;f=scherzo.c;h=7288d5fdbe7efb98b7b4c87879b6549cbbf8f23d;hp=5de614807aca4c8b1f30b2d3a979f0f9803d1cb0;hb=HEAD;hpb=8d6e370cf8a188f7174a4a66ddf382e0f744dfa0

diff --git a/scherzo.c b/scherzo.c
index 5de6148..7288d5f 100644
--- a/scherzo.c
+++ b/scherzo.c
@@ -24,21 +24,32 @@
 #include "score.h"
 #include "mnemon.h"
 
+#define ARRAY_SIZE(arr) ((int) (sizeof(arr) / sizeof(arr[0])))
+
 #define unused(foo) foo __attribute__((unused))
 
 #define MIDI_BUF_SIZE 4096
 
 typedef struct challenge
 {
+    int active;
     bin_t *bin;
     int item_index;
     score_staff_t *staff;
-    score_note_t *note;
+    pitch_t pitch;
 
     int satisfied;
     int mistaken;
 } challenge_t;
 
+typedef struct pitch_group
+{
+    void *ctx;
+    pitch_t *pitches;
+    int size;
+    int num_pitches;
+} pitch_group_t;
+
 typedef struct scherzo
 {
     void *ctx;
@@ -46,30 +57,46 @@ typedef struct scherzo
     GtkWidget *window;
     score_t *score;
     int staff_height;
+
     score_staff_t *treble;
     score_staff_t *bass;
-    int midi_fd;
+    score_chord_t *chord;
+
+    /* The word "keyboard" here is referring to a "computer
+     * keyboard". Any "piano keyboard" key knows its own octave and
+     * accidental already. */
+    int keyboard_octave;
     snd_midi_event_t *snd_midi_event;
 
     mnemon_t mnemon;
     challenge_t challenge;
 
-    int num_notes_pressed;
-    score_note_t **notes_pressed;
+    pitch_group_t notes_pressed;
+    pitch_group_t notes_pedaled;
+
+    int pedal_pressed;
+
+    scherzo_key_t key;
 } scherzo_t;
 
 /* Forward declarations. */
-static score_note_t *
-scherzo_add_note (scherzo_t *scherzo, score_pitch_t pitch, int octave);
+static void
+scherzo_press_note (scherzo_t *scherzo, pitch_t pitch);
 
 static void
-scherzo_remove_note (scherzo_t *scherzo, score_pitch_t pitch, int octave);
+scherzo_release_note (scherzo_t *scherzo, pitch_t pitch);
 
 static void
-_judge_note (scherzo_t *scherzo, score_note_t *note);
+scherzo_press_pedal (scherzo_t *scherzo);
 
 static void
-_score_challenge (scherzo_t *scherzo);
+scherzo_release_pedal (scherzo_t *scherzo);
+
+static void
+pitch_group_remove_pitches (pitch_group_t *group);
+
+static void
+scherzo_update_notes_and_chord (scherzo_t *scherzo);
 
 static int
 on_delete_event_quit (unused (GtkWidget *widget),
@@ -120,8 +147,13 @@ on_key_press_event (GtkWidget *widget,
 		    void *user_data)
 {
     scherzo_t *scherzo = user_data;
-    int octave = scherzo->challenge.note->octave;
-    score_pitch_t pitch;
+    int octave;
+    pitch_t pitch = PITCH_NOT_A_PITCH;
+
+    if (scherzo->challenge.active)
+	octave = PITCH_OCTAVE (scherzo->challenge.pitch);
+    else
+	octave = scherzo->keyboard_octave;
 
     switch (key->keyval) {
     case GDK_KEY_plus:
@@ -138,54 +170,119 @@ on_key_press_event (GtkWidget *widget,
 	gtk_widget_queue_draw (widget);
 	return TRUE;
 	break;
-    case GDK_KEY_q:
-    case GDK_KEY_Q:
     case GDK_KEY_Escape:
 	gtk_main_quit ();
 	return FALSE;
-    case GDK_KEY_c:
-    case GDK_KEY_C:
-	pitch = SCORE_PITCH_C;
+    /* Map a piano keyboard onto the computer keyboard with white keys
+     * along the home row, (piano C on computer A, up to next octave
+     * higher C on computer K). Black keys are in the expected
+     * positions, (C# is W, D# is E, etc.).
+     */
+    case GDK_KEY_a:
+    case GDK_KEY_A:
+	pitch = PITCH_LITERAL (C, NATURAL, octave);
+	break;
+    case GDK_KEY_s:
+    case GDK_KEY_S:
+	pitch = PITCH_LITERAL (D, NATURAL, octave);
 	break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-	pitch = SCORE_PITCH_D;
-	break;
-    case GDK_KEY_e:
-    case GDK_KEY_E:
-	pitch = SCORE_PITCH_E;
+	pitch = PITCH_LITERAL (E, NATURAL, octave);
 	break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-	pitch = SCORE_PITCH_F;
+	pitch = PITCH_LITERAL (F, NATURAL, octave);
 	break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-	pitch = SCORE_PITCH_G;
+	pitch = PITCH_LITERAL (G, NATURAL, octave);
 	break;
-    case GDK_KEY_a:
-    case GDK_KEY_A:
-	pitch = SCORE_PITCH_A;
+    case GDK_KEY_h:
+    case GDK_KEY_H:
+	pitch = PITCH_LITERAL (A, NATURAL, octave);
+	break;
+    case GDK_KEY_j:
+    case GDK_KEY_J:
+	pitch = PITCH_LITERAL (B, NATURAL, octave);
+	break;
+    case GDK_KEY_k:
+    case GDK_KEY_K:
+	pitch = PITCH_LITERAL (C, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_l:
+    case GDK_KEY_L:
+	pitch = PITCH_LITERAL (D, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_semicolon:
+    case GDK_KEY_colon:
+	pitch = PITCH_LITERAL (E, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_apostrophe:
+    case GDK_KEY_quotedbl:
+	pitch = PITCH_LITERAL (F, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_w:
+    case GDK_KEY_W:
+	pitch = PITCH_LITERAL (C, SHARP, octave);
+	break;
+    case GDK_KEY_e:
+    case GDK_KEY_E:
+	pitch = PITCH_LITERAL (D, SHARP, octave);
+	break;
+    case GDK_KEY_t:
+    case GDK_KEY_T:
+	pitch = PITCH_LITERAL (F, SHARP, octave);
+	break;
+    case GDK_KEY_y:
+    case GDK_KEY_Y:
+	pitch = PITCH_LITERAL (G, SHARP, octave);
+	break;
+    case GDK_KEY_u:
+    case GDK_KEY_U:
+	pitch = PITCH_LITERAL (A, SHARP, octave);
 	break;
-    case GDK_KEY_b:
-    case GDK_KEY_B:
-	pitch = SCORE_PITCH_B;
+    case GDK_KEY_o:
+    case GDK_KEY_O:
+	pitch = PITCH_LITERAL (C, SHARP, octave + 1);
+	break;
+    case GDK_KEY_p:
+    case GDK_KEY_P:
+	pitch = PITCH_LITERAL (D, SHARP, octave + 1);
+	break;
+    case GDK_KEY_bracketright:
+    case GDK_KEY_braceright:
+	pitch = PITCH_LITERAL (F, SHARP, octave + 1);
+	break;
+    case GDK_KEY_0:
+    case GDK_KEY_1:
+    case GDK_KEY_2:
+    case GDK_KEY_3:
+    case GDK_KEY_4:
+    case GDK_KEY_5:
+    case GDK_KEY_6:
+    case GDK_KEY_7:
+    case GDK_KEY_8:
+	scherzo->keyboard_octave = key->keyval - GDK_KEY_0;
+	break;
+    case GDK_KEY_space:
+	scherzo_press_pedal (scherzo);
+	break;
+    case GDK_KEY_Return:
+	/* Clear all notes when Return is pressed. */
+	pitch_group_remove_pitches (&scherzo->notes_pressed);
+	pitch_group_remove_pitches (&scherzo->notes_pedaled);
+	scherzo_update_notes_and_chord (scherzo);
 	break;
     }
 
-    if ((key->keyval >= GDK_KEY_A && key->keyval <= GDK_KEY_G) ||
-	(key->keyval >= GDK_KEY_a && key->keyval <= GDK_KEY_g))
+    if (pitch != PITCH_NOT_A_PITCH) 
     {
-	score_note_t *note;
-
-	note = scherzo_add_note (scherzo, pitch, octave);
-	_judge_note (scherzo, note);
-	gtk_widget_queue_draw (scherzo->window);
+	scherzo_press_note (scherzo, pitch);
 
 	return TRUE;
     }
 
-
     /* Allow an unhandled event to propagate to other handlers. */
     return FALSE;
 }
@@ -196,46 +293,99 @@ on_key_release_event (unused (GtkWidget *widget),
 		      void *user_data)
 {
     scherzo_t *scherzo = user_data;
-    int octave = scherzo->challenge.note->octave;
-    score_pitch_t pitch;
+    int octave;
+    pitch_t pitch = PITCH_NOT_A_PITCH;
+
+    if (scherzo->challenge.active)
+	octave = PITCH_OCTAVE (scherzo->challenge.pitch);
+    else
+	octave = scherzo->keyboard_octave;
 
     switch (key->keyval) {
-    case GDK_KEY_c:
-    case GDK_KEY_C:
-	pitch = SCORE_PITCH_C;
+    case GDK_KEY_a:
+    case GDK_KEY_A:
+	pitch = PITCH_LITERAL (C, NATURAL, octave);
+	break;
+    case GDK_KEY_s:
+    case GDK_KEY_S:
+	pitch = PITCH_LITERAL (D, NATURAL, octave);
 	break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-	pitch = SCORE_PITCH_D;
-	break;
-    case GDK_KEY_e:
-    case GDK_KEY_E:
-	pitch = SCORE_PITCH_E;
+	pitch = PITCH_LITERAL (E, NATURAL, octave);
 	break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-	pitch = SCORE_PITCH_F;
+	pitch = PITCH_LITERAL (F, NATURAL, octave);
 	break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-	pitch = SCORE_PITCH_G;
+	pitch = PITCH_LITERAL (G, NATURAL, octave);
 	break;
-    case GDK_KEY_a:
-    case GDK_KEY_A:
-	pitch = SCORE_PITCH_A;
+    case GDK_KEY_h:
+    case GDK_KEY_H:
+	pitch = PITCH_LITERAL (A, NATURAL, octave);
 	break;
-    case GDK_KEY_b:
-    case GDK_KEY_B:
-	pitch = SCORE_PITCH_B;
+    case GDK_KEY_j:
+    case GDK_KEY_J:
+	pitch = PITCH_LITERAL (B, NATURAL, octave);
+	break;
+    case GDK_KEY_k:
+    case GDK_KEY_K:
+	pitch = PITCH_LITERAL (C, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_l:
+    case GDK_KEY_L:
+	pitch = PITCH_LITERAL (D, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_semicolon:
+    case GDK_KEY_colon:
+	pitch = PITCH_LITERAL (E, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_apostrophe:
+    case GDK_KEY_quotedbl:
+	pitch = PITCH_LITERAL (F, NATURAL, octave + 1);
+	break;
+    case GDK_KEY_w:
+    case GDK_KEY_W:
+	pitch = PITCH_LITERAL (C, SHARP, octave);
+	break;
+    case GDK_KEY_e:
+    case GDK_KEY_E:
+	pitch = PITCH_LITERAL (D, SHARP, octave);
+	break;
+    case GDK_KEY_t:
+    case GDK_KEY_T:
+	pitch = PITCH_LITERAL (F, SHARP, octave);
+	break;
+    case GDK_KEY_y:
+    case GDK_KEY_Y:
+	pitch = PITCH_LITERAL (G, SHARP, octave);
+	break;
+    case GDK_KEY_u:
+    case GDK_KEY_U:
+	pitch = PITCH_LITERAL (A, SHARP, octave);
+	break;
+    case GDK_KEY_o:
+    case GDK_KEY_O:
+	pitch = PITCH_LITERAL (C, SHARP, octave + 1);
+	break;
+    case GDK_KEY_p:
+    case GDK_KEY_P:
+	pitch = PITCH_LITERAL (D, SHARP, octave + 1);
+	break;
+    case GDK_KEY_bracketright:
+    case GDK_KEY_braceright:
+	pitch = PITCH_LITERAL (F, SHARP, octave + 1);
+	break;
+    case GDK_KEY_space:
+	scherzo_release_pedal (scherzo);
 	break;
     }
 
-    if ((key->keyval >= GDK_KEY_A && key->keyval <= GDK_KEY_G) ||
-	(key->keyval >= GDK_KEY_a && key->keyval <= GDK_KEY_g))
+    if (pitch != PITCH_NOT_A_PITCH)
     {
-	scherzo_remove_note (scherzo, pitch, octave);
-	_score_challenge (scherzo);
-	gtk_widget_queue_draw (scherzo->window);
+	scherzo_release_note (scherzo, pitch);
 
 	return TRUE;
     }
@@ -245,140 +395,696 @@ on_key_release_event (unused (GtkWidget *widget),
     return FALSE;
 }
 
-static void
-_midi_to_score_pitch_and_octave (unsigned char midi_note,
-				 score_pitch_t *pitch,
-				 int *octave)
+/* Determine a chord name (if any) from the current notes pressed */
+
+typedef struct analyzed_pitch {
+    /* Original note being analzyed. */
+    pitch_t pitch;
+
+    /* Absolute pitch (expressed as midi number). */
+    int midi_pitch;
+
+    /* Pitch relative to bass note. */
+    int relative_pitch;
+} analyzed_pitch_t;
+
+static int
+_compare_analyzed_pitch_by_midi_pitch (const void *va, const void *vb)
 {
-    *octave = midi_note / 12 - 1;
+    const analyzed_pitch_t *a = va, *b = vb;
 
-    switch (midi_note % 12)
-    {
-    case 0:
-	*pitch = SCORE_PITCH_C;
-	break;
+    return a->midi_pitch - b->midi_pitch;
+}
+
+static int
+_compare_analyzed_pitch_by_relative_pitch (const void *va, const void *vb)
+{
+    const analyzed_pitch_t *a = va, *b = vb;
+
+    return a->relative_pitch - b->relative_pitch;
+}
+
+typedef struct modified_degree
+{
+    int degree;
+    int modification;
+} modified_degree_t;
+
+static int
+_modified_degree_to_half_steps (const modified_degree_t *degree)
+{
+    int half_steps;
+    int scale_degree = degree->degree;
+
+    /* Restrict to actual degrees within a scale. */
+    if (scale_degree > 7)
+	scale_degree = (scale_degree % 8) + 1;
+
+    /* Number of half steps from root to specified degree within a
+     * diatonic scale. */
+    switch (scale_degree) {
     case 1:
-	*pitch = SCORE_PITCH_Cs;
+	half_steps = 0;
 	break;
     case 2:
-	*pitch = SCORE_PITCH_D;
+	half_steps = 2;
 	break;
     case 3:
-	*pitch = SCORE_PITCH_Ds;
+	half_steps = 4;
 	break;
     case 4:
-	*pitch = SCORE_PITCH_E;
+	half_steps = 5;
 	break;
     case 5:
-	*pitch = SCORE_PITCH_F;
+	half_steps = 7;
 	break;
     case 6:
-	*pitch = SCORE_PITCH_Fs;
+	half_steps = 9;
 	break;
     case 7:
-	*pitch = SCORE_PITCH_G;
-	break;
-    case 8:
-	*pitch = SCORE_PITCH_Gs;
-	break;
-    case 9:
-	*pitch = SCORE_PITCH_A;
+	half_steps = 11;
 	break;
-    case 10:
-	*pitch = SCORE_PITCH_As;
-	break;
-    case 11:
-	*pitch = SCORE_PITCH_B;
+    default:
+	fprintf (stderr, "Internal: Invalid degree %d\n", degree->degree);
+	exit (1);
 	break;
     }
+
+    return half_steps + degree->modification;
 }
 
-static score_note_t *
-scherzo_add_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
+static int
+_chord_signature_matches (analyzed_pitch_t *pitches,
+			  int num_pitches,
+			  modified_degree_t *degrees,
+			  int num_degrees,
+			  int inversion,
+			  pitch_t *root)
 {
-    score_staff_t *staff;
-    score_note_t *note;
+#define MAX_DEGREES 6
+    int relative_pitches[MAX_DEGREES];
+    int i, root_index;
 
-    staff = scherzo->challenge.staff;
+    assert (num_degrees <= MAX_DEGREES);
 
-    note = score_add_note (staff, pitch, octave, SCORE_DURATION_WHOLE);
+    if (num_pitches != num_degrees)
+	return 0;
 
-    scherzo->num_notes_pressed++;
-    scherzo->notes_pressed = talloc_realloc (scherzo->ctx,
-					     scherzo->notes_pressed,
-					     score_note_t*,
-					     scherzo->num_notes_pressed);
-    if (scherzo->notes_pressed == NULL) {
-	fprintf (stderr, "Out of memory.\n");
+    if (inversion >= num_degrees)
+	return 0;
+
+    /* We never spell simple intervals as inversions. */
+    if (num_degrees == 2 && inversion > 0)
+	return 0;
+
+    for (i = 0; i < num_degrees; i++) {
+	/* The num_degrees is in the addition just to ensure all
+	 * inputs to the modulus operator remain positive. */
+	int index = (i + num_degrees - inversion) % num_degrees;
+
+	/* Again, adding a 12 to keep things positive. */
+	relative_pitches[index] =
+	    (12 +
+	     _modified_degree_to_half_steps (&degrees[i]) -
+	     _modified_degree_to_half_steps (&degrees[inversion])) % 12;
+		
+    }
+
+    for (i = 0; i < num_pitches; i++)
+	if (pitches[i].relative_pitch != relative_pitches[i])
+	    return 0;
+
+    root_index = (num_pitches - inversion) % num_pitches;
+    *root = pitches[root_index].pitch;
+
+    return 1;
+}
+
+typedef struct chord_signature
+{
+    int num_degrees;
+    modified_degree_t degrees[MAX_DEGREES];
+    const char *name;
+} chord_signature_t;
+
+/* XXX: The superscript rise value should be relative to the current
+ * font size. Best would be for pango to support this. See:
+ *
+ * https://bugzilla.gnome.org/show_bug.cgi?id=708780
+ *
+ * For now, these are emipirically-derived values that look reasonable
+ * at the default size that score.c is using to draw the staff. If the
+ * user scales the staff up or down then these will look wrong.
+ */
+
+#define SUP "<span font='33' rise='30000'>"
+#define PUS "</span>"
+
+chord_signature_t signatures[] = {
+    /* Octave */
+    { 1, {{1, 0}}, "P8" },
+
+    /* Intervals */
+    { 2, {{1, 0}, {2, -1}}, "m2" },
+    { 2, {{1, 0}, {2,  0}}, "M2" },
+    { 2, {{1, 0}, {3, -1}}, "m3" },
+    { 2, {{1, 0}, {3,  0}}, "M3" },
+    { 2, {{1, 0}, {4,  0}}, "P4" },
+    { 2, {{1, 0}, {5, -1}}, "Tri-tone" },
+    { 2, {{1, 0}, {5,  0}}, "P5" },
+    { 2, {{1, 0}, {6, -1}}, "m6" },
+    { 2, {{1, 0}, {6,  0}}, "M6" },
+    { 2, {{1, 0}, {7, -1}}, "m7" },
+    { 2, {{1, 0}, {7,  0}}, "M7" },
+
+    /* Triads */
+    { 3, {{1, 0}, {4,  0}, {5,  0}}, "sus" },
+    { 3, {{1, 0}, {3,  0}, {5, +1}}, SUP "+" PUS },
+    { 3, {{1, 0}, {3,  0}, {5,  0}}, "" },
+    { 3, {{1, 0}, {3, -1}, {5,  0}}, "m" },
+    { 3, {{1, 0}, {3, -1}, {5, -1}}, "°" },
+    { 3, {{1, 0}, {2,  0}, {5,  0}}, "msus2" },
+
+    /* Seventh chords with no 3rd */
+    { 3, {{1, 0}, {5, +1}, {7,  0}}, SUP "+M7" PUS },
+    { 3, {{1, 0}, {5, +1}, {7, -1}}, SUP "+7" PUS },
+    { 3, {{1, 0}, {5,  0}, {7,  0}}, "M7" },
+    { 3, {{1, 0}, {5,  0}, {7, -1}}, "7" },
+    { 3, {{1, 0}, {5, -1}, {7, -1}}, "7♭5" },
+
+    /* Seventh chords with no 5th */
+    { 3, {{1, 0}, {4,  0}, {7,  0}}, "M7sus" },
+    { 3, {{1, 0}, {4,  0}, {7, -1}}, "7sus" },
+    { 3, {{1, 0}, {3,  0}, {7,  0}}, "M7" },
+    { 3, {{1, 0}, {3,  0}, {7, -1}}, "7" },
+    { 3, {{1, 0}, {3, -1}, {7,  0}}, "m" SUP "M7" PUS },
+    { 3, {{1, 0}, {3, -1}, {7, -1}}, "m7" },
+    { 3, {{1, 0}, {2,  0}, {7,  0}}, "m" SUP "M7" PUS "sus2" },
+    { 3, {{1, 0}, {2,  0}, {7, -1}}, "m7sus2" },
+
+    /* Sixth chords */
+    { 4, {{1, 0}, {4,  0}, {5,  0}, {6,  0}}, "6sus" },
+    { 4, {{1, 0}, {3,  0}, {5,  0}, {6,  0}}, "6" }, /* Ambiguous with m7 */
+    { 4, {{1, 0}, {3, -1}, {5,  0}, {6,  0}}, "m6" },
+    { 4, {{1, 0}, {2,  0}, {5,  0}, {6,  0}}, "m6sus2" },
+
+    /* Seventh chords */
+    { 4, {{1, 0}, {4,  0}, {5, +1}, {7,  0}}, SUP "+M7" PUS "sus" },
+    { 4, {{1, 0}, {4,  0}, {5, +1}, {7, -1}}, SUP "+7" PUS "sus" },
+    { 4, {{1, 0}, {4,  0}, {5,  0}, {7,  0}}, "M7sus" },
+    { 4, {{1, 0}, {4,  0}, {5,  0}, {7, -1}}, "7sus" },
+    { 4, {{1, 0}, {4,  0}, {5, -1}, {7, -1}}, "7♭5sus" },
+    { 4, {{1, 0}, {3,  0}, {5, +1}, {7,  0}}, SUP "+M7" PUS },
+    { 4, {{1, 0}, {3,  0}, {5, +1}, {7, -1}}, SUP "+7" PUS },
+    { 4, {{1, 0}, {3,  0}, {5,  0}, {7,  0}}, "M7" },
+    { 4, {{1, 0}, {3,  0}, {5,  0}, {7, -1}}, "7" },
+    { 4, {{1, 0}, {3,  0}, {5, -1}, {7, -1}}, "7♭5" },
+    { 4, {{1, 0}, {3, -1}, {5,  0}, {7,  0}}, "m" SUP "M7" PUS },
+    { 4, {{1, 0}, {3, -1}, {5,  0}, {7, -1}}, "m7" },
+    { 4, {{1, 0}, {3, -1}, {5, -1}, {7,  0}}, "°" SUP "M7" PUS },
+    { 4, {{1, 0}, {3, -1}, {5, -1}, {7, -1}}, "𝆩" SUP "7" PUS },
+    { 4, {{1, 0}, {3, -1}, {5, -1}, {7, -2}}, "°" SUP "7" PUS },
+    { 4, {{1, 0}, {2,  0}, {5,  0}, {7,  0}}, "m" SUP "M7" PUS "sus2" },
+    { 4, {{1, 0}, {2,  0}, {5,  0}, {7, -1}}, "m7sus2" },
+    { 4, {{1, 0}, {2,  0}, {5, -1}, {7,  0}}, "°" SUP "M7" PUS "sus2" },
+    { 4, {{1, 0}, {2,  0}, {5, -1}, {7, -1}}, "𝆩" SUP "7" PUS "sus2" },
+    { 4, {{1, 0}, {2,  0}, {5, -1}, {7, -2}}, "°" SUP "7" PUS "sus2" }, /* Ambiguous with 7 */
+
+    /* The sorting for chords with degree higher than 9 is funny
+     * to keep the array in degree order after reducing each
+     * degree to an actual scale degree, (9 -> 2, 11 -> 4, 13 ->
+     * 6) */
+
+    /* Ninth chords voiced with no 5th */
+    { 4, {{1, 0}, {9,  0}, {4,  0}, {7,  0}}, "M9sus" },
+    { 4, {{1, 0}, {9,  0}, {4,  0}, {7, -1}}, "9sus" },
+    { 4, {{1, 0}, {9,  0}, {3,  0}, {7,  0}}, "M9" },
+    { 4, {{1, 0}, {9,  0}, {3,  0}, {7, -1}}, "9" },
+    { 4, {{1, 0}, {9,  0}, {3, -1}, {7,  0}}, "m" SUP "M9" PUS },
+    { 4, {{1, 0}, {9,  0}, {3, -1}, {7, -1}}, "m9" },
+    { 4, {{1, 0}, {9, -1}, {3, -1}, {7, -1}}, "m♭9" },
+    { 4, {{1, 0}, {9,  0}, {3, -1}, {6,  0}}, "m6/9" },
+    { 4, {{1, 0}, {9, -1}, {3, -1}, {6,  0}}, "m6/♭9" },
+
+    /* Sixth plus 9 */
+    { 5, {{1, 0}, {9,  0}, {3,  0}, {5,  0}, {6,  0}}, "6/9" },
+    { 5, {{1, 0}, {9,  0}, {3, -1}, {5,  0}, {6,  0}}, "m6/9" },
+    { 5, {{1, 0}, {9, -1}, {3, -1}, {5,  0}, {6,  0}}, "m6/♭9" },
+
+    /* Seventh plus altered 9 */
+    { 5, {{1, 0}, {9, +1}, {3,  0}, {5,  0}, {7, -1}}, "7♯9" },
+    { 5, {{1, 0}, {9, -1}, {3,  0}, {5,  0}, {7, -1}}, "7♭9" },
+    { 5, {{1, 0}, {9, +1}, {3,  0}, {5, -1}, {7, -1}}, "7♭5♯9" },
+    { 5, {{1, 0}, {9, -1}, {3,  0}, {5, -1}, {7, -1}}, "7♭5♭9" },
+
+    /* Ninth chords */
+    { 5, {{1, 0}, {9,  0}, {4,  0}, {5, +1}, {7,  0}}, SUP "+M9" PUS "sus" },
+    { 5, {{1, 0}, {9,  0}, {4,  0}, {5, +1}, {7, -1}}, SUP "+9" PUS "sus" },
+    { 5, {{1, 0}, {9,  0}, {4,  0}, {5,  0}, {7,  0}}, "M9sus" },
+    { 5, {{1, 0}, {9,  0}, {4,  0}, {5,  0}, {7, -1}}, "9sus" },
+    { 5, {{1, 0}, {9,  0}, {3,  0}, {5, +1}, {7,  0}}, SUP "+M9" PUS },
+    { 5, {{1, 0}, {9,  0}, {3,  0}, {5, +1}, {7, -1}}, SUP "+9" PUS },
+    { 5, {{1, 0}, {9,  0}, {3,  0}, {5,  0}, {7,  0}}, "M9" },
+    { 5, {{1, 0}, {9,  0}, {3,  0}, {5,  0}, {7, -1}}, "9" },
+    { 5, {{1, 0}, {9,  0}, {3, -1}, {5,  0}, {7,  0}}, "m" SUP "M9" PUS },
+    { 5, {{1, 0}, {9,  0}, {3, -1}, {5,  0}, {7, -1}}, "m9" },
+    { 5, {{1, 0}, {9, -1}, {3, -1}, {5,  0}, {7, -1}}, "m♭9" },
+    { 5, {{1, 0}, {9,  0}, {3,  0}, {5, -1}, {7,  0}}, "M9" SUP "♭5" PUS },
+    { 5, {{1, 0}, {9,  0}, {3,  0}, {5, -1}, {7, -1}}, "9" SUP "♭5" PUS },
+    { 5, {{1, 0}, {9,  0}, {3, -1}, {5, -1}, {7,  0}}, "m" SUP "M9♭5" PUS },
+    { 5, {{1, 0}, {9,  0}, {3, -1}, {5, -1}, {7, -1}}, "𝆩" SUP "9" PUS },
+    { 5, {{1, 0}, {9, -1}, {3, -1}, {5, -1}, {7, -1}}, "𝆩" SUP "♭9" PUS },
+    { 5, {{1, 0}, {9,  0}, {3, -1}, {5, -1}, {7, -2}}, "°" SUP "9" PUS },
+    { 5, {{1, 0}, {9, -1}, {3, -1}, {5, -1}, {7, -2}}, "°" SUP "♭9" PUS },
+
+    /* Eleventh chords */
+    { 6, {{1, 0}, {9,  0}, {3,  0}, {11,  0}, {5, +1}, {7,  0}}, SUP "+M11" PUS },
+    { 6, {{1, 0}, {9,  0}, {3,  0}, {11,  0}, {5, +1}, {7, -1}}, SUP "+11" PUS },
+    { 6, {{1, 0}, {9,  0}, {3,  0}, {11,  0}, {5,  0}, {7,  0}}, "M11" },
+    { 6, {{1, 0}, {9,  0}, {3,  0}, {11,  0}, {5,  0}, {7, -1}}, "11" },
+    { 6, {{1, 0}, {9,  0}, {3, -1}, {11,  0}, {5,  0}, {7,  0}}, "m" SUP "M11" PUS },
+    { 6, {{1, 0}, {9,  0}, {3, -1}, {11,  0}, {5,  0}, {7, -1}}, "m11" },
+    { 6, {{1, 0}, {9, -1}, {3, -1}, {11,  0}, {5, -1}, {7, -1}}, "𝆩" SUP "11" PUS },
+    { 6, {{1, 0}, {9, -1}, {3, -1}, {11, -1}, {5, -1}, {7, -2}}, "°" SUP "11" PUS }
+};
+
+static void
+_spell_chord_by_signature (pitch_group_t *chord,
+			   chord_signature_t *signature,
+			   pitch_t root)
+{
+    int i, degree, note_half_steps, degree_half_steps;
+    
+    for (i = 0; i < chord->num_pitches; i++) {
+	note_half_steps = pitch_from_root_in_half_steps (chord->pitches[i],
+							  root);
+	for (degree = 0; degree < signature->num_degrees; degree++) {
+	    degree_half_steps = _modified_degree_to_half_steps (&signature->degrees[degree]);
+	    if (note_half_steps == degree_half_steps) {
+		chord->pitches[i] = pitch_spell_as_degree (chord->pitches[i],
+							   root,
+							   signature->degrees[degree].degree);
+		break;
+	    }
+	}
+	if (note_half_steps != degree_half_steps) {
+	    fprintf (stderr, "Internal error: Chord and degree mis-match\n");
+	    exit (1);
+	}
+    }
+}
+
+static void
+_analyze_chord (pitch_group_t *chord,
+		chord_signature_t **signature_ret,
+		pitch_t **root_ret)
+{
+    void *local = talloc_new (NULL);
+    analyzed_pitch_t *pitches;
+    int i, j, num_pitches;
+    int bass_pitch, inversion;
+    pitch_t root;
+    chord_signature_t *match = NULL;
+
+    /* Default to no-match for any early return */
+    *signature_ret = NULL;
+    *root_ret = NULL;
+
+    num_pitches = chord->num_pitches;
+
+    if (chord->num_pitches <= 1)
+	goto DONE;
+
+    pitches = talloc_array (local, analyzed_pitch_t, num_pitches);
+    if (pitches == NULL)
+	goto DONE;
+
+    for (i = 0; i < num_pitches; i++) {
+	pitch_t pitch = chord->pitches[i];
+	pitches[i].pitch = pitch;
+	pitches[i].midi_pitch = pitch_to_midi (pitch);
+	/* Relative pitch will be filled in after sorting. */
+	pitches[i].relative_pitch = 0;
+    }
+
+    /* First, sort by midi pitch to find the bass note. */
+    qsort (pitches, num_pitches, sizeof (analyzed_pitch_t),
+	   _compare_analyzed_pitch_by_midi_pitch);
+    
+    bass_pitch = pitches[0].midi_pitch;
+
+    /* With the bass note identified, we can find all relative pitches. */
+    for (i = 0; i < num_pitches; i++) {
+	pitches[i].relative_pitch = pitches[i].midi_pitch - bass_pitch;
+	while (pitches[i].relative_pitch >= 12)
+	    pitches[i].relative_pitch -= 12;
+    }
+
+    /* Now, sort again by relative pitch. */
+    qsort (pitches, num_pitches, sizeof (analyzed_pitch_t),
+	   _compare_analyzed_pitch_by_relative_pitch);
+
+    /* Finally, eliminate all duplicate notes. */
+    for (i = 0; i < num_pitches - 1; i++) {
+	    if (pitches[i+1].relative_pitch == pitches[i].relative_pitch) {
+		    j = i+1;
+		    while (j < num_pitches &&
+			   pitches[j].relative_pitch == pitches[i].relative_pitch)
+		    {
+			    j++;
+		    }
+		    /* The loop incremented j one past the last
+		     * duplicate. Decrement so that it points to the
+		     * last duplicate (and is guaranteed to not exceed
+		     * the array bounds).*/
+		    j--;
+
+		    if (j < num_pitches - 1) {
+			    memmove (&pitches[i+1], &pitches[j+1],
+				     (num_pitches - j) * sizeof (analyzed_pitch_t));
+		    }
+
+		    num_pitches -= (j - i);
+	    }
+    }
+
+    for (inversion = 0; inversion < 4; inversion++) {
+	for (i = 0; i < ARRAY_SIZE (signatures); i++) {
+	    if (_chord_signature_matches (pitches, num_pitches,
+					  signatures[i].degrees,
+					  signatures[i].num_degrees,
+					  inversion, &root))
+	    {
+		match = &signatures[i];
+		goto HAVE_MATCH;
+	    }
+	}
+    }
+HAVE_MATCH:
+
+    if (match) {
+	*signature_ret = match;
+	for (i = 0; i < chord->num_pitches; i++) {
+	    if (chord->pitches[i] == root) {
+		*root_ret = &chord->pitches[i];
+		break;
+	    }
+	}
+    }
+
+DONE:
+    talloc_free (local);
+}
+
+static void
+pitch_group_init (void *ctx, pitch_group_t *group)
+{
+    group->ctx = ctx;
+    group->pitches = NULL;
+    group->size = 0;
+    group->num_pitches = 0;
+}
+
+static void
+pitch_group_add_pitch (pitch_group_t *group, pitch_t pitch)
+{
+    int i;
+
+    /* Do nothing if pitch is already in group. */
+    for (i = 0; i < group->num_pitches; i++)
+	if (group->pitches[i] == pitch)
+	    return;
+
+    group->num_pitches++;
+
+    if (group->num_pitches > group->size) {
+	group->size++;
+	group->pitches = talloc_realloc (group->ctx, group->pitches,
+					 pitch_t, group->size);
+
+	if (group->pitches == NULL) {
+	    fprintf (stderr, "Out of memory.\n");
+	    exit (1);
+	}
+    }
+
+    group->pitches[group->num_pitches - 1] = pitch;
+}
+
+static void
+pitch_group_remove_pitch_at (pitch_group_t *group, int i)
+{
+    if (i > group->num_pitches) {
+	fprintf (stderr, "Internal error: Cannot remove pitch %d from group with only %d %s\n",
+		 i, group->num_pitches,
+		 group->num_pitches == 1 ? "pitch" : "pitches");
 	exit (1);
     }
 
-    scherzo->notes_pressed[scherzo->num_notes_pressed - 1] = note;
+    if (i < group->num_pitches - 1) {
+	memmove (group->pitches + i, group->pitches + i + 1,
+		 (group->num_pitches - 1 - i) * sizeof (pitch_t));
+    }
 
-    return note;
+    group->num_pitches--;
 }
 
+/* Remove a 'pitch' from 'group', (including any enharmonic pitch)
+ * See also: pitch_group_remove_pitch
+ */
+static void
+pitch_group_remove_pitch_enharmonic (pitch_group_t *group, pitch_t pitch)
+{
+    int i;
+
+    for (i = 0; i < group->num_pitches; i++)
+	if (pitch_enharmonic_to (group->pitches[i], pitch))
+	    pitch_group_remove_pitch_at (group, i);
+}
 
+/* Remove an exactly-matching pitch from 'group'
+ * See also: pitch_group_remove_pitch_enharmonic
+ *
 static void
-scherzo_remove_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
+pitch_group_remove_pitch (pitch_group_t *group, pitch_t pitch)
 {
-    score_note_t *note;
     int i;
 
-    for (i = 0; i < scherzo->num_notes_pressed; i++) {
-	note = scherzo->notes_pressed[i];
-	if (note->pitch == pitch && note->octave == octave) {
-	    score_remove_note (note);
-	    if (i < scherzo->num_notes_pressed - 1) {
-		memmove (scherzo->notes_pressed + i,
-			 scherzo->notes_pressed + i + 1,
-			 (scherzo->num_notes_pressed - 1 - i) * sizeof (score_note_t*));
-	    }
-	    scherzo->num_notes_pressed--;
-	    i--;
+    for (i = 0; i < group->num_pitches; i++)
+	if (group->pitches[i] == pitch)
+	    pitch_group_remove_pitch_at (group, i);
+}
+*/
+
+/* Remove all pitches from a pitch_group_t */
+static void
+pitch_group_remove_pitches (pitch_group_t *group)
+{
+    talloc_free (group->pitches);
+    pitch_group_init (group->ctx, group);
+}
+
+static void
+scherzo_update_notes_and_chord (scherzo_t *scherzo)
+{
+    void *local = talloc_new (NULL);
+    pitch_group_t *chord;
+    chord_signature_t *signature;
+    char *chord_name = NULL;
+    pitch_t *root;
+    int i;
+
+    /* Remove all notes/chords from score, then add current notes. */
+    score_remove_notes (scherzo->score);
+    score_remove_chords (scherzo->score);
+
+    if (scherzo->pedal_pressed)
+	chord = &scherzo->notes_pedaled;
+    else
+	chord = &scherzo->notes_pressed;
+
+    _analyze_chord (chord, &signature, &root);
+
+    if (signature) {
+	/* Don't print root pitch for octaves and inversions,
+	 * (since a pitch name alone looks like a major triad) */
+	if (signature->num_degrees < 3) {
+	    /* In fact, don't print anything for octaves and
+	     * inversions for now. It leads to a bit of flashing when
+	     * playing chords.
+	     *
+	     * FIXME: What I'd like to have here is a small timeout,
+	     * such that names only appear once an interval has been
+	     * held for at least 100 ms or so. With that, it would be
+	     * nice to display the interval names once again.
+	     *
+	    chord_name = talloc_strdup (local, signature->name);
+	    */
+	} else {
+	    _spell_chord_by_signature (&scherzo->notes_pressed,
+				       signature, *root);
+	    _spell_chord_by_signature (&scherzo->notes_pedaled,
+				       signature, *root);
+
+	    chord_name = talloc_asprintf (local, "%s%s",
+					  pitch_string (*root),
+					  signature->name);
 	}
+    } else if (chord->num_pitches > 2) {
+	chord_name = talloc_strdup (local, "?");
+    }
+
+    if (chord_name)
+	scherzo->chord = score_add_chord (scherzo->treble, chord_name);
+
+    for (i = 0; i < scherzo->notes_pressed.num_pitches; i++)
+    {
+	score_add_note (scherzo->score, scherzo->notes_pressed.pitches[i],
+			SCORE_DURATION_WHOLE);
     }
+
+    for (i = 0; i < scherzo->notes_pedaled.num_pitches; i++)
+    {
+	score_add_note (scherzo->score, scherzo->notes_pedaled.pitches[i],
+			SCORE_DURATION_WHOLE);
+    }
+
+    gtk_widget_queue_draw (scherzo->window);
+
+    talloc_free (local);
 }
 
-static score_note_t *
-scherzo_add_note_midi (scherzo_t *scherzo, unsigned char midi_note)
+static void
+scherzo_set_key (scherzo_t *scherzo, pitch_t pitch)
 {
-    score_pitch_t pitch;
-    int octave;
+    scherzo_key_init (&scherzo->key, pitch);
+    score_set_key (scherzo->score, pitch);
+}
 
-    _midi_to_score_pitch_and_octave (midi_note, &pitch, &octave);
+static bool
+pitches_are_diatonic_scale (pitch_t *pitches, int num_pitches)
+{
+    int diatonic_half_steps[7] = {
+	0, 2, 4, 5, 7, 9, 11
+    };
+    int half_steps;
+    pitch_t root;
+    int i;
+
+    if (num_pitches < 7)
+	return 0;
 
-    return scherzo_add_note (scherzo, pitch, octave);
+    root = pitches[0];
+
+    for (i = 0; i < 7; i++) {
+	half_steps = pitch_from_root_in_half_steps (pitches[i], root);
+	if (half_steps != diatonic_half_steps[i])
+	    return false;
+    }
+
+    return true;
 }
 
+static void
+scherzo_press_note (scherzo_t *scherzo, pitch_t pitch)
+{
+    int i;
+
+    pitch = scherzo_key_spell_pitch (&scherzo->key, pitch);
+
+#define NUM_RECENT_PITCHES 7
+    static pitch_t recent_pitches[NUM_RECENT_PITCHES];
+
+    memmove (recent_pitches, recent_pitches + 1,
+	     (NUM_RECENT_PITCHES - 1) * sizeof (pitch_t));
+    recent_pitches[NUM_RECENT_PITCHES - 1] = pitch;
+
+    if (pitches_are_diatonic_scale (recent_pitches, NUM_RECENT_PITCHES)) {
+	scherzo_set_key (scherzo, recent_pitches[0]);
+
+	/* Respell pitch according to new key. */
+	pitch = scherzo_key_spell_pitch (&scherzo->key, pitch);
+    }
+
+    /* Do nothing if this note is already pressed. */
+    for (i = 0; i < scherzo->notes_pressed.num_pitches; i++)
+	if (scherzo->notes_pressed.pitches[i] == pitch)
+	    return;
+
+    pitch_group_add_pitch (&scherzo->notes_pressed, pitch);
+
+    if (scherzo->pedal_pressed)
+	pitch_group_add_pitch (&scherzo->notes_pedaled, pitch);
+
+    scherzo_update_notes_and_chord (scherzo);
+}
 
 static void
-scherzo_remove_note_midi (scherzo_t *scherzo, unsigned char midi_note)
+scherzo_release_note (scherzo_t *scherzo, pitch_t pitch)
 {
-    score_pitch_t pitch;
-    int octave;
- 
-    _midi_to_score_pitch_and_octave (midi_note, &pitch, &octave);
+    pitch = scherzo_key_spell_pitch (&scherzo->key, pitch);
+
+    pitch_group_remove_pitch_enharmonic (&scherzo->notes_pressed, pitch);
+
+    scherzo_update_notes_and_chord (scherzo);
+}
+
+static void
+scherzo_press_note_midi (scherzo_t *scherzo, unsigned char midi_note)
+{
+    scherzo_press_note (scherzo, pitch_from_midi (midi_note));
+}
 
-    scherzo_remove_note (scherzo, pitch, octave);
+static void
+scherzo_release_note_midi (scherzo_t *scherzo, unsigned char midi_note)
+{
+    scherzo_release_note (scherzo, pitch_from_midi (midi_note));
 }
 
-void
+static void
+scherzo_press_pedal (scherzo_t *scherzo)
+{
+    int i;
+
+    if (scherzo->pedal_pressed)
+	return;
+
+    scherzo->pedal_pressed = 1;
+
+    /* Copy all pressed notes to pedaled notes */
+    for (i = 0; i < scherzo->notes_pressed.num_pitches; i++)
+	pitch_group_add_pitch (&scherzo->notes_pedaled, scherzo->notes_pressed.pitches[i]);
+}
+
+static void
+scherzo_release_pedal (scherzo_t *scherzo)
+{
+    int i;
+
+    if (! scherzo->pedal_pressed)
+	return;
+
+    /* Remove all previously pedaled notes. */
+    for (i = scherzo->notes_pedaled.num_pitches - 1; i >=0; i--)
+	pitch_group_remove_pitch_at (&scherzo->notes_pedaled, i);
+
+    scherzo->pedal_pressed = 0;
+
+    scherzo_update_notes_and_chord (scherzo);
+}
+
+#if 0
+static void
 _select_challenge (scherzo_t *scherzo)
 {
     category_t *category_unused;
     bool_t introduced_unused;
     item_t *item;
     challenge_t *challenge = &scherzo->challenge;
-    score_pitch_t pitch;
+    pitch_name_t pitch_name;
     int octave;
     char *s;
 
-    if (challenge->note) {
-	score_remove_note (challenge->note);
-	challenge->note = NULL;
-    }
-
     mnemon_select_item (&scherzo->mnemon,
 			&challenge->bin,
 			&challenge->item_index,
@@ -403,25 +1109,25 @@ _select_challenge (scherzo_t *scherzo)
 
     switch (*s) {
     case 'C':
-	pitch = SCORE_PITCH_VALUE(C, NATURAL);
+	pitch_name = PITCH_NAME_C;
 	break;
     case 'D':
-	pitch = SCORE_PITCH_VALUE(D, NATURAL);
+	pitch_name = PITCH_NAME_D;
 	break;
     case 'E':
-	pitch = SCORE_PITCH_VALUE(E, NATURAL);
+	pitch_name = PITCH_NAME_E;
 	break;
     case 'F':
-	pitch = SCORE_PITCH_VALUE(F, NATURAL);
+	pitch_name = PITCH_NAME_F;
 	break;
     case 'G':
-	pitch = SCORE_PITCH_VALUE(G, NATURAL);
+	pitch_name = PITCH_NAME_G;
 	break;
     case 'A':
-	pitch = SCORE_PITCH_VALUE(A, NATURAL);
+	pitch_name = PITCH_NAME_A;
 	break;
     case 'B':
-	pitch = SCORE_PITCH_VALUE(B, NATURAL);
+	pitch_name = PITCH_NAME_B;
 	break;
     default:
 	fprintf (stderr, "Malformed pitch name: %s (expected 'A' - 'G')\n", s);
@@ -436,29 +1142,26 @@ _select_challenge (scherzo_t *scherzo)
 
     octave = *s - '0';
 
-    challenge->note = score_add_note (challenge->staff, pitch, octave,
-				      SCORE_DURATION_WHOLE);
+    challenge->pitch = PITCH (pitch_name, PITCH_ACCIDENTAL_NATURAL, octave);
+
+    challenge->active = 1;
     challenge->satisfied = 0;
     challenge->mistaken = 0;
 }
 
 /* Determine whether the user hit the correct note. */
 static void
-_judge_note (scherzo_t *scherzo, score_note_t *note)
+_judge_pitch (scherzo_t *scherzo, pitch_t pitch)
 {
     challenge_t *challenge = &scherzo->challenge;
 
-    if (note->pitch == challenge->note->pitch &&
-	note->octave == challenge->note->octave)
-    {
+    if (! challenge->active)
+	return;
+
+    if (pitch == challenge->pitch)
 	challenge->satisfied = 1;
-	score_set_note_color_rgb (note, 18/256., 130/256., 28/256.); /* green */
-    }
     else
-    {
 	challenge->mistaken = 1;
-	score_set_note_color_rgb (note, 184/256., 4/256., 22/256.); /* red */
-    }
 }
 
 /* If the user got the right note (eventually), then score it in
@@ -468,6 +1171,9 @@ _score_challenge (scherzo_t *scherzo)
 {
     challenge_t *challenge = &scherzo->challenge;
 
+    if (! challenge->active)
+	return;
+
     if (! challenge->satisfied)
 	return;
 
@@ -476,20 +1182,27 @@ _score_challenge (scherzo_t *scherzo)
 
     _select_challenge (scherzo);
 }
+#endif
+
+typedef struct
+{
+    scherzo_t *scherzo;
+    int fd;
+} scherzo_midi_closure_t;
 
 static int
 on_midi_input (unused (GIOChannel *channel),
 	       unused (GIOCondition condition),
 	       void *user_data)
 {
+    scherzo_midi_closure_t *closure = user_data;
     unsigned char buf[MIDI_BUF_SIZE], *next;
-    scherzo_t *scherzo = user_data;
+    scherzo_t *scherzo = closure->scherzo;
+    int fd = closure->fd;
     ssize_t remaining;
     snd_seq_event_t event;
-    score_note_t *note;
-    int need_redraw = FALSE;
 
-    remaining = read (scherzo->midi_fd, buf, MIDI_BUF_SIZE);
+    remaining = read (fd, buf, MIDI_BUF_SIZE);
 
     next = buf;
     while (remaining) {
@@ -506,14 +1219,10 @@ on_midi_input (unused (GIOChannel *channel),
 	    /* Incomplete event. Nothing to do. */
 	    break;
 	case SND_SEQ_EVENT_NOTEON:
-	    note = scherzo_add_note_midi (scherzo, event.data.note.note);
-	    _judge_note (scherzo, note);
-	    need_redraw = TRUE;
+	    scherzo_press_note_midi (scherzo, event.data.note.note);
 	    break;
 	case SND_SEQ_EVENT_NOTEOFF:
-	    scherzo_remove_note_midi (scherzo, event.data.note.note);
-	    _score_challenge (scherzo);
-	    need_redraw = TRUE;
+	    scherzo_release_note_midi (scherzo, event.data.note.note);
 	    break;
 	case SND_SEQ_EVENT_CLOCK:
 	    /* Ignore for now as my piano sends a constant stream of these. */
@@ -521,6 +1230,19 @@ on_midi_input (unused (GIOChannel *channel),
 	case SND_SEQ_EVENT_SENSING:
 	    /* Ignore for now as my piano sends a constant stream of these. */
 	    break;
+	case SND_SEQ_EVENT_CONTROLLER:
+	    /* XXX: My piano gives me 64 for the sustain pedal, is
+	     * that universal? */
+	    if (event.data.control.param == 64) {
+		if (event.data.control.value == 0)
+		    scherzo_release_pedal (scherzo);
+		else
+		    scherzo_press_pedal (scherzo);
+	    } else {
+		fprintf (stderr, "Fixme: Unhandled MIDI Control event (param=%d, value=%d)\n",
+			 event.data.control.param, event.data.control.value);
+	    }
+	    break;
 	default:
 	    fprintf (stderr, "Fixme: Do not yet know how to handle MIDI event %d\n",
 		     event.type);
@@ -528,18 +1250,42 @@ on_midi_input (unused (GIOChannel *channel),
 	}
     }
 
-    if (need_redraw)
-	gtk_widget_queue_draw (scherzo->window);
-
     /* Return TRUE to continue to get called in the future. */
     return TRUE;
 }
 
+static void *
+listen_to_alsa_midi (void *data)
+{
+    scherzo_midi_closure_t *closure = data;
+    int out_fd = closure->fd;
+    snd_rawmidi_t *midi_in;
+    unsigned char buf[MIDI_BUF_SIZE];
+    ssize_t bytes;
+    int err;
+
+    err = snd_rawmidi_open (&midi_in, NULL, "virtual", 0);
+    if (err) {
+	fprintf (stderr, "Failed to open virtual MIDI handle.");
+	return NULL;
+    }
+
+    while (1) {
+	bytes = snd_rawmidi_read (midi_in, buf, MIDI_BUF_SIZE);
+	write (out_fd, buf, bytes);
+    }
+
+    return NULL;
+}
+
 int
 main (int argc, char *argv[])
 {
     GtkWidget *drawing_area;
+    GIOChannel *channel;
     scherzo_t scherzo;
+    int alsa_midi_fd[2];
+    scherzo_midi_closure_t midi_out, alsa_midi_in, alsa_midi_out;
     int err;
 
     srand (time (NULL));
@@ -556,15 +1302,27 @@ main (int argc, char *argv[])
     scherzo.treble = score_add_staff (scherzo.score, SCORE_CLEF_G);
     scherzo.bass = score_add_staff (scherzo.score, SCORE_CLEF_F);
 
-    scherzo.num_notes_pressed = 0;
-    scherzo.notes_pressed = NULL;
+    scherzo.chord = NULL;
+
+    /* Default to octave 4 for computer keyboard keypresses. */
+    scherzo.keyboard_octave = 4;
+
+    pitch_group_init (scherzo.ctx, &scherzo.notes_pressed);
+    pitch_group_init (scherzo.ctx, &scherzo.notes_pedaled);
+
+    scherzo.pedal_pressed = 0;
+
+    /* Default to key of C Major, naturally. */
+    scherzo_set_key (&scherzo, PITCH_CLASS_LITERAL (C, NATURAL));
 
     mnemon_init (&scherzo.mnemon);
     /* XXX: Should create a default file if one cannot be loaded. */
     mnemon_load_category (&scherzo.mnemon, "scherzo-notes");
 
-    scherzo.challenge.note = NULL;
+    scherzo.challenge.active = 0;
+/*
     _select_challenge (&scherzo);
+*/
 
     err = snd_midi_event_new (MIDI_BUF_SIZE, &scherzo.snd_midi_event);
     if (err) {
@@ -573,17 +1331,29 @@ main (int argc, char *argv[])
     }
 
 #define MIDI_DEVICE "/dev/midi1"
-    scherzo.midi_fd = open (MIDI_DEVICE, O_RDONLY);
-    if (scherzo.midi_fd < 0) {
-	printf ("failed to open " MIDI_DEVICE ". Midi input will not be available.\n");
-    } else {
-	GIOChannel *channel;
 
-	channel = g_io_channel_unix_new (scherzo.midi_fd);
+    midi_out.scherzo = &scherzo;
+    midi_out.fd = open (MIDI_DEVICE, O_RDONLY);
+    if (midi_out.fd < 0) {
+	printf ("Failed to open " MIDI_DEVICE ". You will need to connect a MIDI device.\n");
+    } else {
+	channel = g_io_channel_unix_new (midi_out.fd);
 	g_io_channel_set_encoding (channel, NULL, NULL);
-	g_io_add_watch (channel, G_IO_IN, on_midi_input, &scherzo);
+	g_io_add_watch (channel, G_IO_IN, on_midi_input, &midi_out);
     }
 
+    pipe (alsa_midi_fd);
+
+    alsa_midi_in.scherzo = &scherzo;
+    alsa_midi_in.fd = alsa_midi_fd[1];
+    g_thread_new ("scherzo-vmidi", listen_to_alsa_midi, &alsa_midi_in);
+
+    alsa_midi_out.scherzo = &scherzo;
+    alsa_midi_out.fd = alsa_midi_fd[0];
+    channel = g_io_channel_unix_new (alsa_midi_out.fd);
+    g_io_channel_set_encoding (channel, NULL, NULL);
+    g_io_add_watch (channel, G_IO_IN, on_midi_input, &alsa_midi_out);
+
     scherzo.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
     gtk_window_set_default_size (GTK_WINDOW (scherzo.window), 1000, 600);