File Coverage

blib/lib/Audio/AMaMP.pm

Criterion	Covered	Total	%
statement	9	53	16.9
branch	0	22	0.0
condition	0	9	0.0
subroutine	3	10	30.0
pod	7	7	100.0
total	19	101	18.8

package Audio::AMaMP;

use 5.6.0;
use strict;
use warnings;

require Exporter;

our @ISA = qw(Exporter);

our @EXPORT = qw();

our $VERSION = '0.3';

require XSLoader;
XSLoader::load('Audio::AMaMP', $VERSION);


# Constructor.
sub new {
	return bless {}, shift;
}


# This starts the core.  Essentially OO-wraps the C function.
sub startCore {
	# Get input parameters and check.
	my ($self, $corePath, $inputFile) = @_;
	return 0 unless $self && $corePath && $inputFile;

	# Now attempt to invoke the core.
	my $core = amampStartCore($corePath, $inputFile);
	if ($core) {
		# Success. Stash core object and return true.
		$self->{'core'} = $core;
		return 1;
	} else {
		# Failure.  Return false.
		return 0;
	}
}


# Gets a message in plain text. Essentially wraps the C function.
sub getRawMessage {
	# Get input.
	my ($self, $block) = @_;
	return undef unless $self;
	$block = 0+$block;

	# Attempt to call amampGetRawMessage and return what it gives.
	return amampGetRawMessage($self->{'core'}, $block);
}


# Sends a plain text message. Essentially wraps the C function.
sub sendRawMessage {
	# Get input.
	my ($self, $message) = @_;
	return 0 unless $message;

	# Attempt to call amampSendRawMessage and return what it gives.
	return amampSendRawMessage($self->{'core'}, $message);
}


# Sends a message arranged in a hash structure.
sub sendMessage {
	# Get input.
	my ($self, %input) = @_;
	return unless $input{'type'} && $input{'parameters'};

	# Construct message.
	my $message = "$input{'type'}:\n";
	for (keys %{$input{'parameters'}}) {
		$message .= "\t$_: $input{'parameters'}->{$_}\n";
	}
	$message .= "\n";

	# Attempt to send message.
	return $self->sendRawMessage($message);
}


# Gets a message and parses it into a hash based data structure.
sub getMessage {
	# Get input.
	my ($self, $block) = @_;
	return unless $self;

	# Get message.
	my $rawMessage = $self->getRawMessage($block);
	return () unless $rawMessage;

	# Parse.
	my $foundType = 0;
	my $line;
	my %message = ();
	my %params = ();
	foreach $line (split(/\n/, $rawMessage)) {
		if ($foundType) {
			# Should be a parameter.
			if ($line =~ /^\t([\w_\-]{1,30}): (.+)$/) {
				$params{$1} = $2;
			} elsif ($line ne '') {
				# Parse error.
				return ();
			}
		} else {
			# Should be type line.
			if ($line =~ /^([\w_\-]{1,30}):$/) {
				$message{'type'} = $1;
				$foundType = 1;
			} else {
				# Parse error.
				return ();
			}
		}
	}

	# Return message structure.
	$message{'parameters'} = \%params;
	return %message;
}


# This sub checks if the core is still alive/available.
sub isCoreAlive {
	# Just call C function to check.
	my ($self) = @_;
	return amampIsCoreAlive($self->{'core'});
}

1;
__END__