X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=scherzo.c;h=d3ca62843fa1e0beb4921b3a2c3c887e66af4119;hb=659845dcf5781c10a2b292f0b7f6fe372874ff8a;hp=3fcae5cfb9e3e291f367b9cac94726ad6c7f4b7a;hpb=2e37869bdeb7a9a6de2b758eb704320e00aae5c3;p=scherzo

diff --git a/scherzo.c b/scherzo.c
index 3fcae5c..d3ca628 100644
--- a/scherzo.c
+++ b/scherzo.c
@@ -60,9 +60,11 @@ typedef struct scherzo
     score_staff_t *bass;
     score_chord_t *chord;
 
-    /* This is for a "computer keyboard". Any "piano keyboard" key
-     * knows its own octave. */
+    /* The word "keyboard" here is referring to a "computer
+     * keyboard". Any "piano keyboard" key knows its own octave and
+     * accidental already. */
     int keyboard_octave;
+    pitch_accidental_t keyboard_accidental;
 
     int midi_fd;
     snd_midi_event_t *snd_midi_event;
@@ -78,10 +80,10 @@ typedef struct scherzo
 
 /* Forward declarations. */
 static score_note_t *
-scherzo_press_note (scherzo_t *scherzo, score_pitch_t pitch, int octave);
+scherzo_press_note (scherzo_t *scherzo, pitch_t pitch, int octave);
 
 static void
-scherzo_release_note (scherzo_t *scherzo, score_pitch_t pitch, int octave);
+scherzo_release_note (scherzo_t *scherzo, pitch_t pitch, int octave);
 
 static void
 scherzo_press_pedal (scherzo_t *scherzo);
