piano-randomizer

#!/usr/bin/tcc -run

#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

#define LENGTH(xs) (sizeof(xs)/sizeof((xs)[0]))
typedef unsigned int semitone;

struct mode {
    const char* name;
    semitone offset[7];
    size_t length;
};

// https://en.wikipedia.org/wiki/Musical_mode#Analysis
struct mode modes[] = {
    { .name = "Ionian (I)", .offset = { 0, 2, 4, 5, 7, 9, 11 }, .length = 7 },
    { .name = "Dorian (ii)", .offset = { 0, 2, 3, 5, 7, 9, 10 }, .length = 7 },
    { .name = "Phrygian (iii)", .offset = { 0, 1, 3, 5, 7, 8, 10 }, .length = 7 },
    { .name = "Lydian (IV)", .offset = { 0, 2, 4, 6, 7, 9, 11 }, .length = 7 },
    { .name = "Mixolydian (V)", .offset = { 0, 2, 4, 5, 7, 9, 10 }, .length = 7 },
    { .name = "Aeolian (vi)", .offset = { 0, 2, 3, 5, 7, 8, 10 }, .length = 7 },
    { .name = "Locrian (vii)", .offset = { 0, 1, 3, 5, 6, 8, 10 }, .length = 7 },
    { .name = "Whole tone", .offset = { 0, 2, 4, 6, 8, 10 }, .length = 6 },
    { .name = "Blues (m)", .offset = { 0, 3, 5, 6, 7, 10 }, .length = 6 },
    { .name = "Blues (M)", .offset = { 0, 2, 3, 4, 7, 9 }, .length = 6 },
};

#define PROGRESSION_MAX 10

struct chord {
    const char* name;
    const char* suffix;
    size_t index;
};

struct progression {
    const char* name;
    struct mode* mode;
    struct chord chords[PROGRESSION_MAX];
    size_t length;
};

struct progression progressions[] = {
    {
        .name = NULL,
        .mode = &modes[0],
        .chords = {
            { .name = "ii", .suffix = "m", .index = 1 },
            { .name = "V", .suffix = "7", .index = 4 },
            { .name = "I", .suffix = "", .index = 0 },
        },
        .length = 3,
    },{
        // https://en.wikipedia.org/wiki/%2750s_progression
        .name = "50s",
        .mode = &modes[0],
        .chords = {
            { .name = "vi", .suffix = "m", .index = 5 },
            { .name = "IV", .suffix = "", .index = 3 },
            { .name = "V", .suffix = "7", .index = 4 },
            { .name = "I", .suffix = "", .index = 0 },
        },
        .length = 4,
    },{
        // https://en.wikipedia.org/wiki/I%E2%80%93V%E2%80%93vi%E2%80%93IV_progression#Variations
        .name = NULL,
        .mode = &modes[0],
        .chords = {
            { .name = "vi", .suffix = "m", .index = 5 },
            { .name = "IV", .suffix = "", .index = 3 },
            { .name = "I", .suffix = "", .index = 0 },
            { .name = "V", .suffix = "7", .index = 4 },
        },
        .length = 4,
    },{
        .name = "Andalusian",
        .mode = &modes[2],
        .chords = {
            { .name = "vi", .suffix = "m", .index = 5 },
            { .name = "V", .suffix = "", .index = 4 },
            { .name = "IV", .suffix = "", .index = 3 },
            { .name = "iii", .suffix = "", .index = 2 },
        },
        .length = 4,
    },{
        .name = NULL,
        .mode = &modes[0],
        .chords = {
            { .name = "vi", .suffix = "m", .index = 5 },
            { .name = "ii", .suffix = "m", .index = 1 },
            { .name = "V", .suffix = "7", .index = 4 },
            { .name = "I", .suffix = "", .index = 0 },
        },
        .length = 4,
    },
};

static const char* note_name(semitone t, int sharp)
{
    if(sharp) {
        switch(t % 12) {
        case 0: return "C";
        case 1: return "C#";
        case 2: return "D";
        case 3: return "D#";
        case 4: return "E";
        case 5: return "F";
        case 6: return "F#";
        case 7: return "G";
        case 8: return "G#";
        case 9: return "A";
        case 10: return "A#";
        case 11: return "B";
        }
    } else {
        switch(t % 12) {
        case 0: return "C";
        case 1: return "Db";
        case 2: return "D";
        case 3: return "Eb";
        case 4: return "E";
        case 5: return "F";
        case 6: return "Gb";
        case 7: return "G";
        case 8: return "Ab";
        case 9: return "A";
        case 10: return "Bb";
        case 11: return "B";
        }
    }
}

struct options {
    int interval;
    int random_starting_finger;
    const char* font;
    enum {
        SCALE_MODE = 0,
        PROGRESSION_MODE,
        MAX_MODE,
    } mode;
};

