File Coverage

blib/lib/MP3/Daemon/Simple.pm

Criterion	Covered	Total	%
statement	36	242	14.8
branch	0	78	0.0
condition	0	15	0.0
subroutine	12	33	36.3
pod	17	20	85.0
total	65	388	16.7

package MP3::Daemon::Simple;

use strict;
use MP3::Info;
use MP3::Daemon;
use Getopt::Std;
use File::Basename;

use vars qw(@ISA $VERSION);
@ISA     = qw(MP3::Daemon);
$VERSION = 0.11;

# constructor that does NOT daemonize itself
#_______________________________________
sub new {
    my $class = shift;
    my $self  = $class->SUPER::new(@_);

    $self->{playlist} = [ ];    # list of mp3s
    $self->{n}        = undef;  # index into playlist
    $self->{random}   = 0;      # play random songs? or not.
    $self->{loop}     = "all";  # looping behaviour (off|single|all)

    return $self;
}


# valid requests
#_______________________________________
*_play  = \&play;
*_next  = \&next;
*_prev  = \&prev;
*_pause = \&pause;
*_stop  = \&stop;
*_loop  = \&loop;
*_jump  = \&jump;
*_ff    = \&ff;
*_rw    = \&rw;
*_add   = \&add;
*_del   = \&del;
*_ls    = \&ls;
*_info  = \&info;
*_time  = \&time;
*_rand  = \&rand;
*_quit  = \&quit;

# playlist entry indices
#_______________________________________
use constant URL   => 0;
use constant TITLE => 1;
use constant TIME  => 2;

# Audio::Play::MPG123 states
#_______________________________________
use constant STOPPED => 0;
use constant PAUSED  => 1;
use constant PLAYING => 2;

# |>
#_______________________________________
sub play {
    my $self = shift;
    my $x    = shift;
    my $pl   = $self->{playlist};
    my $n    = $self->{n};

    if (defined $x) {
        if ($x =~ /^[-+]?\d+$/) {
            my $end = scalar(@$pl) - 1;
            $x = ($x < 0)    ? $end+1 + $x : $x;
            $x = ($x > $end) ? $end        : $x;
            $self->{n} = $n = $x;
        } else {
            $self->add($x);
            $self->{n} = $n = scalar(@$pl) - 1;
        }
    } else {
        $self->{n} = $n = 0 unless defined($n);
    }
    my $mp3 = $pl->[$n][URL];
    $self->{player}->load($mp3);
    $self->{player}->statfreq(1 / $self->{player}->tpf());
}

# >>
#_______________________________________
sub next {
    my $self = shift;
    if ($self->{random}) { $self->random(); return }
    my $pl   = $self->{playlist};
    my $end  = scalar(@$pl) - 1;
    my $n    = $self->{n};

    my $client = $self->{client};

    if (scalar @$pl) {
	my $loop = $self->{loop};
	if (($loop ne "single") ||
	    ($loop eq "single" && $self->{player}->state == PLAYING))
	{
	    if (not defined $n) {
		$n = 0;
	    } elsif ($n >= $end) {
		$n = 0;
	    } else {
		$n++;
	    }
	}
        $self->{n} = $n;
	if ($loop eq "off") {
	    $self->stop();
	} else {
	    $self->{player}->load($pl->[$n][URL]);
	}
    }
}

# <<
#_______________________________________
sub prev {
    my $self = shift;
    my $pl   = $self->{playlist};
    my $end  = scalar(@$pl) - 1;
    my $n    = $self->{n};

    my $client = $self->{client};

    if (scalar @$pl) {
        if (not defined $n) {
            $n = 0;
        } elsif ($n <= 0) {
            $n = $end;
        } else {
            $n--
        }
        $self->{n} = $n;
        $self->{player}->load($pl->[$n][URL]);
    }
}

# ==
#_______________________________________
sub pause {
    my $self   = shift;
    my $player = $self->{player};
    $player->pause() unless $player->state() == STOPPED;
}

# []
#_______________________________________
sub stop {
    my $self   = shift;
    my $player = $self->{player};
    $player->stop() unless $player->state == STOPPED;
}

# 69
#_______________________________________
sub loop {
    my $self   = shift;
    my $opt    = shift;
    my $client = $self->{client};
    if ($opt) {
	unless (grep { /^$opt$/ } qw(all single off)) {
	    print $client "mp3 loop [all|single|off]\n";
	    return;
	}
	$self->{loop} = $opt;
    }
    print $client "loop $self->{loop}\n";
}

# !!
#_______________________________________
sub jump {
    my $self   = shift;
    my $sec    = shift;
    my $player = $self->{player};
    my $tpf    = $player->tpf;

    $player->jump($sec / $tpf);
}

# ->
#_______________________________________
sub ff {
    my $self   = shift;
    my $sec    = shift;
    my $player = $self->{player};
    my $tpf    = $player->tpf;

    $player->jump("+" . $sec / $tpf);
}

# <-
#_______________________________________
sub rw {
    my $self   = shift;
    my $sec    = shift;
    my $player = $self->{player};
    my $tpf    = $player->tpf;

    $player->jump(-$sec / $tpf);
}

# ++
#_______________________________________
sub add {
    my $self   = shift;
    my $pl     = $self->{playlist};
    my $client = $self->{client};

    foreach (@_) {
        my $tag;
        my $info = get_mp3info($_);
        if (m|^http://|) {
            $info->{TIME} = "00:00";
            $tag->{TITLE} = (fileparse($_, '\..*$'))[0];
        }
        if ($info) {
            $tag ||= get_mp3tag($_);
            $tag->{TITLE} ||= (fileparse($_, '\..*$'))[0];
            my $entry = [
                $_,                     # URL
                $tag->{TITLE},          # TITLE
                $info->{TIME},          # TIME
            ];
            push(@$pl, $entry);
        } else {
            print $client qq("$_" does not seem to be an mp3.\n);
        }
    }
}

