rmidid

#!/usr/bin/perl
# vi:set sw=2 ai sm:
# TEST program to shuffle MIDI messages between two Linux boxes
use strict;
use integer;
use JSON;
use MIDI::ALSA(':CONSTS');
use IO::Socket::INET;
use Getopt::Long;
use Time::HiRes;
use Data::Dumper;

use vars qw( $appName );
$appName = 'rmidid';

use vars qw( $from $to );
use vars qw( $verbose_p );
use vars qw( $get_data $send_data );
use vars qw( $port );
use vars qw( $remote_input_p );
$port = 19798;
$remote_input_p = 0;

sub display_help_and_exit (;$) {
  my($st) = @_;
  my $h = $st? *STDERR: *STDOUT;
  print $h <<EOF;
Usage: $appName [OPTION]...
Send and receive MIDI events between ALSA or UDP peers.

  -f, --from=NAME       get MIDI input from ALSA port or network address NAME
  -t, --to=NAME         send MIDI output to ALSA port or network address NAME
  -v, --verbose         display debug messages
      --help            display this help and exit

This is just a test program to make sure communication is possible.
EOF
  exit $st;
}

sub log_something ($$) {
  my($s, $flag) = @_;
  no integer;
  $s =~ s/\n+$//s;
  printf "%10.4f%s\t%s\n", Time::HiRes::time, $flag, $s;
}
sub log_input ($)	{ log_something($_[0], '<') }
sub log_output ($)	{ log_something($_[0], '>') }
sub log_debug ($)	{ log_something($_[0], '#') }

Getopt::Long::Configure('bundling');
$Data::Dumper::Indent = 0;
$Data::Dumper::Terse = 1;

GetOptions(
  'from|f|i=s' => \$from,
  'to|t|o=s' => \$to,
  'verbose|v+' => \$verbose_p,
  'help' => \&display_help_and_exit,
) || exit(1);

MIDI::ALSA::client($appName, 1, 1, 0);

if ($from =~ /^\d+:\d+$/) {
  MIDI::ALSA::connectfrom(0, $from) or die "$appName: $from: Failed to connect\n";
  $get_data = sub {
	my $s = [ MIDI::ALSA::input ];
	log_input Dumper $s if $verbose_p > 1;
	$s;
      };
  log_debug "connected via ALSA to input $from\n" if $verbose_p;

} elsif ($from =~ /^(\d+\.\d+\.\d+\.\d+)(?::(\d+))?$/) {
  my $socket = new IO::Socket::INET(
	LocalAddr => '0.0.0.0',
	LocalPort => $port,
	Proto => 'udp'
      ) or die "$appName: $from: $!\n";

  $get_data = sub {
	my $s;
	my $st = $socket->recv($s, 1024);
	log_input Dumper $s if $verbose_p > 1;
	if (defined $st) {
	  log_debug "recv returned $st" if $verbose_p > 2;
	} else {
	  log_debug "recv failed: $!";
	}
	if (defined $s) {
	  $s = decode_json $s;
	}
	$s;
      };

  $remote_input_p = 1;
  log_debug "connected via UDP to input $from\n" if $verbose_p;

} else {
  die "$appName: $from: Not numeric ALSA client:port or IPv4 address:port\n";
}
if ($to =~ /^(\d+):(\d+)$/) {
  my($to_client, $to_port) = ($1 + 0, $2 + 0);
  my $from_client = MIDI::ALSA::id;
  MIDI::ALSA::connectto(0, $to) or die "$appName: $to: Failed to connect\n";
  $send_data = sub {
	my($s) = @_;
	my($type, $flags, $tag, $queue, $time, $source, $destination, $data) = @$s;
	if ($remote_input_p) {
	  $source = [$from_client, 0];
	  $destination = [$to_client, $to_port];
	}
	log_output Dumper [$type, $flags, $tag, $queue, $time, $source, $destination, $data] if $verbose_p > 1;
	MIDI::ALSA::output($type, $flags, $tag, $queue, $time, $source, $destination, $data);
      };

  log_debug "connected via ALSA to output $to\n" if $verbose_p;

} elsif ($to =~ /^(\d+\.\d+\.\d+\.\d+)(?::(\d+))?$/) {
  my $socket = new IO::Socket::INET(
	LocalPort => $port,
	PeerAddr => $to,
	Proto => 'udp'
      ) or die "$appName: $to: $!\n";

  $send_data = sub {
	my($s) = @_;
	$s = encode_json $s;
	my $st = $socket->send($s);
	log_output Dumper $s if $verbose_p > 1;
	if (defined $st) {
	  log_debug "send returned $st" if $verbose_p > 2;
	} else {
	  log_debug "send failed: $!";
	}
	$st;
      };

  log_debug "connected via UDP to output $to\n" if $verbose_p;

} else {
  die "$appName: $from: Not numeric ALSA client:port or IPv4 address:port\n";
}

for (;;) {
  my $s = &$get_data;
  &$send_data($s);
}