X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=scherzo.c;h=d3ca62843fa1e0beb4921b3a2c3c887e66af4119;hb=659845dcf5781c10a2b292f0b7f6fe372874ff8a;hp=d6b3af55f8d56cf6dee4cc2fde49ae1c65fc4d59;hpb=73ba6a9e9a9308747fd0fa301e1a349746eaf47c;p=scherzo

diff --git a/scherzo.c b/scherzo.c
index d6b3af5..d3ca628 100644
--- a/scherzo.c
+++ b/scherzo.c
@@ -64,7 +64,7 @@ typedef struct scherzo
      * keyboard". Any "piano keyboard" key knows its own octave and
      * accidental already. */
     int keyboard_octave;
-    score_pitch_accidental_t keyboard_accidental;
+    pitch_accidental_t keyboard_accidental;
 
     int midi_fd;
     snd_midi_event_t *snd_midi_event;
@@ -80,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);
@@ -147,8 +147,9 @@ on_key_press_event (GtkWidget *widget,
 {
     scherzo_t *scherzo = user_data;
     int octave;
-    score_pitch_name_t pitch_name;
-    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;
@@ -177,31 +178,31 @@ on_key_press_event (GtkWidget *widget,
 	return FALSE;
     case GDK_KEY_c:
     case GDK_KEY_C:
-	pitch_name = SCORE_PITCH_NAME_C;
+	pitch_name = PITCH_NAME_C;
 	break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-	pitch_name = SCORE_PITCH_NAME_D;
+	pitch_name = PITCH_NAME_D;
 	break;
     case GDK_KEY_e:
     case GDK_KEY_E:
-	pitch_name = SCORE_PITCH_NAME_E;
+	pitch_name = PITCH_NAME_E;
 	break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-	pitch_name = SCORE_PITCH_NAME_F;
+	pitch_name = PITCH_NAME_F;
 	break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-	pitch_name = SCORE_PITCH_NAME_G;
+	pitch_name = PITCH_NAME_G;
 	break;
     case GDK_KEY_a:
     case GDK_KEY_A:
-	pitch_name = SCORE_PITCH_NAME_A;
+	pitch_name = PITCH_NAME_A;
 	break;
     case GDK_KEY_b:
     case GDK_KEY_B:
-	pitch_name = SCORE_PITCH_NAME_B;
+	pitch_name = PITCH_NAME_B;
 	break;
     case GDK_KEY_0:
     case GDK_KEY_1:
@@ -218,16 +219,16 @@ on_key_press_event (GtkWidget *widget,
 	scherzo_press_pedal (scherzo);
 	break;
     case GDK_KEY_Up:
-	if (scherzo->keyboard_accidental < SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP)
+	if (scherzo->keyboard_accidental < PITCH_ACCIDENTAL_DOUBLE_SHARP)
 	    scherzo->keyboard_accidental++;
 	break;
     case GDK_KEY_Down:
-	if (scherzo->keyboard_accidental > SCORE_PITCH_ACCIDENTAL_DOUBLE_FLAT)
+	if (scherzo->keyboard_accidental > PITCH_ACCIDENTAL_DOUBLE_FLAT)
 	    scherzo->keyboard_accidental--;
 	break;
     }
 
-    pitch = SCORE_PITCH (pitch_name, scherzo->keyboard_accidental);
+    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))
@@ -253,8 +254,9 @@ on_key_release_event (unused (GtkWidget *widget),
 {
     scherzo_t *scherzo = user_data;
     int octave;
-    score_pitch_name_t pitch_name;
-    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;
@@ -264,38 +266,38 @@ on_key_release_event (unused (GtkWidget *widget),
     switch (key->keyval) {
     case GDK_KEY_c:
     case GDK_KEY_C:
-	pitch_name = SCORE_PITCH_NAME_C;
+	pitch_name = PITCH_NAME_C;
 	break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-	pitch_name = SCORE_PITCH_NAME_D;
+	pitch_name = PITCH_NAME_D;
 	break;
     case GDK_KEY_e:
     case GDK_KEY_E:
-	pitch_name = SCORE_PITCH_NAME_E;
+	pitch_name = PITCH_NAME_E;
 	break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-	pitch_name = SCORE_PITCH_NAME_F;
+	pitch_name = PITCH_NAME_F;
 	break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-	pitch_name = SCORE_PITCH_NAME_G;
+	pitch_name = PITCH_NAME_G;
 	break;
     case GDK_KEY_a:
     case GDK_KEY_A:
-	pitch_name = SCORE_PITCH_NAME_A;
+	pitch_name = PITCH_NAME_A;
 	break;
     case GDK_KEY_b:
     case GDK_KEY_B:
-	pitch_name = SCORE_PITCH_NAME_B;
+	pitch_name = PITCH_NAME_B;
 	break;
     case GDK_KEY_space:
 	scherzo_release_pedal (scherzo);
 	break;
     }
 
-    pitch = SCORE_PITCH (pitch_name, scherzo->keyboard_accidental);
+    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))
@@ -313,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;
     }
@@ -361,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;
     }
 }
