685 lines
26 KiB
PHP
685 lines
26 KiB
PHP
<?php
|
|
|
|
class base_mpd_player {
|
|
|
|
protected $connection;
|
|
private $ip;
|
|
private $port;
|
|
private $socket;
|
|
private $password;
|
|
protected $player_type;
|
|
private $is_slave;
|
|
public $playlist_error;
|
|
|
|
public function __construct($ip = null, $port = null, $socket = null, $password = null, $player_type = null, $is_slave = null) {
|
|
global $prefs;
|
|
|
|
if ($ip !== null) {
|
|
$this->ip = $ip;
|
|
} else {
|
|
$this->ip = $prefs['multihosts']->{$prefs['currenthost']}->host;
|
|
}
|
|
if ($port !== null) {
|
|
$this->port = $port;
|
|
} else {
|
|
$this->port = $prefs['multihosts']->{$prefs['currenthost']}->port;
|
|
}
|
|
if ($socket !== null) {
|
|
$this->socket = $socket;
|
|
} else {
|
|
$this->socket = $prefs['multihosts']->{$prefs['currenthost']}->socket;
|
|
}
|
|
if ($password !== null) {
|
|
$this->password = $password;
|
|
} else {
|
|
$this->password = $prefs['multihosts']->{$prefs['currenthost']}->password;
|
|
}
|
|
if ($is_slave !== null) {
|
|
$this->is_slave = $is_slave;
|
|
} else {
|
|
if (property_exists($prefs['multihosts']->{$prefs['currenthost']}, 'mopidy_slave')) {
|
|
$this->is_slave = $prefs['multihosts']->{$prefs['currenthost']}->mopidy_slave;
|
|
} else {
|
|
// Catch the case where we haven't yet upgraded the player defs
|
|
$this->is_slave = false;
|
|
}
|
|
}
|
|
logger::trace("MPDPLAYER", "Creating Player for",$this->ip.':'.$this->port);
|
|
$this->open_mpd_connection();
|
|
if ($player_type !== null) {
|
|
$this->player_type = $player_type;
|
|
} else {
|
|
if (array_key_exists('player_backend', $prefs) && $prefs['player_backend'] !== 'none') {
|
|
$this->player_type = $prefs['player_backend'];
|
|
} else {
|
|
$this->player_type = $this->probe_player_type();
|
|
}
|
|
}
|
|
}
|
|
|
|
public function __destruct() {
|
|
if ($this->is_connected()) {
|
|
$this->close_mpd_connection();
|
|
}
|
|
}
|
|
|
|
public function open_mpd_connection() {
|
|
if ($this->is_connected()) {
|
|
return true;
|
|
}
|
|
if ($this->socket != "") {
|
|
$this->connection = @stream_socket_client('unix://'.$this->socket);
|
|
} else {
|
|
$this->connection = @stream_socket_client('tcp://'.$this->ip.':'.$this->port);
|
|
}
|
|
|
|
if($this->is_connected()) {
|
|
stream_set_timeout($this->connection, 65535);
|
|
stream_set_blocking($this->connection, true);
|
|
while(!feof($this->connection)) {
|
|
$gt = fgets($this->connection, 1024);
|
|
if ($this->parse_mpd_var($gt))
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ($this->password != "" && $this->is_connected()) {
|
|
fputs($this->connection, "password ".$this->password."\n");
|
|
while(!feof($this->connection)) {
|
|
$gt = fgets($this->connection, 1024);
|
|
$a = $this->parse_mpd_var($gt);
|
|
if($a === true) {
|
|
$is_connected = true;
|
|
break;
|
|
} else if ($a == null) {
|
|
|
|
} else {
|
|
$this->close_mpd_connection();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public function close_mpd_connection() {
|
|
if ($this->is_connected()) {
|
|
stream_socket_shutdown($this->connection, STREAM_SHUT_RDWR);
|
|
}
|
|
}
|
|
|
|
public function is_connected() {
|
|
return (isset($this->connection) && is_resource($this->connection));
|
|
}
|
|
|
|
private function parse_mpd_var($in_str) {
|
|
$got = trim($in_str);
|
|
if(!isset($got))
|
|
return null;
|
|
if(strncmp("OK", $got, 2) == 0)
|
|
return true;
|
|
if(strncmp("ACK", $got, 3) == 0) {
|
|
return array(0 => false, 1 => $got);
|
|
}
|
|
$key = trim(strtok($got, ":"));
|
|
$val = trim(strtok("\0"));
|
|
return array(0 => $key, 1 => $val);
|
|
}
|
|
|
|
protected function getline() {
|
|
$got = fgets($this->connection, 2048);
|
|
$key = trim(strtok($got, ":"));
|
|
$val = trim(strtok("\0"));
|
|
if ($val != '') {
|
|
return array($key, $val);
|
|
} else if (strpos($got, "OK") === 0 || strpos($got, "ACK") === 0) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
protected function send_command($command) {
|
|
$retries = 5;
|
|
$l = strlen($command."\n");
|
|
do {
|
|
$b = @fputs($this->connection, $command."\n");
|
|
if (!$b || $b < $l) {
|
|
logger::warn("MPD", "Socket Write Error for",$command,"- Retrying");
|
|
$this->close_mpd_connection();
|
|
usleep(500000);
|
|
$this->open_mpd_connection();
|
|
$retries--;
|
|
} else {
|
|
return true;
|
|
}
|
|
} while ($retries > 0);
|
|
return false;
|
|
}
|
|
|
|
protected function do_mpd_command($command, $return_array = false, $force_array_results = false) {
|
|
|
|
$retarr = array();
|
|
if ($this->is_connected()) {
|
|
|
|
logger::debug("MPD", "MPD Command",$command);
|
|
$success = true;
|
|
if ($command != '') {
|
|
$success = $this->send_command($command);
|
|
}
|
|
if ($success) {
|
|
while(!feof($this->connection)) {
|
|
$var = $this->parse_mpd_var(fgets($this->connection, 1024));
|
|
if(isset($var)){
|
|
if($var === true && count($retarr) == 0) {
|
|
// Got an OK or ACK but - no results or return_array is false
|
|
return true;
|
|
}
|
|
if ($var === true) {
|
|
break;
|
|
}
|
|
if ($var[0] == false) {
|
|
$sdata = stream_get_meta_data($this->connection);
|
|
if (array_key_exists('timed_out', $sdata) && $sdata['timed_out']) {
|
|
$var[1] = 'Timed Out';
|
|
}
|
|
logger::warn("MPD", "Error for'",$command,"':",$var[1]);
|
|
if ($return_array == true) {
|
|
$retarr['error'] = $var[1];
|
|
} else {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
if ($return_array == true) {
|
|
if(array_key_exists($var[0], $retarr)) {
|
|
if(is_array($retarr[($var[0])])) {
|
|
$retarr[($var[0])][] = $var[1];
|
|
} else {
|
|
$tmp = $retarr[($var[0])];
|
|
$retarr[($var[0])] = array($tmp, $var[1]);
|
|
}
|
|
} else {
|
|
if ($force_array_results) {
|
|
$retarr[($var[0])] = array($var[1]);
|
|
} else {
|
|
$retarr[($var[0])] = $var[1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
logger::error("MPD", "Failure to fput command",$command);
|
|
$retarr['error'] = "There was an error communicating with ".ucfirst($this->player_type)."! (could not write to socket)";
|
|
}
|
|
}
|
|
return $retarr;
|
|
}
|
|
|
|
public function do_command_list($cmds) {
|
|
global $prefs;
|
|
$done = 0;
|
|
$cmd_status = null;
|
|
|
|
if ($this->is_slave) {
|
|
$this->translate_commands_for_slave($cmds);
|
|
} else if ($this->player_type != $prefs['collection_player']) {
|
|
$this->translate_player_types($cmds);
|
|
}
|
|
|
|
if (count($cmds) > 1) {
|
|
$this->send_command("command_list_begin");
|
|
foreach ($cmds as $c) {
|
|
logger::trace("POSTCOMMAND", "Command List:",$c);
|
|
// Note. We don't use send_command because that closes and re-opens the connection
|
|
// if it fails to fputs, and that loses our command list status. Also if this fputs
|
|
// fails it means the connection has dropped anyway, so we're screwed whatever happens.
|
|
fputs($this->connection, $c."\n");
|
|
$done++;
|
|
// Command lists have a maximum length, 50 seems to be the default
|
|
if ($done == 50) {
|
|
$this->do_mpd_command("command_list_end", true);
|
|
$this->send_command("command_list_begin");
|
|
$done = 0;
|
|
}
|
|
}
|
|
$cmd_status = $this->do_mpd_command("command_list_end", true, false);
|
|
} else if (count($cmds) == 1) {
|
|
logger::trace("POSTCOMMAND", "Command :",$cmds[0]);
|
|
$cmd_status = $this->do_mpd_command($cmds[0], true, false);
|
|
}
|
|
return $cmd_status;
|
|
}
|
|
|
|
public function parse_list_output($command, &$dirs, $domains) {
|
|
|
|
// Generator Function for parsing MPD output for 'list...info', 'search ...' etc type commands
|
|
// Returns MPD_FILE_MODEL
|
|
|
|
logger::trace("MPD", "MPD Parse",$command);
|
|
|
|
$success = $this->send_command($command);
|
|
$filedata = MPD_FILE_MODEL;
|
|
$parts = true;
|
|
if (is_array($domains) && count($domains) == 0) {
|
|
$domains = false;
|
|
}
|
|
|
|
while( $this->is_connected() &&
|
|
!feof($this->connection) &&
|
|
$parts) {
|
|
|
|
$parts = $this->getline();
|
|
if (is_array($parts)) {
|
|
switch ($parts[0]) {
|
|
case "directory":
|
|
$dirs[] = trim($parts[1]);
|
|
break;
|
|
|
|
case "Last-Modified":
|
|
if ($filedata['file'] != null) {
|
|
// We don't want the Last-Modified stamps of the directories
|
|
// to be used for the files.
|
|
$filedata[$parts[0]] = $parts[1];
|
|
}
|
|
break;
|
|
|
|
case 'file':
|
|
if ($filedata['file'] !== null) {
|
|
$filedata['domain'] = getDomain($filedata['file']);
|
|
if ($domains === false || in_array(getDomain($filedata['file']),$domains)) {
|
|
if ($this->sanitize_data($filedata)) {
|
|
yield $filedata;
|
|
}
|
|
}
|
|
}
|
|
$filedata = MPD_FILE_MODEL;
|
|
$filedata[$parts[0]] = $parts[1];
|
|
break;
|
|
|
|
case 'X-AlbumUri':
|
|
// Mopidy-beets is using SEMICOLONS in its URI schemes.
|
|
// Surely a typo, but we need to work around it by not splitting the string
|
|
// Same applies to file.
|
|
$filedata[$parts[0]] = $parts[1];
|
|
break;
|
|
|
|
default:
|
|
if (in_array($parts[0], MPD_ARRAY_PARAMS)) {
|
|
$filedata[$parts[0]] = array_unique(explode(';',$parts[1]));
|
|
} else {
|
|
$filedata[$parts[0]] = explode(';',$parts[1])[0];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($filedata['file'] !== null) {
|
|
$filedata['domain'] = getDomain($filedata['file']);
|
|
if ($domains === false || in_array(getDomain($filedata['file']),$domains)) {
|
|
if ($this->sanitize_data($filedata)) {
|
|
yield $filedata;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected function sanitize_data(&$filedata) {
|
|
global $dbterms, $numtracks, $totaltime;
|
|
if ($dbterms['tags'] !== null || $dbterms['rating'] !== null) {
|
|
// If this is a search and we have tags or ratings to search for, check them here.
|
|
if (check_url_against_database($filedata['file'], $dbterms['tags'], $dbterms['rating']) == false) {
|
|
return false;
|
|
}
|
|
}
|
|
if (strpos($filedata['Title'], "[unplayable]") === 0) {
|
|
logger::log("COLLECTION", "Ignoring unplayable track ".$filedata['file']);
|
|
return false;
|
|
}
|
|
if (strpos($filedata['Title'], "[loading]") === 0) {
|
|
logger::log("COLLECTION", "Ignoring unloaded track ".$filedata['file']);
|
|
return false;
|
|
}
|
|
$filedata['unmopfile'] = $this->unmopify_file($filedata);
|
|
|
|
if ($filedata['Track'] == 0) {
|
|
$filedata['Track'] = format_tracknum(basename(rawurldecode($filedata['file'])));
|
|
} else {
|
|
$filedata['Track'] = format_tracknum(ltrim($filedata['Track'], '0'));
|
|
}
|
|
|
|
// cue sheet link (mpd only). We're only doing CUE sheets, not M3U
|
|
if ($filedata['X-AlbumUri'] === null && strtolower(pathinfo($filedata['playlist'], PATHINFO_EXTENSION)) == "cue") {
|
|
$filedata['X-AlbumUri'] = $filedata['playlist'];
|
|
logger::mark("COLLECTION", "Found CUE sheet for album ".$filedata['Album']);
|
|
}
|
|
|
|
// Disc Number
|
|
if ($filedata['Disc'] != null) {
|
|
$filedata['Disc'] = format_tracknum(ltrim($filedata['Disc'], '0'));
|
|
}
|
|
|
|
$filedata['year'] = getYear($filedata['Date']);
|
|
|
|
$this->player_specific_fixups($filedata);
|
|
|
|
$numtracks++;
|
|
$totaltime += $filedata['Time'];
|
|
return true;
|
|
|
|
}
|
|
|
|
private function unmopify_file(&$filedata) {
|
|
global $prefs;
|
|
if ($filedata['Pos'] !== null) {
|
|
// Convert URIs for different player types to be appropriate for the collection
|
|
// but only when we're getting the playlist
|
|
if ($this->is_slave && $filedata['domain'] == 'file') {
|
|
$filedata['file'] = $this->swap_file_for_local($filedata['file']);
|
|
$filedata['domain'] = 'local';
|
|
}
|
|
if ($prefs['collection_player'] == 'mopidy' && $this->player_type == 'mpd') {
|
|
$filedata['file'] = $this->mpd_to_mopidy($filedata['file']);
|
|
}
|
|
if ($prefs['collection_player'] == 'mpd' && $this->player_type == 'mopidy') {
|
|
$filedata['file'] = $this->mopidy_to_mpd($filedata['file']);
|
|
}
|
|
}
|
|
// eg local:track:some/uri/of/a/file
|
|
// We want the path, not the domain or type
|
|
// This is much faster than using a regexp
|
|
$cock = explode(':', $filedata['file']);
|
|
if (count($cock) > 1) {
|
|
$file = array_pop($cock);
|
|
} else {
|
|
$file = $filedata['file'];
|
|
}
|
|
return $file;
|
|
}
|
|
|
|
private function album_from_path($p) {
|
|
$a = rawurldecode(basename(dirname($p)));
|
|
if ($a == ".") {
|
|
$a = '';
|
|
}
|
|
return $a;
|
|
}
|
|
|
|
private function artist_from_path($p, $f) {
|
|
$a = rawurldecode(basename(dirname(dirname($p))));
|
|
if ($a == "." || $a == "" || $a == " & ") {
|
|
$a = ucfirst(getDomain(urldecode($f)));
|
|
}
|
|
return $a;
|
|
}
|
|
|
|
protected function check_undefined_tags(&$filedata) {
|
|
if ($filedata['Title'] == null) $filedata['Title'] = rawurldecode(basename($filedata['file']));
|
|
if ($filedata['Album'] == null) $filedata['Album'] = $this->album_from_path($filedata['unmopfile']);
|
|
if ($filedata['Artist'] == null) $filedata['Artist'] = array($this->artist_from_path($filedata['unmopfile'], $filedata['file']));
|
|
}
|
|
|
|
public function get_status() {
|
|
return $this->do_mpd_command('status', true, false);
|
|
}
|
|
|
|
public function wait_for_state($expected_state) {
|
|
if ($expected_state !== null) {
|
|
$status = $this->get_status();
|
|
$retries = 20;
|
|
while ($retries > 0 && array_key_exists('state', $status) && $status['state'] != $expected_state) {
|
|
usleep(500000);
|
|
$retries--;
|
|
$status = $this->get_status();
|
|
}
|
|
}
|
|
}
|
|
|
|
public function clear_error() {
|
|
$this->send_command('clearerror');
|
|
}
|
|
|
|
public function get_current_song() {
|
|
return $this->do_mpd_command('currentsong', true, false);
|
|
}
|
|
|
|
public function get_config() {
|
|
if ($this->socket != '' && $this->player_type == 'mpd') {
|
|
return $this->do_mpd_command('config', true, false);
|
|
} else {
|
|
return array();
|
|
}
|
|
}
|
|
|
|
public function get_tagtypes() {
|
|
return $this->do_mpd_command('tagtypes', true, false);
|
|
}
|
|
|
|
public function get_commands() {
|
|
return $this->do_mpd_command('commands', true, false);
|
|
}
|
|
|
|
public function get_notcommands() {
|
|
return $this->do_mpd_command('notcommands', true, false);
|
|
}
|
|
|
|
public function get_decoders() {
|
|
return $this->do_mpd_command('decoders', true, false);
|
|
}
|
|
|
|
public function cancel_single_quietly() {
|
|
$this->send_command('single 0');
|
|
}
|
|
|
|
public function get_idle_status() {
|
|
return $this->do_mpd_command('idle player', true, false);
|
|
}
|
|
|
|
public function dummy_command() {
|
|
return $this->do_mpd_command('', true, false);
|
|
}
|
|
|
|
public function get_playlist(&$collection) {
|
|
$dirs = array();
|
|
foreach ($this->parse_list_output('playlistinfo', $dirs, false) as $filedata) {
|
|
// Check the database for extra track info
|
|
$filedata = array_replace($filedata, get_extra_track_info($filedata));
|
|
yield $collection->doNewPlaylistFile($filedata);
|
|
}
|
|
}
|
|
|
|
public function get_currentsong_as_playlist(&$collection) {
|
|
$dirs = array();
|
|
$retval = array();
|
|
foreach ($this->parse_list_output('currentsong', $dirs, false) as $filedata) {
|
|
// Check the database for extra track info
|
|
$filedata = array_replace($filedata, get_extra_track_info($filedata));
|
|
$retval = $collection->doNewPlaylistFile($filedata);
|
|
}
|
|
return $retval;
|
|
}
|
|
|
|
public function populate_collection($cmd, $domains, &$collection) {
|
|
$dirs = array();
|
|
foreach ($this->parse_list_output($cmd, $dirs, $domains) as $filedata) {
|
|
$collection->newTrack($filedata);
|
|
}
|
|
}
|
|
|
|
public function get_uris_for_directory($path) {
|
|
logger::log("PLAYER", "Getting Directory Items For",$path);
|
|
$items = array();
|
|
$parts = true;
|
|
$lines = array();
|
|
$this->send_command('lsinfo "'.format_for_mpd($path).'"');
|
|
// We have to read in the entire response then go through it
|
|
// because we only have the one connection to mpd so this function
|
|
// is not strictly re-entrant and recursing doesn't work unless we do this.
|
|
while(!feof($connection) && $parts) {
|
|
$parts = $this->getline($connection);
|
|
if ($parts === false) {
|
|
logger::debug("PLAYER", "Got OK or ACK from MPD");
|
|
} else {
|
|
$lines[] = $parts;
|
|
}
|
|
}
|
|
foreach ($lines as $parts) {
|
|
if (is_array($parts)) {
|
|
$s = trim($parts[1]);
|
|
if (substr($s,0,1) != ".") {
|
|
switch ($parts[0]) {
|
|
case "file":
|
|
$items[] = $s;
|
|
break;
|
|
|
|
case "directory":
|
|
$items = array_merge($items, $this->get_uris_for_directory($s));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $items;
|
|
}
|
|
|
|
public function get_uri_handlers() {
|
|
$handlers = $this->do_mpd_command('urlhandlers', true);
|
|
if (is_array($handlers) && array_key_exists('handler', $handlers)) {
|
|
return $handlers['handler'];
|
|
} else {
|
|
return array();
|
|
}
|
|
}
|
|
|
|
public function get_outputs() {
|
|
return $this->do_mpd_command('outputs', true);
|
|
}
|
|
|
|
public function get_stored_playlists($only_personal = false) {
|
|
global $PLAYER_TYPE;
|
|
$this->playlist_error = false;
|
|
$retval = array();
|
|
$playlists = $this->do_mpd_command('listplaylists', true, true);
|
|
if (is_array($playlists) && array_key_exists('playlist', $playlists)) {
|
|
$retval = $playlists['playlist'];
|
|
usort($retval, 'sort_playlists');
|
|
if ($only_personal) {
|
|
$retval = array_filter($retval, $PLAYER_TYPE.'::is_personal_playlist');
|
|
}
|
|
} else if (is_array($playlists) && array_key_exists('error', $playlists)) {
|
|
// We frequently get an error getting stored playlists - especially from mopidy
|
|
// This flag is set so that loadplaylists.php doesn't remove all our stored playlist
|
|
// images in the event of that happening.
|
|
$this->playlist_error = true;
|
|
}
|
|
return $retval;
|
|
}
|
|
|
|
public function get_stored_playlist_tracks($playlistname, $startpos) {
|
|
$dirs = array();
|
|
$count = 0;
|
|
foreach ($this->parse_list_output('listplaylistinfo "'.$playlistname.'"', $dirs, false) as $filedata) {
|
|
if ($count >= $startpos) {
|
|
list($class, $url) = $this->get_checked_url($filedata['file']);
|
|
yield array($class, $url, $filedata);
|
|
}
|
|
$count++;
|
|
}
|
|
}
|
|
|
|
public function get_tracks_for_spotify_artist($artist) {
|
|
$dirs = array();
|
|
$collection = new musicCollection();
|
|
foreach ($this->parse_list_output('find "artist" "'.format_for_mpd($artist).'"', $dirs, array("spotify")) as $filedata) {
|
|
$collection->newTrack($filedata);
|
|
}
|
|
return $collection->getAllTracks('add');
|
|
}
|
|
|
|
private function translate_commands_for_slave(&$cmds) {
|
|
//
|
|
// Re-check all add and playlistadd commands if we're using a Mopidy File Backend Slave
|
|
//
|
|
foreach ($cmds as $key => $cmd) {
|
|
// add "local:track:
|
|
// playlistadd "local:track:
|
|
if (substr($cmd, 0, 17) == 'add "local:track:' ||
|
|
substr($cmd, 0,25) == 'playlistadd "local:track:') {
|
|
logger::log("MOPIDY", "Translating tracks for Mopidy Slave");
|
|
$cmds[$key] = $this->swap_local_for_file($cmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function translate_player_types(&$cmds) {
|
|
//
|
|
// Experimental translation to and from MPD/Mopidy Local URIs
|
|
//
|
|
global $prefs;
|
|
foreach ($cmds as $key => $cmd) {
|
|
if (substr($cmd, 0, 4) == 'add ') {
|
|
logger::log("PLAYER", "Translating Track Uris from",$prefs['collection_player'],'to',$this->player_type);
|
|
if ($prefs['collection_player']== 'mopidy') {
|
|
$cmds[$key] = $this->mopidy_to_mpd($cmd);
|
|
} else if ($prefs['collection_player']== 'mpd'){
|
|
$file = trim(substr($cmd, 4), '" ');
|
|
$cmds[$key] = 'add '.$this->mpd_to_mopidy($file);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private function mopidy_to_mpd($file) {
|
|
return rawurldecode(preg_replace('#local:track:#', '', $file));
|
|
}
|
|
|
|
private function mpd_to_mopidy($file) {
|
|
if (substr($file, 0, 5) != 'http:' && substr($file, 0, 6) != 'https:') {
|
|
return 'local:track:'.implode("/", array_map("rawurlencode", explode("/", $file)));
|
|
} else {
|
|
return $file;
|
|
}
|
|
}
|
|
|
|
private function swap_local_for_file($string) {
|
|
// url encode the album art directory
|
|
global $prefs;
|
|
$path = implode("/", array_map("rawurlencode", explode("/", $prefs['music_directory_albumart'])));
|
|
logger::log("MOPIDYSLAVE", "Replacing with",$path);
|
|
return preg_replace('#local:track:#', 'file://'.$path.'/', $string);
|
|
}
|
|
|
|
private function swap_file_for_local($string) {
|
|
global $prefs;
|
|
$path = 'file://'.implode("/", array_map("rawurlencode", explode("/", $prefs['music_directory_albumart']))).'/';
|
|
return preg_replace('#'.$path.'#', 'local:track:', $string);
|
|
}
|
|
|
|
private function probe_player_type() {
|
|
global $prefs;
|
|
$retval = false;
|
|
if ($this->is_connected()) {
|
|
logger::shout("MPDPLAYER", "Probing Player Type....");
|
|
$r = $this->do_mpd_command('tagtypes', true, true);
|
|
if (is_array($r) && array_key_exists('tagtype', $r)) {
|
|
if (in_array('X-AlbumUri', $r['tagtype'])) {
|
|
logger::mark("MPDPLAYER", " ....tagtypes test says we're running Mopidy. Setting cookie");
|
|
$retval = "mopidy";
|
|
} else {
|
|
logger::mark("MPDPLAYER", " ....tagtypes test says we're running MPD. Setting cookie");
|
|
$retval = "mpd";
|
|
}
|
|
} else {
|
|
logger::mark("MPDPLAYER", "WARNING! No output for 'tagtypes' - probably an old version of Mopidy. RompЯ may not function correctly");
|
|
$retval = "mopidy";
|
|
}
|
|
setcookie('player_backend',$retval,time()+365*24*60*60*10,'/');
|
|
$prefs['player_backend'] = $retval;
|
|
}
|
|
return $retval;
|
|
}
|
|
|
|
}
|
|
?>
|