squeeze.el

   1 (defgroup squeeze nil
   2   "Interact with Squeezebox media servers"
   3   :prefix "squeeze-"
   4   :group 'applications)
   5
   6 (defcustom squeeze-server-address "localhost"
   7   "Address for the Squeezebox server"
   8   :group 'squeeze)
   9 (defcustom squeeze-server-port 9090
  10   "Port number for the Squeezebox server"
  11   :group 'squeeze)
  12
  13 (defvar squeeze-mode-map
  14   (let ((map (make-sparse-keymap)))
  15     (define-key map (kbd "TAB") 'completion-at-point)
  16     map))
  17
  18 (define-derived-mode squeeze-mode comint-mode "Squeeze"
  19   "Major mode for interacting with the Squeezebox Server CLI.\\<squeeze-mode-map>"
  20   (add-to-list 'completion-at-point-functions 'squeeze-complete-command-at-point)
  21   (add-hook 'comint-preoutput-filter-functions 'url-unhex-string nil t)
  22   (add-hook 'comint-preoutput-filter-functions 'squeeze-update-state nil t))
  23
  24 (defvar squeeze-control-mode-map
  25   (let ((map (make-sparse-keymap)))
  26     (define-key map (kbd "SPC") 'squeeze-control-toggle-power)
  27     (define-key map (kbd "f") 'squeeze-control-play-favorite)
  28     (define-key map (kbd "g") 'squeeze-control-refresh)
  29     (define-key map (kbd "+") 'squeeze-control-volume-up)
  30     (define-key map (kbd "-") 'squeeze-control-volume-down)
  31     (define-key map (kbd "t") 'squeeze-control-toggle-syncgroup-display)
  32     map))
  33
  34 (define-derived-mode squeeze-control-mode special-mode "SqueezeControl"
  35   "Major mode for controlling Squeezebox Servers.\\<squeeze-control-mode-map>")
  36
  37 (defvar squeeze-control-inhibit-display nil)
  38
  39 (defun squeeze-update-state (string)
  40   (let (done-something)
  41     (dolist (line (split-string string "\n"))
  42       (when (squeeze-update-state-from-line line)
  43         (setq done-something t)))
  44     (when done-something
  45       (unless squeeze-control-inhibit-display
  46         (squeeze-control-display-players))))
  47   string)
  48
  49 (defconst squeeze-player-line-regexp
  50   "^\\(\\(?:[0-9a-f]\\{2\\}%3A\\)\\{5\\}[0-9a-f]\\{2\\}\\) ")
  51
  52 (defun squeeze-find-player (id)
  53   (dolist (player squeeze-players)
  54     (when (string= id (squeeze-player-playerid player))
  55       (return player))))
  56
  57 (defun squeeze-update-power (player state)
  58   (if state
  59       (setf (squeeze-player-power player) state)
  60     (let ((current (squeeze-player-power player)))
  61       (setf (squeeze-player-power player)
  62             (cond ((string= current "0") "1")
  63                   ((string= current "1") "0"))))))
  64
  65 (defun squeeze-update-mixer-volume (player value)
  66   (let ((current (squeeze-player-volume player))
  67         (number (string-to-number value)))
  68     (if (string-match "^[-+]" value)
  69         (setf (squeeze-player-volume player)
  70               (and current (max 0 (min 100 (+ current number)))))
  71       (setf (squeeze-player-volume player) number))))
  72
  73 (defun squeeze-update-state-from-line (string)
  74   (cond
  75    ((string-match "^players 0" string)
  76     (setq squeeze-players (squeeze-parse-players-line string))
  77     t)
  78    ((string-match "^syncgroups" string)
  79     (setq squeeze-syncgroups (squeeze-parse-syncgroups-line string))
  80     t)
  81    ((string-match squeeze-player-line-regexp string)
  82     (let ((substring (substring string (match-end 0)))
  83           (id (url-unhex-string (match-string 1 string))))
  84       (cond
  85        ((string-match "^power\\(?: \\([01]\\)\\)?" substring)
  86         (let ((state (match-string 1 substring))
  87               (player (squeeze-find-player id)))
  88           (squeeze-update-power player state))
  89         t)
  90        ((string-match "^mixer volume \\(\\(?:-\\|%2B\\)?[0-9]*\\)" substring)
  91         (let ((value (url-unhex-string (match-string 1 substring)))
  92               (player (squeeze-find-player id)))
  93           (squeeze-update-mixer-volume player value))
  94         t))))))
  95
  96 (defface squeeze-player-face
  97   '((t))
  98   "Face for displaying players"
  99   :group 'squeeze)
 100 (defface squeeze-player-on-face
 101   '((t :weight bold :inherit squeeze-player-face))
 102   "Face for displaying players which are on"
 103   :group 'squeeze)
 104 (defface squeeze-player-off-face
 105   '((t :weight light :inherit squeeze-player-face))
 106   "Face for displaying players which are off"
 107   :group 'squeeze)
 108
 109 (defface squeeze-mixer-face
 110   '((t :weight bold))
 111   "Face for displaying mixer information"
 112   :group 'squeeze)
 113 (defface squeeze-mixer-muted-face
 114   '((t :weight light :inherit squeeze-mixer-face))
 115   "Face for displaying mixer information when muted"
 116   :group 'squeeze)
 117 (defface squeeze-mixer-quiet-face
 118   '((t :foreground "green3" :inherit squeeze-mixer-face))
 119   "Face for quiet volume"
 120   :group 'squeeze)
 121 (defface squeeze-mixer-medium-face
 122   '((t :foreground "gold" :inherit squeeze-mixer-face))
 123   "Face for medium volume"
 124   :group 'squeeze)
 125 (defface squeeze-mixer-loud-face
 126   '((t :foreground "OrangeRed1" :inherit squeeze-mixer-face))
 127   "Face for loud volume"
 128   :group 'squeeze)
 129 (defface squeeze-mixer-muted-quiet-face
 130   '((t :inherit (squeeze-mixer-muted-face squeeze-mixer-quiet-face)))
 131   "Face for quiet volume when muted")
 132 (defface squeeze-syncgroup-face
 133   '((t :slant italic))
 134   "Face for syncgroups"
 135   :group 'squeeze)
 136
 137 (defun squeeze-mixer-compute-bar (vol width)
 138   (let* ((exact (* width (/ vol 100.0)))
 139          (nfull (floor exact))
 140          (frac (- exact nfull))
 141          (nblank (floor (- width exact))))
 142     (format "%s%s%s"
 143             (make-string nfull ?█)
 144             (cond ((= width (+ nfull nblank)) "")
 145                   ((< frac 0.0625) " ")
 146                   ((< frac 0.1875) "▏")
 147                   ((< frac 0.3125) "▎")
 148                   ((< frac 0.4375) "▍")
 149                   ((< frac 0.5625) "▌")
 150                   ((< frac 0.6875) "▋")
 151                   ((< frac 0.8125) "▊")
 152                   ((< frac 0.9375) "▉")
 153                   (t "█"))
 154             (make-string nblank ? ))))
 155
 156 (defun squeeze-mixer-make-bar (vol width)
 157   (let ((bar (squeeze-mixer-compute-bar vol width))
 158         (lo (floor (* 0.65 width)))
 159         (hi (floor (* 0.9 width))))
 160     (concat "▕"
 161             (propertize (substring bar 0 lo) 'face 'squeeze-mixer-quiet-face)
 162             (propertize (substring bar lo hi) 'face 'squeeze-mixer-medium-face)
 163             (propertize (substring bar hi) 'face 'squeeze-mixer-loud-face)
 164             (propertize "▏" 'intangible t))))
 165
 166 (defvar squeeze-players ())
 167 (defvar squeeze-syncgroups ())
 168
 169 (defun squeeze-send-string (control &rest arguments)
 170   (let* ((process (get-buffer-process "*squeeze*"))
 171          (string (apply #'format control arguments))
 172          (length (length string)))
 173     (unless (and (> length 0) (char-equal (aref string (1- length)) ?\n))
 174       (setq string (format "%s\n" string)))
 175     (if process
 176         (comint-send-string process string)
 177       (error "can't find squeeze process"))))
 178
 179 (defun squeeze-control-query-syncgroups ()
 180   (interactive)
 181   (squeeze-send-string "syncgroups ?"))
 182
 183 (defun squeeze-control-query-players ()
 184   (interactive)
 185   (squeeze-send-string "players 0"))
 186
 187 (defun squeeze-control-toggle-power (&optional id)
 188   (interactive)
 189   (unless id
 190     (setq id (get-text-property (point) 'squeeze-playerid)))
 191   (squeeze-send-string "%s power" id))
 192
 193 (defun squeeze-control-play-favorite (&optional favorite id)
 194   (interactive "nFavourite: ")
 195   (unless id
 196     (setq id (get-text-property (point) 'squeeze-playerid)))
 197   (squeeze-send-string "%s favorites playlist play item_id:%d" id favorite))
 198
 199 (defun squeeze-control-query-power (&optional id)
 200   (interactive)
 201   (unless id
 202     (setq id (get-text-property (point) 'squeeze-playerid)))
 203   (when id
 204     (squeeze-send-string "%s power ?" id)))
 205
 206 (defun squeeze-control-volume-up (&optional id inc)
 207   (interactive)
 208   (unless inc (setq inc 5))
 209   (unless id
 210     (setq id (get-text-property (point) 'squeeze-playerid)))
 211   (when id
 212     (squeeze-send-string "%s mixer volume %+d" id inc)))
 213
 214 (defun squeeze-control-volume-down (&optional id inc)
 215   (interactive)
 216   (unless inc (setq inc 5))
 217   (unless id
 218     (setq id (get-text-property (point) 'squeeze-playerid)))
 219   (when id
 220     (squeeze-send-string "%s mixer volume %+d" id (- inc))))
 221
 222 (defun squeeze-control-volume-set (id val)
 223   (interactive)
 224   (squeeze-send-string "%s mixer volume %d" id val))
 225
 226 (defun squeeze-control-query-mixer-volume (&optional id)
 227   (interactive)
 228   (unless id
 229     (setq id (get-text-property (point) 'squeeze-playerid)))
 230   (when id
 231     (squeeze-send-string "%s mixer volume ?" id)))
 232
 233 (defun squeeze-control-player-face (player)
 234   (let ((power (squeeze-player-power player)))
 235     (cond ((string= power "1") 'squeeze-player-on-face)
 236           ((string= power "0") 'squeeze-player-off-face)
 237           (t 'squeeze-player-face))))
 238
 239 (defun squeeze-control-listen ()
 240   (squeeze-send-string "listen 1"))
 241
 242 (defun squeeze-control-refresh ()
 243   (interactive)
 244   (let ((squeeze-control-inhibit-display t))
 245     (squeeze-control-query-players)
 246     (accept-process-output (get-buffer-process "*squeeze*"))
 247     (squeeze-control-query-syncgroups)
 248     (accept-process-output (get-buffer-process "*squeeze*"))
 249     (dolist (player squeeze-players)
 250       (squeeze-control-query-power (squeeze-player-playerid player))
 251       (accept-process-output (get-buffer-process "*squeeze*"))
 252       (squeeze-control-query-mixer-volume (squeeze-player-playerid player))
 253       (accept-process-output (get-buffer-process "*squeeze*"))))
 254   (squeeze-control-display-players))
 255
 256 (defvar squeeze-control-mixer-map
 257   (let ((map (make-sparse-keymap)))
 258     (define-key map (kbd "RET") 'squeeze-control-mixer-set-volume)
 259     (define-key map [mouse-1] 'squeeze-control-mixer-mouse-1)
 260     map))
 261
 262 (defun squeeze-control-compute-volume (pos)
 263   (let* ((end (next-single-property-change pos 'keymap))
 264          (start (previous-single-property-change end 'keymap)))
 265     (/ (* 100 (- (point) start)) (- end start 1))))
 266
 267 (defun squeeze-control-mixer-mouse-1 (event)
 268   (interactive "e")
 269   (let* ((pos (cadadr event))
 270          (val (squeeze-control-compute-volume pos))
 271          (id (get-text-property pos 'squeeze-playerid)))
 272     (squeeze-control-volume-set id val)))
 273
 274 (defun squeeze-control-mixer-set-volume ()
 275   (interactive)
 276   (let* ((val (squeeze-control-compute-volume (point)))
 277          (id (get-text-property (point) 'squeeze-playerid)))
 278     (squeeze-control-volume-set id val)))
 279
 280 (defvar squeeze-control-display-syncgroups nil)
 281
 282 (defun squeeze-control-toggle-syncgroup-display ()
 283   (interactive)
 284   (setf squeeze-control-display-syncgroups
 285         (not squeeze-control-display-syncgroups))
 286   (squeeze-control-display-players))
 287
 288 (defun squeeze-control-insert-player (player)
 289   (insert (propertize (format "%20s" (squeeze-player-name player))
 290                       'face (squeeze-control-player-face player)
 291                       'squeeze-playerid (squeeze-player-playerid player)))
 292   (when (squeeze-player-volume player)
 293     (insert (propertize
 294              (squeeze-mixer-make-bar (squeeze-player-volume player) 28)
 295              'squeeze-playerid (squeeze-player-playerid player)
 296              'keymap squeeze-control-mixer-map
 297              'pointer 'hdrag
 298              'rear-nonsticky '(keymap))))
 299   (insert (propertize "\n" 'intangible t)))
 300
 301 (defun squeeze-control-display-players ()
 302   (interactive)
 303   (with-current-buffer (get-buffer-create "*squeeze-control*")
 304     (let ((saved (point)))
 305       (squeeze-control-mode)
 306       (read-only-mode -1)
 307       (erase-buffer)
 308       (cond
 309        (squeeze-control-display-syncgroups
 310         (let ((syncgroups squeeze-syncgroups)
 311               (seen))
 312           (while syncgroups
 313             (let ((names (getf syncgroups :names))
 314                   (members (split-string (getf syncgroups :members) ",")))
 315               (insert (propertize names 'face 'squeeze-syncgroup-face) "\n")
 316               (dolist (member members)
 317                 (let ((player (squeeze-find-player member)))
 318                   (squeeze-control-insert-player player)
 319                   (push player seen))))
 320             (setq syncgroups (cddddr syncgroups)))
 321           (insert (propertize "No syncgroup" 'face 'squeeze-syncgroup-face) "\n")
 322           (dolist (player squeeze-players)
 323             (unless (member player seen)
 324               (squeeze-control-insert-player player)))))
 325        (t
 326         (dolist (player squeeze-players)
 327           (squeeze-control-insert-player player))
 328         (read-only-mode 1)))
 329       (goto-char saved))))
 330
 331 (cl-defstruct (squeeze-player (:constructor squeeze-make-player))
 332   playerindex playerid uuid ip name model isplayer displaytype canpoweroff connected power volume)
 333
 334 (defun squeeze-string-plistify (string start end)
 335   (save-match-data
 336     (let (result)
 337       (loop
 338        (if (string-match "\\([a-z]+\\)%3A\\([^ \n]+\\)" string start)
 339            (let ((mend (match-end 0)))
 340              (when (> mend end)
 341                (return))
 342              (push (intern (format ":%s" (substring string (match-beginning 1) (match-end 1)))) result)
 343              (push (url-unhex-string (substring string (match-beginning 2) (match-end 2))) result)
 344              (setq start mend))
 345          (return)))
 346       (nreverse result))))
 347
 348 (defun squeeze-parse-syncgroups-line (string)
 349   (let ((syncgroupspos (string-match "^syncgroups " string))
 350         (startpos (match-end 0)))
 351     (when startpos
 352       (squeeze-string-plistify string startpos (length string)))))
 353
 354 (defun squeeze-parse-players-line (string)
 355   (let ((countpos (string-match " count%3A\\([0-9]\\) " string))
 356         (startpos (match-end 0)))
 357     (unless countpos
 358       (message "no count found in players line"))
 359     (let ((count (parse-integer string (match-beginning 1) (match-end 1)))
 360           result endpos)
 361       (dotimes (i (1- count))
 362         (setq endpos (progn (string-match " connected%3A[0-1] " string startpos)
 363                             (match-end 0)))
 364         (push (apply 'squeeze-make-player (squeeze-string-plistify string startpos endpos)) result)
 365         (setq startpos endpos))
 366       (push (apply 'squeeze-make-player (squeeze-string-plistify string startpos (length string))) result)
 367       result)))
 368
 369 (defun squeeze-complete-command-at-point ()
 370   (save-excursion
 371     (list (progn (backward-word) (point))
 372           (progn (forward-word) (point))
 373           '(;; General commands and queries
 374             "login" "can" "version" "listen" "subscribe" "pref"
 375             "logging" "getstring" "setsncredentials" "debug"
 376             "exit" "shutdown"
 377
 378             ;; Player commands and queries
 379             "player" "count" "id" "uuid" "name" "ip" "model" "isplayer"
 380             "displaytype" "canpoweroff" "?" "signalstrength" "connected"
 381             "sleep" "sync" "syncgroups" "power" "mixer" "volume" "muting"
 382             "bass" "treble" "pitch" "show" "display" "linesperscreen"
 383             "displaynow" "playerpref" "button" "ir" "irenable"
 384             "connect" "client" "forget" "disconnect" "players"
 385
 386             ;; Database commands and queries
 387             "rescan" "rescanprogress" "abortscan" "wipecache" "info"
 388             "total" "genres" "artists" "albums" "songs" "years"
 389             "musicfolder" "playlists" "tracks" "new" "rename" "delete"
 390             "edit" "songinfo" "titles" "search" "pragma"
 391
 392             ;; Playlist commands and queries
 393             "play" "stop" "pause" "mode" "time" "genre" "artist" "album"
 394             "title" "duration" "remote" "current_title" "path" "playlist"
 395             "add" "insert" "deleteitem" "move" "delete" "preview" "resume"
 396             "save" "loadalbum" "addalbum" "loadtracks" "addtracks"
 397             "insertalbum" "deletealbum" "clear" "zap" "name" "url"
 398             "modified" "playlistsinfo" "index" "shuffle" "repeat"
 399             "playlistcontrol"
 400
 401             ;; Compound queries
 402             "serverstatus" "status" "displaystatus" "readdirectory"
 403
 404             ;; Notifications
 405
 406             ;; Alarm commands and queries
 407             "alarm" "alarms"
 408
 409             ;; Plugins commands and queries
 410             "favorites"
 411             ))))
 412
 413 (defun squeeze ()
 414   (interactive)
 415   (let ((buffer (make-comint-in-buffer "squeeze" nil
 416                                        (cons squeeze-server-address
 417                                              squeeze-server-port))))
 418     (switch-to-buffer buffer)
 419     (squeeze-mode)))
 420
 421 (defun squeeze-control ()
 422   (interactive)
 423   (squeeze)
 424   (let ((buffer (get-buffer-create "*squeeze-control*")))
 425     (switch-to-buffer buffer)
 426     (squeeze-control-listen)
 427     (squeeze-control-refresh)
 428     (squeeze-control-display-players)))