@@ -448,10 +452,15 @@ 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 scaled. */
-    switch (degree->degree) {
+     * diatonic scale. */
+    switch (scale_degree) {
     case 1:
 	half_steps = 0;
 	break;
@@ -482,56 +491,385 @@ _modified_degree_to_half_steps (const modified_degree_t *degree)
     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,
 			  modified_degree_t *degrees,
 			  int num_degrees,
-			  int *inversion_ret)
+			  int inversion,
+			  pitch_t *root)
 {
-#define MAX_DEGREES 4
+#define MAX_DEGREES 6
     int relative_pitches[MAX_DEGREES];
-    int inversion, max_inversions;
-    int i;
+    int i, root_index;
 
     assert (num_degrees <= MAX_DEGREES);
 
     if (num_notes != num_degrees)
-	    return 0;
+	return 0;
 
-    max_inversions = num_degrees;
+    if (inversion >= num_degrees)
+	return 0;
 
     /* We never spell simple intervals as inversions. */
-    if (num_degrees == 2)
-	max_inversions = 1;
-
-    for (inversion = 0; inversion < max_inversions; inversion++) {
-	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 (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_notes; i++)
-	    if (notes[i].relative_pitch != relative_pitches[i])
-		goto NEXT_INVERSION;
+    for (i = 0; i < num_notes; i++)
+	if (notes[i].relative_pitch != relative_pitches[i])
+	    return 0;
 
-	*inversion_ret = inversion;
+    root_index = (num_notes - inversion) % num_notes;
+    *root = notes[root_index].note->pitch;
 
-	return 1;
+    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;
 
-    NEXT_INVERSION:
-	;
+    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;
     }
 
-    return 0;
+    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
@@ -542,7 +880,9 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     note_group_t *note_group;
     unsigned i, j, num_notes;
     int bass_pitch, inversion;
-    const char *chord_name = NULL;
+    pitch_t root;
+    chord_signature_t *match = NULL;
+    char *chord_name;
 
     if (scherzo->pedal_pressed)
 	note_group = &scherzo->notes_pedaled;
@@ -551,43 +891,6 @@ scherzo_analyze_chord (scherzo_t *scherzo)
 
     num_notes = note_group->num_notes;
 
-    struct { modified_degree_t degrees[1]; const char *name; } octaves[] = {
-	{ {{1, 0}}, "Octave"}
-    };
-
-    struct { modified_degree_t degrees[2]; const char *name; } intervals[] = {
-	{ {{1, 0}, {2, -1}}, "Minor 2nd"},
-	{ {{1, 0}, {2,  0}}, "Major 2nd"},
-	{ {{1, 0}, {3, -1}}, "Minor 3rd"},
-	{ {{1, 0}, {3,  0}}, "Major 3rd"},
-	{ {{1, 0}, {4,  0}}, "Perfect 4th"},
-	{ {{1, 0}, {5, -1}}, "Diminished 5th"},
-	{ {{1, 0}, {5,  0}}, "Perfect 5th"},
-	{ {{1, 0}, {6, -1}}, "Minor 6th"},
-	{ {{1, 0}, {6,  0}}, "Major 6th"},
-	{ {{1, 0}, {7, -1}}, "Minor 7th"},
-	{ {{1, 0}, {7,  0}}, "Major 7th"}
-    };
-
-    struct { modified_degree_t degrees[3]; const char *name; } triads[] = {
-	{ {{1, 0}, {3,  0}, {5, +1}}, "Augmented triad" },
-	{ {{1, 0}, {3,  0}, {5,  0}}, "Major triad" },
-	{ {{1, 0}, {3, -1}, {5,  0}}, "Minor triad" },
-	{ {{1, 0}, {3, -1}, {5, -1}}, "Diminished triad" }
-    };
-
-    struct { modified_degree_t degrees[4]; const char *name; } sevenths[] = {
-	{ {{1, 0}, {3,  0}, {5, +1}, {7,  0}}, "Augmented/major 7" },
-	{ {{1, 0}, {3,  0}, {5, +1}, {7, -1}}, "Augmented 7" },
-	{ {{1, 0}, {3,  0}, {5,  0}, {7,  0}}, "Major 7" },
-	{ {{1, 0}, {3,  0}, {5,  0}, {7, -1}}, "Dominant 7" },
-	{ {{1, 0}, {3, -1}, {5,  0}, {7,  0}}, "Minor/major 7" },
-	{ {{1, 0}, {3, -1}, {5,  0}, {7, -1}}, "Minor 7" },
-	{ {{1, 0}, {3, -1}, {5, -1}, {7,  0}}, "Diminished/major 7" },
-	{ {{1, 0}, {3, -1}, {5, -1}, {7, -1}}, "Half-diminished 7" },
-	{ {{1, 0}, {3, -1}, {5, -1}, {7, -2}}, "Diminished 7" }
-    };
-
     if (scherzo->chord) {
 	score_remove_chord (scherzo->chord);
 	scherzo->chord = NULL;
@@ -603,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;
@@ -650,74 +953,37 @@ scherzo_analyze_chord (scherzo_t *scherzo)
 	    }
     }
 
