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-accept-process-output ()
 243   (while (accept-process-output (get-buffer-process "*squeeze*") 0.1 nil t)))
 244
 245 (defun squeeze-control-refresh ()
 246   (interactive)
 247   (let ((squeeze-control-inhibit-display t))
 248     (squeeze-control-query-players)
 249     (squeeze-accept-process-output)
 250     (squeeze-control-query-syncgroups)
 251     (dolist (player squeeze-players)
 252       (squeeze-control-query-power (squeeze-player-playerid player))
 253       (squeeze-control-query-mixer-volume (squeeze-player-playerid player))))
 254   (squeeze-accept-process-output)
 255   (squeeze-control-display-players))
 256
 257 (defvar squeeze-control-mixer-map
 258   (let ((map (make-sparse-keymap)))
 259     (define-key map (kbd "RET") 'squeeze-control-mixer-set-volume)
 260     (define-key map [mouse-1] 'squeeze-control-mixer-mouse-1)
 261     map))
 262
 263 (defun squeeze-control-compute-volume (pos)
 264   (let* ((end (next-single-property-change pos 'keymap))
 265          (start (previous-single-property-change end 'keymap)))
 266     (/ (* 100 (- (point) start)) (- end start 1))))
 267
 268 (defun squeeze-control-mixer-mouse-1 (event)
 269   (interactive "e")
 270   (let* ((pos (cadadr event))
 271          (val (squeeze-control-compute-volume pos))
 272          (id (get-text-property pos 'squeeze-playerid)))
 273     (squeeze-control-volume-set id val)))
 274
 275 (defun squeeze-control-mixer-set-volume ()
 276   (interactive)
 277   (let* ((val (squeeze-control-compute-volume (point)))
 278          (id (get-text-property (point) 'squeeze-playerid)))
 279     (squeeze-control-volume-set id val)))
 280
 281 (defvar squeeze-control-display-syncgroups nil)
 282
 283 (defun squeeze-control-toggle-syncgroup-display ()
 284   (interactive)
 285   (setf squeeze-control-display-syncgroups
 286         (not squeeze-control-display-syncgroups))
 287   (squeeze-control-display-players))
 288
 289 (defun squeeze-control-insert-player (player)
 290   (insert (propertize (format "%20s" (squeeze-player-name player))
 291                       'face (squeeze-control-player-face player)
 292                       'squeeze-playerid (squeeze-player-playerid player)))
 293   (when (squeeze-player-volume player)
 294     (insert (propertize
 295              (squeeze-mixer-make-bar (squeeze-player-volume player) 28)
 296              'squeeze-playerid (squeeze-player-playerid player)
 297              'keymap squeeze-control-mixer-map
 298              'pointer 'hdrag
 299              'rear-nonsticky '(keymap))))
 300   (insert (propertize "\n" 'intangible t)))
 301
 302 (defun squeeze-control-display-players ()
 303   (interactive)
 304   (with-current-buffer (get-buffer-create "*squeeze-control*")
 305     (let ((saved (point)))
 306       (squeeze-control-mode)
 307       (read-only-mode -1)
 308       (erase-buffer)
 309       (cond
 310        (squeeze-control-display-syncgroups
 311         (let ((syncgroups squeeze-syncgroups)
 312               (seen))
 313           (while syncgroups
 314             (let ((names (getf syncgroups :names))
 315                   (members (split-string (getf syncgroups :members) ",")))
 316               (insert (propertize names 'face 'squeeze-syncgroup-face) "\n")
 317               (dolist (member members)
 318                 (let ((player (squeeze-find-player member)))
 319                   (squeeze-control-insert-player player)
 320                   (push player seen))))
 321             (setq syncgroups (cddddr syncgroups)))
 322           (insert (propertize "No syncgroup" 'face 'squeeze-syncgroup-face) "\n")
 323           (dolist (player squeeze-players)
 324             (unless (member player seen)
 325               (squeeze-control-insert-player player)))))
 326        (t
 327         (dolist (player squeeze-players)
 328           (squeeze-control-insert-player player))
 329         (read-only-mode 1)))
 330       (goto-char saved))))
 331
 332 (cl-defstruct (squeeze-player (:constructor squeeze-make-player))
 333   playerindex playerid uuid ip name model isplayer displaytype canpoweroff connected power volume)
 334
 335 (defun squeeze-string-plistify (string start end)
 336   (save-match-data
 337     (let (result)
 338       (loop
 339        (if (string-match "\\([a-z]+\\)%3A\\([^ \n]+\\)" string start)
 340            (let ((mend (match-end 0)))
 341              (when (> mend end)
 342                (return))
 343              (push (intern (format ":%s" (substring string (match-beginning 1) (match-end 1)))) result)
 344              (push (url-unhex-string (substring string (match-beginning 2) (match-end 2))) result)
 345              (setq start mend))
 346          (return)))
 347       (nreverse result))))
 348
 349 (defun squeeze-parse-syncgroups-line (string)
 350   (let ((syncgroupspos (string-match "^syncgroups " string))
 351         (startpos (match-end 0)))
 352     (when startpos
 353       (squeeze-string-plistify string startpos (length string)))))
 354
 355 (defun squeeze-parse-players-line (string)
 356   (let ((countpos (string-match " count%3A\\([0-9]\\) " string))
 357         (startpos (match-end 0)))
 358     (unless countpos
 359       (message "no count found in players line"))
 360     (let ((count (string-to-number (substring string (match-beginning 1) (match-end 1))))
 361           result endpos)
 362       (dotimes (i (1- count))
 363         (setq endpos (progn (string-match " connected%3A[0-1] " string startpos)
 364                             (match-end 0)))
 365         (push (apply 'squeeze-make-player (squeeze-string-plistify string startpos endpos)) result)
 366         (setq startpos endpos))
 367       (push (apply 'squeeze-make-player (squeeze-string-plistify string startpos (length string))) result)
 368       result)))
 369
 370 (defun squeeze-complete-command-at-point ()
 371   (save-excursion
 372     (list (progn (backward-word) (point))
 373           (progn (forward-word) (point))
 374           '(;; General commands and queries
 375             "login" "can" "version" "listen" "subscribe" "pref"
 376             "logging" "getstring" "setsncredentials" "debug"
 377             "exit" "shutdown"
 378
 379             ;; Player commands and queries
 380             "player" "count" "id" "uuid" "name" "ip" "model" "isplayer"
 381             "displaytype" "canpoweroff" "?" "signalstrength" "connected"
 382             "sleep" "sync" "syncgroups" "power" "mixer" "volume" "muting"
 383             "bass" "treble" "pitch" "show" "display" "linesperscreen"
 384             "displaynow" "playerpref" "button" "ir" "irenable"
 385             "connect" "client" "forget" "disconnect" "players"
 386
 387             ;; Database commands and queries
 388             "rescan" "rescanprogress" "abortscan" "wipecache" "info"
 389             "total" "genres" "artists" "albums" "songs" "years"
 390             "musicfolder" "playlists" "tracks" "new" "rename" "delete"
 391             "edit" "songinfo" "titles" "search" "pragma"
 392
 393             ;; Playlist commands and queries
 394             "play" "stop" "pause" "mode" "time" "genre" "artist" "album"
 395             "title" "duration" "remote" "current_title" "path" "playlist"
 396             "add" "insert" "deleteitem" "move" "delete" "preview" "resume"
 397             "save" "loadalbum" "addalbum" "loadtracks" "addtracks"
 398             "insertalbum" "deletealbum" "clear" "zap" "name" "url"
 399             "modified" "playlistsinfo" "index" "shuffle" "repeat"
 400             "playlistcontrol"
 401
 402             ;; Compound queries
 403             "serverstatus" "status" "displaystatus" "readdirectory"
 404
 405             ;; Notifications
 406
 407             ;; Alarm commands and queries
 408             "alarm" "alarms"
 409
 410             ;; Plugins commands and queries
 411             "favorites"
 412             ))))
 413
 414 (defun squeeze ()
 415   (interactive)
 416   (let ((buffer (make-comint-in-buffer "squeeze" nil
 417                                        (cons squeeze-server-address
 418                                              squeeze-server-port))))
 419     (switch-to-buffer buffer)
 420     (squeeze-mode)))
 421
 422 (defun squeeze-control ()
 423   (interactive)
 424   (squeeze)
 425   (let ((buffer (get-buffer-create "*squeeze-control*")))
 426     (switch-to-buffer buffer)
 427     (squeeze-control-listen)
 428     (squeeze-control-refresh)
 429     (squeeze-control-display-players)))