]> mj.ucw.cz Git - ursary.git/blob - ursaryd.c
Changed name of my sound card
[ursary.git] / ursaryd.c
1 /*
2  *      The Ursary Audio Controls
3  *
4  *      (c) 2014--2018 Martin Mares <mj@ucw.cz>
5  */
6
7 #undef LOCAL_DEBUG
8
9 #include <ucw/lib.h>
10 #include <ucw/clists.h>
11 #include <ucw/daemon.h>
12 #include <ucw/log.h>
13 #include <ucw/mainloop.h>
14 #include <ucw/opt.h>
15 #include <ucw/stkstring.h>
16
17 #include <signal.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <stdlib.h>
21 #include <syslog.h>
22
23 #include "ursaryd.h"
24
25 /*
26  *      Map of all controls
27  *
28  *              rotary          red button      green button
29  *      0       sink PCH        mute            -
30  *      1       -               -               -
31  *      2       -               -               -
32  *      3       -               -               -
33  *      4       MPD             mute            play/pause/stop
34  *      5       Albireo MPV     mute            -
35  *      6       Albireo other   mute            -
36  *      7       other machines  mute            -
37  *
38  *      center  -
39  *      slider  -
40  */
41
42 #define PCH_SINK "alsa_output.pci-0000_00_1f.3.analog-stereo"
43
44 /*** Sink controls ***/
45
46 static double volume_from_pa(pa_volume_t vol)
47 {
48   return (double) vol / PA_VOLUME_NORM;
49 }
50
51 static pa_volume_t volume_to_pa(double vol)
52 {
53   return vol * PA_VOLUME_NORM + 0.0001;
54 }
55
56 static void update_ring_from_sink(int ring, const char *sink_name)
57 {
58   struct pulse_sink *s = pulse_sink_by_name(sink_name);
59   if (!s)
60     {
61       noct_set_ring(ring, RING_MODE_SINGLE_ON, 0x7f);
62       noct_set_button(ring, 0);
63       return;
64     }
65
66   if (s->mute)
67     {
68       noct_set_ring(ring, RING_MODE_SINGLE_ON, 0x7f);
69       noct_set_button(ring, 1);
70       return;
71     }
72
73   double vol = CLAMP(volume_from_pa(s->volume), 0, 1);
74   noct_set_ring(ring, RING_MODE_LEFT, CLAMP((int)(0x7f * vol), 12, 0x7f));
75   noct_set_button(ring, 0);
76 }
77
78 static void update_button_from_port(int button, const char *sink_name, const char *port_name)
79 {
80   struct pulse_sink *s = pulse_sink_by_name(sink_name);
81   if (!s)
82     {
83       noct_set_button(button, 0);
84       return;
85     }
86
87   noct_set_button(button, !strcmp(s->active_port, port_name));
88 }
89
90 static void update_sink_from_rotary(int delta, const char *sink_name)
91 {
92   struct pulse_sink *s = pulse_sink_by_name(sink_name);
93   if (!s)
94     return;
95
96   double vol = volume_from_pa(s->volume) + delta * 0.02;
97   pa_volume_t pavol = volume_to_pa(CLAMP(vol, 0, 1));
98   if (pavol == s->volume)
99     return;
100   pa_cvolume cvol;
101   pa_cvolume_set(&cvol, s->channels, pavol);
102
103   DBG("## Setting volume of sink %s to %d", s->name, cvol.values[0]);
104   pulse_sink_set_volume(s->idx, &cvol);
105 }
106
107 static void update_sink_mute_from_button(int on, const char *sink_name)
108 {
109   if (!on)
110     return;
111
112   struct pulse_sink *s = pulse_sink_by_name(sink_name);
113   if (!s)
114     return;
115
116   DBG("## Setting mute of sink %s to %d", s->name, !s->mute);
117   pulse_sink_set_mute(s->idx, !s->mute);
118 }
119
120 static void update_port_from_button(int on, const char *sink_name, const char *port1, const char *port2)
121 {
122   if (!on)
123     return;
124
125   struct pulse_sink *s = pulse_sink_by_name(sink_name);
126   if (!s)
127     return;
128
129   const char *port = port1;
130   if (!strcmp(s->active_port, port1))
131     port = port2;
132
133   DBG("## Setting port of sink %s to %s", s->name, port);
134   pulse_sink_set_port(s->idx, port);
135 }
136
137 /*** Client controls ***/
138
139 struct client_map {
140   int group;
141   const char *client;
142   const char *host;
143 };
144
145 static struct client_map client_map[] = {
146   { 4, "Music Player Daemon",   "albireo",      },
147   { 5, "mpv",                   "albireo",      },
148   { 6, NULL,                    "albireo",      },
149   { 7, NULL,                    NULL,           },
150 };
151
152 #define CLIENT_MAP_SIZE ARRAY_SIZE(client_map)
153
154 struct group_config {
155   bool enabled;
156   double range;
157 };
158
159 struct group_state {
160   double volume;
161   bool have_muted[2];
162 };
163
164 #define NUM_GROUPS 9
165
166 static struct group_config group_config[NUM_GROUPS] = {
167   [4] = { .enabled = 1, .range = 1.5 },
168   [5] = { .enabled = 1, .range = 1.5 },
169   [6] = { .enabled = 1, .range = 1.5 },
170   [7] = { .enabled = 1, .range = 1.5 },
171 };
172
173 static struct group_state group_state[NUM_GROUPS];
174
175 static void calc_groups(void)
176 {
177   bzero(group_state, sizeof(group_state));
178
179   CLIST_FOR_EACH(struct pulse_sink_input *, s, pulse_sink_input_list)
180     {
181       s->noct_group_idx = -1;
182
183       if (s->client_idx < 0 || s->sink_idx < 0)
184         continue;
185
186       struct pulse_client *c = pulse_client_by_idx(s->client_idx);
187       if (!c)
188         continue;
189
190       for (uns i=0; i < CLIENT_MAP_SIZE; i++)
191         {
192           struct client_map *cm = &client_map[i];
193           if ((!cm->client || !strcmp(cm->client, c->name)) &&
194               (!cm->host || !strcmp(cm->host, c->host)))
195             {
196               int g = cm->group;
197               struct group_state *gs = &group_state[g];
198               DBG("@@ Client #%d, sink input #%d -> group %d", s->client_idx, s->idx, g);
199               s->noct_group_idx = g;
200               gs->volume = MAX(gs->volume, s->volume);
201               gs->have_muted[!!s->mute] = 1;
202               break;
203             }
204         }
205     }
206 }
207
208 static void update_groups(void)
209 {
210   calc_groups();
211
212   for (uns i=0; i < NUM_GROUPS; i++)
213     {
214       struct group_config *gc = &group_config[i];
215       struct group_state *gs = &group_state[i];
216       if (!gc->enabled)
217         continue;
218
219       DBG("@@ Group #%d: mute=%d/%d volume=%.3f/%.3f", i, gs->have_muted[0], gs->have_muted[1], volume_from_pa(gs->volume), gc->range);
220
221       if (!gs->have_muted[0] && !gs->have_muted[1])
222         {
223           noct_set_ring(i, RING_MODE_LEFT, 0);
224           noct_set_button(i, 0);
225         }
226       else if (!gs->have_muted[0])
227         {
228           noct_set_ring(i, RING_MODE_SINGLE_ON, 0x7f);
229           noct_set_button(i, 1);
230         }
231       else
232         {
233           double vol = CLAMP(volume_from_pa(gs->volume), 0, gc->range);
234           int val = 0x7f * vol / gc->range;
235           val = CLAMP(val, 12, 0x7f);
236           noct_set_ring(i, RING_MODE_LEFT, val);
237           noct_set_button(i, 0);
238         }
239     }
240 }
241
242 static void update_group_from_rotary(int i, int delta)
243 {
244   if (i >= NUM_GROUPS)
245     return;
246   struct group_config *gc = &group_config[i];
247   struct group_state *gs = &group_state[i];
248   if (!gc->enabled)
249     return;
250
251   calc_groups();
252   double vol = volume_from_pa(gs->volume) + delta*0.02;
253   pa_volume_t pavol = volume_to_pa(CLAMP(vol, 0, gc->range));
254
255   CLIST_FOR_EACH(struct pulse_sink_input *, s, pulse_sink_input_list)
256     {
257       if (s->noct_group_idx == i && s->volume != pavol)
258         {
259           DBG("@@ Client #%d, sink input #%d: setting volume=%u", s->client_idx, s->idx, pavol);
260           pa_cvolume cvol;
261           pa_cvolume_set(&cvol, s->channels, pavol);
262           pulse_sink_input_set_volume(s->idx, &cvol);
263         }
264     }
265 }
266
267 static void update_group_from_button(int i, int on)
268 {
269   if (!on)
270     return;
271   if (i >= NUM_GROUPS)
272     return;
273   struct group_config *gc = &group_config[i];
274   struct group_state *gs = &group_state[i];
275   if (!gc->enabled)
276     return;
277
278   calc_groups();
279   if (!gs->have_muted[0] && !gs->have_muted[1])
280     return;
281   uns mute = !gs->have_muted[1];
282
283   CLIST_FOR_EACH(struct pulse_sink_input *, s, pulse_sink_input_list)
284     {
285       if (s->noct_group_idx == i)
286         {
287           DBG("@@ Client #%d, sink input #%d: setting mute=%u", s->client_idx, s->idx, mute);
288           pulse_sink_input_set_mute(s->idx, mute);
289         }
290     }
291 }
292
293 #if 0   // Not used at the moment
294
295 static int find_touched_client(void)
296 {
297   int touched = -1;
298
299   for (uns i=0; i < NUM_GROUPS; i++)
300     if (group_config[i].enabled && noct_rotary_touched[i])
301       {
302         if (touched >= 0)
303           return -1;
304         touched = i;
305       }
306   return touched;
307 }
308
309 #endif
310
311 /*** Default sink controls ***/
312
313 #if 0   // Not mapped to any button at the moment
314
315 static const char *get_client_sink(int i)
316 {
317   const char *sink = NULL;
318
319   CLIST_FOR_EACH(struct pulse_sink_input *, s, pulse_sink_input_list)
320     if (s->noct_group_idx == i)
321       {
322         struct pulse_sink *sk = (s->sink_idx >= 0) ? pulse_sink_by_idx(s->sink_idx) : NULL;
323         const char *ss = sk ? sk->name : NULL;
324         if (!sink)
325           sink = ss;
326         else if (strcmp(sink, ss))
327           sink = "?";
328       }
329   return sink ? : "?";
330 }
331
332 static void update_default_sink(void)
333 {
334   int i = find_touched_client();
335   const char *sink;
336   if (i >= 0)
337     sink = get_client_sink(i);
338   else
339     sink = pulse_default_sink_name ? : "?";
340
341   if (!strcmp(sink, "ursarium"))
342     {
343       noct_set_button(8, 1);
344       noct_set_button(9, 0);
345       noct_set_button(10, 0);
346     }
347   else if (!strcmp(sink, "catarium"))
348     {
349       noct_set_button(8, 0);
350       noct_set_button(9, 1);
351       noct_set_button(10, 0);
352     }
353   else if (!strcmp(sink, "compress"))
354     {
355       noct_set_button(8, 0);
356       noct_set_button(9, 0);
357       noct_set_button(10, 1);
358     }
359   else
360     {
361       noct_set_button(8, 0);
362       noct_set_button(9, 0);
363       noct_set_button(10, 0);
364     }
365 }
366
367 static void update_default_sink_from_button(int button, int on)
368 {
369   if (!on)
370     return;
371
372   int i = find_touched_client();
373   const char *sink;
374   if (i >= 0)
375     sink = get_client_sink(i);
376   else
377     sink = pulse_default_sink_name ? : "?";
378
379   const char *switch_to = NULL;
380   if (button == 8)
381     {
382       if (!strcmp(sink, "ursarium"))
383         switch_to = "burrow";
384       else
385         switch_to = "ursarium";
386     }
387   else if (button == 9)
388     {
389       if (!strcmp(sink, "catarium"))
390         switch_to = "burrow";
391       else
392         switch_to = "catarium";
393     }
394   else if (button == 10)
395     {
396       if (!strcmp(sink, "compress"))
397         switch_to = "burrow";
398       else
399         switch_to = "compress";
400     }
401
402   if (!switch_to)
403     return;
404
405   if (i >= 0)
406     {
407       struct pulse_sink *sk = pulse_sink_by_name(switch_to);
408       if (!sk)
409         return;
410
411       CLIST_FOR_EACH(struct pulse_sink_input *, s, pulse_sink_input_list)
412         if (s->noct_group_idx == i)
413           {
414             DBG("Moving input #%d to sink #%d", s->idx, sk->idx);
415             pulse_sink_input_move(s->idx, sk->idx);
416           }
417     }
418   else
419     {
420       DBG("Switching default sink to %s", switch_to);
421       pulse_server_set_default_sink(switch_to);
422     }
423 }
424
425 #endif
426
427 /*** MPD controls ***/
428
429 static bool mpd_flash_state;
430
431 static void mpd_flash_timeout(struct main_timer *t)
432 {
433   mpd_flash_state ^= 1;
434   noct_set_button(12, mpd_flash_state);
435   timer_add_rel(t, 500);
436 }
437
438 static struct main_timer mpd_flash_timer = {
439   .handler = mpd_flash_timeout,
440 };
441
442 static void update_mpd(void)
443 {
444   const char *state = mpd_get_player_state();
445   if (!strcmp(state, "play"))
446     {
447       noct_set_button(12, 1);
448       timer_del(&mpd_flash_timer);
449     }
450   else if (!strcmp(state, "pause"))
451     {
452       if (!timer_is_active(&mpd_flash_timer))
453         {
454           mpd_flash_state = 1;
455           mpd_flash_timeout(&mpd_flash_timer);
456         }
457     }
458   else
459     {
460       noct_set_button(12, 0);
461       timer_del(&mpd_flash_timer);
462     }
463 }
464
465 static void mpd_button_timeout(struct main_timer *t)
466 {
467   DBG("MPD stop");
468   timer_del(t);
469   mpd_stop();
470 }
471
472 static void update_mpd_from_button(int button UNUSED, int on)
473 {
474   static struct main_timer mpd_button_timer = {
475     .handler = mpd_button_timeout,
476   };
477
478   const char *state = mpd_get_player_state();
479
480   if (!on)
481     {
482       if (timer_is_active(&mpd_button_timer))
483         {
484           timer_del(&mpd_button_timer);
485           if (!strcmp(state, "play"))
486             {
487               DBG("MPD pause");
488               mpd_pause(1);
489             }
490           else if (!strcmp(state, "pause"))
491             {
492               DBG("MPD resume");
493               mpd_pause(0);
494             }
495         }
496       return;
497     }
498
499   if (!strcmp(state, "stop"))
500     {
501       DBG("MPD play");
502       mpd_play();
503     }
504   else
505     {
506       DBG("MPD starting button timer");
507       timer_add_rel(&mpd_button_timer, 1000);
508     }
509 }
510
511 /*** Main update routines ***/
512
513 static struct main_timer update_timer;
514 static timestamp_t last_touch_time;
515
516 enum update_state {
517   US_OFFLINE,
518   US_ONLINE,
519   US_SLEEPING,
520   US_PULSE_DEAD,
521 };
522
523 static enum update_state update_state;
524
525 static bool want_sleep_p(void)
526 {
527   CLIST_FOR_EACH(struct pulse_sink *, s, pulse_sink_list)
528     if (!s->suspended)
529       return 0;
530   return 1;
531 }
532
533 static void do_update(struct main_timer *t)
534 {
535   DBG("## UPDATE in state %u", update_state);
536   timer_del(t);
537
538   // Nocturn dead?
539   if (!noct_is_ready())
540     {
541       DBG("## UPDATE: Nocturn is not ready");
542       update_state = US_OFFLINE;
543       return;
544     }
545   else if (update_state == US_OFFLINE)
546     {
547       DBG("## UPDATE: Going online");
548       update_state = US_ONLINE;
549     }
550
551   // Pulse dead?
552   if (!pulse_is_ready())
553     {
554       DBG("## UPDATE: Pulse is not online");
555       if (update_state != US_PULSE_DEAD)
556         {
557           update_state = US_PULSE_DEAD;
558           noct_clear();
559           for (int i=0; i<8; i++)
560             noct_set_button(i, 1);
561         }
562       return;
563     }
564   else if (update_state == US_PULSE_DEAD)
565     {
566       DBG("## UPDATE: Waking up from the dead");
567       update_state = US_ONLINE;
568       noct_clear();
569     }
570
571 #ifdef LOCAL_DEBUG
572   pulse_dump();
573 #endif
574
575   // Sleeping?
576   bool want_sleep = want_sleep_p();
577   if (!want_sleep)
578     last_touch_time = main_get_now();
579   timestamp_t since_touch = last_touch_time ? main_get_now() - last_touch_time : 0;
580   timestamp_t sleep_in = 5000;
581   if (since_touch >= sleep_in)
582     {
583       DBG("UPDATE: Sleeping");
584       if (update_state == US_ONLINE)
585         {
586           update_state = US_SLEEPING;
587           noct_clear();
588           noct_set_ring(8, RING_MODE_LEFT, 127);
589         }
590       return;
591     }
592   else
593     {
594       if (update_state == US_SLEEPING)
595         {
596           DBG("UPDATE: Waking up");
597           update_state = US_ONLINE;
598           noct_clear();
599         }
600       if (want_sleep)
601         {
602           timestamp_t t = sleep_in - since_touch + 10;
603           DBG("UPDATE: Scheduling sleep in %d ms", (int) t);
604           timer_add_rel(&update_timer, t);
605         }
606     }
607
608   // Everything normal
609   update_ring_from_sink(0, PCH_SINK);
610   update_button_from_port(8, PCH_SINK, "analog-output-headphones");
611   update_groups();
612 #if 0
613   update_default_sink();
614 #endif
615   update_mpd();
616 }
617
618 void schedule_update(void)
619 {
620   timer_add_rel(&update_timer, 10);
621 }
622
623 static bool prepare_notify(void)
624 {
625   if (!pulse_is_ready())
626     {
627       DBG("## NOTIFY: Pulse is not online");
628       return 0;
629     }
630
631   last_touch_time = main_get_now();
632   if (update_state == US_SLEEPING)
633     {
634       DBG("## NOTIFY: Scheduling wakeup");
635       schedule_update();
636     }
637
638   return 1;
639 }
640
641 void notify_rotary(int rotary, int delta)
642 {
643   if (!prepare_notify())
644     return;
645
646   switch (rotary)
647     {
648     case 0:
649       update_sink_from_rotary(delta, PCH_SINK);
650       break;
651     default:
652       update_group_from_rotary(rotary, delta);
653     }
654 }
655
656 void notify_button(int button, int on)
657 {
658   if (!prepare_notify())
659     return;
660
661   switch (button)
662     {
663     case 0:
664       update_sink_mute_from_button(on, PCH_SINK);
665       break;
666     case 8:
667       update_port_from_button(on, PCH_SINK, "analog-output-lineout", "analog-output-headphones");
668       break;
669 #if 0
670     case 9:
671     case 10:
672       update_default_sink_from_button(button, on);
673       break;
674 #endif
675     case 12:
676       update_mpd_from_button(button, on);
677       break;
678     case 13:
679       if (on)
680         mpd_stop();
681       break;
682     case 14:
683       if (on)
684         mpd_prev();
685       break;
686     case 15:
687       if (on)
688         mpd_next();
689       break;
690     default:
691       update_group_from_button(button, on);
692     }
693 }
694
695 void notify_touch(int rotary, int on UNUSED)
696 {
697   if (!prepare_notify())
698     return;
699
700   // Rotary touches switch meaning of LEDs, this is handled inside display updates
701   if (rotary >= 4 && rotary < 8)
702     schedule_update();
703 }
704
705 /*** Main entry point ***/
706
707 static int debug;
708 static int no_fork;
709
710 static struct opt_section options = {
711   OPT_ITEMS {
712     OPT_HELP("Control console for the Ursary"),
713     OPT_HELP(""),
714     OPT_HELP("Options:"),
715     OPT_HELP_OPTION,
716     OPT_BOOL('d', "debug", debug, 0, "\tEnable debugging mode (no fork etc.)"),
717     OPT_BOOL(0, "no-fork", no_fork, 0, "\tDo not fork\n"),
718     OPT_END
719   }
720 };
721
722 static void sigterm_handler(struct main_signal *ms UNUSED)
723 {
724   main_shut_down();
725 }
726
727 static void daemon_body(struct daemon_params *dp)
728 {
729   main_init();
730   update_timer.handler = do_update;
731
732   noct_init();
733   pulse_init();
734   mpd_init();
735
736   static struct main_signal term_sig = {
737     .signum = SIGTERM,
738     .handler = sigterm_handler,
739   };
740   signal_add(&term_sig);
741
742   msg(L_INFO, "Ursary daemon starting");
743   main_loop();
744   msg(L_INFO, "Ursary daemon shut down");
745   daemon_exit(dp);
746 }
747
748 int main(int argc UNUSED, char **argv)
749 {
750   opt_parse(&options, argv+1);
751   unsetenv("DISPLAY");
752   unsetenv("HOME");
753
754   struct daemon_params dp = {
755     .flags = ((debug || no_fork) ? DAEMON_FLAG_SIMULATE : 0),
756     .pid_file = "/run/ursaryd.pid",
757     .run_as_user = "ursary",
758   };
759   daemon_init(&dp);
760
761   log_init(argv[0]);
762   if (!debug)
763     {
764       struct log_stream *ls = log_new_syslog("daemon", LOG_PID);
765       ls->levels = ~(1U << L_DEBUG);
766       log_set_default_stream(ls);
767     }
768
769   daemon_run(&dp, daemon_body);
770   return 0;
771 }