osdd.c

/*
 *	On-screen Display Daemon
 *
 *	(c) 2010--2014 Martin Mares <mj@ucw.cz>
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>
#include <getopt.h>
#include <locale.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>

#undef DEBUG
#include "util.h"
#include "display.h"

static struct osd_state *osd;

static timestamp_t now;

/*** Options ***/

static char *font_name = "times-64:bold";
static char *default_color = "green";
static char *default_outline_color = "black";
static int default_outline_width = 2;
static int default_duration = 1000;
static int default_min_duration = 250;
static int debug_mode;
static int test_mode;
static double line_spacing = 0.2;

static const char short_opts[] = "c:d:Df:m:o:O:s:";

enum long_opt {
  OPT_TEST = 256,
};

static const struct option long_opts[] = {
  { "color",		required_argument,	NULL,	'c' },
  { "debug",		no_argument,		NULL,	'D' },
  { "duration",		required_argument,	NULL,	'd' },
  { "font",		required_argument,	NULL,	'f' },
  { "min-duration",	required_argument,	NULL,	'm' },
  { "outline-color",	required_argument,	NULL,	'o' },
  { "outline-width",	required_argument,	NULL,	'O' },
  { "line-spacing",	required_argument,	NULL,	's' },
  { "test",		no_argument,		NULL,	OPT_TEST },	// Undocumented test mode
  { NULL,		0,			NULL,	0   },
};

static void NONRET
usage(void)
{
  fprintf(stderr, "Usage: osdd <options>\n\n\
Options:\n\
-c, --color=<c>\t\tDefault color (#rgb, #rrggbb or a name from rgb.txt)\n\
-D, --debug\t\tDebugging mode (do not detach from the terminal)\n\
-d, --duration=<ms>\tDefault message duration in milliseconds\n\
-f, --font=<f>\t\tFont to use for the OSD\n\
-m, --min-duration=<ms>\tDefault minimum message duration in milliseconds\n\
-o, --outline-color=<c>\tDefault outline color\n\
-O, --outline-width=<n>\tDefault outline width (default=2)\n\
-s, --line-spacing=<n>\tSet line spacing factor (decimal fraction, default=0.2)\n\
");
  exit(1);
}

static void
parse_opts(int argc, char **argv)
{
  int opt;
  while ((opt = getopt_long(argc, argv, short_opts, long_opts, NULL)) >= 0)
    switch (opt)
      {
      case 'c':
	default_color = optarg;
	break;
      case 'd':
	default_duration = atoi(optarg);
	break;
      case 'D':
	debug_mode = 1;
	break;
      case 'f':
	font_name = optarg;
	break;
      case 'l':
	line_spacing = atof(optarg);
	break;
      case 'm':
	default_min_duration = atoi(optarg);
	break;
      case 'o':
	default_outline_color = optarg;
	break;
      case 'O':
	default_outline_width = atoi(optarg);
	break;
      case OPT_TEST:
	test_mode = 1;
	debug_mode = 1;
	break;
      default:
	usage();
      }

  if (optind < argc)
    usage();
}

/*** Displaying of messages ***/

struct msg {
  struct msg *next;
  timestamp_t min_light, max_light;
  char text[1];
};

static void
display_msg(struct msg *msg)
{
  DBG("## Displaying message\n");
  msg->min_light = now + default_min_duration;
  msg->max_light = now + default_duration;
  char *fg_color = default_color;
  char *outline_color = default_outline_color;
  int outline_width = default_outline_width;

  char *line = msg->text;
  while (*line)
    {
      // The parser it destructive, but it does not do any harm, since we display each message only once.
      char *nl = strchr(line, '\n');
      *nl++ = 0;

      char *key;
      char *val = strchr(line, ':');
      if (val)
	{
	  key = line;
	  *val++ = 0;
	}
      else
	{
	  key = "";
	  val = line;
	}
      DBG("\t%s:%s\n", key, val);

      struct osd_line *l = NULL;
      if (!key[0])
	{
	  l = osd_add_line(osd, OSD_TYPE_TEXT);
	  sprintf(l->u.text, "%.*s", OSD_MAX_LINE_LEN, val);
	}
      else if (!strcmp(key, "percentage") || !strcmp(key, "percent"))
	{
	  l = osd_add_line(osd, OSD_TYPE_PERCENTAGE);
	  l->u.percent = atoi(val);
	}
      else if (!strcmp(key, "slider"))
	{
	  l = osd_add_line(osd, OSD_TYPE_SLIDER);
	  l->u.percent = atoi(val);
	}
      else if (!strcmp(key, "duration"))
	msg->max_light = now + atoi(val);
      else if (!strcmp(key, "min-duration"))
	msg->min_light = now + atoi(val);
      else if (!strcmp(key, "color"))
	fg_color = val;
      else if (!strcmp(key, "outline-color"))
	outline_color = val;
      else if (!strcmp(key, "outline-width"))
	outline_width = atoi(val);
      if (l)
	{
	  l->fg_color = fg_color;
	  l->outline_color = outline_color;
	  l->outline_width = outline_width;
	}

      line = nl;
    }

  if (msg->min_light > msg->max_light)
    msg->min_light = msg->max_light;

  osd_show(osd);
}

