* 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;
/* 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);
scherzo_t *scherzo = user_data;
int octave;
/* Initialize to keep the compiler quiet. */
- score_pitch_name_t pitch_name = SCORE_PITCH_C;
- score_pitch_t pitch;
+ pitch_name_t pitch_name = PITCH_NATURAL (C);
+ pitch_t pitch;
if (scherzo->challenge.note)
octave = scherzo->challenge.note->octave;
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:
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))
scherzo_t *scherzo = user_data;
int octave;
/* Initialize to keep the compiler quiet. */
- score_pitch_name_t pitch_name = SCORE_PITCH_NAME_C;
- score_pitch_t pitch;
+ pitch_name_t pitch_name = PITCH_NAME_C;
+ pitch_t pitch;
if (scherzo->challenge.note)
octave = scherzo->challenge.note->octave;
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))
}
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;
}
/* 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)
{
if (octave)
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;
}
}
/* 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 (score_pitch_t pitch, score_pitch_t root)
+_pitch_from_root_in_half_steps (pitch_t pitch, pitch_t root)
{
- int root_midi = _score_pitch_and_octave_to_midi (root, 0);
- int pitch_midi = _score_pitch_and_octave_to_midi (pitch, 0);
+ 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;
modified_degree_t *degrees,
int num_degrees,
int inversion,
- score_pitch_t *root)
+ pitch_t *root)
{
#define MAX_DEGREES 6
int relative_pitches[MAX_DEGREES];
}
static const char *
-_pitch_str (score_pitch_t pitch)
+_pitch_str (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𝄪";
+ 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;
}
- fprintf (stderr, "Internal error: Unknown pitch %d\n", pitch);
- exit (1);
+ return ret;
}
typedef struct chord_signature
static void
scherzo_adjust_note_to_match_modified_degree (score_note_t *note,
- score_pitch_t root,
+ pitch_t root,
modified_degree_t *degree)
{
- score_pitch_name_t name = SCORE_PITCH_NAME (note->pitch);
- score_pitch_accidental_t accidental = SCORE_PITCH_ACCIDENTAL (note->pitch);
+ 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 - SCORE_PITCH_NAME (root);
+ int note_degree_zero_based = name - PITCH_NAME (root);
if (note_degree_zero_based < 0)
note_degree_zero_based += 7;
}
if (degree_delta == -1) {
- if (name == SCORE_PITCH_NAME_B) {
- name = SCORE_PITCH_NAME_C;
+ if (name == PITCH_NAME_B) {
+ name = PITCH_NAME_C;
note->octave++;
} else {
name++;
}
switch (name) {
- case SCORE_PITCH_NAME_D:
- case SCORE_PITCH_NAME_E:
- case SCORE_PITCH_NAME_G:
- case SCORE_PITCH_NAME_A:
- case SCORE_PITCH_NAME_B:
+ case PITCH_NAME_D:
+ case PITCH_NAME_E:
+ case PITCH_NAME_G:
+ case PITCH_NAME_A:
+ case PITCH_NAME_B:
accidental -= 2;
break;
- case SCORE_PITCH_NAME_C:
- case SCORE_PITCH_NAME_F:
+ case PITCH_NAME_C:
+ case PITCH_NAME_F:
accidental -= 1;
break;
}
}
if (degree_delta == +1) {
- if (name == SCORE_PITCH_NAME_C) {
- name = SCORE_PITCH_NAME_B;
+ if (name == PITCH_NAME_C) {
+ name = PITCH_NAME_B;
note->octave--;
} else {
name--;
}
switch (name) {
- case SCORE_PITCH_NAME_C:
- case SCORE_PITCH_NAME_D:
- case SCORE_PITCH_NAME_F:
- case SCORE_PITCH_NAME_G:
- case SCORE_PITCH_NAME_A:
+ case PITCH_NAME_C:
+ case PITCH_NAME_D:
+ case PITCH_NAME_F:
+ case PITCH_NAME_G:
+ case PITCH_NAME_A:
accidental += 2;
break;
- case SCORE_PITCH_NAME_E:
- case SCORE_PITCH_NAME_B:
+ case PITCH_NAME_E:
+ case PITCH_NAME_B:
accidental += 1;
}
}
- if (accidental < 0 || accidental > SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP) {
+ 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 = SCORE_PITCH (name, accidental);
+ note->pitch = PITCH (name, accidental);
}
static void
_spell_chord_by_signature (note_group_t *chord,
int num_notes,
chord_signature_t *signature,
- score_pitch_t root)
+ 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 = _score_pitch_and_octave_to_midi (root, 0);
- _midi_to_score_pitch_and_octave (root_midi, &root, NULL);
+ 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,
note_group_t *note_group;
unsigned i, j, num_notes;
int bass_pitch, inversion;
- score_pitch_t root;
+ pitch_t root;
chord_signature_t *match = NULL;
char *chord_name;
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;
_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);
}
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;
}
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 = _score_pitch_and_octave_to_midi (pitch, octave);
+ 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];
- note_midi = _score_pitch_and_octave_to_midi (note->pitch, note->octave);
+ note_midi = _pitch_and_octave_to_midi (note->pitch, note->octave);
if (note_midi == target_midi) {
found = 1;
if (! scherzo->pedal_pressed)
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);
}
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);
}
bool_t introduced_unused;
item_t *item;
challenge_t *challenge = &scherzo->challenge;
- score_pitch_t pitch;
+ pitch_t pitch;
int octave;
char *s;
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);
/* 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);