PHP MPD Class

Question

Most mpd.class.php's are old and produce a lot of errors which caused me much frustration in this thread.
I was wrapping my head around why phpmpreloaded worked and the others never and it's because it uses an updated mpd.class.php. To save others the frustration and hassle I figured I'd post the new class here.
Enjoy.
<?php
* Sven Ginka 03/2010
* Version mpd.class.php-1.3
* - take over from Hendrik Stoetter
* - removed "split()" as this function is marked depracted
* - added property "xfade" (used by IPodMp, phpMp+)
* - added property "bitrate" (used by phpMp+)
* - added define "MPD_SEARCH_FILENAME"
* - included sorting algorithm "msort"
* - added function validateFile() for guessing a title if no ID3 data is given
* Hendrik Stoetter 03/2008
* - this a lightly modified version of mod.class Version 1.2.
* - fixed some bugs and added some new functions
* - Changes:
* GetDir($url) -> GetDir(url,$sort)
* var $stats
* Benjamin Carlisle 05/05/2004
* mpd.class.php - PHP Object Interface to the MPD Music Player Daemon
* Version 1.2, Released 05/05/2004
* Copyright (C) 2003-2004 Benjamin Carlisle ([email protected])
* http://mpd.24oz.com/ | http://www.musicpd.org/
* 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
// Create common command definitions for MPD to use
define("MPD_CMD_STATUS", "status");
define("MPD_CMD_STATISTICS", "stats");
define("MPD_CMD_VOLUME", "volume");
define("MPD_CMD_SETVOL", "setvol");
define("MPD_CMD_PLAY", "play");
define("MPD_CMD_STOP", "stop");
define("MPD_CMD_PAUSE", "pause");
define("MPD_CMD_NEXT", "next");
define("MPD_CMD_PREV", "previous");
define("MPD_CMD_PLLIST", "playlistinfo");
define("MPD_CMD_PLADD", "add");
define("MPD_CMD_PLREMOVE", "delete");
define("MPD_CMD_PLCLEAR", "clear");
define("MPD_CMD_PLSHUFFLE", "shuffle");
define("MPD_CMD_PLLOAD", "load");
define("MPD_CMD_PLSAVE", "save");
define("MPD_CMD_KILL", "kill");
define("MPD_CMD_REFRESH", "update");
define("MPD_CMD_REPEAT", "repeat");
define("MPD_CMD_LSDIR", "lsinfo");
define("MPD_CMD_SEARCH", "search");
define("MPD_CMD_START_BULK", "command_list_begin");
define("MPD_CMD_END_BULK", "command_list_end");
define("MPD_CMD_FIND", "find");
define("MPD_CMD_RANDOM", "random");
define("MPD_CMD_SEEK", "seek");
define("MPD_CMD_PLSWAPTRACK", "swap");
define("MPD_CMD_PLMOVETRACK", "move");
define("MPD_CMD_PASSWORD", "password");
define("MPD_CMD_TABLE", "list");
define("MPD_CMD_PLMOVE", "move" );
// Predefined MPD Response messages
define("MPD_RESPONSE_ERR", "ACK");
define("MPD_RESPONSE_OK", "OK");
// MPD State Constants
define("MPD_STATE_PLAYING", "play");
define("MPD_STATE_STOPPED", "stop");
define("MPD_STATE_PAUSED", "pause");
// MPD Searching Constants
define("MPD_SEARCH_ARTIST", "artist");
define("MPD_SEARCH_TITLE", "title");
define("MPD_SEARCH_ALBUM", "album");
define("MPD_SEARCH_ANY", "any");
define("MPD_SEARCH_FILENAME","filename");
// MPD Cache Tables
define("MPD_TBL_ARTIST","artist");
define("MPD_TBL_ALBUM","album");
$mpd_debug = 0;
function addLog($text){
global $mpd_debug;
$style="background-color:lightgrey;border:thin solid grey;margin:5px;padding:5px";
if ($mpd_debug) echo '<div style="'.$style.'">log:>'.$text.'</div>';
function addErr($err){
global $mpd_debug;
if ($mpd_debug) echo 'error:>'.$err.'<br>';
class mpd {
// TCP/Connection variables
var $host;
var $port;
var $password;
var $mpd_sock = NULL;
var $connected = FALSE;
// MPD Status variables
var $mpd_version = "(unknown)";
var $state;
var $current_track_position;
var $current_track_length;
var $current_track_id;
var $volume;
var $repeat;
var $random;
var $uptime;
var $playtime;
var $db_last_refreshed;
var $num_songs_played;
var $playlist_count;
var $xfade;
var $bitrate;
var $num_artists;
var $num_albums;
var $num_songs;
var $playlist = array();
var $stats;
// Misc Other Vars
var $mpd_class_version = "1.2";
var $debugging = FALSE; // Set to TRUE to turn extended debugging on.
var $errStr = ""; // Used for maintaining information about the last error message
var $command_queue; // The list of commands for bulk command sending
// =================== BEGIN OBJECT METHODS ================
/* mpd() : Constructor
* Builds the MPD object, connects to the server, and refreshes all local object properties.
function mpd($srv,$port,$pwd = NULL, $debug= FALSE ) {
$this->host = $srv;
$this->port = $port;
$this->password = $pwd;
$this->debugging = $debug;
global $mpd_debug;
$mpd_debug = $debug;
$resp = $this->Connect();
if ( is_null($resp) ) {
addErr( "Could not connect" );
return;
} else {
addLog( "connected");
list ( $this->mpd_version ) = sscanf($resp, MPD_RESPONSE_OK . " MPD %s\n");
if ( ! is_null($pwd) ) {
if ( is_null($this->SendCommand(MPD_CMD_PASSWORD,$pwd)) ) {
$this->connected = FALSE;
addErr("bad password");
return; // bad password or command
if ( is_null($this->RefreshInfo()) ) { // no read access -- might as well be disconnected!
$this->connected = FALSE;
addErr("Password supplied does not have read access");
return;
} else {
if ( is_null($this->RefreshInfo()) ) { // no read access -- might as well be disconnected!
$this->connected = FALSE;
addErr("Password required to access server");
return;
/* Connect()
* Connects to the MPD server.
* NOTE: This is called automatically upon object instantiation; you should not need to call this directly.
function Connect() {
addLog( "mpd->Connect() / host: ".$this->host.", port: ".$this->port."\n" );
$this->mpd_sock = fsockopen($this->host,$this->port,$errNo,$errStr,10);
if (!$this->mpd_sock) {
addErr("Socket Error: $errStr ($errNo)");
return NULL;
} else {
$counter=0;
while(!feof($this->mpd_sock)) {
$counter++;
if ($counter > 10){
addErr("no file end");
return NULL;
$response = fgets($this->mpd_sock,1024);
addLog( $response );
if (strncmp(MPD_RESPONSE_OK,$response,strlen(MPD_RESPONSE_OK)) == 0) {
$this->connected = TRUE;
return $response;
if (strncmp(MPD_RESPONSE_ERR,$response,strlen(MPD_RESPONSE_ERR)) == 0) {
// close socket
fclose($this->mpd_sock);
addErr("Server responded with: $response");
return NULL;
// close socket
fclose($this->mpd_sock);
// Generic response
addErr("Connection not available");
return NULL;
/* SendCommand()
* Sends a generic command to the MPD server. Several command constants are pre-defined for
* use (see MPD_CMD_* constant definitions above).
function SendCommand($cmdStr,$arg1 = "",$arg2 = "") {
addLog("mpd->SendCommand() / cmd: ".$cmdStr.", args: ".$arg1." ".$arg2 );
// Clear out the error String
$this->errStr = NULL;
$respStr = "";
if ( ! $this->connected ) {
addErr( "mpd->SendCommand() / Error: Not connected");
} else {
// Check the command compatibility:
if ( ! $this->_checkCompatibility($cmdStr) ) {
return NULL;
if (strlen($arg1) > 0) $cmdStr .= " \"$arg1\"";
if (strlen($arg2) > 0) $cmdStr .= " \"$arg2\"";
fputs($this->mpd_sock,"$cmdStr\n");
while(!feof($this->mpd_sock)) {
$response = fgets($this->mpd_sock,1024);
//addLog($response);
// An OK signals the end of transmission -- we'll ignore it
if (strncmp(MPD_RESPONSE_OK,$response,strlen(MPD_RESPONSE_OK)) == 0) {
break;
// An ERR signals the end of transmission with an error! Let's grab the single-line message.
if (strncmp(MPD_RESPONSE_ERR,$response,strlen(MPD_RESPONSE_ERR)) == 0) {
list ( $junk, $errTmp ) = strtok(MPD_RESPONSE_ERR . " ",$response );
addErr( strtok($errTmp,"\n") );
return NULL;
// Build the response string
$respStr .= $response;
addLog("mpd->SendCommand() / response: '".$respStr."'\n");
return $respStr;
/* 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 are queued, using
* the SendCommandQueue() method. The syntax for queueing commands is identical to SendCommand().
function QueueCommand($cmdStr,$arg1 = "",$arg2 = "") {
if ( $this->debugging ) echo "mpd->QueueCommand() / cmd: ".$cmdStr.", args: ".$arg1." ".$arg2."\n";
if ( ! $this->connected ) {
echo "mpd->QueueCommand() / Error: Not connected\n";
return NULL;
} else {
if ( strlen($this->command_queue) == 0 ) {
$this->command_queue = MPD_CMD_START_BULK . "\n";
if (strlen($arg1) > 0) $cmdStr .= " \"$arg1\"";
if (strlen($arg2) > 0) $cmdStr .= " \"$arg2\"";
$this->command_queue .= $cmdStr ."\n";
if ( $this->debugging ) echo "mpd->QueueCommand() / return\n";
return TRUE;
/* SendCommandQueue()
* Sends all commands in the Command Queue to the MPD server. See also QueueCommand().
function SendCommandQueue() {
if ( $this->debugging ) echo "mpd->SendCommandQueue()\n";
if ( ! $this->connected ) {
echo "mpd->SendCommandQueue() / Error: Not connected\n";
return NULL;
} else {
$this->command_queue .= MPD_CMD_END_BULK . "\n";
if ( is_null($respStr = $this->SendCommand($this->command_queue)) ) {
return NULL;
} else {
$this->command_queue = NULL;
if ( $this->debugging ) echo "mpd->SendCommandQueue() / response: '".$respStr."'\n";
return $respStr;
/* AdjustVolume()
* Adjusts the mixer volume on the MPD by <modifier>, which can be a positive (volume increase),
* or negative (volume decrease) value.
function AdjustVolume($modifier) {
if ( $this->debugging ) echo "mpd->AdjustVolume()\n";
if ( ! is_numeric($modifier) ) {
$this->errStr = "AdjustVolume() : argument 1 must be a numeric value";
return NULL;
$this->RefreshInfo();
$newVol = $this->volume + $modifier;
$ret = $this->SetVolume($newVol);
if ( $this->debugging ) echo "mpd->AdjustVolume() / return\n";
return $ret;
/* SetVolume()
* Sets the mixer volume to <newVol>, which should be between 1 - 100.
function SetVolume($newVol) {
if ( $this->debugging ) echo "mpd->SetVolume()\n";
if ( ! is_numeric($newVol) ) {
$this->errStr = "SetVolume() : argument 1 must be a numeric value";
return NULL;
// Forcibly prevent out of range errors
if ( $newVol < 0 ) $newVol = 0;
if ( $newVol > 100 ) $newVol = 100;
// If we're not compatible with SETVOL, we'll try adjusting using VOLUME
if ( $this->_checkCompatibility(MPD_CMD_SETVOL) ) {
if ( ! is_null($ret = $this->SendCommand(MPD_CMD_SETVOL,$newVol))) $this->volume = $newVol;
} else {
$this->RefreshInfo(); // Get the latest volume
if ( is_null($this->volume) ) {
return NULL;
} else {
$modifier = ( $newVol - $this->volume );
if ( ! is_null($ret = $this->SendCommand(MPD_CMD_VOLUME,$modifier))) $this->volume = $newVol;
if ( $this->debugging ) echo "mpd->SetVolume() / return\n";
return $ret;
/* 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.
function GetDir($dir = "",$sort = "") {
addLog( "mpd->GetDir()" );
$resp = $this->SendCommand(MPD_CMD_LSDIR,$dir);
$listArray = $this->_parseFileListResponse($resp);
if ($listArray==null){
return null;
// we have 3 differnt items: directory, playlist and file
// we have to sort them individually and separate
// playlist and directory by name
// file by $sort
// 1st: subarrays
$array_directory = $listArray['directories'];
$array_playlist = $listArray['playlists'];
$array_file = $listArray['files'];
// 2nd: sort them
natcasesort($array_directory);
natcasesort($array_playlist);
usort($array_file,"msort");
// 3rd: rebuild
$array_return= array(
"directories"=> $array_directory,
"playlists"=> $array_playlist,
"files"=> $array_file
foreach ($array_directory as $value) {
$array_return[]["directory"] = $value;
foreach ($array_playlist as $value) {
$array_return[]["playlist"] = $value;
$array_return = array_merge($array_return,$array_file);
addLog( "mpd->GetDir() / return ".print_r($array_return,true));
return $array_return;
/* GetDirTest() (Unoffical add) -- Returns readable dir contents
* 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.
function GetDirTest($dir = "") {
if ( $this->debugging ) echo "mpd->GetDir()\n";
$resp = $this->SendCommand(MPD_CMD_LSDIR,$dir);
#$dirlist = $this->_parseFileListResponse($resp);
$dirlist = $this->_parseFileListResponseHumanReadable($resp);
if ( $this->debugging ) echo "mpd->GetDir() / return ".print_r($dirlist)."\n";
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.
function PLAddBulk($trackArray) {
if ( $this->debugging ) echo "mpd->PLAddBulk()\n";
$num_files = count($trackArray);
for ( $i = 0; $i < $num_files; $i++ ) {
$this->QueueCommand(MPD_CMD_PLADD,$trackArray[$i]);
$resp = $this->SendCommandQueue();
$this->RefreshInfo();
if ( $this->debugging ) echo "mpd->PLAddBulk() / return\n";
return $resp;
/* PLAdd()
* Adds the file <file> to the end of the playlist. <file> must be a track in the MPD database.
function PLAdd($fileName) {
if ( $this->debugging ) echo "mpd->PLAdd()\n";
if ( ! is_null($resp = $this->SendCommand(MPD_CMD_PLADD,$fileName))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->PLAdd() / return\n";
return $resp;
/* PLMoveTrack()
* Moves track number <origPos> to position <newPos> in the playlist. This is used to reorder
* the songs in the playlist.
function PLMoveTrack($origPos, $newPos) {
if ( $this->debugging ) echo "mpd->PLMoveTrack()\n";
if ( ! is_numeric($origPos) ) {
$this->errStr = "PLMoveTrack(): argument 1 must be numeric";
return NULL;
if ( $origPos < 0 or $origPos > $this->playlist_count ) {
$this->errStr = "PLMoveTrack(): argument 1 out of range";
return NULL;
if ( $newPos < 0 ) $newPos = 0;
if ( $newPos > $this->playlist_count ) $newPos = $this->playlist_count;
if ( ! is_null($resp = $this->SendCommand(MPD_CMD_PLMOVETRACK,$origPos,$newPos))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->PLMoveTrack() / return\n";
return $resp;
/* PLShuffle()
* Randomly reorders the songs in the playlist.
function PLShuffle() {
if ( $this->debugging ) echo "mpd->PLShuffle()\n";
if ( ! is_null($resp = $this->SendCommand(MPD_CMD_PLSHUFFLE))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->PLShuffle() / return\n";
return $resp;
/* PLLoad()
* Retrieves the playlist from <file>.m3u and loads it into the current playlist.
function PLLoad($file) {
if ( $this->debugging ) echo "mpd->PLLoad()\n";
if ( ! is_null($resp = $this->SendCommand(MPD_CMD_PLLOAD,$file))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->PLLoad() / return\n";
return $resp;
/* PLSave()
* Saves the playlist to <file>.m3u for later retrieval. The file is saved in the MPD playlist
* directory.
function PLSave($file) {
if ( $this->debugging ) echo "mpd->PLSave()\n";
$resp = $this->SendCommand(MPD_CMD_PLSAVE,$file);
if ( $this->debugging ) echo "mpd->PLSave() / return\n";
return $resp;
/* PLClear()
* Empties the playlist.
function PLClear() {
if ( $this->debugging ) echo "mpd->PLClear()\n";
if ( ! is_null($resp = $this->SendCommand(MPD_CMD_PLCLEAR))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->PLClear() / return\n";
return $resp;
/* PLRemove()
* Removes track <id> from the playlist.
function PLRemove($id) {
if ( $this->debugging ) echo "mpd->PLRemove()\n";
if ( ! is_numeric($id) ) {
$this->errStr = "PLRemove() : argument 1 must be a numeric value";
return NULL;
if ( ! is_null($resp = $this->SendCommand(MPD_CMD_PLREMOVE,$id))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->PLRemove() / return\n";
return $resp;
/* SetRepeat()
* Enables 'loop' mode -- tells MPD continually loop the playlist. The <repVal> parameter
* is either 1 (on) or 0 (off).
function SetRepeat($repVal) {
if ( $this->debugging ) echo "mpd->SetRepeat()\n";
$rpt = $this->SendCommand(MPD_CMD_REPEAT,$repVal);
$this->repeat = $repVal;
if ( $this->debugging ) echo "mpd->SetRepeat() / return\n";
return $rpt;
/* SetRandom()
* Enables 'randomize' mode -- tells MPD to play songs in the playlist in random order. The
* <rndVal> parameter is either 1 (on) or 0 (off).
function SetRandom($rndVal) {
if ( $this->debugging ) echo "mpd->SetRandom()\n";
$resp = $this->SendCommand(MPD_CMD_RANDOM,$rndVal);
$this->random = $rndVal;
if ( $this->debugging ) echo "mpd->SetRandom() / return\n";
return $resp;
/* Shutdown()
* Shuts down the MPD server (aka sends the KILL command). This closes the current connection,
* and prevents future communication with the server.
function Shutdown() {
if ( $this->debugging ) echo "mpd->Shutdown()\n";
$resp = $this->SendCommand(MPD_CMD_SHUTDOWN);
$this->connected = FALSE;
unset($this->mpd_version);
unset($this->errStr);
unset($this->mpd_sock);
if ( $this->debugging ) echo "mpd->Shutdown() / return\n";
return $resp;
/* DBRefresh()
* Tells MPD to rescan the music directory for new tracks, and to refresh the Database. Tracks
* cannot be played unless they are in the MPD database.
function DBRefresh() {
if ( $this->debugging ) echo "mpd->DBRefresh()\n";
$resp = $this->SendCommand(MPD_CMD_REFRESH);
// Update local variables
$this->RefreshInfo();
if ( $this->debugging ) echo "mpd->DBRefresh() / return\n";
return $resp;
/* Play()
* Begins playing the songs in the MPD playlist.
function Play() {
if ( $this->debugging ) echo "mpd->Play()\n";
if ( ! is_null($rpt = $this->SendCommand(MPD_CMD_PLAY) )) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->Play() / return\n";
return $rpt;
/* Stop()
* Stops playing the MPD.
function Stop() {
if ( $this->debugging ) echo "mpd->Stop()\n";
if ( ! is_null($rpt = $this->SendCommand(MPD_CMD_STOP) )) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->Stop() / return\n";
return $rpt;
/* Pause()
* Toggles pausing on the MPD. Calling it once will pause the player, calling it again
* will unpause.
function Pause() {
if ( $this->debugging ) echo "mpd->Pause()\n";
if ( ! is_null($rpt = $this->SendCommand(MPD_CMD_PAUSE) )) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->Pause() / return\n";
return $rpt;
/* SeekTo()
* Skips directly to the <idx> song in the MPD playlist.
function SkipTo($idx) {
if ( $this->debugging ) echo "mpd->SkipTo()\n";
if ( ! is_numeric($idx) ) {
$this->errStr = "SkipTo() : argument 1 must be a numeric value";
return NULL;
if ( ! is_null($rpt = $this->SendCommand(MPD_CMD_PLAY,$idx))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->SkipTo() / return\n";
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.
function SeekTo($pos, $track = -1) {
if ( $this->debugging ) echo "mpd->SeekTo()\n";
if ( ! is_numeric($pos) ) {
$this->errStr = "SeekTo() : argument 1 must be a numeric value";
return NULL;
if ( ! is_numeric($track) ) {
$this->errStr = "SeekTo() : argument 2 must be a numeric value";
return NULL;
if ( $track == -1 ) {
$track = $this->current_track_id;
if ( ! is_null($rpt = $this->SendCommand(MPD_CMD_SEEK,$track,$pos))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->SeekTo() / return\n";
return $pos;
/* Next()
* Skips to the next song in the MPD playlist. If not playing, returns an error.
function Next() {
if ( $this->debugging ) echo "mpd->Next()\n";
if ( ! is_null($rpt = $this->SendCommand(MPD_CMD_NEXT))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->Next() / return\n";
return $rpt;
/* Previous()
* Skips to the previous song in the MPD playlist. If not playing, returns an error.
function Previous() {
if ( $this->debugging ) echo "mpd->Previous()\n";
if ( ! is_null($rpt = $this->SendCommand(MPD_CMD_PREV))) $this->RefreshInfo();
if ( $this->debugging ) echo "mpd->Previous() / return\n";
return $rpt;
/* Search()
* Searches the MPD database. The search <type> should be one of the following:
* MPD_SEARCH_ARTIST, MPD_SEARCH_TITLE, MPD_SEARCH_ALBUM
* The search <string> is a case-insensitive locator string. Anything that contains
* <string> will be returned in the results.
function Search($type,$string) {
addLog("mpd->Search()");
if ( $type != MPD_SEARCH_ARTIST and
$type != MPD_SEARCH_ALBUM and
$type != MPD_SEARCH_ANY and
$type != MPD_SEARCH_TITLE ) {
addErr( "mpd->Search(): invalid search type" );
return NULL;
} else {
if ( is_null($resp = $this->SendCommand(MPD_CMD_SEARCH,$type,$string))) return NULL;
$searchlist = $this->_parseFileListResponse($resp);
addLog( "mpd->Search() / return ".print_r($searchlist,true) );
return $searchlist;
/* Find()
* Find() looks for exact matches in the MPD database. The find <type> should be one of
* the following:
* MPD_SEARCH_ARTIST, MPD_SEARCH_TITLE, MPD_SEARCH_ALBUM
* The find <string> is a case-insensitive locator string. Anything that exactly matches
* <string> will be returned in the results.
function Find($type,$string) {
if ( $this->debugging ) echo "mpd->Find()\n";
if ( $type != MPD_SEARCH_ARTIST and
$type != MPD_SEARCH_ALBUM and
$type != MPD_SEARCH_TITLE ) {
$this->errStr = "mpd->Find(): invalid find type";
return NULL;
} else {
if ( is_null($resp = $this->SendCommand(MPD_CMD_FIND,$type,$string))) return NULL;
$searchlist = $this->_parseFileListResponse($resp);
if ( $this->debugging ) echo "mpd->Find() / return ".print_r($searchlist)."\n";
return $searchlist;
/* Disconnect()
* Closes the connection to the MPD server.
function Disconnect() {
if ( $this->debugging ) echo "mpd->Disconnect()\n";
fclose($this->mpd_sock);
$this->connected = FALSE;
unset($this->mpd_version);
unset($this->errStr);
unset($this->mpd_sock);
/* GetArtists()
* Returns the list of artists in the database in an associative array.
function GetArtists() {
if ( $this->debugging ) echo "mpd->GetArtists()\n";
if ( is_null($resp = $this->SendCommand(MPD_CMD_TABLE, MPD_TBL_ARTIST))) return NULL;
$arArray = array();
$arLine = strtok($resp,"\n");
$arName = "";
$arCounter = -1;
while ( $arLine ) {
list ( $element, $value ) = explode(": ",$arLine);
if ( $element == "Artist" ) {
$arCounter++;
$arName = $value;
$arArray[$arCounter] = $arName;
$arLine = strtok("\n");
if ( $this->debugging ) echo "mpd->GetArtists()\n";
return $arArray;
/* 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.
function GetAlbums( $ar = NULL) {
if ( $this->debugging ) echo "mpd->GetAlbums()\n";
if ( is_null($resp = $this->SendCommand(MPD_CMD_TABLE, MPD_TBL_ALBUM, $ar ))) return NULL;
$alArray = array();
$alLine = strtok($resp,"\n");
$alName = "";
$alCounter = -1;
while ( $alLine ) {
list ( $element, $value ) = explode(": ",$alLine);
if ( $element == "Album" ) {
$alCounter++;
$alName = $value;
$alArray[$alCounter] = $alName;
$alLine = strtok("\n");
if ( $this->debugging ) echo "mpd->GetAlbums()\n";
return $alArray;
//***************************** INTERNAL FUNCTIONS ******************************//
/* _computeVersionValue()
* Computes a compatibility value from a version string
private function _computeVersionValue($verStr) {
list ($ver_maj, $ver_min, $ver_rel ) = explode(".",$verStr);
return ( 100 * $ver_maj ) + ( 10 * $ver_min ) + ( $ver_rel );
/* _checkCompatibility()
* Check MPD command compatibility against our internal table. If there is no version
* listed in the table, allow it by default.
private function _checkCompatibility($cmd) {
// Check minimum compatibility
if (isset($this->COMPATIBILITY_MIN_TBL[$cmd])){
$req_ver_low = $this->COMPATIBILITY_MIN_TBL[$cmd];
} else {
$req_ver_low = "0.9.1";
// check max compatibility
if (isset($this->COMPATIBILITY_MAX_TBL[$cmd])){
$req_ver_hi = $this->COMPATIBILITY_MAX_TBL[$cmd];
} else {
$req_ver_hi = "0.20.0";
$mpd_ver = $this->_computeVersionValue($this->mpd_version);
if ( $req_ver_low ) {
$req_ver = $this->_computeVersionValue($req_ver_low);
if ( $mpd_ver < $req_ver ) {
addErr("Command '$cmd' is not compatible with this version of MPD, version ".$req_ver_low." required");
return FALSE;
// Check maximum compatibility -- this will check for deprecations
if ( $req_ver_hi ) {
$req_ver = $this->_computeVersionValue($req_ver_hi);
if ( $mpd_ver > $req_ver ) {
addErr("Command '$cmd' has been deprecated in this version of MPD.");
return FALSE;
return TRUE;
* checks the file entry and complete it if necesarry
* checked fields are 'Artist', 'Genre' and 'Title'
private function _validateFile( $fileItem ){
$filename = $fileItem['file'];
if (!isset($fileItem['Artist'])){ $fileItem['Artist']=null; }
if (!isset($fileItem['Genre'])){ $fileItem['Genre']=null; }
// special conversion for streams
if (stripos($filename, 'http' )!==false){
if (!isset($fileItem['Title'])) $title = ''; else $title=$fileItem['Title'];
if (!isset($fileItem['Name'])) $name = ''; else $name=$fileItem['Name'];
if (!isset($fileItem['Artist'])) $artist = ''; else $artist=$fileItem['Artist'];
if (strlen($title.$name.$artist)==0){
$fileItem['Title'] = $filename;
} else {
$fileItem['Title'] = 'stream://'.$title.' '.$name.' '.$artist;
if (!isset($fileItem['Title'])){
$file_parts = explode('/', $filename);
$fileItem['Title'] = $filename;
return $fileItem;
* take the response of mpd and split it up into
* items of types 'file', 'directory' and 'playlist'
private function _extractItems( $resp ){
if ( $resp == null ) {
addLog('empty file list');
return NULL;
// strip unwanted chars
$resp = trim($resp);
// split up into lines
$lineList = explode("\n", $resp );
$array = array();
$item=null;
foreach ($lineList as $line ){
list ( $element, $value ) = explode(": ",$line);
// if one of the key words come up, store the item
if (($element == "directory") or ($element=="playlist") or ($element=="file")){
if ($item){
$array[] = $item;
$item = array();
$item[$element] = $value;
// check if there is a last item to store
if (sizeof($item)>0){
$array[] = $item;
return $array;
/* _parseFileListResponse()
* Builds a multidimensional array with MPD response lists.
* NOTE: This function is used internally within the class. It should not be used.
private function _parseFileListResponse($resp) {
$valuesArray = $this->_extractItems( $resp );
if ($valuesArray == null ){
return null;
//1. create empty arrays
$directoriesArray = array();
$filesArray = array();
$playlistsArray = array();
//2. sort the items
foreach ( $valuesArray as $item ) {
if (isset($item['file'])){
$filesArray[] = $this->_validateFile($item);
} else if (isset($item['directory'])){
$directoriesArray[] = $item['directory'];
} else if (isset($item['playlist'])){
$playlistsArray[] = $item['playlist'];
} else {
addErr('should not enter this');
//3. create a combined list of items
$returnArray = array(
"directories"=>$directoriesArray,
"playlists"=>$playlistsArray,
"files"=>$filesArray
addLog( print_r($valuesArray,true) );
return $returnArray;
/* RefreshInfo()
* Updates all class properties with the values from the MPD server.
* NOTE: This function is automatically called upon Connect() as of v1.1.
function RefreshInfo() {
// Get the Server Statistics
$statStr = $this->SendCommand(MPD_CMD_STATISTICS);
if ( !$statStr ) {
return NULL;
} else {
$stats = array();
$statStr=trim($statStr);
$statLine = explode( "\n", $statStr );
foreach ( $statLine as $line ) {
list ( $element, $value ) = explode(": ",$line);
$stats[$element] = $value;
// Get the Server Status
$statusStr = $this->SendCommand(MPD_CMD_STATUS);
if ( ! $statusStr ) {
return NULL;
} else {
$status = array();
$statusStr=trim($statusStr);
$statusLine = explode("\n", $statusStr );
foreach ( $statusLine as $line ) {
list ( $element, $value ) = explode(": ",$line);
$status[$element] = $value;
// Get the Playlist
$plStr = $this->SendCommand(MPD_CMD_PLLIST);
$array = $this->_parseFileListResponse($plStr);
$playlist = $array['files'];
$this->playlist_count = count($playlist);
$this->playlist = array();
if (sizeof($playlist)>0){
foreach ($playlist as $item ){
$this->playlist[$item['Pos']]=$item;
// Set Misc Other Variables
$this->state = $status['state'];
if ( ($this->state == MPD_STATE_PLAYING) || ($this->state == MPD_STATE_PAUSED) ) {
$this->current_track_id = $status['song'];
list ($this->current_track_position, $this->current_track_length ) = explode(":",$status['time']);
} else {
$this->current_track_id = -1;
$this->current_track_position = -1;
$this->current_track_length = -1;
$this->repeat = $status['repeat'];
$this->random = $status['random'];
$this->db_last_refreshed = $stats['db_update'];
$this->volume = $status['volume'];
$this->uptime = $stats['uptime'];
$this->playtime = $stats['playtime'];
$this->num_songs_played = $stats['songs'];
$this->num_artists = $stats['artists'];
$this->num_songs = $stats['songs'];
$this->num_albums = $stats['albums'];
$this->xfade = $status['xfade'];
if(isset($status['bitrate'])) $this->bitrate = $status['bitrate'];
else $this->bitrate = FALSE;
return TRUE;
/* ------------------ DEPRECATED METHODS -------------------*/
/* GetStatistics()
* Retrieves the 'statistics' variables from the server and tosses them into an array.
* NOTE: This function really should not be used. Instead, use $this->[variable]. The function
* will most likely be deprecated in future releases.
function GetStatistics() {
if ( $this->debugging ) echo "mpd->GetStatistics()\n";
$stats = $this->SendCommand(MPD_CMD_STATISTICS);
if ( !$stats ) {
return NULL;
} else {
$statsArray = array();
$statsLine = strtok($stats,"\n");
while ( $statsLine ) {
list ( $element, $value ) = explode(": ",$statsLine);
$statsArray[$element] = $value;
$statsLine = strtok("\n");
if ( $this->debugging ) echo "mpd->GetStatistics() / return: " . print_r($statsArray) ."\n";
return $statsArray;
/* GetStatus()
* Retrieves the 'status' variables from the server and tosses them into an array.
* NOTE: This function really should not be used. Instead, use $this->[variable]. The function
* will most likely be deprecated in future releases.
function GetStatus() {
if ( $this->debugging ) echo "mpd->GetStatus()\n";
$status = $this->SendCommand(MPD_CMD_STATUS);
if ( ! $status ) {
return NULL;
} else {
$statusArray = array();
$statusLine = strtok($status,"\n");
while ( $statusLine ) {
list ( $element, $value ) = explode(": ",$statusLine);
$statusArray[$element] = $value;
$statusLine = strtok("\n");
if ( $this->debugging ) echo "mpd->GetStatus() / return: " . print_r($statusArray) ."\n";
return $statusArray;
/* GetVolume()
* Retrieves the mixer volume from the server.
* NOTE: This function really should not be used. Instead, use $this->volume. The function
* will most likely be deprecated in future releases.
function GetVolume() {
if ( $this->debugging ) echo "mpd->GetVolume()\n";
$volLine = $this->SendCommand(MPD_CMD_STATUS);
if ( ! $volLine ) {
return NULL;
} else {
list ($vol) = sscanf($volLine,"volume: %d");
if ( $this->debugging ) echo "mpd->GetVolume() / return: $vol\n";
return $vol;
/* GetPlaylist()
* Retrieves the playlist from the server and tosses it into a multidimensional array.
* NOTE: This function really should not be used. Instead, use $this->playlist. The function
* will most likely be deprecated in future releases.
function GetPlaylist() {
if ( $this->debugging ) echo "mpd->GetPlaylist()\n";
$resp = $this->SendCommand(MPD_CMD_PLLIST);
$playlist = $this->_parseFileListResponse($resp);
if ( $this->debugging ) echo "mpd->GetPlaylist() / return ".print_r($playlist)."\n";
return $playlist;
/* ----------------- Command compatibility tables --------------------- */
var $COMPATIBILITY_MIN_TBL = array(
MPD_CMD_SEEK => "0.9.1" ,
MPD_CMD_PLMOVE => "0.9.1" ,
MPD_CMD_RANDOM => "0.9.1" ,
MPD_CMD_PLSWAPTRACK => "0.9.1" ,
MPD_CMD_PLMOVETRACK => "0.9.1" ,
MPD_CMD_PASSWORD => "0.10.0" ,
MPD_CMD_SETVOL => "0.10.0"
var $COMPATIBILITY_MAX_TBL = array(
MPD_CMD_VOLUME => "0.10.0"
} // ---------------------------- end of class ------------------------------
function msort($a,$b) {
global $sort_array,$filenames_only;
$i=0;
$ret = 0;
while($filenames_only!="yes" && $i<4 && $ret==0) {
if(!isset($a[$sort_array[$i]])) {
if(isset($b[$sort_array[$i]])) {
$ret = -1;
else if(!isset($b[$sort_array[$i]])) {
$ret = 1;
else if(strcmp($sort_array[$i],"Track")==0) {
$ret = strnatcmp($a[$sort_array[$i]],$b[$sort_array[$i]]);
else {
$ret = strcasecmp($a[$sort_array[$i]],$b[$sort_array[$i]]);
$i++;
if($ret==0)
$ret = strcasecmp($a["file"],$b["file"]);
return $ret;
function picksort($pick) {
global $sort_array;
if(0==strcmp($pick,$sort_array[0])) {
return "$sort_array[0],$sort_array[1],$sort_array[2],$sort_array[3]";
else if(0==strcmp($pick,$sort_array[1])) {
return "$pick,$sort_array[0],$sort_array[2],$sort_array[3]";
else if(0==strcmp($pick,$sort_array[2])) {
return "$pick,$sort_array[0],$sort_array[1],$sort_array[3]";
else if(0==strcmp($pick,$sort_array[3])) {
return "$pick,$sort_array[0],$sort_array[1],$sort_array[2]";
?>

Answer 1

BaconPie wrote:I used it to make a web based remote control for my phone. Glad it was of some help.
regarding the phone client, ... there is one in the phpMpReloaded project called IPodMp :-)
http://phpmpreloaded.sourceforge.net/sc … IPodMp.png
cheers
-tswaehn