lib/Audio/MPD.pm

   1 #
   2 # This file is part of Audio::MPD
   3 # Copyright (c) 2007 Jerome Quelin, all rights reserved.
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the same terms as Perl itself.
   7 #
   8 #
   9
  10 package Audio::MPD;
  11
  12 use warnings;
  13 use strict;
  14
  15 use Audio::MPD::Collection;
  16 use Audio::MPD::Common::Item;
  17 use Audio::MPD::Common::Stats;
  18 use Audio::MPD::Common::Status;
  19 use Audio::MPD::Playlist;
  20 use Encode;
  21 use IO::Socket;
  22 use Readonly;
  23
  24
  25 use base qw[ Class::Accessor::Fast Exporter ];
  26 __PACKAGE__->mk_accessors(
  27     qw[ _conntype _host _password _port _socket
  28         collection playlist version ] );
  29
  30
  31 our $VERSION = '0.19.2';
  32
  33 Readonly our $REUSE => 0;
  34 Readonly our $ONCE  => 1;
  35
  36 our @EXPORT = qw[ $REUSE $ONCE ];
  37
  38
  39 #--
  40 # Constructor
  41
  42 #
  43 # my $mpd = Audio::MPD->new( [%opts] )
  44 #
  45 # This is the constructor for Audio::MPD. One can specify the following
  46 # options:
  47 #   - hostname => $hostname : defaults to environment var MPD_HOST, then to 'localhost'
  48 #   - port     => $port     : defaults to env var MPD_PORT, then to 6600
  49 #   - password => $password : defaults to env var MPD_PASSWORD, then to ''
  50 #   - conntype => $type     : how the connection to mpd server is handled. it can be
  51 #               either $REUSE: reuse the same connection
  52 #                    or $ONCE: open a new connection per command (default)
  53 #
  54 sub new {
  55     my ($class, %opts) = @_;
  56
  57     # use mpd defaults.
  58     my ($default_password, $default_host) = split( '@', $ENV{MPD_HOST} )
  59        if exists $ENV{MPD_HOST} && $ENV{MPD_HOST} =~ /@/;
  60     my $host     = $opts{host}     || $default_host      || $ENV{MPD_HOST} || 'localhost';
  61     my $port     = $opts{port}     || $ENV{MPD_PORT}     || '6600';
  62     my $password = $opts{password} || $ENV{MPD_PASSWORD} || $default_password || '';
  63
  64     # create & bless the object.
  65     my $self = {
  66         _host     => $host,
  67         _port     => $port,
  68         _password => $password,
  69         _conntype => exists $opts{conntype} ? $opts{conntype} : $ONCE,
  70     };
  71     bless $self, $class;
  72
  73     # create the connection if conntype is set to $REUSE
  74     $self->_connect_to_mpd_server if $self->_conntype == $REUSE;
  75
  76
  77     # create the helper objects and store them.
  78     $self->collection( Audio::MPD::Collection->new($self) );
  79     $self->playlist  ( Audio::MPD::Playlist->new($self) );
  80
  81     # try to issue a ping to test connection - this can die.
  82     $self->ping;
  83
  84     return $self;
  85 }
  86
  87
  88 #--
  89 # Private methods
  90
  91
  92 #
  93 # $mpd->_connect_to_mpd_server;
  94 #
  95 # This method connects to the mpd server. It can die on several conditions:
  96 #  - if the server cannot be reached,
  97 #  - if it's not an mpd server,
  98 #  - or if the password is incorrect,
  99 #
 100 sub _connect_to_mpd_server {
 101     my ($self) = @_;
 102
 103     # try to connect to mpd.
 104     my $socket = IO::Socket::INET->new(
 105         PeerAddr => $self->_host,
 106         PeerPort => $self->_port,
 107     )
 108     or die "Could not create socket: $!\n";
 109
 110     # parse version information.
 111     my $line = $socket->getline;
 112     chomp $line;
 113     die "Not a mpd server - welcome string was: [$line]\n"
 114         if $line !~ /^OK MPD (.+)$/;
 115     $self->version($1);
 116
 117     # send password.
 118     if ( $self->_password ) {
 119         $socket->print( 'password ' . encode('utf-8', $self->_password) . "\n" );
 120         $line = $socket->getline;
 121         die $line if $line =~ s/^ACK //;
 122     }
 123
 124     # save socket
 125     $self->_socket($socket);
 126 }
 127
 128
 129 #
 130 # my @result = $mpd->_send_command( $command );
 131 #
 132 # This method is central to the module. It is responsible for interacting with
 133 # mpd by sending the $command and reading output - that will be returned as an
 134 # array of chomped lines (status line will not be returned).
 135 #
 136 # This method can die on several conditions:
 137 #  - if the server cannot be reached,
 138 #  - if it's not an mpd server,
 139 #  - if the password is incorrect,
 140 #  - or if the command is an invalid mpd command.
 141 # In the latter case, the mpd error message will be returned.
 142 #
 143 sub _send_command {
 144     my ($self, $command) = @_;
 145
 146     $self->_connect_to_mpd_server if $self->_conntype == $ONCE;
 147     my $socket = $self->_socket;
 148
 149     # ok, now we're connected - let's issue the command.
 150     $socket->print( encode('utf-8', $command) );
 151     my @output;
 152     while (defined ( my $line = $socket->getline ) ) {
 153         chomp $line;
 154         die $line if $line =~ s/^ACK //; # oops - error.
 155         last if $line =~ /^OK/;          # end of output.
 156         push @output, decode('utf-8', $line);
 157     }
 158
 159     # close the socket.
 160     $socket->close if $self->_conntype == $ONCE;
 161
 162     return @output;
 163 }
 164
 165
 166 #
 167 # my @items = $mpd->_cooked_command_as_items( $command );
 168 #
 169 # Lots of Audio::MPD methods are using _send_command() and then parse the
 170 # output as a collection of AMC::Item. This method is meant to factorize
 171 # this code, and will parse the raw output of _send_command() in a cooked
 172 # list of items.
 173 #
 174 sub _cooked_command_as_items {
 175     my ($self, $command) = @_;
 176
 177     my @lines = $self->_send_command($command);
 178     my (@items, %param);
 179
 180     # parse lines in reverse order since "file:" or "directory:" lines
 181     # come first. therefore, let's first store every other parameter,
 182     # and the last line will trigger the object creation.
 183     # of course, since we want to preserve the playlist order, this means
 184     # that we're going to unshift the objects instead of push.
 185     foreach my $line (reverse @lines) {
 186         my ($k,$v) = split /:\s/, $line, 2;
 187         $param{$k} = $v;
 188         next unless $k eq 'file' || $k eq 'directory' || $k eq 'playlist'; # last param of item
 189         unshift @items, Audio::MPD::Common::Item->new(%param);
 190         %param = ();
 191     }
 192
 193     return @items;
 194 }
 195
 196
 197 #
 198 # my %hash = $mpd->_cooked_command_as_kv( $command );
 199 #
 200 # Lots of Audio::MPD methods are using _send_command() and then parse the
 201 # output to get a list of key / value (with the colon ":" acting as separator).
 202 # This method is meant to factorize this code, and will parse the raw output
 203 # of _send_command() in a cooked hash.
 204 #
 205 sub _cooked_command_as_kv {
 206     my ($self, $command) = @_;
 207     my %hash =
 208         map { split(/:\s/, $_, 2) }
 209         $self->_send_command($command);
 210     return %hash;
 211 }
 212
 213 #
 214 # my @list = $mpd->_cooked_command_strip_first_field( $command );
 215 #
 216 # Lots of Audio::MPD methods are using _send_command() and then parse the
 217 # output to remove the first field (with the colon ":" acting as separator).
 218 # This method is meant to factorize this code, and will parse the raw output
 219 # of _send_command() in a cooked list of strings.
 220 #
 221 sub _cooked_command_strip_first_field {
 222     my ($self, $command) = @_;
 223
 224     my @list =
 225         map { ( split(/:\s+/, $_, 2) )[1] }
 226         $self->_send_command($command);
 227     return @list;
 228 }
 229
 230
 231 #--
 232 # Public methods
 233
 234 # -- MPD interaction: general commands
 235
 236 #
 237 # $mpd->ping;
 238 #
 239 # Sends a ping command to the mpd server.
 240 #
 241 sub ping {
 242     my ($self) = @_;
 243     $self->_send_command( "ping\n" );
 244 }
 245
 246
 247 #
 248 # my $version = $mpd->version;
 249 #
 250 # Return version of MPD server's connected.
 251 #
 252 # sub version {} # implemented as an accessor.
 253 #
 254
 255
 256 #
 257 # $mpd->kill;
 258 #
 259 # Send a message to the MPD server telling it to shut down.
 260 #
 261 sub kill {
 262     my ($self) = @_;
 263     $self->_send_command("kill\n");
 264 }
 265
 266
 267 #
 268 # $mpd->password( [$password] )
 269 #
 270 # Change password used to communicate with MPD server to $password.
 271 # Empty string is assumed if $password is not supplied.
 272 #
 273 sub password {
 274     my ($self, $passwd) = @_;
 275     $passwd ||= '';
 276     $self->_password($passwd);
 277     $self->ping; # ping sends a command, and thus the password is sent
 278 }
 279
 280
 281 #
 282 # $mpd->updatedb( [$path] );
 283 #
 284 # Force mpd to rescan its collection. If $path (relative to MPD's music
 285 # directory) is supplied, MPD will only scan it - otherwise, MPD will rescan
 286 # its whole collection.
 287 #
 288 sub updatedb {
 289     my ($self, $path) = @_;
 290     $path ||= '';
 291     $self->_send_command("update $path\n");
 292 }
 293
 294
 295 #
 296 # my @handlers = $mpd->urlhandlers;
 297 #
 298 # Return an array of supported URL schemes.
 299 #
 300 sub urlhandlers {
 301     my ($self) = @_;
 302     return $self->_cooked_command_strip_first_field("urlhandlers\n");
 303 }
 304
 305
 306 # -- MPD interaction: handling volume & output
 307
 308 #
 309 # $mpd->volume( [+][-]$volume );
 310 #
 311 # Sets the audio output volume percentage to absolute $volume.
 312 # If $volume is prefixed by '+' or '-' then the volume is changed relatively
 313 # by that value.
 314 #
 315 sub volume {
 316     my ($self, $volume) = @_;
 317
 318     if ($volume =~ /^(-|\+)(\d+)/ )  {
 319         my $current = $self->status->volume;
 320         $volume = $1 eq '+' ? $current + $2 : $current - $2;
 321     }
 322     $self->_send_command("setvol $volume\n");
 323 }
 324
 325
 326 #
 327 # $mpd->output_enable( $output );
 328 #
 329 # Enable the specified audio output. $output is the ID of the audio output.
 330 #
 331 sub output_enable {
 332     my ($self, $output) = @_;
 333     $self->_send_command("enableoutput $output\n");
 334 }
 335
 336
 337 #
 338 # $mpd->output_disable( $output );
 339 #
 340 # Disable the specified audio output. $output is the ID of the audio output.
 341 #
 342 sub output_disable {
 343     my ($self, $output) = @_;
 344     $self->_send_command("disableoutput $output\n");
 345 }
 346
 347
 348
 349 # -- MPD interaction: retrieving info from current state
 350
 351 #
 352 # $mpd->stats;
 353 #
 354 # Return an AMC::Stats object with the current statistics of MPD.
 355 #
 356 sub stats {
 357     my ($self) = @_;
 358     my %kv = $self->_cooked_command_as_kv( "stats\n" );
 359     return Audio::MPD::Common::Stats->new(\%kv);
 360 }
 361
 362
 363 #
 364 # my $status = $mpd->status;
 365 #
 366 # Return an AMC::Status object with various information on current
 367 # MPD server settings. Check the embedded pod for more information on the
 368 # available accessors.
 369 #
 370 sub status {
 371     my ($self) = @_;
 372     my %kv = $self->_cooked_command_as_kv( "status\n" );
 373     my $status = Audio::MPD::Common::Status->new( \%kv );
 374     return $status;
 375 }
 376
 377
 378 #
 379 # my $song = $mpd->current;
 380 #
 381 # Return an AMC::Item::Song representing the song currently playing.
 382 #
 383 sub current {
 384     my ($self) = @_;
 385     my ($item) = $self->_cooked_command_as_items("currentsong\n");
 386     return $item;
 387 }
 388
 389
 390 #
 391 # my $song = $mpd->song( [$song] )
 392 #
 393 # Return an AMC::Item::Song representing the song number $song.
 394 # If $song is not supplied, returns the current song.
 395 #
 396 sub song {
 397     my ($self, $song) = @_;
 398     return $self->current unless defined $song;
 399     my ($item) = $self->_cooked_command_as_items("playlistinfo $song\n");
 400     return $item;
 401 }
 402
 403
 404 #
 405 # my $song = $mpd->songid( [$songid] )
 406 #
 407 # Return an AMC::Item::Song representing the song with id $songid.
 408 # If $songid is not supplied, returns the current song.
 409 #
 410 sub songid {
 411     my ($self, $songid) = @_;
 412     return $self->current unless defined $songid;
 413     my ($item) = $self->_cooked_command_as_items("playlistid $songid\n");
 414     return $item;
 415 }
 416
 417
 418 # -- MPD interaction: altering settings
 419
 420 #
 421 # $mpd->repeat( [$repeat] );
 422 #
 423 # Set the repeat mode to $repeat (1 or 0). If $repeat is not specified then
 424 # the repeat mode is toggled.
 425 #
 426 sub repeat {
 427     my ($self, $mode) = @_;
 428
 429     $mode = not $self->status->repeat
 430         unless defined $mode; # toggle if no param
 431     $mode = $mode ? 1 : 0;               # force integer
 432     $self->_send_command("repeat $mode\n");
 433 }
 434
 435
 436 #
 437 # $mpd->random( [$random] );
 438 #
 439 # Set the random mode to $random (1 or 0). If $random is not specified then
 440 # the random mode is toggled.
 441 #
 442 sub random {
 443     my ($self, $mode) = @_;
 444
 445     $mode = not $self->status->random
 446         unless defined $mode; # toggle if no param
 447     $mode = $mode ? 1 : 0;               # force integer
 448     $self->_send_command("random $mode\n");
 449 }
 450
 451
 452 #
 453 # $mpd->fade( [$seconds] );
 454 #
 455 # Enable crossfading and set the duration of crossfade between songs. If
 456 # $seconds is not specified or $seconds is 0, then crossfading is disabled.
 457 #
 458 sub fade {
 459     my ($self, $value) = @_;
 460     $value ||= 0;
 461     $self->_send_command("crossfade $value\n");
 462 }
 463
 464
 465 # -- MPD interaction: controlling playback
 466
 467 #
 468 # $mpd->play( [$song] );
 469 #
 470 # Begin playing playlist at song number $song. If no argument supplied,
 471 # resume playing.
 472 #
 473 sub play {
 474     my ($self, $number) = @_;
 475     $number = '' unless defined $number;
 476     $self->_send_command("play $number\n");
 477 }
 478
 479 #
 480 # $mpd->playid( [$songid] );
 481 #
 482 # Begin playing playlist at song ID $songid. If no argument supplied,
 483 # resume playing.
 484 #
 485 sub playid {
 486     my ($self, $number) = @_;
 487     $number ||= '';
 488     $self->_send_command("playid $number\n");
 489 }
 490
 491
 492 #
 493 # $mpd->pause( [$sate] );
 494 #
 495 # Pause playback. If $state is 0 then the current track is unpaused, if
 496 # $state is 1 then the current track is paused.
 497 #
 498 # Note that if $state is not given, pause state will be toggled.
 499 #
 500 sub pause {
 501     my ($self, $state) = @_;
 502     $state ||= ''; # default is to toggle
 503     $self->_send_command("pause $state\n");
 504 }
 505
 506
 507 #
 508 # $mpd->stop;
 509 #
 510 # Stop playback.
 511 #
 512 sub stop {
 513     my ($self) = @_;
 514     $self->_send_command("stop\n");
 515 }
 516
 517
 518 #
 519 # $mpd->next;
 520 #
 521 # Play next song in playlist.
 522 #
 523 sub next {
 524     my ($self) = @_;
 525     $self->_send_command("next\n");
 526 }
 527
 528 #
 529 # $mpd->prev;
 530 #
 531 # Play previous song in playlist.
 532 #
 533 sub prev {
 534     my($self) = shift;
 535     $self->_send_command("previous\n");
 536 }
 537
 538
 539 #
 540 # $mpd->seek( $time, [$song] );
 541 #
 542 # Seek to $time seconds in song number $song. If $song number is not specified
 543 # then the perl module will try and seek to $time in the current song.
 544 #
 545 sub seek {
 546     my ($self, $time, $song) = @_;
 547     $time ||= 0; $time = int $time;
 548     $song = $self->status->song if not defined $song; # seek in current song
 549     $self->_send_command( "seek $song $time\n" );
 550 }
 551
 552
 553 #
 554 # $mpd->seekid( $time, [$songid] );
 555 #
 556 # Seek to $time seconds in song ID $songid. If $songid number is not specified
 557 # then the perl module will try and seek to $time in the current song.
 558 #
 559 sub seekid {
 560     my ($self, $time, $song) = @_;
 561     $time ||= 0; $time = int $time;
 562     $song = $self->status->songid if not defined $song; # seek in current song
 563     $self->_send_command( "seekid $song $time\n" );
 564 }
 565
 566
 567 1;
 568
 569
 570
 571 __END__
 572
 573 =pod
 574
 575 =head1 NAME
 576
 577 Audio::MPD - class to talk to MPD (Music Player Daemon) servers
 578
 579
 580 =head1 SYNOPSIS
 581
 582     use Audio::MPD;
 583
 584     my $mpd = Audio::MPD->new();
 585     $mpd->play();
 586     sleep 10;
 587     $mpd->next();
 588
 589
 590 =head1 DESCRIPTION
 591
 592 Audio::MPD gives a clear object-oriented interface for talking to and
 593 controlling MPD (Music Player Daemon) servers. A connection to the MPD
 594 server is established as soon as a new Audio::MPD object is created.
 595
 596 Note that the module will by default connect to mpd before sending any
 597 command, and will disconnect after the command has been issued. This scheme
 598 is far from optimal, but allows us not to care about timeout disconnections.
 599
 600 B</!\> Note that Audio::MPD is using high-level, blocking sockets. This
 601 means that if the mpd server is slow, or hangs for whatever reason, or
 602 even crash abruptly, the program will be hung forever in this sub. The
 603 POE::Component::Client::MPD module is way safer - you're advised to use
 604 it instead of Audio::MPD. Or you can try to set C<conntype> to C<$REUSE>
 605 (see Audio::MPD constructor for more details), but you would be then on
 606 your own to deal with disconnections.
 607
 608
 609 =head1 METHODS
 610
 611 =head2 Constructor
 612
 613 =over 4
 614
 615 =item new( [%opts] )
 616
 617 This is the constructor for Audio::MPD. One can specify the following
 618 options:
 619
 620 =over 4
 621
 622 =item hostname => C<$hostname>
 623
 624 defaults to environment var MPD_HOST, then to 'localhost'. Note that
 625 MPD_HOST can be of the form password@host.
 626
 627 =item port => C<$port>
 628
 629 defaults to environment var MPD_PORT, then to 6600.
 630
 631 =item password => $password
 632
 633 defaults to environment var MPD_PASSWORD, then to ''.
 634
 635 =item conntype => $type
 636
 637 change how the connection to mpd server is handled. It can be either
 638 C<$REUSE> to reuse the same connection or C<$ONCE> to open a new
 639 connection per command (default)
 640
 641 =back
 642
 643
 644 =back
 645
 646
 647 =head2 Controlling the server
 648
 649 =over 4
 650
 651 =item $mpd->ping()
 652
 653 Sends a ping command to the mpd server.
 654
 655
 656 =item $mpd->version()
 657
 658 Return the version number for the server we are connected to.
 659
 660
 661 =item $mpd->kill()
 662
 663 Send a message to the MPD server telling it to shut down.
 664
 665
 666 =item $mpd->password( [$password] )
 667
 668 Change password used to communicate with MPD server to $password.
 669 Empty string is assumed if $password is not supplied.
 670
 671
 672 =item $mpd->updatedb( [$path] )
 673
 674 Force mpd to recan its collection. If $path (relative to MPD's music directory)
 675 is supplied, MPD will only scan it - otherwise, MPD will rescan its whole
 676 collection.
 677
 678
 679 =item $mpd->urlhandlers()
 680
 681 Return an array of supported URL schemes.
 682
 683
 684 =back
 685
 686
 687 =head2 Handling volume & output
 688
 689 =over 4
 690
 691 =item $mpd->volume( [+][-]$volume )
 692
 693 Sets the audio output volume percentage to absolute $volume.
 694 If $volume is prefixed by '+' or '-' then the volume is changed relatively
 695 by that value.
 696
 697
 698 =item $mpd->output_enable( $output )
 699
 700 Enable the specified audio output. $output is the ID of the audio output.
 701
 702
 703 =item $mpd->output_disable( $output )
 704
 705 Disable the specified audio output. $output is the ID of the audio output.
 706
 707 =back
 708
 709
 710 =head2 Retrieving info from current state
 711
 712 =over 4
 713
 714 =item $mpd->stats()
 715
 716 Return an C<Audio::MPD::Common::Stats> object with the current statistics
 717 of MPD. See the associated pod for more information.
 718
 719
 720 =item $mpd->status()
 721
 722 Return an C<Audio::MPD::Common::Status> object with various information on
 723 current MPD server settings. Check the embedded pod for more information on
 724 the available accessors.
 725
 726
 727 =item $mpd->current()
 728
 729 Return an C<Audio::MPD::Common::Item::Song> representing the song currently
 730 playing.
 731
 732
 733 =item $mpd->song( [$song] )
 734
 735 Return an C<Audio::MPD::Common::Item::Song> representing the song number
 736 C<$song>. If C<$song> is not supplied, returns the current song.
 737
 738
 739 =item $mpd->songid( [$songid] )
 740
 741 Return an C<Audio::MPD::Common::Item::Song> representing the song with id
 742 C<$songid>. If C<$songid> is not supplied, returns the current song.
 743
 744 =back
 745
 746
 747 =head2 Altering MPD settings
 748
 749 =over 4
 750
 751 =item $mpd->repeat( [$repeat] )
 752
 753 Set the repeat mode to $repeat (1 or 0). If $repeat is not specified then
 754 the repeat mode is toggled.
 755
 756
 757 =item $mpd->random( [$random] )
 758
 759 Set the random mode to $random (1 or 0). If $random is not specified then
 760 the random mode is toggled.
 761
 762
 763 =item $mpd->fade( [$seconds] )
 764
 765 Enable crossfading and set the duration of crossfade between songs.
 766 If $seconds is not specified or $seconds is 0, then crossfading is disabled.
 767
 768 =back
 769
 770
 771 =head2 Controlling playback
 772
 773 =over 4
 774
 775 =item $mpd->play( [$song] )
 776
 777 Begin playing playlist at song number $song. If no argument supplied,
 778 resume playing.
 779
 780
 781 =item $mpd->playid( [$songid] )
 782
 783 Begin playing playlist at song ID $songid. If no argument supplied,
 784 resume playing.
 785
 786
 787 =item $mpd->pause( [$state] )
 788
 789 Pause playback. If C<$state> is 0 then the current track is unpaused,
 790 if $state is 1 then the current track is paused.
 791
 792 Note that if C<$state> is not given, pause state will be toggled.
 793
 794
 795 =item $mpd->stop()
 796
 797 Stop playback.
 798
 799
 800 =item $mpd->next()
 801
 802 Play next song in playlist.
 803
 804
 805 =item $mpd->prev()
 806
 807 Play previous song in playlist.
 808
 809
 810 =item $mpd->seek( $time, [$song])
 811
 812 Seek to $time seconds in song number $song. If $song number is not specified
 813 then the perl module will try and seek to $time in the current song.
 814
 815
 816 =item $mpd->seekid( $time, $songid )
 817
 818 Seek to $time seconds in song ID $songid. If $song number is not specified
 819 then the perl module will try and seek to $time in the current song.
 820
 821 =back
 822
 823
 824 =head2 Searching the collection
 825
 826 To search the collection, use the C<collection()> accessor, returning the
 827 associated C<Audio::MPD::Collection> object. You will then be able to call:
 828
 829     $mpd->collection->random_song();
 830
 831 See C<Audio::MPD::Collection> documentation for more details on available
 832 methods.
 833
 834
 835 =head2 Handling the playlist
 836
 837 To update the playlist, use the C<playlist()> accessor, returning the
 838 associated C<Audio::MPD::Playlist> object. You will then be able to call:
 839
 840     $mpd->playlist->clear;
 841
 842 See C<Audio::MPD::Playlist> documentation for more details on available
 843 methods.
 844
 845
 846 =head1 SEE ALSO
 847
 848 You can find more information on the mpd project on its homepage at
 849 L<http://www.musicpd.org>, or its wiki L<http://mpd.wikia.com>.
 850
 851 Regarding this Perl module, you can report bugs on CPAN via
 852 L<http://rt.cpan.org/Public/Bug/Report.html?Queue=Audio-MPD>.
 853
 854 Audio::MPD development takes place on <audio-mpd@googlegroups.com>: feel free
 855 to join us. (use L<http://groups.google.com/group/audio-mpd> to sign in). Our
 856 subversion repository is located at L<https://svn.musicpd.org>.
 857
 858
 859 =head1 AUTHOR
 860
 861 Jerome Quelin, C<< <jquelin at cpan.org> >>
 862
 863 Original code by Tue Abrahamsen C<< <tue.abrahamsen at gmail.com> >>,
 864 documented by Nicholas J. Humfrey C<< <njh at aelius.com> >>.
 865
 866
 867 =head1 COPYRIGHT & LICENSE
 868
 869 Copyright (c) 2005 Tue Abrahamsen, all rights reserved.
 870 Copyright (c) 2006 Nicolas J. Humfrey, all rights reserved.
 871 Copyright (c) 2007 Jerome Quelin, all rights reserved.
 872
 873 This program is free software; you can redistribute it and/or modify
 874 it under the same terms as Perl itself.
 875
 876 =cut