lib/Audio/MPD.pm

   1 #
   2 # This file is part of Audio::MPD
   3 # Copyright (c) 2007-2009 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.6';
  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 #   - host     => $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 C<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 C<Audio::MPD> object is created.
 595
 596 Since mpd is still in 0.x versions, C<Audio::MPD> sticks to latest mpd
 597 (0.14 as time of writing) protocol & behaviour, and does B<not> try to
 598 maintain backward compatibility.
 599
 600 Note that the module will by default connect to mpd before sending any
 601 command, and will disconnect after the command has been issued. This
 602 scheme is far from optimal, but allows us not to care about timeout
 603 disconnections. Because of that, the C<idle> command (new in mpd 0.14)
 604 is B<not> (and will not) be supported in C<Audio::MPD>. This will be
 605 implemented in C<POE::Component::Client::MPD>.
 606
 607 B</!\> Note that C<Audio::MPD> is using high-level, blocking sockets.
 608 This means that if the mpd server is slow, or hangs for whatever reason,
 609 or even crash abruptly, the program will be hung forever in this sub.
 610 The C<POE::Component::Client::MPD> module is way safer - you're advised
 611 to use it instead of C<Audio::MPD>. Or you can try to set C<conntype> to
 612 C<$REUSE> (see C<Audio::MPD> constructor for more details), but you
 613 would be then on your own to deal with disconnections.
 614
 615
 616 =head1 METHODS
 617
 618 =head2 Constructor
 619
 620 =over 4
 621
 622 =item new( [%opts] )
 623
 624 This is the constructor for C<Audio::MPD>. One can specify the following
 625 options:
 626
 627 =over 4
 628
 629 =item host => C<$hostname>
 630
 631 defaults to environment var C<MPD_HOST>, then to 'localhost'. Note that
 632 C<MPD_HOST> can be of the form password@host.
 633
 634 =item port => C<$port>
 635
 636 defaults to environment var C<MPD_PORT>, then to 6600.
 637
 638 =item password => $password
 639
 640 defaults to environment var C<MPD_PASSWORD>, then to ''.
 641
 642 =item conntype => $type
 643
 644 change how the connection to mpd server is handled. It can be either
 645 C<$REUSE> to reuse the same connection or C<$ONCE> to open a new
 646 connection per command (default)
 647
 648 =back
 649
 650
 651 =back
 652
 653
 654 =head2 Controlling the server
 655
 656 =over 4
 657
 658 =item $mpd->ping()
 659
 660 Sends a ping command to the mpd server.
 661
 662
 663 =item $mpd->version()
 664
 665 Return mpd's version number as advertised during connection. Note that
 666 mpd returns B<protocol> version when connected. This protocol version
 667 can differ from the real mpd version. eg, mpd version 0.13.2 is
 668 "speaking" and thus advertising version 0.13.0.
 669
 670
 671
 672 =item $mpd->kill()
 673
 674 Send a message to the MPD server telling it to shut down.
 675
 676
 677 =item $mpd->password( [$password] )
 678
 679 Change password used to communicate with MPD server to C<$password>.
 680 Empty string is assumed if C<$password> is not supplied.
 681
 682
 683 =item $mpd->updatedb( [$path] )
 684
 685 Force mpd to recan its collection. If C<$path> (relative to MPD's music
 686 directory) is supplied, MPD will only scan it - otherwise, MPD will
 687 rescan its whole collection.
 688
 689
 690 =item $mpd->urlhandlers()
 691
 692 Return an array of supported URL schemes.
 693
 694
 695 =back
 696
 697
 698 =head2 Handling volume & output
 699
 700 =over 4
 701
 702 =item $mpd->volume( [+][-]$volume )
 703
 704 Sets the audio output volume percentage to absolute C<$volume>.  If
 705 C<$volume> is prefixed by '+' or '-' then the volume is changed
 706 relatively by that value.
 707
 708
 709 =item $mpd->output_enable( $output )
 710
 711 Enable the specified audio output. C<$output> is the ID of the audio
 712 output.
 713
 714
 715 =item $mpd->output_disable( $output )
 716
 717 Disable the specified audio output. C<$output> is the ID of the audio
 718 output.
 719
 720 =back
 721
 722
 723 =head2 Retrieving info from current state
 724
 725 =over 4
 726
 727 =item $mpd->stats()
 728
 729 Return an C<Audio::MPD::Common::Stats> object with the current statistics
 730 of MPD. See the associated pod for more information.
 731
 732
 733 =item $mpd->status()
 734
 735 Return an C<Audio::MPD::Common::Status> object with various information on
 736 current MPD server settings. Check the embedded pod for more information on
 737 the available accessors.
 738
 739
 740 =item $mpd->current()
 741
 742 Return an C<Audio::MPD::Common::Item::Song> representing the song currently
 743 playing.
 744
 745
 746 =item $mpd->song( [$song] )
 747
 748 Return an C<Audio::MPD::Common::Item::Song> representing the song number
 749 C<$song>. If C<$song> is not supplied, returns the current song.
 750
 751
 752 =item $mpd->songid( [$songid] )
 753
 754 Return an C<Audio::MPD::Common::Item::Song> representing the song with id
 755 C<$songid>. If C<$songid> is not supplied, returns the current song.
 756
 757 =back
 758
 759
 760 =head2 Altering MPD settings
 761
 762 =over 4
 763
 764 =item $mpd->repeat( [$repeat] )
 765
 766 Set the repeat mode to C<$repeat> (1 or 0). If C<$repeat> is not
 767 specified then the repeat mode is toggled.
 768
 769
 770 =item $mpd->random( [$random] )
 771
 772 Set the random mode to C<$random> (1 or 0). If C<$random> is not
 773 specified then the random mode is toggled.
 774
 775
 776 =item $mpd->fade( [$seconds] )
 777
 778 Enable crossfading and set the duration of crossfade between songs.  If
 779 C<$seconds> is not specified or $seconds is 0, then crossfading is
 780 disabled.
 781
 782 =back
 783
 784
 785 =head2 Controlling playback
 786
 787 =over 4
 788
 789 =item $mpd->play( [$song] )
 790
 791 Begin playing playlist at song number C<$song>. If no argument supplied,
 792 resume playing.
 793
 794
 795 =item $mpd->playid( [$songid] )
 796
 797 Begin playing playlist at song ID C<$songid>. If no argument supplied,
 798 resume playing.
 799
 800
 801 =item $mpd->pause( [$state] )
 802
 803 Pause playback. If C<$state> is 0 then the current track is unpaused,
 804 if C<$state> is 1 then the current track is paused.
 805
 806 Note that if C<$state> is not given, pause state will be toggled.
 807
 808
 809 =item $mpd->stop()
 810
 811 Stop playback.
 812
 813
 814 =item $mpd->next()
 815
 816 Play next song in playlist.
 817
 818
 819 =item $mpd->prev()
 820
 821 Play previous song in playlist.
 822
 823
 824 =item $mpd->seek( $time, [$song])
 825
 826 Seek to C<$time> seconds in song number C<$song>. If C<$song> number is
 827 not specified then the perl module will try and seek to C<$time> in the
 828 current song.
 829
 830
 831 =item $mpd->seekid( $time, $songid )
 832
 833 Seek to C<$time> seconds in song ID C<$songid>. If C<$song> number is
 834 not specified then the perl module will try and seek to C<$time> in the
 835 current song.
 836
 837 =back
 838
 839
 840 =head2 Searching the collection
 841
 842 To search the collection, use the C<collection()> accessor, returning the
 843 associated C<Audio::MPD::Collection> object. You will then be able to call:
 844
 845     $mpd->collection->random_song;
 846
 847 See C<Audio::MPD::Collection> documentation for more details on available
 848 methods.
 849
 850
 851 =head2 Handling the playlist
 852
 853 To update the playlist, use the C<playlist()> accessor, returning the
 854 associated C<Audio::MPD::Playlist> object. You will then be able to call:
 855
 856     $mpd->playlist->clear;
 857
 858 See C<Audio::MPD::Playlist> documentation for more details on available
 859 methods.
 860
 861
 862
 863 =head1 BUGS
 864
 865 Please report any bugs or feature requests to
 866 C<bug-audio-mpd@rt.cpan.org>, or through the web interface at
 867 L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Audio-MPD>. I will be
 868 notified, and then you'll automatically be notified of progress on your
 869 bug as I make changes.
 870
 871
 872
 873 =head1 SEE ALSO
 874
 875 You can find more information on the mpd project on its homepage at
 876 L<http://www.musicpd.org>.wikia.com>.
 877
 878 C<Audio::MPD> development takes place on <audio-mpd@googlegroups.com>:
 879 feel free to join us. (use L<http://groups.google.com/group/audio-mpd>
 880 to sign in). Our git repository is located at
 881 L<git://repo.or.cz/audio-mpd.git>, and can be browsed at
 882 L<http://repo.or.cz/w/audio-mpd.git>.
 883
 884
 885 You can also look for information on this module at:
 886
 887 =over 4
 888
 889 =item * AnnoCPAN: Annotated CPAN documentation
 890
 891 L<http://annocpan.org/dist/Audio-MPD>
 892
 893 =item * CPAN Ratings
 894
 895 L<http://cpanratings.perl.org/d/Audio-MPD>
 896
 897 =item * Open bugs
 898
 899 L<http://rt.cpan.org/NoAuth/Bugs.html?Dist=Audio-MPD>
 900
 901 =back
 902
 903
 904
 905 =head1 AUTHOR
 906
 907 Jerome Quelin, C<< <jquelin@cpan.org> >>
 908
 909 Original code by Tue Abrahamsen C<< <tue.abrahamsen@gmail.com> >>,
 910 documented by Nicholas J. Humfrey C<< <njh@aelius.com> >>.
 911
 912
 913 =head1 COPYRIGHT & LICENSE
 914
 915 Copyright (c) 2005 Tue Abrahamsen, all rights reserved.
 916 Copyright (c) 2006 Nicolas J. Humfrey, all rights reserved.
 917 Copyright (c) 2007-2009 Jerome Quelin, all rights reserved.
 918
 919 This program is free software; you can redistribute it and/or modify
 920 it under the same terms as Perl itself.
 921
 922 =cut