fade.c

   1 /*
   2  * Copyright (C) 1998-2012 Andre Noll <maan@systemlinux.org>
   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 #include <sys/types.h>
  11 #include <sys/ioctl.h>
  12 #include <signal.h>
  13 #include <sys/soundcard.h>
  14
  15 #include "fade.cmdline.h"
  16 #include "para.h"
  17 #include "fd.h"
  18 #include "string.h"
  19 #include "error.h"
  20 #include "version.h"
  21
  22 INIT_FADE_ERRLISTS;
  23 static struct fade_args_info conf;
  24
  25 __printf_2_3 void date_log(__a_unused int ll, const char *fmt, ...)
  26 {
  27         va_list argp;
  28         time_t t1;
  29         struct tm *tm;
  30
  31         time(&t1);
  32         tm = localtime(&t1);
  33         printf("%d:%02d:%02d ", tm->tm_hour, tm->tm_min, tm->tm_sec);
  34         va_start(argp, fmt);
  35         vprintf(fmt, argp);
  36         va_end(argp);
  37 }
  38 __printf_2_3 void (*para_log)(int, const char*, ...) = date_log;
  39
  40 /*
  41  * Open the mixer device.
  42  */
  43 static int open_mixer(void)
  44 {
  45         PARA_INFO_LOG("opening %s\n", conf.mixer_device_arg);
  46         return para_open(conf.mixer_device_arg, O_RDWR, 42);
  47 }
  48
  49 /*
  50  * Get channel volume via mixer_fd.
  51  */
  52 static int get_mixer_channel(int mixer_fd)
  53 {
  54         int volume;
  55
  56         if (ioctl(mixer_fd, MIXER_READ(conf.mixer_channel_arg), &volume) < 0)
  57                 return -ERRNO_TO_PARA_ERROR(errno);
  58         /* take the mean value of left and right volume */
  59         return (volume % 256 + (volume >> 8)) / 2;
  60 }
  61
  62 /*
  63  * Open mixer, get volume and close mixer.
  64  */
  65 static int open_and_get_mixer_channel(void)
  66 {
  67         int mixer_fd;
  68         int volume;
  69
  70         mixer_fd = open_mixer();
  71         if (mixer_fd < 0)
  72                 return mixer_fd;
  73         volume = get_mixer_channel(mixer_fd);
  74         close(mixer_fd);
  75         return volume;
  76 }
  77
  78 /*
  79  * Set channel volume via mixer_fd.
  80  */
  81 static int set_mixer_channel(int mixer_fd, int volume)
  82 {
  83         int tmp = (volume << 8) + volume;
  84
  85         if (ioctl(mixer_fd, MIXER_WRITE(conf.mixer_channel_arg), &tmp) < 0)
  86                 return -ERRNO_TO_PARA_ERROR(errno);
  87         return 1;
  88 }
  89
  90 /*
  91  * Open mixer, set volume and close mixer.
  92  */
  93 static int open_and_set_mixer_channel(int volume)
  94 {
  95         int mixer_fd, ret = open_mixer();
  96
  97         if (ret < 0)
  98                 return ret;
  99         mixer_fd = ret;
 100         ret = set_mixer_channel(mixer_fd, volume);
 101         close(mixer_fd);
 102         return ret;
 103 }
 104
 105 static void fixup_mixer_channel_arg(void)
 106 {
 107         int val = SOUND_MIXER_VOLUME; /* STFU, gcc */
 108
 109         switch (conf.mixer_channel_arg) {
 110                 case mixer_channel_arg_volume: val = SOUND_MIXER_VOLUME; break;
 111                 case mixer_channel_arg_bass: val = SOUND_MIXER_BASS; break;
 112                 case mixer_channel_arg_treble: val = SOUND_MIXER_TREBLE; break;
 113                 case mixer_channel_arg_synth: val = SOUND_MIXER_SYNTH; break;
 114                 case mixer_channel_arg_pcm: val = SOUND_MIXER_PCM; break;
 115                 case mixer_channel_arg_speaker: val = SOUND_MIXER_SPEAKER; break;
 116                 case mixer_channel_arg_line: val = SOUND_MIXER_LINE; break;
 117                 case mixer_channel_arg_mic: val = SOUND_MIXER_MIC; break;
 118                 case mixer_channel_arg_cd: val = SOUND_MIXER_CD; break;
 119                 case mixer_channel_arg_imix: val = SOUND_MIXER_IMIX; break;
 120                 case mixer_channel_arg_altpcm: val = SOUND_MIXER_ALTPCM; break;
 121                 case mixer_channel_arg_reclev: val = SOUND_MIXER_RECLEV; break;
 122                 case mixer_channel_arg_igain: val = SOUND_MIXER_IGAIN; break;
 123                 case mixer_channel_arg_ogain: val = SOUND_MIXER_OGAIN; break;
 124                 default: break;
 125         }
 126         conf.mixer_channel_arg = val;
 127 }
 128
 129 /*
 130  * Open mixer, get volume, fade to new_vol in secs seconds and
 131  * close mixer.
 132  */
 133 static int fade(int new_vol, int fade_time)
 134 {
 135         int vol, mixer_fd, diff, incr, ret;
 136         unsigned secs;
 137         struct timespec ts;
 138         unsigned long long tmp, tmp2; /* Careful with that axe, Eugene! */
 139
 140         if (fade_time <= 0)
 141                 return 1;
 142         secs = fade_time;
 143         PARA_NOTICE_LOG("fading to %d in %d seconds\n", new_vol, secs);
 144         ret = open_mixer();
 145         if (ret < 0)
 146                 return ret;
 147         mixer_fd = ret;
 148         ret = get_mixer_channel(mixer_fd);
 149         if (ret < 0)
 150                 goto out;
 151         vol = ret;
 152         diff = new_vol - vol;
 153         if (!diff) {
 154                 sleep(secs);
 155                 goto out;
 156         }
 157         incr = diff > 0? 1: -1;
 158         diff = diff > 0? diff: -diff;
 159         tmp = secs * 1000 / diff;
 160         tmp2 = tmp % 1000;
 161         while ((new_vol - vol) * incr > 0) {
 162                 ts.tv_nsec = tmp2 * 1000000; /* really nec ?*/
 163                 ts.tv_sec = tmp / 1000; /* really nec ?*/
 164                 //printf("ts.tv_sec: %i\n", ts.tv_nsec);
 165                 vol += incr;
 166                 ret = set_mixer_channel(mixer_fd, vol);
 167                 if (ret < 0)
 168                         goto out;
 169                 //printf("vol = %i\n", vol);
 170                 nanosleep(&ts, NULL);
 171         }
 172 out:
 173         close(mixer_fd);
 174         return ret;
 175 }
 176
 177 static void client_cmd(const char *cmd)
 178 {
 179         int ret, status, fds[3] = {0, 0, 0};
 180         pid_t pid;
 181         char *cmdline = make_message(BINDIR "/para_client %s", cmd);
 182
 183         PARA_INFO_LOG("%s\n", cmdline);
 184         ret = para_exec_cmdline_pid(&pid, cmdline, fds);
 185         free(cmdline);
 186         if (ret < 0) {
 187                 PARA_ERROR_LOG("%s\n", para_strerror(-ret));
 188                 goto fail;
 189         }
 190         do
 191                 pid = waitpid(pid, &status, 0);
 192         while (pid == -1 && errno == EINTR);
 193         if (pid < 0) {
 194                 PARA_ERROR_LOG("%s\n", strerror(errno));
 195                 goto fail;
 196         }
 197         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
 198                 goto fail;
 199         return;
 200 fail:
 201         PARA_EMERG_LOG("command \"%s\" failed\n", cmd);
 202         exit(EXIT_FAILURE);
 203 }
 204
 205 static void change_afs_mode_and_play(char *afs_mode)
 206 {
 207         char *cmd;
 208
 209         client_cmd("stop");
 210         if (!afs_mode)
 211                 return;
 212         cmd = make_message("select %s", afs_mode);
 213         client_cmd(cmd);
 214         free(cmd);
 215         client_cmd("play");
 216 }
 217
 218 /*
 219  * sleep
 220  */
 221 static int sweet_dreams(void)
 222 {
 223         time_t t1, wake_time_epoch;
 224         unsigned int delay;
 225         struct tm *tm;
 226         int ret, min = conf.wake_min_arg;
 227         char *fo_mood = conf.fo_mood_arg;
 228         char *fi_mood = conf.fi_mood_arg;
 229         char *sleep_mood = conf.sleep_mood_arg;
 230         int fit = conf.fi_time_arg;
 231         int fot = conf.fo_time_arg;
 232         int fiv = conf.fi_vol_arg;
 233         int fov = conf.fo_vol_arg;
 234         int iv = conf.ivol_arg;
 235
 236         /* calculate wake time */
 237         time(&t1);
 238         if (conf.wake_hour_given) {
 239                 int hour = conf.wake_hour_arg;
 240                 tm = localtime(&t1);
 241                 if (tm->tm_hour > hour || (tm->tm_hour == hour && tm->tm_min> min)) {
 242                         t1 += 86400; /* wake time is tomorrow */
 243                         tm = localtime(&t1);
 244                 }
 245                 tm->tm_hour = hour;
 246                 tm->tm_min = min;
 247                 tm->tm_sec = 0;
 248         } else {
 249                 t1 += 9 * 60 * 60; /* nine hours from now */
 250                 PARA_INFO_LOG("default wake time: %lu\n", (long unsigned)t1);
 251                 tm = localtime(&t1);
 252         }
 253         wake_time_epoch = mktime(tm);
 254         PARA_INFO_LOG("waketime: %s", asctime(tm));
 255         client_cmd("stop");
 256         sleep(1);
 257         if (fot) {
 258                 PARA_INFO_LOG("initial volume: %d\n", iv);
 259                 ret = open_and_set_mixer_channel(iv);
 260                 if (ret < 0)
 261                         return ret;
 262                 change_afs_mode_and_play(fo_mood);
 263                 ret = fade(fov, fot);
 264                 if (ret < 0)
 265                         return ret;
 266         } else {
 267                 ret = open_and_set_mixer_channel(fov);
 268                 if (ret < 0)
 269                         return ret;
 270         }
 271         if (conf.sleep_mood_given)
 272                 change_afs_mode_and_play(sleep_mood);
 273         else
 274                 client_cmd("stop");
 275         if (!fit)
 276                 return 1;
 277         for (;;) {
 278                 time(&t1);
 279                 if (wake_time_epoch <= t1 + fit)
 280                         break;
 281                 delay = wake_time_epoch - t1 - fit;
 282                 PARA_INFO_LOG("sleeping %u seconds (%u:%02u)\n",
 283                         delay, delay / 3600,
 284                         (delay % 3600) / 60);
 285                 sleep(delay);
 286         }
 287         change_afs_mode_and_play(fi_mood);
 288         ret = fade(fiv, fit);
 289         PARA_INFO_LOG("fade complete, returning\n");
 290         return ret;
 291 }
 292
 293 static int snooze(void)
 294 {
 295         int ret;
 296
 297         if (conf.so_time_arg <= 0)
 298                 return 1;
 299         if (open_and_get_mixer_channel() < conf.so_vol_arg)
 300                 ret = open_and_set_mixer_channel(conf.so_vol_arg);
 301         else
 302                 ret = fade(conf.so_vol_arg, conf.so_time_arg);
 303         if (ret < 0)
 304                 return ret;
 305         client_cmd("pause");
 306         PARA_NOTICE_LOG("%d seconds snooze time...\n", conf.snooze_time_arg);
 307         sleep(conf.snooze_time_arg);
 308         client_cmd("play");
 309         return fade(conf.si_vol_arg, conf.si_time_arg);
 310 }
 311
 312 static int configfile_exists(void)
 313 {
 314         static char *config_file;
 315
 316         if (!conf.config_file_given) {
 317                 char *home = para_homedir();
 318                 free(config_file);
 319                 config_file = make_message("%s/.paraslash/fade.conf", home);
 320                 free(home);
 321                 conf.config_file_arg = config_file;
 322         }
 323         return file_exists(conf.config_file_arg);
 324 }
 325
 326 int main(int argc, char *argv[])
 327 {
 328         int ret;
 329
 330         if (fade_cmdline_parser(argc, argv, &conf))
 331                 exit(EXIT_FAILURE);
 332         HANDLE_VERSION_FLAG("fade", conf);
 333         ret = configfile_exists();
 334         if (!ret && conf.config_file_given) {
 335                 PARA_EMERG_LOG("can not read config file %s\n",
 336                         conf.config_file_arg);
 337                 exit(EXIT_FAILURE);
 338         }
 339         if (ret) {
 340                 struct fade_cmdline_parser_params params = {
 341                         .override = 0,
 342                         .initialize = 0,
 343                         .check_required = 0,
 344                         .check_ambiguity = 0,
 345                         .print_errors = 1
 346                 };
 347                 fade_cmdline_parser_config_file(conf.config_file_arg,
 348                         &conf, &params);
 349         }
 350         fixup_mixer_channel_arg();
 351         switch (conf.mode_arg) {
 352         case mode_arg_fade:
 353                 ret = fade(conf.fade_vol_arg, conf.fade_time_arg);
 354                 break;
 355         case mode_arg_snooze:
 356                 ret = snooze();
 357                 break;
 358         default: /* sleep mode */
 359                 ret = sweet_dreams();
 360                 break;
 361         }
 362         if (ret < 0)
 363                 PARA_EMERG_LOG("%s\n", para_strerror(-ret));
 364         return ret < 0? EXIT_FAILURE : EXIT_SUCCESS;
 365 }