%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
/* vim:set softtabstop=4 shiftwidth=4 expandtab: */
/*
* mpd.class.php - PHP Object Interface to the MPD Music Player Daemon
* Version 1.3
*
* Copyright (C) 2003-2004 Benjamin Carlisle (bcarlisle@24oz.com)
* Copyright 2010 Paul Arthur MacIain
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
class mpd {
// Command names
// Status queries
const COMMAND_CLEARERROR = 'clearerror';
const COMMAND_CURRENTSONG = 'currentsong';
const COMMAND_IDLE = 'idle';
const COMMAND_STATUS = 'status';
const COMMAND_STATISTICS = 'stats';
// Playback options
const COMMAND_CONSUME = 'consume';
const COMMAND_CROSSFADE = 'crossfade';
const COMMAND_RANDOM = 'random';
const COMMAND_REPEAT = 'repeat';
const COMMAND_SETVOL = 'setvol';
const COMMAND_SINGLE = 'single';
const COMMAND_REPLAY_GAIN_MODE = 'replay_gain_mode';
const COMMAND_REPLAY_GAIN_STATUS = 'replay_gain_status';
// Playback control
const COMMAND_NEXT = 'next';
const COMMAND_PAUSE = 'pause';
const COMMAND_PLAY = 'play';
const COMMAND_PLAYID = 'playid';
const COMMAND_PREVIOUS = 'previous';
const COMMAND_SEEK = 'seek';
const COMMAND_SEEKID = 'seekid';
const COMMAND_STOP = 'stop';
// Current playlist control
const COMMAND_ADD = 'add';
const COMMAND_ADDID = 'addid';
const COMMAND_CLEAR = 'clear';
const COMMAND_DELETE = 'delete';
const COMMAND_DELETEID = 'deleteid';
const COMMAND_MOVETRACK = 'move';
const COMMAND_MOVEID = 'moveid';
const COMMAND_PLFIND = 'playlistfind';
const COMMAND_PLID = 'playlistid';
const COMMAND_PLINFO = 'playlistinfo';
const COMMAND_PLSEARCH = 'playlistsearch';
const COMMAND_PLCHANGES = 'plchanges';
const COMMAND_PLCHANGESPOSID = 'plchangesposid';
const COMMAND_PLSHUFFLE = 'shuffle';
const COMMAND_PLSWAPTRACK = 'swap';
const COMMAND_PLSWAPID = 'swapid';
// Stored playlists
const COMMAND_LISTPL = 'listplaylist';
const COMMAND_LISTPLINFO = 'listplaylistinfo';
const COMMAND_LISTPLAYLISTS = 'listplaylists';
const COMMAND_PLLOAD = 'load';
const COMMAND_PLADD = 'playlistadd';
const COMMAND_PLCLEAR = 'playlistclear';
const COMMAND_PLDELETE = 'playlistdelete';
const COMMAND_PLMOVE = 'playlistmove';
const COMMAND_RENAME = 'rename';
const COMMAND_RM = 'rm';
const COMMAND_PLSAVE = 'save';
// Music database
const COMMAND_COUNT = 'count';
const COMMAND_FIND = 'find';
const COMMAND_FINDADD = 'findadd';
const COMMAND_TABLE = 'list';
const COMMAND_LISTALL = 'listall';
const COMMAND_LISTALLINFO = 'listallinfo';
const COMMAND_LSDIR = 'lsinfo';
const COMMAND_SEARCH = 'search';
const COMMAND_REFRESH = 'update';
const COMMAND_RESCAN = 'rescan';
// Stickers
const COMMAND_STICKER = 'sticker';
const STICKER_GET = 'get';
const STICKER_SET = 'set';
const STICKER_DELETE = 'delete';
const STICKER_LIST = 'list';
const STICKER_FIND = 'find';
// Connection
const COMMAND_CLOSE = 'close';
const COMMAND_KILL = 'kill';
const COMMAND_PASSWORD = 'password';
const COMMAND_PING = 'ping';
// Deprecated commands
const COMMAND_VOLUME = 'volume';
// Bulk commands
const COMMAND_START_BULK = 'command_list_begin';
const COMMAND_END_BULK = 'command_list_end';
// Predefined MPD Response messages
const RESPONSE_ERR = 'ACK';
const RESPONSE_OK = 'OK';
// MPD State Constants
const STATE_PLAYING = 'play';
const STATE_STOPPED = 'stop';
const STATE_PAUSED = 'pause';
// MPD Searching Constants
const SEARCH_ARTIST = 'artist';
const SEARCH_TITLE = 'title';
const SEARCH_ALBUM = 'album';
// MPD Cache Tables
const TABLE_ARTIST = 'artist';
const TABLE_ALBUM = 'album';
// Table holding version compatibility information
private static $_COMPATIBILITY_TABLE = array(
self::COMMAND_CONSUME => array('min' => '0.15.0', 'max' => false),
self::COMMAND_IDLE => array('min' => '0.14.0', 'max' => false),
self::COMMAND_PASSWORD => array('min' => '0.10.0', 'max' => false),
self::COMMAND_MOVETRACK => array('min' => '0.9.1', 'max' => false),
self::COMMAND_PLSWAPTRACK => array('min' => '0.9.1', 'max' => false),
self::COMMAND_RANDOM => array('min' => '0.9.1', 'max' => false),
self::COMMAND_SEEK => array('min' => '0.9.1', 'max' => false),
self::COMMAND_SETVOL => array('min' => '0.10.0', 'max' => false),
self::COMMAND_SINGLE => array('min' => '0.15.0', 'max' => false),
self::COMMAND_STICKER => array('min' => '0.15.0', 'max' => false),
self::COMMAND_VOLUME => array('min' => false, 'max' => '0.10.0')
);
// TCP/Connection variables
private $host;
private $port;
private $password;
private $_mpd_sock = null;
public $connected = false;
// MPD Status variables
public $mpd_version = "(unknown)";
public $stats;
public $status;
public $playlist;
// Misc Other Vars
public $mpd_class_version = '1.3';
public $err_str = ''; // Stores the latest error message
private $_command_queue; // The list of commands for bulk command sending
private $_debug_callback = null; // Optional callback to be run on debug
public $debugging = false;
/* Constructor
* Builds the MPD object, connects to the server, and refreshes all
* local object properties.
*/
public function __construct($server, $port, $password = null, $debug_callback = null) {
$this->host = $server;
$this->port = $port;
$this->password = $password;
if (is_callable($debug_callback)) {
$this->_debug_callback = $debug_callback;
}
$this->_debug('construct', 'constructor called', 5);
$response = $this->Connect();
if (!$response) {
$this->_error('Could not connect');
return false;
}
$version = sscanf($response, self::RESPONSE_OK . " MPD %s\n");
$this->mpd_version = $version[0];
if ($password) {
if (!$this->SendCommand(self::COMMAND_PASSWORD, $password, false)) {
$this->connected = false;
$this->_error('construct', 'Password supplied is incorrect or Invalid Command');
return false; // bad password or command
}
} // if password
else {
if (!$this->RefreshInfo()) {
// no read access, might as well be disconnected
$this->connected = false;
if ($password) {
$this->_error('construct', 'Password supplied does not have read access');
}
else {
$this->_error('construct', 'Password required to access server');
}
return false;
}
}
return true;
} // constructor
/* Connect
*
* Connects to the MPD server.
*
* NOTE: This is called automatically upon object instantiation; you
* should not need to call this directly.
*/
public function Connect() {
$this->_debug('Connect', "host: " . $this->host . ", port: " . $this->port, 5);
$this->_mpd_sock = fsockopen($this->host, $this->port, $err, $err_str, 6);
// Vollmerize this bizatch
/* Set the timeout on the connection */
stream_set_timeout($this->_mpd_sock, 6);
/* We want blocking, cause otherwise it doesn't
* timeout, and feof just keeps on spinning
*/
stream_set_blocking($this->_mpd_sock,true);
$status = socket_get_status($this->_mpd_sock);
if (!$this->_mpd_sock) {
$this->_error('Connect', "Socket Error: $err_str ($err)");
return false;
}
else {
while(!feof($this->_mpd_sock) && !$status['timed_out']) {
$response = fgets($this->_mpd_sock,1024);
if (function_exists('socket_get_status')) {
$status = socket_get_status($this->_mpd_sock);
}
if (strncmp(self::RESPONSE_OK, $response, strlen(self::RESPONSE_OK)) == 0) {
$this->connected = true;
return $response;
break;
}
if (strncmp(self::RESPONSE_ERR,$response,strlen(self::RESPONSE_ERR)) == 0) {
$this->_error('Connect', "Server responded with: $response");
return false;
}
} // end while
// Generic response
$this->_error('Connect', "Connection not available");
return false;
}
} // connect
/* SendCommand
*
* Sends a generic command to the MPD server. Several command constants
* are pre-defined for use (see self::COMMAND_* constant definitions
* above).
*/
public function SendCommand($command, $arguments = null, $refresh_info = true) {
$this->_debug('SendCommand', "cmd: $command, args: " . json_encode($arguments), 5);
if ( ! $this->connected ) {
$this->_error('SendCommand', 'Not connected', 1);
return false;
}
else {
$response_string = '';
// Check the command compatibility:
if ( ! self::_checkCompatibility($command, $this->mpd_version) ) {
return false;
}
if (isset($arguments)) {
if (is_array($arguments)) {
foreach ($arguments as $arg) {
$command .= ' "' . $arg . '"';
}
}
else {
$command .= ' "' . $arguments . '"';
}
}
fputs($this->_mpd_sock,"$command\n");
while(!feof($this->_mpd_sock)) {
$response = fgets($this->_mpd_sock, 1024);
// An OK signals the end of transmission
if (strncmp(self::RESPONSE_OK, $response, strlen(self::RESPONSE_OK)) == 0) {
break;
}
// An ERR signals an error!
if (strncmp(self::RESPONSE_ERR, $response, strlen(self::RESPONSE_ERR)) == 0) {
$this->_error('SendCommand', "MPD Error: $response");
return false;
}
// Build the response string
$response_string .= $response;
}
$this->_debug('SendCommand', "response: $response_string" , 5);
}
if ($refresh_info) {
$this->RefreshInfo();
}
return $response_string ? $response_string : true;
}
/* QueueCommand
*
* Queues a generic command for later sending to the MPD server. The
* CommandQueue can hold as many commands as needed, and are sent all
* at once, in the order they were queued, using the SendCommandQueue
* method. The syntax for queueing commands is identical to SendCommand.
*/
public function QueueCommand($command, $arguments = '') {
$this->_debug('QueueCommand', "start; cmd: $command args: " . json_encode($arguments), 5);
if ( ! $this->connected ) {
$this->_error('QueueCommand', 'Not connected');
return false;
}
if (!$this->_command_queue) {
$this->_command_queue = self::COMMAND_START_BULK . "\n";
}
if ($arguments) {
if (is_array($arguments)) {
foreach ($arguments as $arg) {
$command .= ' "' . $arg . '"';
}
}
else {
$command .= ' "' . $arguments . '"';
}
}
$this->_command_queue .= $command . "\n";
$this->_debug('QueueCommand', 'return', 5);
return true;
}
/* SendCommandQueue
*
* Sends all commands in the Command Queue to the MPD server.
*/
public function SendCommandQueue() {
$this->_debug('SendCommandQueue', 'start', 5);
if ( ! $this->connected ) {
_error('SendCommandQueue', 'Not connected');
return false;
}
$this->_command_queue .= self::COMMAND_END_BULK . "\n";
$response = $this->SendCommand($this->_command_queue);
if ($response) {
$this->_command_queue = null;
}
$this->_debug('SendCommandQueue', "response: $response", 5);
return $response;
}
/* RefreshInfo
*
* Updates all class properties with the values from the MPD server.
* NOTE: This function is automatically called on Connect()
*/
public function RefreshInfo() {
$stats = $this->SendCommand(self::COMMAND_STATISTICS, null, false);
$status = $this->SendCommand(self::COMMAND_STATUS, null, false);
if (!$stats || !$status) {
return false;
}
$stats = self::_parseResponse($stats);
$status = self::_parseResponse($status);
$this->stats = $stats;
$this->status = $status;
// Get the Playlist
$playlist = $this->SendCommand(self::COMMAND_PLINFO, null, false);
$this->playlist = self::_parseFileListResponse($playlist);
return true;
}
/* AdjustVolume
*
* Adjusts the mixer volume on the MPD by <value>, which can be a
* positive (volume increase) or negative (volume decrease) value.
*/
public function AdjustVolume($value) {
$this->_debug('AdjustVolume', 'start', 5);
if ( ! is_numeric($value) ) {
$this->_error('AdjustVolume', "argument must be numeric: $value");
return false;
}
$this->RefreshInfo();
$value = $this->status['volume'] + $value;
$response = $this->SetVolume($value);
$this->_debug('AdjustVolume', "return $response", 5);
return $response;
}
/* SetVolume
*
* Sets the mixer volume to <value>, which should be between 1 - 100.
*/
public function SetVolume($value) {
$this->_debug('SetVolume', 'start', 5);
if (!is_numeric($value)) {
$this->_error('SetVolume', "argument must be numeric: $value");
return false;
}
// Forcibly prevent out of range errors
$value = $value > 0 ? $value : 0;
$value = $value < 100 ? $value : 100;
// If we're not compatible with SETVOL, we'll try adjusting
// using VOLUME
if (self::_checkCompatibility(self::COMMAND_SETVOL, $this->mpd_version)) {
$command = self::COMMAND_SETVOL;
}
else {
$this->RefreshInfo(); // Get the latest volume
if (is_null($this->status['volume'])) {
return false;
}
else {
$command = self::COMMAND_VOLUME;
$value = $value - $this->status['volume'];
}
}
$response = $this->SendCommand($command, $value);
$this->_debug('SetVolume', "return: $response", 5);
return $response;
}
/* GetDir
*
* Retrieves a database directory listing of the <dir> directory and
* places the results into a multidimensional array. If no directory is
* specified the directory listing is at the base of the MPD music path.
*/
public function GetDir($dir = '') {
$this->_debug('GetDir', 'start', 5);
$response = $this->SendCommand(self::COMMAND_LSDIR, $dir, false);
$dirlist = self::_parseFileListResponse($response);
$this->_debug('GetDir', 'return: ' . json_encode($dirlist), 5);
return $dirlist;
}
/* PLAdd
*
* Adds each track listed in a single-dimensional <trackArray>, which
* contains filenames of tracks to add to the end of the playlist. This
* is used to add many, many tracks to the playlist in one swoop.
*/
public function PLAddBulk($trackArray) {
$this->_debug('PLAddBulk', 'start', 5);
$num_files = count($trackArray);
for ( $i = 0; $i < $num_files; $i++ ) {
$this->QueueCommand(self::COMMAND_ADD, $trackArray[$i]);
}
$response = $this->SendCommandQueue();
$this->_debug('PLAddBulk', "return: $response", 5);
return $response;
}
/* PLAdd
*
* Adds the file <file> to the end of the playlist. <file> must be a
* track in the MPD database.
*/
public function PLAdd($filename) {
$this->_debug('PLAdd', 'start', 5);
$response = $this->SendCommand(self::COMMAND_ADD, $filename);
$this->_debug('PLAdd', "return: $response", 5);
return $response;
}
/* PLMoveTrack
*
* Moves track number <current_position> to position <new_position> in
* the playlist. This is used to reorder the songs in the playlist.
*/
public function PLMoveTrack($current_position, $new_position) {
$this->_debug('PLMoveTrack', 'start', 5);
if (!is_numeric($current_position)) {
$this->_error('PLMoveTrack', "current_position must be numeric: $current_position");
return false;
}
if ($current_position < 0 || $current_position > count($this->playlist)) {
$this->_error('PLMoveTrack', "current_position out of range");
return false;
}
$new_position = $new_position > 0 ? $new_position : 0;
$new_position = $new_position < count($this->playlist)
? $new_position
: count($this->playlist);
$response = $this->SendCommand(self::COMMAND_MOVETRACK, array($current_position, $new_position));
$this->_debug('PLMoveTrack', "return: $response", 5);
return $response;
}
/* PLShuffle
*
* Randomly reorders the songs in the playlist.
*/
public function PLShuffle() {
$this->_debug('PLShuffle', 'start', 5);
$response = $this->SendCommand(self::COMMAND_PLSHUFFLE);
$this->_debug('PLShuffle', "return: $response", 5);
return $response;
}
/* PLLoad
*
* Retrieves the playlist from <file>.m3u and loads it into the current
* playlist.
*/
public function PLLoad($file) {
$this->_debug('PLLoad', 'start', 5);
$response = $this->SendCommand(self::COMMAND_PLLOAD, $file);
$this->_debug('PLLoad', "return: $response", 5);
return $response;
}
/* PLSave
*
* Saves the playlist to <file>.m3u for later retrieval. The file is
* saved in the MPD playlist directory.
*/
public function PLSave($file) {
$this->_debug('PLSave', 'start', 5);
$response = $this->SendCommand(self::COMMAND_PLSAVE, $file, false);
$this->_debug('PLSave', "return: $response", 5);
return $response;
}
/* PLClear
*
* Empties the playlist.
*/
public function PLClear() {
$this->_debug('PLClear', 'start', 5);
$response = $this->SendCommand(self::COMMAND_CLEAR);
$this->_debug('PLClear', "return: $response", 5);
return $response;
}
/* PLRemove
*
* Removes track <id> from the playlist.
*/
public function PLRemove($id) {
if ( ! is_numeric($id) ) {
$this->_error('PLRemove', "id must be numeric: $id");
return false;
}
$response = $this->SendCommand(self::COMMAND_DELETE, $id);
$this->_debug('PLRemove', "return: $response", 5);
return $response;
} // PLRemove
/* SetRepeat
*
* Enables 'loop' mode -- tells MPD continually loop the playlist. The
* <repVal> parameter is either 1 (on) or 0 (off).
*/
public function SetRepeat($value) {
$this->_debug('SetRepeat', 'start', 5);
$value = $value ? 1 : 0;
$response = $this->SendCommand(self::COMMAND_REPEAT, $value);
$this->_debug('SetRepeat', "return: $response", 5);
return $response;
}
/* SetRandom
*
* Enables 'randomize' mode -- tells MPD to play songs in the playlist
* in random order. The parameter is either 1 (on) or 0 (off).
*/
public function SetRandom($value) {
$this->_debug('SetRandom', 'start', 5);
$value = $value ? 1 : 0;
$response = $this->SendCommand(self::COMMAND_RANDOM, $value);
$this->_debug('SetRandom', "return: $response", 5);
return $response;
}
/* Shutdown
*
* Shuts down the MPD server (aka sends the KILL command). This closes
* the current connection and prevents future communication with the
* server.
*/
public function Shutdown() {
$this->_debug('Shutdown', 'start', 5);
$response = $this->SendCommand(self::COMMAND_SHUTDOWN);
$this->connected = false;
unset($this->mpd_version);
unset($this->err_str);
unset($this->_mpd_sock);
$this->_debug('Shutdown', "return: $response", 5);
return $response;
}
/* DBRefresh
*
* Tells MPD to rescan the music directory for new tracks and refresh
* the Database. Tracks cannot be played unless they are in the MPD
* database.
*/
public function DBRefresh() {
$this->_debug('DBRefresh', 'start', 5);
$response = $this->SendCommand(self::COMMAND_REFRESH);
$this->_debug('DBRefresh', "return: $response", 5);
return $response;
}
/* Play
*
* Begins playing the songs in the MPD playlist.
*/
public function Play() {
$this->_debug('Play', 'start', 5);
$response = $this->SendCommand(self::COMMAND_PLAY);
$this->_debug('Play', "return: $response", 5);
return $response;
}
/* Stop
*
* Stops playback.
*/
public function Stop() {
$this->_debug('Stop', 'start', 5);
$response = $this->SendCommand(self::COMMAND_STOP);
$this->_debug('Stop', "return: $response", 5);
return $response;
}
/* Pause
*
* Toggles pausing.
*/
public function Pause() {
$this->_debug('Pause', 'start', 5);
$response = $this->SendCommand(self::COMMAND_PAUSE);
$this->_debug('Pause', "return: $response", 5);
return $response;
}
/* SeekTo
*
* Skips directly to the <idx> song in the MPD playlist.
*/
public function SkipTo($idx) {
$this->_debug('SkipTo', 'start', 5);
if ( ! is_numeric($idx) ) {
$this->_error('SkipTo', "argument must be numeric: $idx");
return false;
}
$response = $this->SendCommand(self::COMMAND_PLAY, $idx);
$this->_debug('SkipTo', "return: $idx", 5);
return $idx;
}
/* SeekTo
*
* Skips directly to a given position within a track in the MPD
* playlist. The <pos> argument, given in seconds, is the track position
* to locate. The <track> argument, if supplied, is the track number in
* the playlist. If <track> is not specified, the current track is
* assumed.
*/
public function SeekTo($pos, $track = -1) {
$this->_debug('SeekTo', 'start', 5);
if ( ! is_numeric($pos) ) {
$this->_error('SeekTo', "pos must be numeric: $pos");
return false;
}
if ( ! is_numeric($track) ) {
$this->_error('SeekTo', "track must be numeric: $track");
return false;
}
if ( $track == -1 ) {
$track = $this->current_track_id;
}
$response = $this->SendCommand(self::COMMAND_SEEK, array($track, $pos));
$this->_debug('SeekTo', "return: $pos", 5);
return $pos;
}
/* Next
*
* Skips to the next song in the MPD playlist. If not playing, returns
* an error.
*/
public function Next() {
$this->_debug('Next', 'start', 5);
$response = $this->SendCommand(self::COMMAND_NEXT);
$this->_debug('Next', "return: $response", 5);
return $response;
}
/* Previous
*
* Skips to the previous song in the MPD playlist. If not playing,
* returns an error.
*/
public function Previous() {
$this->_debug('Previous', 'start', 5);
$response = $this->SendCommand(self::COMMAND_PREVIOUS);
$this->_debug('Previous', "return: $response", 5);
return $response;
}
/* Search
*
* Searches the MPD database. The search <type> should be one of the
* following:
* self::SEARCH_ARTIST, self::SEARCH_TITLE, self::SEARCH_ALBUM
* The search <string> is a case-insensitive locator string. Anything
* that contains <string> will be returned in the results.
*/
public function Search($type,$string) {
$this->_debug('Search', 'start', 5);
if ( $type != self::SEARCH_ARTIST &&
$type != self::SEARCH_ALBUM &&
$type != self::SEARCH_TITLE ) {
$this->_error('Search', 'invalid search type');
return false;
}
$response = $this->SendCommand(self::COMMAND_SEARCH, array($type, $string), false);
$results = false;
if ($response) {
$results = self::_parseFileListResponse($response);
}
$this->_debug('Search', 'return: ' . json_encode($results), 5);
return $results;
}
/* Find
*
* Find looks for exact matches in the MPD database. The find <type>
* should be one of the following:
* self::SEARCH_ARTIST, self::SEARCH_TITLE, self::SEARCH_ALBUM
* The find <string> is a case-insensitive locator string. Anything that
* exactly matches <string> will be returned in the results.
*/
public function Find($type, $string) {
$this->_debug('Find', 'start', 5);
if ( $type != self::SEARCH_ARTIST &&
$type != self::SEARCH_ALBUM &&
$type != self::SEARCH_TITLE ) {
$this->_error('Find', 'invalid find type');
return false;
}
$response = $this->SendCommand(self::COMMAND_FIND, array($type, $string), false);
$results = false;
if ($response) {
$results = self::_parseFileListResponse($response);
}
$this->_debug('Find', 'return: ' . json_encode($results), 5);
return $results;
}
/* Disconnect
*
* Closes the connection to the MPD server.
*/
public function Disconnect() {
$this->_debug('Disconnect', 'start', 5);
fclose($this->_mpd_sock);
$this->connected = false;
unset($this->mpd_version);
unset($this->err_str);
unset($this->_mpd_sock);
}
/* GetArtists
*
* Returns the list of artists in the database in an associative array.
*/
public function GetArtists() {
$this->_debug('GetArtists', 'start', 5);
if (!$response = $this->SendCommand(self::COMMAND_TABLE, self::TABLE_ARTIST, false)) {
return false;
}
$results = array();
$parsed = self::_parseResponse($response);
foreach ($parsed as $key => $value) {
if ($key == 'Artist') {
$results[] = $value;
}
}
$this->_debug('GetArtists', 'return: ' . json_encode($results), 5);
return $results;
}
/* GetAlbums
*
* Returns the list of albums in the database in an associative array.
* Optional parameter is an artist Name which will list all albums by a
* particular artist.
*/
public function GetAlbums($artist = null) {
$this->_debug('GetAlbums', 'start', 5);
$params[] = self::TABLE_ALBUM;
if (!is_null($artist)) {
$params[] = $artist;
}
if (!$response = $this->SendCommand(self::COMMAND_TABLE, $params, false)) {
return false;
}
$results = array();
$parsed = self::_parseResponse($response);
foreach ($parsed as $key => $value) {
if ($key == 'Album') {
$results[] = $value;
}
}
$this->_debug('GetAlbums', 'return: ' . json_encode($results), 5);
return $results;
}
/* _computeVersionValue
*
* Computes numeric value from a version string
*
*/
private static function _computeVersionValue($string) {
$parts = explode('.', $string);
return (100 * $parts[0]) + (10 * $parts[1]) + $parts[2];
}
/* _checkCompatibility
*
* Check MPD command compatibility against our internal table of
* incompatibilities.
*/
private static function _checkCompatibility($cmd, $mpd_version) {
$mpd = self::_computeVersionValue($mpd_version);
if (isset(self::$_COMPATIBILITY_TABLE[$cmd])) {
$min_version = self::$_COMPATIBILITY_TABLE[$cmd]['min'];
$max_version = self::$_COMPATIBILITY_TABLE[$cmd]['max'];
if ($min_version) {
$min = self::_computeVersionValue($min_version);
if ($mpd < $min) {
$this->_error('compatibility', "Command '$cmd' is not compatible with this version of MPD, version $min_version required");
return false;
}
}
if ($max_version) {
$max = self::_computeVersionValue($max_version);
if ($mpd >= $max) {
$this->_error('compatibility', "Command '$cmd' has been deprecated in this version of MPD. Last compatible version: $max_version");
return false;
}
}
}
return true;
}
/* _parseFileListResponse
*
* Builds a multidimensional array with MPD response lists.
*/
private static function _parseFileListResponse($response) {
if (!$response) {
return false;
}
$results = array();
$counter = -1;
$lines = explode("\n", $response);
foreach ($lines as $line) {
if (preg_match('/(\w+): (.+)/', $line, $matches)) {
if($matches[1] == 'file') {
$counter++;
}
$results[$counter][$matches[1]] = $matches[2];
}
}
return $results;
}
/* _parseResponse
* Turns a response into an array
*/
private static function _parseResponse($response) {
if (!$response) {
return false;
}
$results = array();
$lines = explode("\n", $response);
foreach ($lines as $line) {
if (preg_match('/(\w+): (.+)/', $line, $matches)) {
$results[$matches[1]] = $matches[2];
}
}
return $results;
}
/* _error
*
* Set error state
*/
private function _error($source, $message) {
$this->err_str = "$source: $message";
$this->_debug($source, $message, 1);
}
/* _debug
*
* Do the debugging boogaloo
*/
private function _debug($source, $message, $level) {
if ($this->debugging) {
echo "$source / $message\n";
}
if (!is_null($this->_debug_callback)) {
call_user_func($this->_debug_callback, 'MPD', "$source / $message", $level);
}
}
} // end class mpd
?>
Zerion Mini Shell 1.0