Sort errors alphabetically.
[paraslash.git] / fade.c
1 /*
2 * Copyright (C) 1998 Andre Noll <maan@tuebingen.mpg.de>
3 *
4 * Licensed under the GPL v2. For licencing details see COPYING.
5 */
6
7 /** \file fade.c A volume fader and alarm clock for OSS. */
8
9 #include <regex.h>
10
11 #include "fade.cmdline.h"
12 #include "para.h"
13 #include "fd.h"
14 #include "string.h"
15 #include "mix.h"
16 #include "error.h"
17 #include "ggo.h"
18 #include "version.h"
19
20 /** Array of error strings. */
21 DEFINE_PARA_ERRLIST;
22
23 static struct fade_args_info conf;
24
25 enum mixer_id {MIXER_ENUM};
26 static char *mixer_name[] = {MIXER_NAMES};
27 DECLARE_MIXER_INITS;
28 static struct mixer supported_mixer[] = {MIXER_ARRAY};
29 #define FOR_EACH_MIXER(i) for ((i) = 0; (i) < NUM_SUPPORTED_MIXERS; (i)++)
30
31 static int loglevel;
32 static __printf_2_3 void date_log(int ll, const char *fmt, ...)
33 {
34 va_list argp;
35 time_t t1;
36 struct tm *tm;
37
38 if (ll < loglevel)
39 return;
40 time(&t1);
41 tm = localtime(&t1);
42 fprintf(stderr, "%d:%02d:%02d ", tm->tm_hour, tm->tm_min, tm->tm_sec);
43 va_start(argp, fmt);
44 vprintf(fmt, argp);
45 va_end(argp);
46 }
47 __printf_2_3 void (*para_log)(int, const char*, ...) = date_log;
48
49 static int set_channel(struct mixer *m, struct mixer_handle *h, const char *channel)
50 {
51
52 PARA_NOTICE_LOG("using %s mixer channel\n", channel?
53 channel : "default");
54 return m->set_channel(h, channel);
55 }
56
57 /* Fade to new volume in fade_time seconds. */
58 static int fade(struct mixer *m, struct mixer_handle *h, int new_vol, int fade_time)
59 {
60 int vol, diff, incr, ret;
61 unsigned secs;
62 struct timespec ts;
63 unsigned long long tmp, tmp2; /* Careful with that axe, Eugene! */
64
65 if (fade_time <= 0)
66 return m->set(h, new_vol);
67 secs = fade_time;
68 ret = m->get(h);
69 if (ret < 0)
70 goto out;
71 vol = ret;
72 PARA_NOTICE_LOG("fading %s from %d to %d in %d seconds\n",
73 conf.mixer_channel_arg, vol, new_vol, secs);
74 diff = new_vol - vol;
75 if (!diff) {
76 sleep(secs);
77 goto out;
78 }
79 incr = diff > 0? 1: -1;
80 diff = diff > 0? diff: -diff;
81 tmp = secs * 1000 / diff;
82 tmp2 = tmp % 1000;
83 while ((new_vol - vol) * incr > 0) {
84 ts.tv_nsec = tmp2 * 1000000; /* really nec ?*/
85 ts.tv_sec = tmp / 1000; /* really nec ?*/
86 //printf("ts.tv_sec: %i\n", ts.tv_nsec);
87 vol += incr;
88 ret = m->set(h, vol);
89 if (ret < 0)
90 goto out;
91 //printf("vol = %i\n", vol);
92 nanosleep(&ts, NULL);
93 }
94 out:
95 return ret;
96 }
97
98 static void client_cmd(const char *cmd)
99 {
100 int ret, status, fds[3] = {0, 0, 0};
101 pid_t pid;
102 char *cmdline = make_message(BINDIR "/para_client %s", cmd);
103
104 PARA_NOTICE_LOG("%s\n", cmdline);
105 ret = para_exec_cmdline_pid(&pid, cmdline, fds);
106 free(cmdline);
107 if (ret < 0) {
108 PARA_ERROR_LOG("%s\n", para_strerror(-ret));
109 goto fail;
110 }
111 do
112 pid = waitpid(pid, &status, 0);
113 while (pid == -1 && errno == EINTR);
114 if (pid < 0) {
115 PARA_ERROR_LOG("%s\n", strerror(errno));
116 goto fail;
117 }
118 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
119 goto fail;
120 return;
121 fail:
122 PARA_EMERG_LOG("command \"%s\" failed\n", cmd);
123 exit(EXIT_FAILURE);
124 }
125
126 static void change_afs_mode(char *afs_mode)
127 {
128 char *cmd;
129
130 client_cmd("stop");
131 if (!afs_mode)
132 return;
133 cmd = make_message("select %s", afs_mode);
134 client_cmd(cmd);
135 free(cmd);
136 }
137
138 static int set_initial_volume(struct mixer *m, struct mixer_handle *h)
139 {
140 int i, ret;
141
142 for (i = 0; i < conf.ivol_given; i++) {
143 char *p, *ch, *arg = para_strdup(conf.ivol_arg[i]);
144 int32_t iv;
145 p = strchr(arg, ':');
146 if (p) {
147 *p = '\0';
148 p++;
149 ch = arg;
150 } else {
151 p = arg;
152 ch = NULL;
153 }
154 ret = para_atoi32(p, &iv);
155 if (ret < 0) {
156 free(arg);
157 return ret;
158 }
159 ret = set_channel(m, h, ch);
160 if (!ch)
161 ch = "default";
162 if (ret < 0) {
163 PARA_WARNING_LOG("ignoring channel %s\n", ch);
164 ret = 0;
165 } else {
166 PARA_INFO_LOG("initial volume %s: %d\n", ch, iv);
167 ret = m->set(h, iv);
168 }
169 free(arg);
170 if (ret < 0)
171 return ret;
172 }
173 return 1;
174 }
175
176 static int sweet_dreams(struct mixer *m, struct mixer_handle *h)
177 {
178 time_t t1, wake_time_epoch;
179 unsigned int delay;
180 struct tm *tm;
181 int ret, min = conf.wake_min_arg;
182 char *fo_mood = conf.fo_mood_arg;
183 char *fi_mood = conf.fi_mood_arg;
184 char *sleep_mood = conf.sleep_mood_arg;
185 int fit = conf.fi_time_arg;
186 int fot = conf.fo_time_arg;
187 int fiv = conf.fi_vol_arg;
188 int fov = conf.fo_vol_arg;
189
190 /* calculate wake time */
191 time(&t1);
192 if (conf.wake_hour_given) {
193 int hour = conf.wake_hour_arg;
194 tm = localtime(&t1);
195 if (tm->tm_hour > hour || (tm->tm_hour == hour && tm->tm_min> min)) {
196 t1 += 86400; /* wake time is tomorrow */
197 tm = localtime(&t1);
198 }
199 tm->tm_hour = hour;
200 tm->tm_min = min;
201 tm->tm_sec = 0;
202 } else {
203 t1 += 9 * 60 * 60; /* nine hours from now */
204 PARA_INFO_LOG("default wake time: %lu\n", (long unsigned)t1);
205 tm = localtime(&t1);
206 }
207 wake_time_epoch = mktime(tm);
208 PARA_INFO_LOG("waketime: %u:%02u\n", tm->tm_hour, tm->tm_min);
209 client_cmd("stop");
210 sleep(1);
211 if (fot) {
212 ret = set_initial_volume(m, h);
213 if (ret < 0)
214 return ret;
215 change_afs_mode(fo_mood);
216 client_cmd("play");
217 ret = set_channel(m, h, conf.mixer_channel_arg);
218 if (ret < 0)
219 return ret;
220 ret = fade(m, h, fov, fot);
221 if (ret < 0)
222 return ret;
223 } else {
224 ret = m->set(h, fov);
225 if (ret < 0)
226 return ret;
227 }
228 if (conf.sleep_mood_given) {
229 change_afs_mode(sleep_mood);
230 client_cmd("play");
231 } else
232 client_cmd("stop");
233 if (!fit)
234 return 1;
235 change_afs_mode(fi_mood);
236 for (;;) {
237 time(&t1);
238 if (wake_time_epoch <= t1 + fit)
239 break;
240 delay = wake_time_epoch - t1 - fit;
241 PARA_INFO_LOG("sleeping %u seconds (%u:%02u)\n",
242 delay, delay / 3600,
243 (delay % 3600) / 60);
244 sleep(delay);
245 }
246 client_cmd("play");
247 ret = fade(m, h, fiv, fit);
248 PARA_INFO_LOG("fade complete, returning\n");
249 return ret;
250 }
251
252 static int snooze(struct mixer *m, struct mixer_handle *h)
253 {
254 int ret, val;
255
256 if (conf.so_time_arg <= 0)
257 return 1;
258 ret = m->get(h);
259 if (ret < 0)
260 return ret;
261 val = ret;
262 if (val < conf.so_vol_arg)
263 ret = m->set(h, conf.so_vol_arg);
264 else
265 ret = fade(m, h, conf.so_vol_arg, conf.so_time_arg);
266 if (ret < 0)
267 return ret;
268 client_cmd("pause");
269 PARA_NOTICE_LOG("%d seconds snooze time...\n", conf.snooze_time_arg);
270 sleep(conf.snooze_time_arg);
271 client_cmd("play");
272 return fade(m, h, conf.si_vol_arg, conf.si_time_arg);
273 }
274
275 static int configfile_exists(void)
276 {
277 static char *config_file;
278
279 if (!conf.config_file_given) {
280 char *home = para_homedir();
281 free(config_file);
282 config_file = make_message("%s/.paraslash/fade.conf", home);
283 free(home);
284 conf.config_file_arg = config_file;
285 }
286 return file_exists(conf.config_file_arg);
287 }
288
289 static void init_mixers(void)
290 {
291 int i;
292
293 FOR_EACH_MIXER(i) {
294 struct mixer *m = &supported_mixer[i];
295 PARA_DEBUG_LOG("initializing mixer API #%d (%s)\n",
296 i, mixer_name[i]);
297 m->init(m);
298 }
299 }
300
301 static int set_val(struct mixer *m, struct mixer_handle *h)
302 {
303 return m->set(h, conf.val_arg);
304 }
305
306 static struct mixer *get_mixer_or_die(void)
307 {
308 int i;
309
310 if (!conf.mixer_api_given)
311 i = DEFAULT_MIXER;
312 else
313 FOR_EACH_MIXER(i)
314 if (!strcmp(mixer_name[i], conf.mixer_api_arg))
315 break;
316 if (i < NUM_SUPPORTED_MIXERS) {
317 PARA_NOTICE_LOG("using %s mixer API\n", mixer_name[i]);
318 return supported_mixer + i;
319 }
320 printf("available mixer APIs: ");
321 FOR_EACH_MIXER(i) {
322 int d = (i == DEFAULT_MIXER);
323 printf("%s%s%s ", d? "[" : "", mixer_name[i], d? "]" : "");
324 }
325 printf("\n");
326 exit(EXIT_FAILURE);
327 }
328
329 __noreturn static void print_help_and_die(void)
330 {
331 struct ggo_help h = DEFINE_GGO_HELP(fade);
332 bool d = conf.detailed_help_given;
333
334 ggo_print_help(&h, d? GPH_STANDARD_FLAGS_DETAILED : GPH_STANDARD_FLAGS);
335 exit(0);
336 }
337
338 int main(int argc, char *argv[])
339 {
340 int ret;
341 struct mixer *m;
342 struct mixer_handle *h = NULL;
343
344 fade_cmdline_parser(argc, argv, &conf);
345 loglevel = get_loglevel_by_name(conf.loglevel_arg);
346 version_handle_flag("fade", conf.version_given);
347 if (conf.help_given || conf.detailed_help_given)
348 print_help_and_die();
349 ret = configfile_exists();
350 if (!ret && conf.config_file_given) {
351 PARA_EMERG_LOG("can not read config file %s\n",
352 conf.config_file_arg);
353 exit(EXIT_FAILURE);
354 }
355 if (ret) {
356 struct fade_cmdline_parser_params params = {
357 .override = 0,
358 .initialize = 0,
359 .check_required = 0,
360 .check_ambiguity = 0,
361 .print_errors = 1
362 };
363 fade_cmdline_parser_config_file(conf.config_file_arg,
364 &conf, &params);
365 loglevel = get_loglevel_by_name(conf.loglevel_arg);
366 }
367 init_mixers();
368 m = get_mixer_or_die();
369 ret = m->open(conf.mixer_device_arg, &h);
370 if (ret < 0)
371 goto out;
372 ret = set_channel(m, h, conf.mixer_channel_arg);
373 if (ret == -E_BAD_CHANNEL) {
374 char *channels = m->get_channels(h);
375 printf("Available channels: %s\n", channels);
376 free(channels);
377 }
378 if (ret < 0)
379 goto out;
380 switch (conf.mode_arg) {
381 case mode_arg_fade:
382 ret = fade(m, h, conf.fade_vol_arg, conf.fade_time_arg);
383 break;
384 case mode_arg_snooze:
385 ret = snooze(m, h);
386 break;
387 case mode_arg_set:
388 ret = set_val(m, h);
389 break;
390 default: /* sleep mode */
391 ret = sweet_dreams(m, h);
392 break;
393 }
394 out:
395 m->close(&h);
396 if (ret < 0)
397 PARA_EMERG_LOG("%s\n", para_strerror(-ret));
398 return ret < 0? EXIT_FAILURE : EXIT_SUCCESS;
399 }