static void run_graphical(const char* this, struct options* o)
{
    char text[1024];
    const char* m = "";
    switch(o->mode) {
    case SCALE_MODE: m = "-s"; break;
    case PROGRESSION_MODE: m = "-p"; break;
    }
    sprintf(text, "${exec %s -c -i %d %s %s}", this,
            o->interval,
            o->random_starting_finger ? "-F" : "",
            m);

    char ints[1024];
    sprintf(ints, "--interval=%u", o->interval);

    if(o->font) {
        execlp("conky", "conky", ints,
               "--quiet",
               "-x", "0", "-y", "0",
               "--text", text,
               "--font", o->font,
               "--alignment=bottom_right",
               NULL);
    } else {
        execlp("conky", "conky", ints,
               "--quiet",
               "-x", "0", "-y", "0",
               "--text", text,
               "--alignment=bottom_right",
               NULL);
    }
}

static int flavor_from_on_key(semitone key)
{
    size_t f = 0;
    for(int t = key; t != 0; t = (t + 5) % 12, f++) ;
    int flavor = f < 5;
    if(f >= 5 && f <= 7) flavor = rand() % 2;
    return flavor;
}

static void run_console(struct options* o)
{
    int mode = o->mode == MAX_MODE ? rand() % MAX_MODE : o->mode;

    semitone base = rand() % 12;
    if(mode == SCALE_MODE) {
        size_t i = rand() % LENGTH(modes);
        struct mode* m = &modes[i];

        semitone key = base + m->offset[(m->length - i) % m->length];
        int flavor = flavor_from_on_key(key);

        printf("%s (%s): ", m->name, note_name(key, flavor));

        if(o->random_starting_finger) {
            printf("(%d) ", rand() % 5 + 1);
        }

        for(size_t i = 0; i < m->length; i++) {
            const char* n = note_name(base + m->offset[i], flavor);
            if(i + 1 == m->length) {
                printf("%s", n);
            } else {
                printf("%s ", n);
            }
        }
    } else if(mode == PROGRESSION_MODE) {
        int flavor = flavor_from_on_key(base);
        struct progression* p = &progressions[rand() % LENGTH(progressions)];

        if(p->name) {
            printf("%s (", p->name);
        }

        for(size_t i = 0; i < p->length; i++) {
            if(i + 1 == p->length) {
                printf("%s", p->chords[i].name);
            } else {
                printf("%s-", p->chords[i].name);
            }
        }

        if(p->name) {
            printf("): ");
        } else {
            printf(": ");
        }

        for(size_t i = 0; i < p->length; i++) {
            const char* n = note_name(
                base + p->mode->offset[p->chords[i].index], flavor);
            if(i + 1 == p->length) {
                printf("%s%s", n, p->chords[i].suffix);
            } else {
                printf("%s%s-", n, p->chords[i].suffix);
            }
        }
    }
    printf("\n");
}

static void print_usage(int fd, const char* prog)
{
    dprintf(fd, "usage: %s [OPTION]...\n", prog);
    dprintf(fd, "\n");
    dprintf(fd, "modes:\n");
    dprintf(fd, "  -s         random modal scales\n");
    dprintf(fd, "  -p         random chord progressions\n");
    dprintf(fd, "\n");
    dprintf(fd, "options:\n");
    dprintf(fd, "  -g         output to X11 (using conky) (default)\n");
    dprintf(fd, "  -c         output to stdout\n");
    dprintf(fd, "  -f FONT    set the font\n");
    dprintf(fd, "  -F         randomize starting finger\n");
    dprintf(fd, "  -h         print this message\n");
}

int main(int argc, char* argv[])
{
    srand(time(NULL));

    int graphical = 1;
    struct options o = {
        .interval = 180,
        .font = NULL,
        .random_starting_finger = 0,
        .mode = MAX_MODE,
    };

    int res;
    while((res = getopt(argc, argv, "hgci:f:Fsp")) != -1) {
        switch(res) {
        case 'g': graphical = 1; break;
        case 'c': graphical = 0; break;
        case 'f': o.font = strdup(optarg); break;
        case 'F': o.random_starting_finger = 1; break;
        case 'i':
            if(sscanf(optarg, "%u", &o.interval) != 1) {
                exit(1);
            }
            break;
        case 's': o.mode = SCALE_MODE; break;
        case 'p': o.mode = PROGRESSION_MODE; break;
        case 'h':
        default:
            print_usage(res == 'h' ? 1 : 2, argv[0]);
            exit(res == 'h' ? 0 : 1);
        }
    }

    if(graphical) {
        run_graphical(argv[0], &o);
    } else {
        run_console(&o);
    }

    return 0;
}