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