# --
#_______________________________________
sub del {
    my $self = shift;
    my $pl   = $self->{playlist};
    my $end  = scalar(@$pl) - 1;
    my $n    = $self->{n};
    my $x    = $n;

    # no parameter deletes current item from list
    push(@_, $n) unless (scalar(@_));

    # delete 1 or more from list
    my @new_playlist;
    my $adjust = 0;
    my %kill =
        map  { $adjust++ if $_ < $n; $_ => 1 }      # create set
        grep { $_ <= $end }                         # check range
        map  { ($_ < 0) ? $_ = $end+1 + $_ : $_ }   # normalize
        grep { /^[-+]?\d+$/ } @_;                   # integers only
    return unless (scalar keys %kill);
    for (my $i = 0; $i <= $end; $i++) {
        push(@new_playlist, $pl->[$i]) unless ($kill{$i});
    }

    # assign new list and prepare to reindex if necessary
    $self->{playlist} = $pl = \@new_playlist;
    $end = scalar(@$pl) - 1;
    my $player = $self->{player};

    # nothing left?
    if ($end < 0) {
        $self->{n} = 0;
        $player->stop if $player->state;
        return;
    }

    # before current track
    if ($adjust) { $n -= $adjust; $self->{n} = $n; }

    # at and after current track
    if (defined $kill{$x}) {
        $n = 0 if ($n > $end);
        $self->{n} = $n;
        $self->{player}->load($pl->[$n][URL]);
    }
}

#_______________________________________
sub ls_short_entry_factory {
    my $attr = shift;
    return sub {
        my $i     = shift;
        my $entry = shift;
        return sprintf('%5s %s', $i, qq("$entry->[$attr]"));
    }
}

#_______________________________________
sub ls_long_entry {
    my $i     = shift;
    my $entry = shift;
    return sprintf(
        '%5s %5s %-30s "%s"',
        $i, $entry->[TIME], qq("$entry->[TITLE]"), $entry->[URL]
    );
}

# @
#_______________________________________
sub ls {
    my $self   = shift;
    my $client = $self->{client};
    my $pl     = $self->{playlist};

    my %opt;
    local @ARGV = @_;
    getopts('lf', \%opt);
    my $re = shift(@ARGV);

    my $attr = defined($opt{f}) ? URL : TITLE;
    my $i;
    my $n = $self->{n};
    my $l = defined($opt{l})
        ? \&ls_long_entry
        :  &ls_short_entry_factory($attr);
    for ($i = 0 ; $i < scalar(@$pl); $i++) {
        defined($re) && do { $pl->[$i][TITLE] =~ /$re/ || next };
        if ($i == $n) {
            $_ = $l->($i, $pl->[$i]);
            s/^ />/;
            print $client "$_\n";
        } else {
            print $client $l->($i, $pl->[$i]), "\n";
        }
    }
}

# i
#_______________________________________
sub info {
    my $self   = shift;
    my $player = $self->{player};
    my $client = $self->{client};
    my $mp3_attribute;
    my @method = qw(
        artist album title year genre url
        type layer bitrate samplerate channels mode mode_extension bpf
        copyrighted error_protected
    );

    my $format = "%-15s | \%s\n";
    foreach $mp3_attribute (@method) {
        printf $client (
            $format, $mp3_attribute, $player->$mp3_attribute()
        );
    }
    printf $client ($format, "state",
        (qw(stopped paused playing))[$player->state()]);
    printf $client ($format, "random", $self->{random});
    printf $client ($format, "loop", $self->{loop});
    $self->time;
}

# $
#_______________________________________
sub time {
    my $self   = shift;
    my $player = $self->{player};
    my $client = $self->{client};
    my $format = "%-15s | \%s\n";

    my $f = $player->{frame};
    printf $client ($format, "elapsed", $f->[2] . " seconds");
    printf $client ($format, "remaining", $f->[3] . " seconds");
    printf $client ($format, "total", $f->[2] + $f->[3] . " seconds");
    printf $client ($format, "track", $self->{n});
}

# ?
#_______________________________________
sub rand {
    my $self    = shift;
    my $client  = $self->{client};
    my $setting = shift || ("on", "off")[$self->{random}];

    if ($setting eq "off") {
        $self->{random} = 0;
        *_next = \&next;
        *_prev = \&prev;
        print $client "random play off\n";
    } elsif ($setting eq "on") {
        $self->{random} = 1;
        *_next = \&random;
        *_prev = \&random;
        print $client "random play on\n";
    } else {
        print $client qq("$setting" is not a valid random state.\n);
    }
}

# *
#_______________________________________
sub random {
    my $self = shift;
    my $pl   = $self->{playlist};
    my $len  = scalar @$pl;
    my $n;

    if ($len) {

        # prevent an mp3 from being played twice in a row
	if ($len == 1) {
	    $n = 0;
	} else {
	    do { $n = int(rand($len)) } until ($n != $self->{n});
	}
        $self->{n} = $n;
        $self->{player}->load($pl->[$n][URL]);
    }
}

# __
#_______________________________________
sub quit {
    my $self = shift;
    unlink($self->{socket_path});
    exit 0;
}

1;

__END__