@@ -145,7 +147,9 @@ on_key_press_event (GtkWidget *widget,
 {
     scherzo_t *scherzo = user_data;
     int octave;
-    score_pitch_t pitch;
+    /* Initialize to keep the compiler quiet. */
+    pitch_name_t pitch_name = PITCH_NATURAL (C);
+    pitch_t pitch;
 
     if (scherzo->challenge.note)
 	octave = scherzo->challenge.note->octave;
@@ -174,31 +178,31 @@ on_key_press_event (GtkWidget *widget,
 	return FALSE;
     case GDK_KEY_c:
     case GDK_KEY_C:
-	pitch = SCORE_PITCH_C;
+	pitch_name = PITCH_NAME_C;
 	break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-	pitch = SCORE_PITCH_D;
+	pitch_name = PITCH_NAME_D;
 	break;
     case GDK_KEY_e:
     case GDK_KEY_E:
-	pitch = SCORE_PITCH_E;
+	pitch_name = PITCH_NAME_E;
 	break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-	pitch = SCORE_PITCH_F;
+	pitch_name = PITCH_NAME_F;
 	break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-	pitch = SCORE_PITCH_G;
+	pitch_name = PITCH_NAME_G;
 	break;
     case GDK_KEY_a:
     case GDK_KEY_A:
-	pitch = SCORE_PITCH_A;
+	pitch_name = PITCH_NAME_A;
 	break;
     case GDK_KEY_b:
     case GDK_KEY_B:
-	pitch = SCORE_PITCH_B;
+	pitch_name = PITCH_NAME_B;
 	break;
     case GDK_KEY_0:
     case GDK_KEY_1:
@@ -214,8 +218,18 @@ on_key_press_event (GtkWidget *widget,
     case GDK_KEY_space:
 	scherzo_press_pedal (scherzo);
 	break;
+    case GDK_KEY_Up:
+	if (scherzo->keyboard_accidental < PITCH_ACCIDENTAL_DOUBLE_SHARP)
+	    scherzo->keyboard_accidental++;
+	break;
+    case GDK_KEY_Down:
+	if (scherzo->keyboard_accidental > PITCH_ACCIDENTAL_DOUBLE_FLAT)
+	    scherzo->keyboard_accidental--;
+	break;
     }
 
+    pitch = PITCH (pitch_name, scherzo->keyboard_accidental);
+
     if ((key->keyval >= GDK_KEY_A && key->keyval <= GDK_KEY_G) ||
 	(key->keyval >= GDK_KEY_a && key->keyval <= GDK_KEY_g))
     {
@@ -240,7 +254,9 @@ on_key_release_event (unused (GtkWidget *widget),
 {
     scherzo_t *scherzo = user_data;
     int octave;
-    score_pitch_t pitch;
+    /* Initialize to keep the compiler quiet. */
+    pitch_name_t pitch_name = PITCH_NAME_C;
+    pitch_t pitch;
 
     if (scherzo->challenge.note)
 	octave = scherzo->challenge.note->octave;
@@ -250,37 +266,39 @@ on_key_release_event (unused (GtkWidget *widget),
     switch (key->keyval) {
     case GDK_KEY_c:
     case GDK_KEY_C:
-	pitch = SCORE_PITCH_C;
+	pitch_name = PITCH_NAME_C;
 	break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-	pitch = SCORE_PITCH_D;
+	pitch_name = PITCH_NAME_D;
 	break;
     case GDK_KEY_e:
     case GDK_KEY_E:
-	pitch = SCORE_PITCH_E;
+	pitch_name = PITCH_NAME_E;
 	break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-	pitch = SCORE_PITCH_F;
+	pitch_name = PITCH_NAME_F;
 	break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-	pitch = SCORE_PITCH_G;
+	pitch_name = PITCH_NAME_G;
 	break;
     case GDK_KEY_a:
     case GDK_KEY_A:
-	pitch = SCORE_PITCH_A;
+	pitch_name = PITCH_NAME_A;
 	break;
     case GDK_KEY_b:
     case GDK_KEY_B:
-	pitch = SCORE_PITCH_B;
+	pitch_name = PITCH_NAME_B;
 	break;
     case GDK_KEY_space:
 	scherzo_release_pedal (scherzo);
 	break;
     }
 
+    pitch = PITCH (pitch_name, scherzo->keyboard_accidental);
+
     if ((key->keyval >= GDK_KEY_A && key->keyval <= GDK_KEY_G) ||
 	(key->keyval >= GDK_KEY_a && key->keyval <= GDK_KEY_g))
     {
@@ -297,47 +315,47 @@ on_key_release_event (unused (GtkWidget *widget),
 }
 
 static unsigned char
-_score_pitch_and_octave_to_midi (score_pitch_t pitch,
+_pitch_and_octave_to_midi (pitch_t pitch,
 				 int octave)
 {
     unsigned char midi_note = 12 * (octave + 1);
 
-    switch (SCORE_PITCH_NAME (pitch)) {
-    case SCORE_PITCH_NAME_C:
+    switch (PITCH_NAME (pitch)) {
+    case PITCH_NAME_C:
 	break;
-    case SCORE_PITCH_NAME_D:
+    case PITCH_NAME_D:
 	midi_note += 2;
 	break;
-    case SCORE_PITCH_NAME_E:
+    case PITCH_NAME_E:
 	midi_note += 4;
 	break;
-    case SCORE_PITCH_NAME_F:
+    case PITCH_NAME_F:
 	midi_note += 5;
 	break;
-    case SCORE_PITCH_NAME_G:
+    case PITCH_NAME_G:
 	midi_note += 7;
 	break;
-    case SCORE_PITCH_NAME_A:
+    case PITCH_NAME_A:
 	midi_note += 9;
 	break;
-    case SCORE_PITCH_NAME_B:
+    case PITCH_NAME_B:
 	midi_note += 11;
 	break;
     }
 
-    switch (SCORE_PITCH_ACCIDENTAL (pitch)) {
-    case SCORE_PITCH_ACCIDENTAL_DOUBLE_FLAT:
+    switch (PITCH_ACCIDENTAL (pitch)) {
+    case PITCH_ACCIDENTAL_DOUBLE_FLAT:
 	midi_note -= 2;
 	break;
-    case SCORE_PITCH_ACCIDENTAL_FLAT:
+    case PITCH_ACCIDENTAL_FLAT:
 	midi_note -= 1;
 	break;
-    case SCORE_PITCH_ACCIDENTAL_NATURAL:
+    case PITCH_ACCIDENTAL_NATURAL:
 	break;
-    case SCORE_PITCH_ACCIDENTAL_SHARP:
+    case PITCH_ACCIDENTAL_SHARP:
 	midi_note += 1;
 	break;
-    case SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP:
+    case PITCH_ACCIDENTAL_DOUBLE_SHARP:
 	midi_note += 2;
 	break;
     }
@@ -345,50 +363,52 @@ _score_pitch_and_octave_to_midi (score_pitch_t pitch,
     return midi_note;
 }
 
+/* octave can optionally by NULL */
 static void
-_midi_to_score_pitch_and_octave (unsigned char midi_note,
-				 score_pitch_t *pitch,
+_midi_to_pitch_and_octave (unsigned char midi_note,
+				 pitch_t *pitch,
 				 int *octave)
 {
-    *octave = midi_note / 12 - 1;
+    if (octave)
+	*octave = midi_note / 12 - 1;
 
     switch (midi_note % 12)
     {
     case 0:
-	*pitch = SCORE_PITCH_C;
+	*pitch = PITCH_LITERAL (C, NATURAL);
 	break;
     case 1:
-	*pitch = SCORE_PITCH_Cs;
+	*pitch = PITCH_LITERAL (C, SHARP);
 	break;
     case 2:
-	*pitch = SCORE_PITCH_D;
+	*pitch = PITCH_LITERAL (D, NATURAL);
 	break;
     case 3:
-	*pitch = SCORE_PITCH_Ds;
+	*pitch = PITCH_LITERAL (D, SHARP);
 	break;
     case 4:
-	*pitch = SCORE_PITCH_E;
+	*pitch = PITCH_LITERAL (E, NATURAL);
 	break;
     case 5:
-	*pitch = SCORE_PITCH_F;
+	*pitch = PITCH_LITERAL (F, NATURAL);
 	break;
     case 6:
-	*pitch = SCORE_PITCH_Fs;
+	*pitch = PITCH_LITERAL (F, SHARP);
 	break;
     case 7:
-	*pitch = SCORE_PITCH_G;
+	*pitch = PITCH_LITERAL (G, NATURAL);
 	break;
     case 8:
-	*pitch = SCORE_PITCH_Gs;
+	*pitch = PITCH_LITERAL (G, SHARP);
 	break;
     case 9:
-	*pitch = SCORE_PITCH_A;
+	*pitch = PITCH_LITERAL (A, NATURAL);
 	break;
     case 10:
-	*pitch = SCORE_PITCH_As;
+	*pitch = PITCH_LITERAL (A, SHARP);
 	break;
     case 11:
-	*pitch = SCORE_PITCH_B;
+	*pitch = PITCH_LITERAL (B, NATURAL);
 	break;
     }
 }
@@ -422,45 +442,447 @@ _compare_analyzed_note_by_relative_pitch (const void *va, const void *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:
+	half_steps = 0;
+	break;
+    case 2:
+	half_steps = 2;
+	break;
+    case 3:
+	half_steps = 4;
+	break;
+    case 4:
+	half_steps = 5;
+	break;
+    case 5:
+	half_steps = 7;
+	break;
+    case 6:
+	half_steps = 9;
+	break;
+    case 7:
+	half_steps = 11;
+	break;
+    default:
+	fprintf (stderr, "Internal: Invalid degree %d\n", degree->degree);
+	exit (1);
+	break;
+    }
+
+    return half_steps + degree->modification;
+}
+
+/* Number of half steps from 'root' up to 'pitch' (that is, counting
+ * the steps up a chromatic scale). */
+static int
+_pitch_from_root_in_half_steps (pitch_t pitch, pitch_t root)
+{
+    int root_midi = _pitch_and_octave_to_midi (root, 0);
+    int pitch_midi = _pitch_and_octave_to_midi (pitch, 0);
+
+    if (pitch_midi < root_midi)
+	pitch_midi += 12;
+
+    if (pitch_midi < root_midi) {
+	fprintf (stderr, "Internal error: midi values differ by more than expected.\n");
+	exit (1);
+    }
+
+    return (pitch_midi - root_midi) % 12;
+}
+
 static int
 _chord_signature_matches (analyzed_note_t *notes,
 			  int num_notes,
-			  int *signature_pitches,
-			  int num_signature_pitches)
+			  modified_degree_t *degrees,
+			  int num_degrees,
+			  int inversion,
+			  pitch_t *root)
 {
-    int n, s;
+#define MAX_DEGREES 6
+    int relative_pitches[MAX_DEGREES];
+    int i, root_index;
 
-    for (n = 0, s = 0; s < num_signature_pitches; s++) {
-	if (n >= num_notes)
-	    return 0;
-	if (notes[n].relative_pitch != signature_pitches[s])
-	    return 0;
-	n++;
-	/* Skip repeated notes in chord being tested. */
-	while (n < num_notes &&
-	       notes[n].relative_pitch == signature_pitches[s])
-	{
-	    n++;
-	}
+    assert (num_degrees <= MAX_DEGREES);
+
+    if (num_notes != num_degrees)
+	return 0;
+
+    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;
+		
     }
 
-    /* If there are fewer notes in the signature than in the chord,
-     * then there is no match. */
-    if (n < num_notes)
+    for (i = 0; i < num_notes; i++)
+	if (notes[i].relative_pitch != relative_pitches[i])
 	    return 0;
 
+    root_index = (num_notes - inversion) % num_notes;
+    *root = notes[root_index].note->pitch;
+
     return 1;
 }
 
+static const char *
+_pitch_str (pitch_t pitch)
+{
+    static char double_flat[] = "X𝄫";
+    static char flat[] = "X♭";
+    static char natural[] = "X";
+    static char sharp[] = "X♯";
+    static char double_sharp[] = "X𝄪";
+    char *ret;
+
+    switch (PITCH_ACCIDENTAL (pitch)) {
+    case PITCH_ACCIDENTAL_DOUBLE_FLAT:
+	ret = double_flat;
+	break;
+    case PITCH_ACCIDENTAL_FLAT:
+	ret = flat;
+	break;
+    case PITCH_ACCIDENTAL_NATURAL:
+	ret = natural;
+	break;
+    case PITCH_ACCIDENTAL_SHARP:
+	ret = sharp;
+	break;
+    case PITCH_ACCIDENTAL_DOUBLE_SHARP:
+	ret = double_sharp;
+	break;
+    }
+
+    switch (PITCH_NAME(pitch)) {
+    case PITCH_NAME_C:
+	ret[0] = 'C';
+	break;
+    case PITCH_NAME_D:
+	ret[0] = 'D';
+	break;
+    case PITCH_NAME_E:
+	ret[0] = 'E';
+	break;
+    case PITCH_NAME_F:
+	ret[0] = 'F';
+	break;
+    case PITCH_NAME_G:
+	ret[0] = 'G';
+	break;
+    case PITCH_NAME_A:
+	ret[0] = 'A';
+	break;
+    case PITCH_NAME_B:
+	ret[0] = 'B';
+	break;
+    }
+
+    return ret;
+}
+
+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
+scherzo_adjust_note_to_match_modified_degree (score_note_t *note,
+					      pitch_t root,
+					      modified_degree_t *degree)
+{
+    pitch_name_t name = PITCH_NAME (note->pitch);
+    pitch_accidental_t accidental = PITCH_ACCIDENTAL (note->pitch);
+    int degree_zero_based = (degree->degree - 1) % 7;
+    int degree_delta;
+
+    int note_degree_zero_based = name - PITCH_NAME (root);
+    if (note_degree_zero_based < 0)
+	note_degree_zero_based += 7;
+
+    if (note_degree_zero_based == degree_zero_based)
+	return;
+
+    degree_delta = note_degree_zero_based - degree_zero_based;
+    if (degree_delta > 3)
+	degree_delta = - (7 - degree_delta);
+    if (degree_delta < -3)
+	degree_delta = - (-7 - degree_delta);
+
+    if (abs (degree_delta) != 1) {
+	fprintf (stderr, "Internal error: Cannot adjust a note more than one degree (%d vs. %d).\n", note_degree_zero_based + 1, degree->degree);
+	exit (1);
+    }
+
+    if (degree_delta == -1) {
+	if (name == PITCH_NAME_B) {
+	    name = PITCH_NAME_C;
+	    note->octave++;
+	} else {
+	    name++;
+	}
+	switch (name) {
+	case PITCH_NAME_D:
+	case PITCH_NAME_E:
+	case PITCH_NAME_G:
+	case PITCH_NAME_A:
+	case PITCH_NAME_B:
+	    accidental -= 2;
+	    break;
+	case PITCH_NAME_C:
+	case PITCH_NAME_F:
+	    accidental -= 1;
+	    break;
+	}
+    }
+
+    if (degree_delta == +1) {
+	if (name == PITCH_NAME_C) {
+	    name = PITCH_NAME_B;
+	    note->octave--;
+	} else {
+	    name--;
+	}
+	switch (name) {
+	case PITCH_NAME_C:
+	case PITCH_NAME_D:
+	case PITCH_NAME_F:
+	case PITCH_NAME_G:
+	case PITCH_NAME_A:
+	    accidental += 2;
+	    break;
+	case PITCH_NAME_E:
+	case PITCH_NAME_B:
+	    accidental += 1;
+	}
+    }
+
+    if (accidental < 0 || accidental > PITCH_ACCIDENTAL_DOUBLE_SHARP) {
+	fprintf (stderr, "Internal error: Trying to adjust an accidental out of range (degree_delta == %d (%d - %d), new accidental == %d).\n", degree_delta, note_degree_zero_based, degree_zero_based, accidental);
+	exit (1);
+    }
+
+    note->pitch = PITCH (name, accidental);
+}
+
+static void
+_spell_chord_by_signature (note_group_t *chord,
+			   int num_notes,
+			   chord_signature_t *signature,
+			   pitch_t root)
+{
+    int i, degree, note_half_steps, degree_half_steps;
+    int root_midi;
+
+    /* Sanitize root to eliminate things like double-flats,
+     * double-sharps, Cb, E#, etc. */
+    root_midi = _pitch_and_octave_to_midi (root, 0);
+    _midi_to_pitch_and_octave (root_midi, &root, NULL);
+    
+    for (i = 0; i < num_notes; i++) {
+	note_half_steps = _pitch_from_root_in_half_steps (chord->notes[i]->pitch,
+							  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) {
+		scherzo_adjust_note_to_match_modified_degree (chord->notes[i],
+							      root,
+							      &signature->degrees[degree]);
+		break;
+	    }
+	}
+	if (note_half_steps != degree_half_steps) {
+	    fprintf (stderr, "Internal error: Chord and degree mis-match\n");
+	    exit (1);
+	}
+    }
+}
+
 static void
 scherzo_analyze_chord (scherzo_t *scherzo)
 {
     void *local = talloc_new (NULL);
     analyzed_note_t *notes;
     note_group_t *note_group;
-    unsigned i, num_notes;
-    int bass_pitch;
-    const char *chord_name = NULL;
+    unsigned i, j, num_notes;
+    int bass_pitch, inversion;
+    pitch_t root;
+    chord_signature_t *match = NULL;
+    char *chord_name;
 
     if (scherzo->pedal_pressed)
 	note_group = &scherzo->notes_pedaled;
@@ -469,43 +891,6 @@ scherzo_analyze_chord (scherzo_t *scherzo)
 
     num_notes = note_group->num_notes;
 
-    struct { int pitches[1]; const char *name; } octaves[] = {
-	{ {0}, "Octave"}
-    };
-
-    struct { int pitches[2]; const char *name; } intervals[] = {
-	{ {0, 1}, "Minor 2nd"},
-	{ {0, 2}, "Major 2nd"},
-	{ {0, 3}, "Minor 3rd"},
-	{ {0, 4}, "Major 3rd"},
-	{ {0, 5}, "Perfect 4th"},
-	{ {0, 6}, "Diminished 5th/Augmented 4th"},
-	{ {0, 7}, "Perfect 5th"},
-	{ {0, 8}, "Minor 6th"},
-	{ {0, 9}, "Major 6th"},
-	{ {0, 10}, "Minor 7th"},
-	{ {0, 11}, "Major 7th"}
-    };
-
-    struct { int pitches[3]; const char *name; } triads[] = {
-	{ {0, 4, 8}, "Augmented triad" },
-	{ {0, 4, 7}, "Major triad" },
-	{ {0, 3, 7}, "Minor triad" },
-	{ {0, 3, 6}, "Diminished triad" }
-    };
-
-    struct { int pitches[4]; const char *name; } sevenths[] = {
-	{ {0, 4, 8, 11}, "Augmented/major 7" },
-	{ {0, 4, 7, 11}, "Major 7" },
-	{ {0, 4, 7, 10}, "Dominant 7" },
-	{ {0, 3, 7, 11}, "Minor/major 7" },
-	{ {0, 3, 7, 10}, "Minor 7" },
-	{ {0, 3, 6, 10}, "Half-diminished 7" },
-	{ {0, 3, 6, 9},  "Diminished 7" },
-	{ {0, 4, 8, 10}, "Augmented 7" },
-	{ {0, 3, 6, 11}, "Diminished/major 7" },
-    };
-
     if (scherzo->chord) {
 	score_remove_chord (scherzo->chord);
 	scherzo->chord = NULL;
@@ -521,7 +906,7 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     for (i = 0; i < num_notes; i++) {
 	score_note_t *note = note_group->notes[i];
 	notes[i].note = note;
-	notes[i].midi_pitch = _score_pitch_and_octave_to_midi (note->pitch,
+	notes[i].midi_pitch = _pitch_and_octave_to_midi (note->pitch,
 							       note->octave);
 	/* Relative pitch will be filled in after sorting. */
 	notes[i].relative_pitch = 0;
@@ -544,30 +929,64 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     qsort (notes, num_notes, sizeof (analyzed_note_t),
 	   _compare_analyzed_note_by_relative_pitch);
 
-    for (i = 0; i < ARRAY_SIZE (octaves); i++) {
-	if (_chord_signature_matches (notes, num_notes, octaves[i].pitches, 1))
-	    chord_name = octaves[i].name;
-    }
-
-    for (i = 0; i < ARRAY_SIZE (intervals); i++) {
-	if (_chord_signature_matches (notes, num_notes, intervals[i].pitches, 2))
-	    chord_name = intervals[i].name;
+    /* Finally, eliminate all duplicate notes. */
+    for (i = 0; i < num_notes - 1; i++) {
+	    if (notes[i+1].relative_pitch == notes[i].relative_pitch) {
+		    j = i+1;
+		    while (j < num_notes &&
+			   notes[j].relative_pitch == notes[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_notes - 1) {
+			    memmove (&notes[i+1], &notes[j+1],
+				     (num_notes - j) * sizeof (analyzed_note_t));
+		    }
+
+		    num_notes -= (j - i);
+	    }
     }
 
-    for (i = 0; i < ARRAY_SIZE (triads); i++) {
-	if (_chord_signature_matches (notes, num_notes, triads[i].pitches, 3))
-	    chord_name = triads[i].name;
+    for (inversion = 0; inversion < 4; inversion++) {
+	for (i = 0; i < ARRAY_SIZE (signatures); i++) {
+	    if (_chord_signature_matches (notes, num_notes,
+					  signatures[i].degrees,
+					  signatures[i].num_degrees,
+					  inversion, &root))
+	    {
+		match = &signatures[i];
+		goto HAVE_MATCH;
+	    }
+	}
     }
+HAVE_MATCH:
+
+    chord_name = (char *) signatures[i].name;
+
+    if (match) {
+	/* Don't print root pitch for octaves and inversions,
+	 * (since a pitch name alone looks like a major triad) */
+	if (num_notes < 3) {
+	    chord_name = talloc_strdup (local, chord_name);
+	} else {
+	    chord_name = talloc_asprintf (local, "%s%s",
+					  _pitch_str (root),
+					  chord_name);
+	}
 
-    for (i = 0; i < ARRAY_SIZE(sevenths); i++) {
-	if (_chord_signature_matches (notes, num_notes, sevenths[i].pitches, 4))
-	    chord_name = sevenths[i].name;
+	_spell_chord_by_signature (note_group, num_notes,
+				   match, root);
+    } else {
+	chord_name = talloc_strdup (local, "?");
     }
 
-    if (chord_name)
-	scherzo->chord = score_add_chord (scherzo->treble, chord_name);
-    else
-	scherzo->chord = score_add_chord (scherzo->treble, "Unknown or not a chord");
+    scherzo->chord = score_add_chord (scherzo->treble, chord_name);
 
 DONE:
     talloc_free (local);
@@ -628,7 +1047,7 @@ note_group_remove_note_at (note_group_t *group, int i)
 }
 
 static score_note_t *
-scherzo_press_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
+scherzo_press_note (scherzo_t *scherzo, pitch_t pitch, int octave)
 {
     score_staff_t *staff;
     score_note_t *note;
@@ -664,15 +1083,18 @@ scherzo_press_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
 }
 
 static void
-scherzo_release_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
+scherzo_release_note (scherzo_t *scherzo, pitch_t pitch, int octave)
 {
     score_note_t *note;
     int i;
     int found = 0;
+    int target_midi = _pitch_and_octave_to_midi (pitch, octave);
+    int note_midi;
 
     for (i = scherzo->notes_pressed.num_notes - 1; i >=0; i--) {
 	note = scherzo->notes_pressed.notes[i];
-	if (note->pitch == pitch && note->octave == octave) {
+	note_midi = _pitch_and_octave_to_midi (note->pitch, note->octave);
+	if (note_midi == target_midi) {
 	    found = 1;
 	    if (! scherzo->pedal_pressed)
 		score_remove_note (note);
@@ -690,10 +1112,10 @@ scherzo_release_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
 static score_note_t *
 scherzo_press_note_midi (scherzo_t *scherzo, unsigned char midi_note)
 {
-    score_pitch_t pitch;
+    pitch_t pitch;
     int octave;
 
-    _midi_to_score_pitch_and_octave (midi_note, &pitch, &octave);
+    _midi_to_pitch_and_octave (midi_note, &pitch, &octave);
 
     return scherzo_press_note (scherzo, pitch, octave);
 }
@@ -701,10 +1123,10 @@ scherzo_press_note_midi (scherzo_t *scherzo, unsigned char midi_note)
 static void
 scherzo_release_note_midi (scherzo_t *scherzo, unsigned char midi_note)
 {
-    score_pitch_t pitch;
+    pitch_t pitch;
     int octave;
  
-    _midi_to_score_pitch_and_octave (midi_note, &pitch, &octave);
+    _midi_to_pitch_and_octave (midi_note, &pitch, &octave);
 
     scherzo_release_note (scherzo, pitch, octave);
 }
@@ -755,7 +1177,7 @@ _select_challenge (scherzo_t *scherzo)
     bool_t introduced_unused;
     item_t *item;
     challenge_t *challenge = &scherzo->challenge;
-    score_pitch_t pitch;
+    pitch_t pitch;
     int octave;
     char *s;
 
@@ -788,25 +1210,25 @@ _select_challenge (scherzo_t *scherzo)
 
     switch (*s) {
     case 'C':
-	pitch = SCORE_PITCH_VALUE(C, NATURAL);
+	pitch = PITCH_NATURAL (C);
 	break;
     case 'D':
-	pitch = SCORE_PITCH_VALUE(D, NATURAL);
+	pitch = PITCH_NATURAL (D);
 	break;
     case 'E':
-	pitch = SCORE_PITCH_VALUE(E, NATURAL);
+	pitch = PITCH_NATURAL (E);
 	break;
     case 'F':
-	pitch = SCORE_PITCH_VALUE(F, NATURAL);
+	pitch = PITCH_NATURAL (F);
 	break;
     case 'G':
-	pitch = SCORE_PITCH_VALUE(G, NATURAL);
+	pitch = PITCH_NATURAL (G);
 	break;
     case 'A':
-	pitch = SCORE_PITCH_VALUE(A, NATURAL);
+	pitch = PITCH_NATURAL (A);
 	break;
     case 'B':
-	pitch = SCORE_PITCH_VALUE(B, NATURAL);
+	pitch = PITCH_NATURAL (B);
 	break;
     default:
 	fprintf (stderr, "Malformed pitch name: %s (expected 'A' - 'G')\n", s);
@@ -964,8 +1386,9 @@ main (int argc, char *argv[])
 
     scherzo.chord = NULL;
 
-    /* Default to octave 4 for computer keyboard keypresses. */
+    /* Default to octave 4 and natural for computer keyboard keypresses. */
     scherzo.keyboard_octave = 4;
+    scherzo.keyboard_accidental = PITCH_ACCIDENTAL_NATURAL;
 
     note_group_init (scherzo.ctx, &scherzo.notes_pressed);
     note_group_init (scherzo.ctx, &scherzo.notes_pedaled);