static void
msg_to_stdout(struct msg *msg)
{
  DBG("## Printing message to stdout\n");

  char *line = msg->text;
  int out_parametr_index=0;
  while (*line)
    {
      // The parser it destructive, but it does not do any harm, since we display each message only once.
      char *nl = strchr(line, '\n');
      *nl++ = 0;

      char *key;
      char *val = strchr(line, ':');
      if (val)
	{
	  key = line;
	  *val++ = 0;
	}
      else
	{
	  key = "";
	  val = line;
	}
      DBG("\t%s:%s\n", key, val);

      if (!key[0])
	{
		printf(out_parametr_index++?" %s":"%s",val);
	}

      line = nl;
    }
	printf("\n");
	fflush(stdout);
}

static void
hide_msg(struct msg *msg)
{
  DBG("## Hiding message\n");
  osd_clear(osd);
  free(msg);
}

/*** The message queue ***/

static struct msg *current_msg, *first_msg, *last_msg;

static void
enqueue_msg(unsigned char *buf, int len)
{
  DBG("Received: [%.*s]\n", len, buf);
  if (!len || buf[len-1] != '\n')
    return;

  struct msg *msg = xmalloc(sizeof(*msg) + len);
  memcpy(msg->text, buf, len);
  msg->text[len] = 0;

  char to[123];
  *to=0;

  char *line = msg->text;
  while (*line)
    {
      char *nl = strchr(line, '\n');
      *nl++=0;

      char *key;
      char *val = strchr(line, ':');
      if (val)
	{
	  key = line;
	  *val++ = 0;
	}
      else
	{
	  key = "";
	  val = line;
	}
      DBG("\t%s:%s\n", key, val);

      if (!strcmp(key, "to"))
      {
	      if(strlen(val)<120)
		      strcpy(to,val);
      }

      val[-1]=':';
      nl[-1]=10;
      line = nl;
    }
  if(!strcmp(to,"stdout"))
  {
	  msg_to_stdout(msg);
  }
  else
  {
	  if (first_msg)
	    last_msg->next = msg;
	  else
	    first_msg = msg;
	  last_msg = msg;
	  msg->next = NULL;
  }
}

static void
parse_input(unsigned char *buf, int len)
{
  /* The property might contain several messages concatenated. Split them. */
  while (len > 0)
    {
      if (buf[0] == '\n')
	{
	  buf++, len--;
	  continue;
	}
      int i = 0;
      while (i < len && (buf[i] != '\n' || (i && buf[i-1] != '\n')))
	i++;
      enqueue_msg(buf, i);
      buf += i, len -= i;
    }
}

static void
do_test(void)
{
  unsigned char buf[4096];
  int len = 0;
  int c;

  while ((c = read(0, buf + len, 4096 - len)) > 0)
    len += c;
  if (len)
    enqueue_msg(buf, len);
}

/*** Main loop ***/

int
main(int argc, char **argv)
{
  parse_opts(argc, argv);
  setlocale(LC_CTYPE, "");
  XInitThreads();

  Display *dpy = XOpenDisplay(NULL);
  if (!dpy)
    die("Cannot open display");
  Window win = DefaultRootWindow(dpy);

  Atom pty = XInternAtom(dpy, "OSD_QUEUE", False);
  if (!pty)
    die("Cannot intern OSD_QUEUE atom");

  if (!debug_mode)
    {
      pid_t pid = fork();
      if (pid < 0)
	die("Cannot fork: %m");
      if (pid > 0)
        return 0;
      setsid();
    }

  if (test_mode)
    {
      do_test();
      pty = 0;
    }
  else
    {
      XSelectInput(dpy, win, PropertyChangeMask);
      XDeleteProperty(dpy, win, pty);
      XFlush(dpy);
    }

  osd = osd_new(dpy);
  osd_set_font(osd, font_name, line_spacing);

  struct pollfd pfd = {
    .fd = ConnectionNumber(dpy),
    .events = POLLIN,
  };

  for (;;)
    {
      now = get_current_time();

      timestamp_t wait_until = now - 1;
      if (!current_msg && first_msg)
	{
	  current_msg = first_msg;
	  first_msg = first_msg->next;
	  display_msg(current_msg);
	}
      if (current_msg)
	{
	  if (first_msg)
	    wait_until = current_msg->min_light;
	  else
	    wait_until = current_msg->max_light;
	  if (wait_until <= now)
	    {
	      hide_msg(current_msg);
	      current_msg = NULL;
	      continue;
	    }
	}
      if (test_mode && !current_msg)
	break;

      DBG("... waiting for %d ms\n", (int)(wait_until - now));
      poll(&pfd, 1, wait_until - now);
      if (pfd.revents & POLLIN)
	{
	  while (XPending(dpy))
	    {
	      XEvent ev;
	      XNextEvent(dpy, &ev);
	      if (osd_handle_event(osd, &ev))
		continue;
	      if (ev.type != PropertyNotify)
		continue;
	      XPropertyEvent *p = &ev.xproperty;
	      if (p->window == win && p->atom == pty)
		{
		  Atom pty_type;
		  int pty_fmt;
		  unsigned long pty_items, pty_remains;
		  unsigned char *pty_buf = NULL;
		  XGetWindowProperty(dpy, win, pty, 0, 4096, True, XA_STRING, &pty_type, &pty_fmt, &pty_items, &pty_remains, &pty_buf);
		  if (pty_type == XA_STRING && pty_fmt == 8 && pty_items)
		    parse_input(pty_buf, pty_items);
		  if (pty_buf)
		    XFree(pty_buf);
		}
	    }
	}
    }
}