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   (cond
 304    (squeeze-control-display-syncgroups
 305     (with-current-buffer (get-buffer-create "*squeeze-control*")
 306       (squeeze-control-mode)
 307       (read-only-mode -1)
 308       (erase-buffer)
 309       (let ((syncgroups squeeze-syncgroups)
 310             (seen))
 311         (while syncgroups
 312           (let ((names (getf syncgroups :names))
 313                 (members (split-string (getf syncgroups :members) ",")))
 314             (insert (propertize names 'face 'squeeze-syncgroup-face) "\n")
 315             (dolist (member members)
 316               (let ((player (squeeze-find-player member)))
 317                 (squeeze-control-insert-player player)
 318                 (push player seen))))
 319           (setq syncgroups (cddddr syncgroups)))
 320         (insert (propertize "No syncgroup" 'face 'squeeze-syncgroup-face) "\n")
 321         (dolist (player squeeze-players)
 322           (unless (member player seen)
 323             (squeeze-control-insert-player player))))))
 324    (t
 325     (with-current-buffer (get-buffer-create "*squeeze-control*")
 326       (squeeze-control-mode)
 327       (read-only-mode -1)
 328       (erase-buffer)
 329       (dolist (player squeeze-players)
 330         (squeeze-control-insert-player player))
 331       (read-only-mode 1)))))
 332
 333 (cl-defstruct (squeeze-player (:constructor squeeze-make-player))
 334   playerindex playerid uuid ip name model isplayer displaytype canpoweroff connected power volume)
 335
 336 (defun squeeze-string-plistify (string start end)
 337   (save-match-data
 338     (let (result)
 339       (loop
 340        (if (string-match "\\([a-z]+\\)%3A\\([^ \n]+\\)" string start)
 341            (let ((mend (match-end 0)))
 342              (when (> mend end)
 343                (return))
 344              (push (intern (format ":%s" (substring string (match-beginning 1) (match-end 1)))) result)
 345              (push (url-unhex-string (substring string (match-beginning 2) (match-end 2))) result)
 346              (setq start mend))
 347          (return)))
 348       (nreverse result))))
 349
 350 (defun squeeze-parse-syncgroups-line (string)
 351   (let ((syncgroupspos (string-match "^syncgroups " string))
 352         (startpos (match-end 0)))
 353     (when startpos
 354       (squeeze-string-plistify string startpos (length string)))))
 355
 356 (defun squeeze-parse-players-line (string)
 357   (let ((countpos (string-match " count%3A\\([0-9]\\) " string))
 358         (startpos (match-end 0)))
 359     (unless countpos
 360       (message "no count found in players line"))
 361     (let ((count (parse-integer string (match-beginning 1) (match-end 1)))
 362           result endpos)
 363       (dotimes (i (1- count))
 364         (setq endpos (progn (string-match " connected%3A[0-1] " string startpos)
 365                             (match-end 0)))
 366         (push (apply 'squeeze-make-player (squeeze-string-plistify string startpos endpos)) result)
 367         (setq startpos endpos))
 368       (push (apply 'squeeze-make-player (squeeze-string-plistify string startpos (length string))) result)
 369       result)))
 370
 371 (defun squeeze-complete-command-at-point ()
 372   (save-excursion
 373     (list (progn (backward-word) (point))
 374           (progn (forward-word) (point))
 375           '(;; General commands and queries
 376             "login" "can" "version" "listen" "subscribe" "pref"
 377             "logging" "getstring" "setsncredentials" "debug"
 378             "exit" "shutdown"
 379
 380             ;; Player commands and queries
 381             "player" "count" "id" "uuid" "name" "ip" "model" "isplayer"
 382             "displaytype" "canpoweroff" "?" "signalstrength" "connected"
 383             "sleep" "sync" "syncgroups" "power" "mixer" "volume" "muting"
 384             "bass" "treble" "pitch" "show" "display" "linesperscreen"
 385             "displaynow" "playerpref" "button" "ir" "irenable"
 386             "connect" "client" "forget" "disconnect" "players"
 387
 388             ;; Database commands and queries
 389             "rescan" "rescanprogress" "abortscan" "wipecache" "info"
 390             "total" "genres" "artists" "albums" "songs" "years"
 391             "musicfolder" "playlists" "tracks" "new" "rename" "delete"
 392             "edit" "songinfo" "titles" "search" "pragma"
 393
 394             ;; Playlist commands and queries
 395             "play" "stop" "pause" "mode" "time" "genre" "artist" "album"
 396             "title" "duration" "remote" "current_title" "path" "playlist"
 397             "add" "insert" "deleteitem" "move" "delete" "preview" "resume"
 398             "save" "loadalbum" "addalbum" "loadtracks" "addtracks"
 399             "insertalbum" "deletealbum" "clear" "zap" "name" "url"
 400             "modified" "playlistsinfo" "index" "shuffle" "repeat"
 401             "playlistcontrol"
 402
 403             ;; Compound queries
 404             "serverstatus" "status" "displaystatus" "readdirectory"
 405
 406             ;; Notifications
 407
 408             ;; Alarm commands and queries
 409             "alarm" "alarms"
 410
 411             ;; Plugins commands and queries
 412             "favorites"
 413             ))))
 414
 415 (defun squeeze ()
 416   (interactive)
 417   (let ((buffer (make-comint-in-buffer "squeeze" nil
 418                                        (cons squeeze-server-address
 419                                              squeeze-server-port))))
 420     (switch-to-buffer buffer)
 421     (squeeze-mode)))
 422
 423 (defun squeeze-control ()
 424   (interactive)
 425   (squeeze)
 426   (let ((buffer (get-buffer-create "*squeeze-control*")))
 427     (switch-to-buffer buffer)
 428     (squeeze-control-listen)
 429     (squeeze-control-refresh)
 430     (squeeze-control-display-players)))