Detect the root pitch of chord and display it

One ugly thing here is that any accidental in the chord name is in a
different font than the accidental on the stave.

diff --git a/scherzo.c b/scherzo.c
index 8c6d394934087dd61da9bab7fbd16dc0a6111d3a..a7bd785786ede2d57ca13784ad24220db322b8fe 100644 (file)
--- a/scherzo.c
+++ b/scherzo.c
@@ -489,12 +489,13 @@ _chord_signature_matches (analyzed_note_t *notes,
                          int num_notes,
                          modified_degree_t *degrees,
                          int num_degrees,
                          int num_notes,
                          modified_degree_t *degrees,
                          int num_degrees,

-                         int *inversion_ret)
+                         int *inversion_ret,
+                         score_pitch_t *root)

 {
 #define MAX_DEGREES 4
     int relative_pitches[MAX_DEGREES];
     int inversion, max_inversions;
 {
 #define MAX_DEGREES 4
     int relative_pitches[MAX_DEGREES];
     int inversion, max_inversions;

-    int i;
+    int i, root_index;

 
     assert (num_degrees <= MAX_DEGREES);
 
 
     assert (num_degrees <= MAX_DEGREES);
 


@@ -525,6 +526,9 @@ _chord_signature_matches (analyzed_note_t *notes,
            if (notes[i].relative_pitch != relative_pitches[i])
                goto NEXT_INVERSION;
 
            if (notes[i].relative_pitch != relative_pitches[i])
                goto NEXT_INVERSION;
 

+       root_index = (num_notes - inversion) % num_notes;
+       *root = notes[root_index].note->pitch;
+

        *inversion_ret = inversion;
 
        return 1;
        *inversion_ret = inversion;
 
        return 1;


@@ -536,6 +540,86 @@ _chord_signature_matches (analyzed_note_t *notes,
     return 0;
 }
 
     return 0;
 }
 

+static const char *
+_pitch_str (score_pitch_t pitch)
+{
+    switch (pitch) {
+    case SCORE_PITCH_Cff:
+       return "C𝄫";
+    case SCORE_PITCH_Cf:
+       return "C♭";
+    case SCORE_PITCH_C:
+       return "C";
+    case SCORE_PITCH_Cs:
+       return "C♯";
+    case SCORE_PITCH_Css:
+       return "C𝄪";
+    case SCORE_PITCH_Dff:
+       return "D𝄫";
+    case SCORE_PITCH_Df:
+       return "D♭";
+    case SCORE_PITCH_D:
+       return "D";
+    case SCORE_PITCH_Ds:
+       return "D♯";
+    case SCORE_PITCH_Dss:
+       return "D𝄪";
+    case SCORE_PITCH_Eff:
+       return "E𝄫";
+    case SCORE_PITCH_Ef:
+       return "E♭";
+    case SCORE_PITCH_E:
+       return "E";
+    case SCORE_PITCH_Es:
+       return "E♯";
+    case SCORE_PITCH_Ess:
+       return "E𝄪";
+    case SCORE_PITCH_Fff:
+       return "F𝄫";
+    case SCORE_PITCH_Ff:
+       return "F♭";
+    case SCORE_PITCH_F:
+       return "F";
+    case SCORE_PITCH_Fs:
+       return "F♯";
+    case SCORE_PITCH_Fss:
+       return "F𝄪";
+    case SCORE_PITCH_Gff:
+       return "G𝄫";
+    case SCORE_PITCH_Gf:
+       return "G♭";
+    case SCORE_PITCH_G:
+       return "G";
+    case SCORE_PITCH_Gs:
+       return "G♯";
+    case SCORE_PITCH_Gss:
+       return "G𝄪";
+    case SCORE_PITCH_Aff:
+       return "A𝄫";
+    case SCORE_PITCH_Af:
+       return "A♭";
+    case SCORE_PITCH_A:
+       return "A";
+    case SCORE_PITCH_As:
+       return "A♯";
+    case SCORE_PITCH_Ass:
+       return "A𝄪";
+    case SCORE_PITCH_Bff:
+       return "B𝄫";
+    case SCORE_PITCH_Bf:
+       return "B♭";
+    case SCORE_PITCH_B:
+       return "B";
+    case SCORE_PITCH_Bs:
+       return "B♯";
+    case SCORE_PITCH_Bss:
+       return "B𝄪";
+    }
+
+    fprintf (stderr, "Internal error: Unknown pitch %d\n", pitch);
+    exit (1);
+}
+

 static void
 scherzo_analyze_chord (scherzo_t *scherzo)
 {
 static void
 scherzo_analyze_chord (scherzo_t *scherzo)
 {


@@ -544,6 +628,7 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     note_group_t *note_group;
     unsigned i, j, num_notes;
     int bass_pitch, inversion;
     note_group_t *note_group;
     unsigned i, j, num_notes;
     int bass_pitch, inversion;

+    score_pitch_t root;

     const char *chord_name = NULL;
 
     if (scherzo->pedal_pressed)
     const char *chord_name = NULL;
 
     if (scherzo->pedal_pressed)


@@ -656,7 +741,8 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     case 1:
        for (i = 0; i < ARRAY_SIZE (octaves); i++) {
            if (_chord_signature_matches (notes, num_notes,
     case 1:
        for (i = 0; i < ARRAY_SIZE (octaves); i++) {
            if (_chord_signature_matches (notes, num_notes,

-                                         octaves[i].degrees, 1, &inversion))
+                                         octaves[i].degrees, 1,
+                                         &inversion, &root))

            {
                chord_name = octaves[i].name;
                break;
            {
                chord_name = octaves[i].name;
                break;


@@ -666,7 +752,8 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     case 2:
        for (i = 0; i < ARRAY_SIZE (intervals); i++) {
            if (_chord_signature_matches (notes, num_notes,
     case 2:
        for (i = 0; i < ARRAY_SIZE (intervals); i++) {
            if (_chord_signature_matches (notes, num_notes,

-                                         intervals[i].degrees, 2, &inversion))
+                                         intervals[i].degrees, 2,
+                                         &inversion, &root))

            {
                chord_name = intervals[i].name;
                break;
            {
                chord_name = intervals[i].name;
                break;


@@ -676,7 +763,8 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     case 3:
        for (i = 0; i < ARRAY_SIZE (triads); i++) {
            if (_chord_signature_matches (notes, num_notes,
     case 3:
        for (i = 0; i < ARRAY_SIZE (triads); i++) {
            if (_chord_signature_matches (notes, num_notes,

-                                         triads[i].degrees, 3, &inversion))
+                                         triads[i].degrees, 3,
+                                         &inversion, &root))

            {
                chord_name = triads[i].name;
                break;
            {
                chord_name = triads[i].name;
                break;


@@ -686,7 +774,8 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     case 4:
        for (i = 0; i < ARRAY_SIZE(sevenths); i++) {
            if (_chord_signature_matches (notes, num_notes,
     case 4:
        for (i = 0; i < ARRAY_SIZE(sevenths); i++) {
            if (_chord_signature_matches (notes, num_notes,

-                                         sevenths[i].degrees, 4, &inversion))
+                                         sevenths[i].degrees, 4,
+                                         &inversion, &root))

            {
                chord_name = sevenths[i].name;
                break;
            {
                chord_name = sevenths[i].name;
                break;


@@ -713,10 +802,13 @@ scherzo_analyze_chord (scherzo_t *scherzo)
                         inversion);
                exit(1);
            }
                         inversion);
                exit(1);
            }

-           chord_name = talloc_asprintf (local, "%s %s",
+           chord_name = talloc_asprintf (local, "%s %s %s",
+                                         _pitch_str (root),

                                          chord_name, inversion_str);
        } else {
                                          chord_name, inversion_str);
        } else {

-           chord_name = talloc_strdup (local, chord_name);
+           chord_name = talloc_asprintf (local, "%s %s",
+                                         _pitch_str (root),
+                                         chord_name);

        }
     } else {
        chord_name = talloc_strdup (local, "Unknown chord");
        }
     } else {
        chord_name = talloc_strdup (local, "Unknown chord");