From: Carl Worth Date: Tue, 17 Sep 2013 21:17:37 +0000 (-0700) Subject: Add preliminary chord analysis X-Git-Url: https://git.cworth.org/git?p=scherzo;a=commitdiff_plain;h=05713bff8bc084c401d58b1b9526d83d9a42b641 Add preliminary chord analysis With this commit, challenges are disabled (for the moment), and scherzo will analyze the notes pressed as a chord. Currently, only the four basic types of triads (augemented, major, minor, and dminished) are recognized, and these only in root position. --- diff --git a/scherzo.c b/scherzo.c index 5de6148..9b0e2d9 100644 --- a/scherzo.c +++ b/scherzo.c @@ -24,6 +24,8 @@ #include "score.h" #include "mnemon.h" +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) + #define unused(foo) foo __attribute__((unused)) #define MIDI_BUF_SIZE 4096 @@ -48,6 +50,7 @@ typedef struct scherzo int staff_height; score_staff_t *treble; score_staff_t *bass; + score_chord_t *chord; int midi_fd; snd_midi_event_t *snd_midi_event; @@ -120,9 +123,14 @@ on_key_press_event (GtkWidget *widget, void *user_data) { scherzo_t *scherzo = user_data; - int octave = scherzo->challenge.note->octave; + int octave; score_pitch_t pitch; + if (scherzo->challenge.note) + octave = scherzo->challenge.note->octave; + else + octave = 4; + switch (key->keyval) { case GDK_KEY_plus: case GDK_KEY_KP_Add: @@ -196,9 +204,14 @@ on_key_release_event (unused (GtkWidget *widget), void *user_data) { scherzo_t *scherzo = user_data; - int octave = scherzo->challenge.note->octave; + int octave; score_pitch_t pitch; + if (scherzo->challenge.note) + octave = scherzo->challenge.note->octave; + else + octave = 4; + switch (key->keyval) { case GDK_KEY_c: case GDK_KEY_C: @@ -245,6 +258,55 @@ on_key_release_event (unused (GtkWidget *widget), return FALSE; } +static unsigned char +_score_pitch_and_octave_to_midi (score_pitch_t pitch, + int octave) +{ + unsigned char midi_note = 12 * (octave + 1); + + switch (SCORE_PITCH_NAME (pitch)) { + case SCORE_PITCH_NAME_C: + break; + case SCORE_PITCH_NAME_D: + midi_note += 2; + break; + case SCORE_PITCH_NAME_E: + midi_note += 4; + break; + case SCORE_PITCH_NAME_F: + midi_note += 5; + break; + case SCORE_PITCH_NAME_G: + midi_note += 7; + break; + case SCORE_PITCH_NAME_A: + midi_note += 9; + break; + case SCORE_PITCH_NAME_B: + midi_note += 11; + break; + } + + switch (SCORE_PITCH_ACCIDENTAL (pitch)) { + case SCORE_PITCH_ACCIDENTAL_DOUBLE_FLAT: + midi_note -= 2; + break; + case SCORE_PITCH_ACCIDENTAL_FLAT: + midi_note -= 1; + break; + case SCORE_PITCH_ACCIDENTAL_NATURAL: + break; + case SCORE_PITCH_ACCIDENTAL_SHARP: + midi_note += 1; + break; + case SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP: + midi_note += 2; + break; + } + + return midi_note; +} + static void _midi_to_score_pitch_and_octave (unsigned char midi_note, score_pitch_t *pitch, @@ -293,13 +355,138 @@ _midi_to_score_pitch_and_octave (unsigned char midi_note, } } +/* Determine a chord name (if any) from the current notes pressed */ + +typedef struct analyzed_note { + /* Original note being analzyed. */ + score_note_t *note; + + /* Absolute pitch (expressed as midi number). */ + int midi_pitch; + + /* Pitch relative to bass note. */ + int relative_pitch; +} analyzed_note_t; + +static int +_compare_analyzed_note (const void *va, const void *vb) +{ + const analyzed_note_t *a = va, *b = vb; + + return a->midi_pitch - b->midi_pitch; +} + +static int +_chord_signature_matches (analyzed_note_t *notes, + int num_notes, + int *signature_pitches, + int num_signature_pitches) +{ + int n, s; + + 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++; + } + } + + return 1; +} + +static void +scherzo_analyze_chord (scherzo_t *scherzo) +{ + void *local = talloc_new (NULL); + analyzed_note_t *notes; + unsigned i, num_notes = scherzo->num_notes_pressed; + int bass_pitch; + const char *chord_name = NULL; + + 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" } + }; + + if (scherzo->chord) { + score_remove_chord (scherzo->chord); + scherzo->chord = NULL; + } + + if (num_notes == 0) + goto DONE; + + notes = talloc_array (local, analyzed_note_t, num_notes); + if (notes == NULL) + goto DONE; + + for (i = 0; i < num_notes; i++) { + score_note_t *note = scherzo->notes_pressed[i]; + notes[i].note = note; + notes[i].midi_pitch = _score_pitch_and_octave_to_midi (note->pitch, + note->octave); + /* Relative pitch will be filled in after sorting. */ + notes[i].relative_pitch = 0; + } + + qsort (notes, num_notes, sizeof (analyzed_note_t), _compare_analyzed_note); + + bass_pitch = notes[0].midi_pitch; + + for (i = 0; i < num_notes; i++) { + notes[i].relative_pitch = notes[i].midi_pitch - bass_pitch; + } + + 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 (i = 0; i < num_sevenths; i++) { + if (_chord_signature_matches (notes, num_notes, seventh[i].pitches, 4)) + chord_name = seventh[i].name; + } +*/ + + 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"); + +DONE: + talloc_free (local); +} + static score_note_t * scherzo_add_note (scherzo_t *scherzo, score_pitch_t pitch, int octave) { score_staff_t *staff; score_note_t *note; + int i; - staff = scherzo->challenge.staff; + if (scherzo->challenge.note) + staff = scherzo->challenge.staff; + else + staff = scherzo->treble; + + /* Do nothing if this note is already pressed. */ + for (i = 0; i < scherzo->num_notes_pressed; i++) { + if (scherzo->notes_pressed[i]->pitch == pitch && + scherzo->notes_pressed[i]->octave == octave) + { + return scherzo->notes_pressed[i]; + } + } note = score_add_note (staff, pitch, octave, SCORE_DURATION_WHOLE); @@ -315,6 +502,8 @@ scherzo_add_note (scherzo_t *scherzo, score_pitch_t pitch, int octave) scherzo->notes_pressed[scherzo->num_notes_pressed - 1] = note; + scherzo_analyze_chord (scherzo); + return note; } @@ -338,6 +527,8 @@ scherzo_remove_note (scherzo_t *scherzo, score_pitch_t pitch, int octave) i--; } } + + scherzo_analyze_chord (scherzo); } static score_note_t * @@ -448,6 +639,11 @@ _judge_note (scherzo_t *scherzo, score_note_t *note) { challenge_t *challenge = &scherzo->challenge; + if (! scherzo->challenge.note) { + score_set_note_color_rgb (note, 0.0, 0.0, 0.0); /* black */ + return; + } + if (note->pitch == challenge->note->pitch && note->octave == challenge->note->octave) { @@ -468,6 +664,9 @@ _score_challenge (scherzo_t *scherzo) { challenge_t *challenge = &scherzo->challenge; + if (! challenge->note) + return; + if (! challenge->satisfied) return; @@ -556,6 +755,8 @@ 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.chord = NULL; + scherzo.num_notes_pressed = 0; scherzo.notes_pressed = NULL; @@ -564,7 +765,9 @@ main (int argc, char *argv[]) mnemon_load_category (&scherzo.mnemon, "scherzo-notes"); scherzo.challenge.note = NULL; +/* _select_challenge (&scherzo); +*/ err = snd_midi_event_new (MIDI_BUF_SIZE, &scherzo.snd_midi_event); if (err) { diff --git a/score.c b/score.c index db07d5e..e319af0 100644 --- a/score.c +++ b/score.c @@ -26,6 +26,9 @@ struct score_staff { score_clef_t clef; + score_chord_t **chords; + int num_chords; + score_note_t **notes; int num_notes; @@ -178,6 +181,38 @@ _score_note_to_line (score_staff_t *staff, score_note_t *note) return c_line - (name - SCORE_PITCH_NAME_C) / 2.0 - 3.5 * (note->octave - 4); } +/* chord->width is updated as a side effect */ +static void +_draw_chord (score_t *score, cairo_t *cr, + score_staff_t *staff, score_chord_t *chord) +{ + cairo_text_extents_t chord_extents; + double total_staff_height; + + /* XXX: The staff should manage this height itself. */ + total_staff_height = (staff->upper_ledger_lines * score->space_height + + score->staff_height + + staff->lower_ledger_lines * score->space_height); + + cairo_save (cr); + + cairo_text_extents (cr, chord->name, &chord_extents); + + cairo_select_font_face (cr, "serif", 0, 0); + cairo_set_font_size (cr, score->space_height * 3); + + if (staff->clef == SCORE_CLEF_G) + cairo_move_to (cr, 0, - score->space_height * 0.5); + else + cairo_move_to (cr, 0, score->space_height * 0.5 + total_staff_height + chord_extents.y_bearing); + + cairo_show_text (cr, chord->name); + + chord->width = chord_extents.x_advance; + + cairo_restore (cr); +} + static void _draw_note (score_t *score, cairo_t *cr, score_staff_t *staff, score_note_t *note) @@ -300,6 +335,16 @@ _draw_staff (score_t *score, cairo_t *cr, /* Make space for clef before drawing notes */ cairo_translate (cr, (int) (4 * score->space_height), 0); + /* Draw chord symbols */ + cairo_save (cr); + { + for (i = 0; i < staff->num_chords; i++) { + _draw_chord (score, cr, staff, staff->chords[i]); + cairo_translate (cr, staff->chords[i]->width, 0.0); + } + } + cairo_restore (cr); + /* Draw notes */ for (i = 0; i < staff->num_notes; i++) { _draw_note (score, cr, staff, staff->notes[i]); @@ -409,6 +454,9 @@ score_add_staff (score_t *score, score_clef_t clef) staff->notes = NULL; staff->num_notes = 0; + staff->chords = NULL; + staff->num_chords = 0; + staff->upper_ledger_lines = 0; staff->lower_ledger_lines = 0; @@ -427,6 +475,61 @@ score_add_staff (score_t *score, score_clef_t clef) return staff; } +score_chord_t * +score_add_chord (score_staff_t *staff, + const char *name) +{ + score_chord_t *chord; + + chord = talloc (staff, score_chord_t); + if (chord == NULL) + return NULL; + + chord->staff = staff; + chord->name = talloc_strdup (chord, name); + + /* The width will get set correctly the first time _draw_chord is + * called. */ + chord->width = 0.0; + + staff->num_chords++; + staff->chords = talloc_realloc (staff, + staff->chords, + score_chord_t*, + staff->num_chords); + if (staff->chords == NULL) { + staff->num_chords = 0; + return NULL; + } + + staff->chords[staff->num_chords - 1] = chord; + + return chord; +} + +void +score_remove_chord (score_chord_t *chord) +{ + score_staff_t *staff = chord->staff; + int i; + + for (i = 0; i < staff->num_chords; i++) + if (staff->chords[i] == chord) + break; + + if (i == staff->num_chords) + return; + + if (i < staff->num_chords - 1) + { + memmove (staff->chords + i, + staff->chords + i + 1, + (staff->num_chords - 1 - i) * sizeof (score_chord_t *)); + } + + staff->num_chords -= 1; +} + score_note_t * score_add_note (score_staff_t *staff, score_pitch_t pitch, diff --git a/score.h b/score.h index fe627b8..ea36353 100644 --- a/score.h +++ b/score.h @@ -140,6 +140,14 @@ typedef struct score_note } color; } score_note_t; +typedef struct score_chord +{ + score_staff_t *staff; + + char *name; + double width; +} score_chord_t; + typedef enum score_clef { SCORE_CLEF_G, @@ -191,7 +199,19 @@ score_add_note (score_staff_t *staff, int octave, score_duration_t); -/* Remove the given note from the given staff. */ +/* Add a chord symbol of 'name' to a staff. + * + * For now, the chord symbols are free-form names. + */ +score_chord_t * +score_add_chord (score_staff_t *staff, + const char * name); + +/* Remove the given chord from its staff. */ +void +score_remove_chord (score_chord_t *chord); + +/* Remove the given note from its staff. */ void score_remove_note (score_note_t *note);