#!/usr/bin/env perl
# primal - generate notes at periodic intervals, the original being the
# prime numbers 3 5 7 11 13 at some arbitrary pitch for each interval.
use 5.36.0;
use MIDI;

my $out_file = shift // 'out.midi';

my @beats = qw( 3  5  7 11 13);
my @pitch = qw(69 75 79 70 74);

# How long to go on for; this might be some number of beats over some
# number of measures (e.g. 64) or a least common multiple of the beats.
my $max_beat = 3466;

my $channel  = 0;     # MIDI channel
my $duration = 60;    # minimum MIDI dtime

# From the ##forth IRC chat:
#   < soweli_iki> they aren't primes, but you should try 8-12-15-18-20
#                 sometime as well
if (1) {
    @beats = qw( 8 12 15 18 20);
    # For better "mathcore" points we might map the beats to the pitches
    # (or even a frequency) by some scheme, e.g. by ratio or here to
    # modulate into the 12-tone pitch set, with an adjustment.
    #   $ perl -E 'say for map { 60 + $_ % 12 } qw(8 12 15 18 20)'
    #   ...
    #   $ atonal-util basic 68 60 63 66 80
    #   c,d,f,aes
    #   012111
    #   4-27    Dominant seventh chord
    #   c,ees,ges,aes   half_prime
    @pitch = qw(68 60 63 66 80);
    # The duration usually will need to be pretty long to hear "enough"
    # of the pattern variations, and might be automatically scaled by a
    # least common multiple, unless that value gets too large, unless
    # you're into that sort of thing.
    $max_beat = 1024;
    # This will likely need to be fiddled with depending on the
    # beats involved.
    $duration = 14;
}

my $beat = 0;
while ( $beat < $max_beat ) {
    my @active;
    for my $i ( 0 .. $#beats ) {
        $active[$i] = $pitch[$i] if $beat % $beats[$i] == 0;
    }
    sound( $beat, $duration, @active ) if @active;
    $beat++;
}

generate_midi();

{
    my @last_beat;      # when did the last note_on for the pitch fire?
    my @trackevents;    # array references of MIDI events for each pitch

    sub generate_midi {
        my $o = MIDI::Opus->new(
            {   format => 1,    # assume multiple tracks
                ticks  => 96,
                tracks =>
                  [ map { MIDI::Track->new( { events => $_ } ) } @trackevents ]
            }
        );
        $o->write_to_file($out_file);
    }

    # Generate pitch-to-a-unique-track note events with appropriate
    # dtime values.
    sub sound ( $beat, $dtime, @pitches ) {
        for my $i ( 0 .. $#pitches ) {
            next unless defined $pitches[$i];
            my $previous = $last_beat[$i];
            my $now      = $beat * $dtime;
            # Start the MIDI events relative to the first note that sounds.
            unless ( defined $previous ) {
                $previous  = $now;
                @last_beat = ($now) x @last_beat;
            }
            my $offset = $now - $previous;
            push @{ $trackevents[$i] },
              [ note_on  => $offset, $channel, $pitches[$i], velocity() ],
              [ note_off => $dtime,  $channel, $pitches[$i], 0 ];
            # Advance plus dtime due to the note_off consuming a beat.
            # To hold the note for longer one would need more dtime with
            # the note_off, at the risk of running into or beyond the
            # next note_on for the pitch.
            $last_beat[$i] = $now + $dtime;
        }
    }

    # Humanize the loudness a little. Other options here would be to
    # impose some rhythmic pattern based on 4/4 or whatever time, or at
    # some period based on the interval the pitch sounds at (e.g. hit
    # harder every third note for 3, every 5th note for 5, etc). Or the
    # velocity could have a global adjustment based on a sine wave
    # unique to each beat, etc.
    sub velocity { 80 + int( rand 6 + rand 6 + rand 6 ) }
}