irc-bot

#!/usr/bin/env perl

# Musical processing IRC bot

# Write-up: https://ology.github.io/2021/03/30/irc-music-bot/

# Sample config (irc-bot.yml):
#
# nick: 'yourbot'
# user: 'Your Name Bot'
# password: 'open-sesame'
# channel: '#yourchan'
# server: 'chat.host.net:6667'
# scp_host: 'foo'
# scp_dir: 'web/docroot/tunes/'
# web_host: 'https://foo.host.net/tunes'
# fretboard: 'https://foo.host.net/frets'
# allowed:
#   - jack
#   - jill

use strict;
use warnings;

use Data::Dumper::Compact qw(ddc);
use Encoding::FixLatin qw(fix_latin);
use List::Util qw(any);
use Mojo::IRC ();
use Mojo::DOM ();
use Mojo::UserAgent ();
use MP3::Tag ();
use Music::Scales qw(get_scale_notes);
use Music::Chord::Namer qw(chordname);
use Music::Chord::Note ();
use Music::Note ();
use Music::Note::Frequency ();
use Parse::IRC ();
use Syntax::Keyword::Try;
use Text::Unidecode qw(unidecode);
use YAML::XS qw(LoadFile);

# App::MusicTools           } Needed for `vov`
# Algorithm::Combinatorics  ⎫
# Math::Factor::XS          ⎬ Needed for local modules
# MIDI::Pitch               ⎪
# Number::Fraction          |
# Text::CSV_XS              |
# strictures                |
# Math::Bezier              ⎪
# File::Slurper             ⎪
# Music::RhythmSet::Util    ⎪
# Math::Random::Discrete    ⎪
# AI::Prolog                ⎭

# Use local author libraries
use if exists $ENV{USER} && $ENV{USER} eq "gene", lib => map { "$ENV{HOME}/sandbox/$_/lib" } qw(MIDI-Chord-Guitar MIDI-Drummer-Tiny MIDI-Util Music-Duration Music-Duration-Partition Music-Intervals Music-ModalFunction);

use MIDI::Chord::Guitar;
use MIDI::Drummer::Tiny;
use MIDI::Util qw(setup_score set_chan_patch midi_format dura_size);
use Music::Duration;
use Music::Duration::Partition;
use Music::Intervals;
use Music::Intervals::Numeric;
use Music::Intervals::Ratios;
use Music::ModalFunction ();

use constant OPTIONS         => { max_width => 256 }; # For ddc()
use constant MIN_BPM         => 60;
use constant DEFAULT_BPM     => 100;
use constant DEFAULT_REPEATS => 2;
use constant MAX_REPEATS     => 8;
use constant MAX_PHRASE      => 8 * 4; # 8 whole-notes

my $conf = LoadFile("$0.yml");

my $irc = Mojo::IRC->new(
  server => $conf->{server},
  nick   => $conf->{nick},
  user   => $conf->{user},
#  pass   => $conf->{password},
#  tls    => {},
);

$irc->parser(Parse::IRC->new(ctcp => 1, public => 1));

$irc->on(irc_join => sub {
  my($self, $message) = @_;
  my $who = parse_nick($message);
  print "SUCCESS: $message->{prefix} joined $message->{params}[0]\n"
    if $who eq $conf->{nick};
});

$irc->on(irc_privmsg => sub {
  my($self, $message) = @_;
  print "$message->{prefix} said: $message->{params}[1]\n";
  my $who = parse_nick($message);
  my $to = [ privmsg => $who ];
#  if (any { $_ eq $who } @{ $conf->{allowed} }) {
    process_msg($to, $who, $message->{params}[1]);
#  }
#  else {
#    $irc->write(@$to, ':Publics only please');
#  }
});

$irc->on(irc_public => sub {
  my($self, $message) = @_;
  # Only act if addressed
  if ($message->{params}[1] =~ /^(\w+)[:,]\s*(.+)$/) {
    my $nick = $1;
    my $msg = $2;
    if ($nick eq $conf->{nick}) {
      print "$message->{prefix} said: $message->{params}[1]\n";
      my $who = parse_nick($message);
      my $to = [ privmsg => $conf->{channel} ];
      process_msg($to, $who, $msg);
    }
  }
});