-    switch (num_notes) {
-    case 1:
-	for (i = 0; i < ARRAY_SIZE (octaves); i++) {
+    for (inversion = 0; inversion < 4; inversion++) {
+	for (i = 0; i < ARRAY_SIZE (signatures); i++) {
 	    if (_chord_signature_matches (notes, num_notes,
-					  octaves[i].degrees, 1, &inversion))
+					  signatures[i].degrees,
+					  signatures[i].num_degrees,
+					  inversion, &root))
 	    {
-		chord_name = octaves[i].name;
-		break;
+		match = &signatures[i];
+		goto HAVE_MATCH;
 	    }
 	}
-	break;
-    case 2:
-	for (i = 0; i < ARRAY_SIZE (intervals); i++) {
-	    if (_chord_signature_matches (notes, num_notes,
-					  intervals[i].degrees, 2, &inversion))
-	    {
-		chord_name = intervals[i].name;
-		break;
-	    }
-	}
-	break;
-    case 3:
-	for (i = 0; i < ARRAY_SIZE (triads); i++) {
-	    if (_chord_signature_matches (notes, num_notes,
-					  triads[i].degrees, 3, &inversion))
-	    {
-		chord_name = triads[i].name;
-		break;
-	    }
-	}
-	break;
-    case 4:
-	for (i = 0; i < ARRAY_SIZE(sevenths); i++) {
-	    if (_chord_signature_matches (notes, num_notes,
-					  sevenths[i].degrees, 4, &inversion))
-	    {
-		chord_name = sevenths[i].name;
-		break;
-	    }
-	}
-	break;
     }
+HAVE_MATCH:
 
-    if (chord_name) {
-	if (inversion) {
-	    const char *inversion_str;
-	    switch (inversion) {
-	    case 1:
-		inversion_str = "1st inversion";
-		break;
-	    case 2:
-		inversion_str = "2nd inversion";
-		break;
-	    case 3:
-		inversion_str = "3rd inversion";
-		break;
-	    default:
-		fprintf (stderr, "Internal error: Unexpected inversion: %d\n",
-			 inversion);
-		exit(1);
-	    }
-	    chord_name = talloc_asprintf (local, "%s %s",
-					  chord_name, inversion_str);
-	} else {
+    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);
 	}
+
+	_spell_chord_by_signature (note_group, num_notes,
+				   match, root);
     } else {
-	chord_name = talloc_strdup (local, "Unknown chord");
+	chord_name = talloc_strdup (local, "?");
     }
 
     scherzo->chord = score_add_chord (scherzo->treble, chord_name);
@@ -781,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;
@@ -817,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);
@@ -843,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);
 }
@@ -854,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);
 }
@@ -908,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;
 
@@ -941,25 +1210,25 @@ _select_challenge (scherzo_t *scherzo)
 
     switch (*s) {
     case 'C':
-	pitch = SCORE_PITCH_C;
+	pitch = PITCH_NATURAL (C);
 	break;
     case 'D':
-	pitch = SCORE_PITCH_D;
+	pitch = PITCH_NATURAL (D);
 	break;
     case 'E':
-	pitch = SCORE_PITCH_E;
+	pitch = PITCH_NATURAL (E);
 	break;
     case 'F':
-	pitch = SCORE_PITCH_F;
+	pitch = PITCH_NATURAL (F);
 	break;
     case 'G':
-	pitch = SCORE_PITCH_G;
+	pitch = PITCH_NATURAL (G);
 	break;
     case 'A':
-	pitch = SCORE_PITCH_A;
+	pitch = PITCH_NATURAL (A);
 	break;
     case 'B':
-	pitch = SCORE_PITCH_B;
+	pitch = PITCH_NATURAL (B);
 	break;
     default:
 	fprintf (stderr, "Malformed pitch name: %s (expected 'A' - 'G')\n", s);
@@ -1119,7 +1388,7 @@ main (int argc, char *argv[])
 
     /* Default to octave 4 and natural for computer keyboard keypresses. */
     scherzo.keyboard_octave = 4;
-    scherzo.keyboard_accidental = SCORE_PITCH_ACCIDENTAL_NATURAL;
+    scherzo.keyboard_accidental = PITCH_ACCIDENTAL_NATURAL;
 
     note_group_init (scherzo.ctx, &scherzo.notes_pressed);
     note_group_init (scherzo.ctx, &scherzo.notes_pedaled);