$irc->connect(sub {
  my($irc, $err) = @_;
  return warn $err if $err;
  $irc->write(join => $conf->{channel});
});

Mojo::IOLoop->start;

sub process_msg {
  my ($to, $who, $msg) = @_;
  my %enharmonic = (
    'C#' => 'Db',
    'D#' => 'Eb',
    'E#' => 'F',
    'F#' => 'Gb',
    'G#' => 'Ab',
    'A#' => 'Bb',
    'B#' => 'C',
  );
  my $imslp = 'https://imslp.org'; # for bwv
  # COMMAND: leave
  if ($msg eq 'leave') {
    $irc->write(QUIT => 'oof');
    exit;
  }
  # COMMAND: help
  elsif ($msg eq 'help') {
    $irc->write(@$to, ':https://ology.github.io/2021/03/30/irc-music-bot/');
  }
  # COMMAND: source
  elsif ($msg eq 'source') {
    $irc->write(@$to, ':https://github.com/ology/Music/blob/master/irc-bot');
  }
  # COMMAND: convert
  elsif ($msg =~ /^convert\s+(.+)$/) {
    my $note = $1;
    my ($from_format, $to_format) = ('ISO', 'midinum');
    if ($note =~ /^\d+$/) {
      ($from_format, $to_format) = ('midinum', 'ISO');
    }
    $note = Music::Note->new($note, $from_format);
    $irc->write(@$to, ":$to_format note: " . $note->format($to_format));
  }
  # COMMAND: patch
  # TODO handle percussion2notenum midi_dump
  elsif ($msg =~ /^patch\s+(\w+)$/) {
    my $arg = $1;
    if ($arg =~ /^\d+$/) {
      my $instrument = '?';
      $instrument = $MIDI::number2patch{$arg} if exists $MIDI::number2patch{$arg};
      $irc->write(@$to, ":Instrument: $instrument");
    }
    else {
      $arg = lc $arg;
      my $instruments = classes();
      my @classes = grep { $instruments->{$_} =~ /$arg/ } sort keys %$instruments;
      my @instruments = grep { lc($_) =~ /$arg/ } sort keys %MIDI::patch2number;
      my @patches = map { $_ . ' [' . $MIDI::patch2number{$_} . ']' } @classes, @instruments;
      my $result = join ', ', @patches;
      $irc->write(@$to, ":Patch: $result");
    }
  }
  # COMMAND: motif
  elsif ($msg =~ /^motif\s+([\d.]+)\s*([a-z ]*)$/) {
    my $size = $1;
    my $pool = $2 ? [split / /, $2] : [qw(hn dqn qn den en sn)];
    my $mdp = Music::Duration::Partition->new(size => $size, pool => $pool);
    my $motif = $mdp->motif;
    my @scale = map { $_ . 4 } get_scale_notes('C');
    my $phrase = [ map { $scale[int rand @scale] . '.' . $_ } @$motif ];
    $phrase = join ' ', @$phrase;
    $phrase =~ s/'//g;
    $phrase =~ s/,//g;
    $irc->write(@$to, ":$size beats: $phrase");
  }
  # COMMAND: play
  elsif ($msg =~ /^play\s+(.+)$/) {
    if (exists $conf->{scp_host}) {
      my $phrase = $1;
      my @phrase = split /\s+/, $phrase;
      my $bpm = DEFAULT_BPM;
      $bpm = shift @phrase if $phrase[0] =~ /^\d+$/;
      my $repeat = DEFAULT_REPEATS;
      $repeat = shift @phrase if $phrase[0] =~ /^\d+$/;
      my $name = sprintf '%s-%s-%d', $who, $0, time();
      my $mid_file = "/tmp/$name.mid";
      my $mp3_file = "/tmp/$name.mp3";
      my $score = setup_score(bpm => $bpm);
      my $cn = Music::Chord::Note->new;
      my $size = 0;
      try {
        for my $i (1 .. $repeat) {
          $size += parse_phrase($score, $cn, \@phrase);
        }
        die "Phrase too large\n" if $size / $repeat > MAX_PHRASE;
        die "Not enough BPM\n" if $bpm < MIN_BPM;
        die "Too many repeats\n" if $repeat > MAX_REPEATS;
        $score->write_score($mid_file);
        my $url = mid2mp3($conf, $name, $mid_file, $mp3_file, $phrase);
        $irc->write(@$to, ":URL: $url");
      }
      catch ($e) {
        $irc->write(@$to, ":Something went wrong: $e");
      }
      unlink $mid_file;
      unlink $mp3_file;
    }
    else {
        $irc->write(@$to, ":Something went wrong: No scp_host");
    }
  }
  # COMMAND: perc
  elsif ($msg =~ /^perc\s+(.+)$/) {
    if (exists $conf->{scp_host}) {
      my $phrase = $1;
      my @phrase = split /\s+/, $phrase;
      my $bpm = DEFAULT_BPM;
      $bpm = shift @phrase if $phrase[0] =~ /^\d+$/;
      my $repeat = DEFAULT_REPEATS;
      $repeat = shift @phrase if $phrase[0] =~ /^\d+$/;
      my $name = sprintf '%s-%s-%d', $who, $0, time();
      my $mid_file = "/tmp/$name.mid";
      my $mp3_file = "/tmp/$name.mp3";
      my $d = MIDI::Drummer::Tiny->new(
          file   => $mid_file,
          bpm    => $bpm,
          reverb => 15,
      );
      my $size = 0;
      try {
        for my $i (1 .. $repeat) {
          $size += parse_drums($d, \@phrase);
        }
        die "Phrase too large\n" if $size / $repeat > MAX_PHRASE;
        die "Not enough BPM\n" if $bpm < MIN_BPM;
        die "Too many repeats\n" if $repeat > MAX_REPEATS;
        $d->write;
        my $url = mid2mp3($conf, $name, $mid_file, $mp3_file, $phrase);
        $irc->write(@$to, ":URL: $url");
      }
      catch ($e) {
        $irc->write(@$to, ":Something went wrong: $e");
      }
      unlink $mid_file;
      unlink $mp3_file;
    }
    else {
        $irc->write(@$to, ":Something went wrong: No scp_host");
    }
  }
  # COMMAND: vov
  elsif ($msg =~ /^vov\s+([\w \/]+)$/) {
    my @args = split /\s+/, $1;
    my @parts;
    for my $arg (@args) {
      my $vov = qx{ vov $arg };
      chomp $vov;
      $vov = uc $vov;
      $vov =~ s/([A-G])IS/$enharmonic{ $1 . '#' }/g
        if $arg =~ /b/;
      $vov =~ s/IS/#/g;
      push @parts, $vov;
    }
    my $flattened = join ' | ', @parts;
    $irc->write(@$to, ":$flattened");
  }
  # COMMAND: chord
  elsif ($msg =~ /^chord\s+(.+)$/) {
    my $arg = $1;
    my @notes = split /\s+/, $arg;
    my $chord = '?';
    eval { $chord = chordname(@notes) };
    $chord =~ s/([A-G]#)(.*)$/$enharmonic{$1}$2/g
      if $arg =~ /b/;
    $chord =~ s/maj/M/;
    $irc->write(@$to, ":Chord: $chord");
  }
  # COMMAND: notes
  elsif ($msg =~ /^notes\s+(.+)$/) {
    my $arg = $1;
    $arg =~ s/maj/M/;
    my $cn = Music::Chord::Note->new;
    my @notes = ();
    eval { @notes = $cn->chord($arg) };
    # A flat request has any sharp notes replaced
    if ($arg =~ /b/) {
      for (@notes) {
        s/^([A-G]#)$/$enharmonic{$1}/;
      }
    }
    # A request that is not sharp, has A# & D# replaced
    elsif ($arg !~ /#/) {
      for (@notes) {
        s/^([AD]#)$/$enharmonic{$1}/;
      }
    }
    push @notes, '?' unless @notes;
    $irc->write(@$to, ":Notes: @notes");
  }
  # COMMAND: freq
  elsif ($msg =~ /^freq\s+(.+?)\s+(\d+)$/) {
    my $freq = $1;
    my $num = $2;
    if ($freq =~ /[A-G]/) {
      my $note = Music::Note::Frequency->new($freq);
      $freq = $note->frequency;
    }
    my $freqs = join ', ', map { sprintf '%.2f', $_ * $freq } 1 .. $num;
    $irc->write(@$to, ":Harmonics: $freqs");
  }
  # COMMAND: interval
  elsif ($msg =~ /^interval\s+(.+)$/) {
    my $arg = $1;
    my @notes = split /\s+/, $arg;
    try {
      my ($mi, $v);
      if ($arg =~ /[A-Za-z]/) {
        $mi = Music::Intervals->new(notes => \@notes);
        $v = $mi->natural_intervals;
      }
      else {
        $mi = Music::Intervals::Numeric->new(notes => \@notes);
        $v = $mi->intervals;
      }
      # Gymnastics :\
      my $flat = ddc($v, OPTIONS);
      $flat =~ s/\n//g;
      $flat =~ s/\s+/ /g;
      $flat =~ s/^{\s*//;
      $flat =~ s/\s*}$//;
      $flat =~ s/ =>/:/g;
      $irc->write(@$to, ":Interval: $flat");
    }
    catch ($e) {
      $irc->write(@$to, ":Something went wrong: $e");
    }
  }
  # COMMAND: ratio
  elsif ($msg =~ /^ratio\s+(.+)$/) {
    my $arg = $1;
    my $res;
    if ($arg =~ /[A-Za-z]/) {
      my $ratio = $Music::Intervals::Ratios::ratio->{$arg};
      $res = "$ratio->{ratio} => $ratio->{name}" if $ratio;
    }
    else {
      my $ratios = {
        map {
          $Music::Intervals::Ratios::ratio->{$_}{ratio} => "$_ => $Music::Intervals::Ratios::ratio->{$_}{name}"
        } keys %$Music::Intervals::Ratios::ratio
      };
      $res = $ratios->{$arg};
    }
    $res = '?' unless $res;
    $irc->write(@$to, ":Ratio: $res");
  }
  # COMMAND: key
  elsif ($msg =~ /^key\s+(.+)$/) {
    my $arg = $1;
    # No fancy computation here
    my %key = (
      '1b'    => 'F',
      '1#'    => 'G',
      '2b'    => 'Bb',
      '2#'    => 'D',
      '3b'    => 'Eb',
      '3#'    => 'A',
      '4b'    => 'Ab',
      '4#'    => 'E',
      '5b 7#' => 'C#/Db', '7# 5b' => 'C#/Db',
      '6b 6#' => 'F#/Gb', '6# 6b' => 'F#/Gb',
      '7b 5#' => 'B/Cb',  '5# 7b' => 'B/Cb',
      # inverted:
      'F'  => '1b',
      'G'  => '1#',
      'Bb' => '2b',
      'D'  => '2#',
      'Eb' => '3b',
      'A'  => '3#',
      'Ab' => '4b',
      'E'  => '4#',
      'C#' => '5b 7#', 'Db' => '5b 7#',
      'F#' => '6b 6#', 'Gb' => '6b 6#',
      'B'  => '7b 5#', 'Cb' => '7b 5#',
    );
    my $key = exists $key{$arg} ? $key{$arg} : '?';
    $irc->write(@$to, ":Key: $key");
  }
  # COMMAND: scale
  elsif ($msg =~ /^scale\s+([A-G][b#]?)\s*(.+)?$/) {
    my $note = $1;
    my $name = $2 || 'major';
    my @scale = get_scale_notes($note, $name);
    $irc->write(@$to, ":Notes: @scale");
  }
  # COMMAND: hit
  elsif ($msg =~ /^hit\s+(\d{8})$/) {
    my $date = $1;
    my $url = 'https://www.umdmusic.com/default.asp?Lang=English&Chart=D&ChDate=' . $date . '&ChMode=N';
    my @lines = get_lines($url, 'table > tr > td:last-child > table > tr');
    my $record;
    for my $line (@lines) {
        next unless $line->[0] =~ /^\d+$/;
        $record = $line;
        last;
    }
    my $hit = $record->[4] ? $record->[4] : '?';
    $irc->write(@$to, ":#1 on $date: $hit");
  }
  # COMMAND: bwv url
  elsif ($msg =~ /^bwv url\s+(.+)$/) {
    my $num = $1;
    $num = unidecode($num);
    my $url = $imslp . '/wiki/List_of_works_by_Johann_Sebastian_Bach';
    my $ua  = Mojo::UserAgent->new;
    my $tx = $ua->get($url);
    my $dom = Mojo::DOM->new($tx->res->body);
    my @data = $dom->find('a[href$="(Bach,_Johann_Sebastian)"]')->each;
    my %bwv;
    for my $link (@data) {
      (my $bwv = $link->attr('href')) =~ s/^.+?_BWV_(.+?)_\(.+$/$1/;
      $bwv{$bwv} = $link->attr('href') unless $bwv =~ /\//;
    }
    my $bwv = exists $bwv{$num} ? "$imslp$bwv{$num}" : '?';
    $irc->write(@$to, ":$bwv");
  }
  # COMMAND: bwv
  elsif ($msg =~ /^bwv\s+(.+)$/) {
    my $num = sprintf '%03s', $1;
    my $url = $imslp . '/wiki/List_of_works_by_Johann_Sebastian_Bach';
    my @lines = get_lines($url, 'table.wikitable tr');
    my %bwv;
    for my $line (@lines) {
        my $bwv = shift @$line;
        $bwv{$bwv} = $line;
    }
    my $bwv = exists $bwv{$num} ? join ', ', @{ $bwv{$num} } : '?';
    $irc->write(@$to, ":$bwv");
  }
  # COMMAND: fret
  elsif ($msg =~ /^fret\s+(\w+)\s+(\d+)$/) {
    if (exists $conf->{fretboard}) {
      my $url = sprintf '%s/%s/%d', $conf->{fretboard}, $1, $2;
      $irc->write(@$to, ":URL: $url");
    }
    else {
        $irc->write(@$to, ":Something went wrong: No fretboard host");
    }
  }
  # COMMAND: fingering
  elsif ($msg =~ /^fingering\s+([A-G][b#]?\d+)\s*(.+)?$/) {
    my $note = $1;
    my $chord = $2 // '';
    my $mcg = MIDI::Chord::Guitar->new(
      # Not needed if module installed:
      voicing_file => "$ENV{HOME}/sandbox/MIDI-Chord-Guitar/share/midi-guitar-chord-voicings.csv"
    );
    my $fingerings;
    my $result;
    eval { $fingerings = $mcg->fingering($note, $chord) };
    if ($@) {
      $result = '?';
    }
    else {
      $result = join ', ', @$fingerings;
    }
    $irc->write(@$to, ":Fingerings: $result");
  }
  # COMMAND: range
  elsif ($msg =~ /^range\s+(\w+)$/) {
    my $instrument = $1;
    # No fancy computation here either
    my %range = (
      violin       => 'G3 - G7',
      viola        => 'C3 - C7',
      cello        => 'C2 - C6',
      bass         => 'C1 - C5',
      trumpet      => 'E3 - C6',
      trombone     => 'E2 - F5',
      french_horn  => 'B1 - F5',
      tuba         => 'D1 - F4',
      piccolo      => 'D5 - B7',
      flute        => 'C4 - D7',
      oboe         => 'B3 - A6',
      clarinet     => 'D3 - A6',
      alto_sax     => 'D3 - A5',
      tenor_sax    => 'A2 - F5',
      baritone_sax => 'D2 - A4',
      bassoon      => 'B1 - D5',
      harp         => 'C2 - F7',
      harpsichord  => 'F1 - F6',
      piano        => 'A0 - B7',
      xylophone    => 'G4 - C7',
      glockenspiel => 'G3 - C6',
      vibraphone   => 'F3 - F6',
      timpani      => 'D2 - C4',
      marimba      => 'C2 - C7',
      guitar       => 'E2 - E6',
    );
    my $range = exists $range{$instrument} ? $range{$instrument} : '?';
    $irc->write(@$to, ":$instrument range: $range");
  }
  # COMMAND: common
  elsif ($msg =~ /^common\s+(\w+)\s+(\w+)$/) {
    my ($mode_note, $mode) = split /[_.-]/, $1;
    my ($key_note, $key)   = split /[_.-]/, $2;
    my $m = Music::ModalFunction->new(
      mode_note    => $mode_note,
      mode         => $mode,
      key_note     => $key_note,
      key          => $key,
      hash_results => 1,
    );
    my $results = $m->pivot_chord_keys;
    my $chords = join ', ', map { $_->{chord_note} . '_' . $_->{chord} } @$results;
    $irc->write(@$to, ":Common chords: $chords");
  }

  # Fallthough
  else {
    $irc->write(@$to, qq|:You said, "$msg" $who|);
  }
}

sub get_lines {
  my ($url, $selector) = @_;
  my $ua  = Mojo::UserAgent->new;
  my $tx = $ua->get($url);
  my $dom = Mojo::DOM->new($tx->res->body);
  my @data = $dom->find($selector)
                 ->map('all_text')
                 ->each;
  my $n = quotemeta('\\n');
  my $r = quotemeta('\\r');
  my $t = quotemeta('\\t');
  my @lines;
  for my $d (@data) {
    $d =~ s/$n//g;
    $d =~ s/$r//g;
    $d =~ s/$t//g;
    my @row = split /[\n\r\t]+/, $d;
    my @partial;
    for my $r (@row) {
      $r =~ s/\s+/ /g;
      $r =~ s/^\s+//;
      $r =~ s/\s+$//;
      next if $r =~ /^\s*$/;
      $r = fix_latin($r);
      push @partial, $r;
    }
    push @lines, \@partial;
  }
  return @lines;
}

sub parse_phrase {
  my ($score, $cn, $phrase) = @_;
  my $size = 0;
  my @chord;
  for my $n (@$phrase) {
    # Patch change
    if ($n =~ /^\^(\d+)$/) {
      set_chan_patch($score, 0, $1);
    }
    # Volume change
    elsif ($n =~ /^~(\d+)$/) {
      $score->Volume($1);
    }
    # Pan change
    elsif ($n =~ /^!(\d+)$/) {
      $score->control_change(0, 10, $1);
    }
    # Named chord
    elsif ($n =~ /^=(.+)$/) {
      my ($chord, $octave, $duration) = split /\./, $1;
      $octave //= 4;
      $duration ||= 'wn';
      $size += dura_size($duration);
      my @notes = $cn->chord_with_octave($chord, $octave);
      @notes = midi_format(@notes);
      $score->n($duration, @notes);
    }
    # Chord start
    elsif ($n =~ /^\(\s*([A-G][b#]?\d+)/) {
      push @chord, $1;
    }
    # Chord end
    elsif ($n =~ /^([A-G][b#]?\d+)\s*\)\.([a-z]n)$/) {
      push @chord, $1;
      @chord = midi_format(@chord);
      $score->n($2, @chord);
      @chord = ();
    }
    # Mid-chord
    elsif (@chord && $n =~ /^([A-G][b#]?\d+)$/) {
      push @chord, $1;
    }
    # Single note/rest
    else {
      my ($pitch, $duration) = split /\./, $n;
      if ($pitch eq 'r' || $pitch eq 'R') {
        $score->r($duration);
      }
      else {
        $size += dura_size($duration);
        $pitch = (midi_format($pitch))[0];
        $score->n($duration, $pitch);
      }
    }
  }
  return $size;
}

sub parse_drums {
  my ($d, $phrase) = @_;
  my %abbrevs = (
    oh => 'open_hh',
    ch => 'closed_hh',
    ph => 'pedal_hh',
    c1 => 'crash1',
    c2 => 'crash2',
    cn => 'china',
    sp => 'splash',
    r1 => 'ride1',
    r2 => 'ride2',
    rb => 'ride_bell',
    sn => 'snare',
    es => 'electric_snare',
    ht => 'hi_tom',
    mt => 'hi_mid_tom',
    ft => 'hi_floor_tom',
    bd => 'kick',
    eb => 'electric_bass',
  );
  my $size = 0;
  my @voices;
  for my $n (@$phrase) {
    # Volume change
    if ($n =~ /^~(\d+)$/) {
      $d->score->Volume($1);
    }
    # Voices start
    elsif ($n =~ /^\(\s*(\w+)/) {
      push @voices, $1;
    }
    # Voices end
    elsif ($n =~ /^(\w+)\s*\)\.([a-z]n)$/) {
      push @voices, $1;
      my $duration = $2;
      $size += dura_size($duration);
      @voices = map { exists $abbrevs{$_} ? $abbrevs{$_} : $_ } @voices;
      @voices = map { $d->$_ } @voices;
      $d->note($duration, @voices);
      @voices = ();
    }
    # Mid-voices
    elsif (@voices && $n =~ /^(\w+)$/) {
      push @voices, $1;
    }
    # Single strike/rest
    else {
      my ($strike, $duration) = split /\./, $n;
      if ($strike eq 'r' || $strike eq 'R') {
        $d->rest($duration);
      }
      else {
        $size += dura_size($duration);
        $strike = $abbrevs{$strike} if exists $abbrevs{$strike};
        $d->note($duration, $d->$strike);
      }
    }
  }
  return $size;
}

sub mid2mp3 {
  my ($conf, $name, $mid_file, $mp3_file, $phrase) = @_;
  my $cmd = "timidity $mid_file -Ow -o - | ffmpeg -i - -acodec libmp3lame -ab 64k $mp3_file";
  system($cmd) == 0
    or die "system($cmd) failed: $?\n";
  my $mp3 = MP3::Tag->new($mp3_file);
  eval { $mp3->update_tags({ comment => $phrase }) };
  $cmd = "scp $mp3_file $conf->{scp_host}:$conf->{scp_dir}"; # Requires a passwordless key
  system($cmd) == 0
    or die "system($cmd) failed: $?\n";
  my $url = sprintf '%s/%s.mp3', $conf->{web_host}, $name;
  return $url;
}

sub parse_nick {
  my ($msg) = @_;
  (my $who = $msg->{prefix}) =~ s/^(.+?)!.*$/$1/;
  return $who;
}

sub classes {
  return {
    Accordion                => 'wind',
    'Acoustic Bass'          => 'bass',
    'Acoustic Grand'         => 'keyboard',
    'Acoustic Guitar(nylon)' => 'string',
    'Acoustic Guitar(steel)' => 'string',
    Agogo                    => 'idiophone',
    'Alto Sax'               => 'brass',
    Applause                 => 'idiophone',
    Bagpipe                  => 'wind',
    Banjo                    => 'string',
    'Baritone Sax'           => 'brass',
    Bassoon                  => 'wind',
    'Bird Tweet'             => 'wind',
    'Blown Bottle'           => 'wind',
    'Brass Section'          => 'brass',
    'Breath Noise'           => 'wind',
    'Bright Acoustic'        => 'keyboard',
    Celesta                  => 'keyboard',
    Cello                    => 'string',
    'Choir Aahs'             => 'voice',
    'Church Organ'           => 'keyboard',
    Clarinet                 => 'wind',
    Clav                     => 'keyboard',
    Contrabass               => 'bass',
    'Distortion Guitar'      => 'string',
    'Drawbar Organ'          => 'keyboard',
    Dulcimer                 => 'string',
    'Electric Bass(finger)'  => 'bass',
    'Electric Bass(pick)'    => 'bass',
    'Electric Grand'         => 'keyboard',
    'Electric Guitar(clean)' => 'string',
    'Electric Guitar(jazz)'  => 'string',
    'Electric Guitar(muted)' => 'string',
    'Electric Piano 1'       => 'keyboard',
    'Electric Piano 2'       => 'keyboard',
    'English Horn'           => 'wind',
    'FX 1 (rain)'            => 'effect',
    'FX 2 (soundtrack)'      => 'effect',
    'FX 3 (crystal)'         => 'effect',
    'FX 4 (atmosphere)'      => 'effect',
    'FX 5 (brightness)'      => 'effect',
    'FX 6 (goblins)'         => 'effect',
    'FX 7 (echoes)'          => 'effect',
    'FX 8 (sci-fi)'          => 'effect',
    Fiddle                   => 'string',
    Flute                    => 'wind',
    'French Horn'            => 'brass',
    'Fretless Bass'          => 'bass',
    Glockenspiel             => 'idiophone',
    'Guitar Fret Noise'      => 'string',
    'Guitar Harmonics'       => 'string',
    Gunshot                  => 'effect',
    Harmonica                => 'wind',
    Harpsichord              => 'keyboard',
    Helicopter               => 'effect',
    'Honky-Tonk'             => 'keyboard',
    Kalimba                  => 'lamellaphone',
    Koto                     => 'string',
    'Lead 1 (square)'        => 'synth',
    'Lead 2 (sawtooth)'      => 'synth',
    'Lead 3 (calliope)'      => 'synth',
    'Lead 4 (chiff)'         => 'synth',
    'Lead 5 (charang)'       => 'synth',
    'Lead 6 (voice)'         => 'voice',
    'Lead 7 (fifths)'        => 'synth',
    'Lead 8 (bass+lead)'     => 'synth',
    Marimba                  => 'idiophone',
    'Melodic Tom'            => 'membranophone',
    'Music Box'              => 'idiophone',
    'Muted Trumpet'          => 'brass',
    Oboe                     => 'wind',
    Ocarina                  => 'wind',
    'Orchestra Hit'          => 'string',
    'Orchestral Strings'     => 'string',
    'Overdriven Guitar'      => 'string',
    'Pad 1 (new age)'        => 'synth',
    'Pad 2 (warm)'           => 'synth',
    'Pad 3 (polysynth)'      => 'synth',
    'Pad 4 (choir)'          => 'synth',
    'Pad 5 (bowed)'          => 'synth',
    'Pad 6 (metallic)'       => 'synth',
    'Pad 7 (halo)'           => 'synth',
    'Pad 8 (sweep)'          => 'synth',
    'Pan Flute'              => 'wind',
    'Percussive Organ'       => 'keyboard',
    Piccolo                  => 'wind',
    'Pizzicato Strings'      => 'string',
    Recorder                 => 'wind',
    'Reed Organ'             => 'keyboard',
    'Reverse Cymbal'         => 'effect',
    'Rock Organ'             => 'keyboard',
    Seashore                 => 'effect',
    Shamisen                 => 'string',
    Shanai                   => 'wind',
    Sitar                    => 'string',
    Skakuhachi               => 'wind',
    'Slap Bass 1'            => 'bass',
    'Slap Bass 2'            => 'bass',
    'Soprano Sax'            => 'brass',
    'Steel Drums'            => 'idiophone',
    'String Ensemble 1'      => 'string',
    'String Ensemble 2'      => 'string',
    'Synth Bass 1'           => 'bass',
    'Synth Bass 2'           => 'bass',
    'Synth Drum'             => 'membranophone',
    'Synth Voice'            => 'voice',
    'SynthBrass 1'           => 'brass',
    'SynthBrass 2'           => 'brass',
    'SynthStrings 1'         => 'string',
    'SynthStrings 2'         => 'string',
    'Taiko Drum'             => 'membranophone',
    'Tango Accordion'        => 'wind',
    'Telephone Ring'         => 'effect',
    'Tenor Sax'              => 'brass',
    Timpani                  => 'membranophone',
    'Tinkle Bell'            => 'idiophone',
    'Tremolo Strings'        => 'string',
    Trombone                 => 'brass',
    Trumpet                  => 'brass',
    Tuba                     => 'brass',
    'Tubular Bells'          => 'idiophone',
    Vibraphone               => 'idiophone',
    Viola                    => 'string',
    Violin                   => 'string',
    'Voice Oohs'             => 'voice',
    Whistle                  => 'wind',
    Woodblock                => 'idiophone',
    Xylophone                => 'idiophone',
  }
}