tssimd.c

Go to the documentation of this file.

/********************************************************
 This file is part of fbvncserver.

 fbvncserver is free software; you can redistribute it
 and/or modify it under the terms of the
 GNU General Public License as published by
 the Free Software Foundation; either version 2 of the
 License, or (at your option) any later version.

 fbvncserver is distributed in the hope that it will be
 useful, but WITHOUT ANY WARRANTY; without even the
 implied warranty of MERCHANTABILITY or FITNESS FOR A
 PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.

 You should have received a copy of the GNU General Public
 License along with fbvncserver; if not, write to the
 Free Software Foundation, Inc., 51 Franklin St,
 Fifth Floor, Boston, MA  02110-1301  USA
 ********************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>

#include <sys/types.h>

#include <fcntl.h>
#include <errno.h>

/* KERNEL */
#include <linux/input.h>
/* 2.4 kernel headers */
#ifndef EV_SYN
#define EV_SYN 0
#endif
#include <linux/uinput.h>

/* GNU C Library */
#include <sys/time.h>
#include <gmp.h> /* Multiple Precision Arithmetic
                  * Documentation @ http://www.gnu.org/software/gmp/manual/html_node/index.html
                  */

/* POSIX */
#include <sys/select.h> /* synchronous I/O multiplexing         */
#include <sys/stat.h>   /* data returned by the stat() function */

/* aux */
#include <tslib.h>

/* Project */
#include "fbvncserver.h" /* Projectwide Macros & Definitions */
#include "dev_uinput.h"  /* uinput kernel interface          */

/* Constants */
#define DefaultTS "/dev/sharp_ts"       
#define DefaultTSCal "/etc/pointercal"  
/* Used for Sharp Zaurus SL-5000d and SL-5500 */
struct t_ts_event {
        long y;
        long x;
        long pressure;
        long long millisecs;
};

static struct t_ts_event tsevent;

void write_to_input(int fd, struct t_ts_event *tsevent) {
  ptr_abs(fd,tsevent->x,tsevent->y);
  TRACE2(" [I] inputAPI - x=%d, y=%d \n",tsevent->x,tsevent->y);
  if ((tsevent->pressure) > 0) {
    button_click(fd,1);
  } else {
    button_click(fd,0);
  } // end of [if]
  dev_uinput_sync(fd);
}

int write_to_fifo (char *buf, int size) {
  char *fname;
  static int fifo;

  fname="/dev/tsvnc";

  TRACE2(" [I] %d Bytes => fifo (fd: %d)...\n", size, fifo);

  if(fifo<=0)
    if((fifo=open(fname,O_WRONLY | O_NONBLOCK))<=0) {
      TRACE1(" [W] unable to open fifo %s - no listeners? \n",fname);
      return(-1);
    }

  if(size!=0 && write(fifo,buf,size)==-1 && errno==EPIPE) {
    close(fifo);
    fifo=-1;
    return(-1);
  }

  TRACE1(" [I] sent to %s \n", fname);
  return(0);
}

static char *devs[] = {
        "/dev/input/event0",
        "/dev/input/event1",
        "/dev/input/event2",
        "/dev/input/event3",
        NULL
};

int node_is_sane (int fd) {
  int version;
  u_int32_t bit;
  u_int64_t absbit;
  char name[UINPUT_MAX_NAME_SIZE] = "unknown";

  if (! ((ioctl(fd, EVIOCGVERSION, &version) >= 0) &&
    (version == EV_VERSION) &&
    (ioctl(fd, EVIOCGBIT(0, sizeof(bit) * 8), &bit) >= 0) &&
    (bit & (1 << EV_ABS)) &&
    (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit) * 8), &absbit) >= 0) &&
    (bit & (1 << EV_SYN))   &&
    (bit & (1 << EV_KEY))   &&
    (absbit & (1 << ABS_X)) &&
    (absbit & (1 << ABS_Y)) )) {

    TRACE(" => event source did NOT pass sanity check. \n");
    return -1;
    }

  ioctl(fd, EVIOCGNAME(sizeof(name)), name);
  if (strcmp(name,UINPUT_TS_NAME) != 0) {
    TRACE2(" [I] node name (%s) does not match (!= %s) \n", &name, UINPUT_TS_NAME);
    TRACE(" => event source did NOT pass sanity check. \n");
    return -1;
  }

  TRACE (" => event source passed sanity check. \n");
  TRACE1("  - %s - will be used. \n",name);
  return 1;
}

int vncts(int vnctsfd, struct ts_sample *samp) {
  struct buffer {
    int current_x;
    int current_y;
    int current_p;

    struct timeval time;
  };

  struct input_event ev;
  static struct buffer i;
  static int pressed = 0;
  int size = 0;

  size = read(vnctsfd, &ev, sizeof(struct input_event));
  TRACE1(" [I] %d bytes read from uinput \n", size);
  if (size < (int)sizeof(struct input_event)) {
                if (pressed == 1) {
                        samp->x = i.current_x;
                        samp->y = i.current_y;
                        samp->pressure = i.current_p;
                        gettimeofday(&(i.time),NULL);
                        samp->tv = i.time;
                        return 1;
                } else {
                }
        }

        switch (ev.type) {
                case EV_KEY:
                        switch (ev.code) {
                                case BTN_TOUCH:
                                        if (ev.value == 0) {    /* pen up */
                                                samp->x = 0;
                                                samp->y = 0;
                                                samp->pressure = 0;
                                                samp->tv = ev.time;
                                                pressed = 0;
                                                return 1;
                                        } else {
                                                pressed = 1;
                                        }
                                break;
                        }
                        break;
                case EV_SYN:    /* Fill out a new complete event */
                        samp->x = i.current_x;
                        samp->y = i.current_y;
                        samp->pressure = i.current_p;
                        i.time = ev.time;
                        samp->tv = ev.time;
                        if (i.current_p > 0) {
                                pressed = 1;
                        } else {
                                pressed = 0;
                        }
                        return 1;
                break;
                case EV_ABS:
                        switch (ev.code) {
                                case ABS_X:
                                        i.current_x = ev.value;
                                        break;
                                case ABS_Y:
                                        i.current_y = ev.value;
                                break;
                                case ABS_PRESSURE:
                                        i.current_p = ev.value;
                                break;
                        }
                        break;
                }

  return -1;
}

void display_help(char* arg0) {
  printf("%s: error !\n",arg0);
#ifdef DEBUG
  printf("Usage: %s [-inputAPI] [-debug] ",arg0);
#else
  printf("Usage: %s [-inputAPI] ",arg0);
#endif
  printf("\n");
  printf("  -input: send TS events to input API \n");
#ifdef DEBUG
  printf("  -debug \n\n");
#endif
};

int main(int argc, char **argv) {
  struct tsdev *ts;

  struct linear {
    int     swap_xy;

// Linear scaling and offset parameters for pressure
    int     p_offset;
    int     p_mult;
    int     p_div;

// Linear scaling and offset parameters for x,y (can include rotation)
    mpf_t   a[7];
  };

  char *tsdev;         // HW touchscreen device node
  char *calfile=NULL;  // TS clibration file
  char *tokptr;
  char pcalbuf[200];

  int hwtsfd = 0,      // HW TS file descriptor
     vnctsfd = 0,      // VNC TS file descriptor

      pcal_fd = 0,     // calibration file fd

   inputAPIfd = 0;     // merged TS (inputAPI)

  fd_set fds;          // fd(s) for synchronous I/O multiplexing

  struct linear lin;   // linear calibration constants
  struct stat sbuf;
  struct timeval tv;

  int vnctssane = 0,   // vnc event source passed sanity check(s)
      inputAPI = 0,    // send events to input API (0,1)
      index = 0, i = 0, retval = 0;

/***
 * read environment settings
 ***/
  if( (tsdev = getenv("TSLIB_TSDEVICE")) == NULL)  tsdev = strdup (DefaultTS);
  if( (calfile = getenv("TSLIB_CALIBFILE")) == NULL) calfile = strdup (DefaultTSCal);

  mpf_t b[9]; // pre-calculated calibration values (derived from linear.a)
  mpf_t c[6]; // pre-calculated calibration values (derived from b)
  mpf_t mpf_helper1, mpf_helper2;

  mpf_init(lin.a[0]);
  mpf_init(lin.a[1]);
  mpf_init(lin.a[2]);
  mpf_init(lin.a[3]);
  mpf_init(lin.a[4]);
  mpf_init(lin.a[5]);
  mpf_init(lin.a[6]);

  printf("%s (%s %s) \n",PACKAGE_STRING,__DATE__, __TIME__ );
/***
 * process command line arguments
 ***/
  for(i=1;i<argc;i++) {
    if(!strcmp(argv[i],"-h") ||
       !strcmp(argv[i],"-?") ||
       !strcmp(argv[i],"/?") ||
       !strcmp(argv[i],"-help") ||
       !strcmp(argv[i],"--help")) { display_help(argv[0]); return(-1); }
      else if(!strcmp(argv[i],"-inputAPI")) { inputAPI = 1;}
#ifdef DEBUG
      else if(!strcmp(argv[i],"-debug")) { debug = 1;}
#endif
  }

  TRACE1(" [I] %s will be used as HW TS event source \n",tsdev);
  TRACE1(" [I] %s will be used to calculate raw frames \n", calfile);

/***
 * prepare HW TS
 ***/
  ts = ts_open(tsdev,0);
  if (!ts) {
    perror("ts_open");
    exit(1);
  }
  TRACE(" [I] HW TS open ...\n");
  if (ts_config(ts)) {
    perror("ts_config");
    exit(1);
  }
  TRACE(" [I] HW TS configured ... \n");
  hwtsfd = ts_fd(ts);
  TRACE1(" [I] HW TS FD: %d\n", hwtsfd);

/***
 * prepare VNC TS
 ***/
    i=0;
    while (devs[i] != NULL) {
      TRACE1(" [I] %s ... ",devs[i]);
      vnctsfd = open(devs[i++], O_RDONLY | O_NONBLOCK);
       if (vnctsfd > 0) {
         if  ((node_is_sane(vnctsfd)) > 0) {
           vnctssane = 1;
           break;
         }
       } else {
       TRACE(" - not present. \n");
      }
    }
/***
 * prepare merged TS
 ***/
    if (inputAPI) {
      inputAPIfd = dev_uinput_init_mouse(UINPUT_INPUTAPI_NAME);
      if (inputAPIfd < 1) {
        TRACE(" [F] unable to create a new uinput node for the merged TS \n");
        perror("dev_uinput_init_mouse");
        exit(1);
      } // end of [if]
      TRACE(" [I] we'll use inputAPI ... \n");
    } // end of [if]
/***
 * read calibration file
 ***/
   // Use default values that leave ts numbers unchanged after transform

     mpf_set_si(lin.a[0],1);
     mpf_set_si(lin.a[1],0);
     mpf_set_si(lin.a[2],0);
     mpf_set_si(lin.a[3],0);
     mpf_set_si(lin.a[4],1);
     mpf_set_si(lin.a[5],0);
     mpf_set_si(lin.a[6],1);

     lin.p_offset = 0;
     lin.p_mult   = 1;
     lin.p_div    = 1;
     lin.swap_xy  = 0;

     if(stat(calfile,&sbuf)==0) {
       pcal_fd = open(calfile,O_RDONLY);
       read(pcal_fd,pcalbuf,200);
       mpf_set_si(lin.a[0],atoi(strtok(pcalbuf," ")));
       index=1;
       while(index<7) {
         tokptr = strtok(NULL," ");
         if(*tokptr!='\0') {
           mpf_set_si(lin.a[index],atoi(tokptr));
           index++;
         }
       }
     }
/* Ignore SIGPIPE, so our writes can return EPIPE */
  signal(SIGPIPE,SIG_IGN);

/* some pre-calculations (to save cpu power) ...
 * ... as some quite big numbers are involved we have to use high precision
 *     arithmetics
 */
  mpf_init(mpf_helper1);
  mpf_init(mpf_helper2);

  for(index=0;index<9;index++) mpf_init(b[index]);
  for(index=0;index<6;index++) mpf_init(c[index]);

  mpf_neg(mpf_helper1,lin.a[1]);          // b[0] = -lin.a[1] * lin.a[6];
  mpf_mul(b[0],mpf_helper1,lin.a[6]);
  mpf_mul(b[1],lin.a[4],lin.a[6]);        // b[1] =  lin.a[4] * lin.a[6];
  mpf_mul(b[2],lin.a[1],lin.a[5]);        // b[2] =  lin.a[1] * lin.a[5];
  mpf_mul(b[3],lin.a[2],lin.a[4]);        // b[3] =  lin.a[2] * lin.a[4];
  mpf_mul(mpf_helper1,lin.a[1],lin.a[3]); // b[4] =  lin.a[1] * lin.a[3] - lin.a[0] * lin.a[4];
  mpf_mul(mpf_helper2,lin.a[0],lin.a[4]);
  mpf_sub(b[4],mpf_helper1,mpf_helper2);
  mpf_neg(mpf_helper1,lin.a[0]);          // b[5] = -lin.a[0] * lin.a[6];
  mpf_mul(b[5],mpf_helper1,lin.a[6]);
  mpf_mul(b[6],lin.a[3],lin.a[6]);        // b[6] =  lin.a[3] * lin.a[6];
  mpf_mul(b[7],lin.a[0],lin.a[6]);        // b[7] =  lin.a[0] * lin.a[5];
  mpf_mul(b[8],lin.a[2],lin.a[3]);        // b[8] =  lin.a[2] * lin.a[3];

  mpf_div(c[0],b[0],b[4]);                // c[0] = b[0] / b[4];
  mpf_div(c[1],b[1],b[4]);                // c[1] = b[1] / b[4];
  mpf_sub(mpf_helper1,b[2],b[3]);         // c[2] = (b[2] - b[3]) / b[4];
  mpf_div(c[2],mpf_helper1,b[4]);
  mpf_div(c[3],b[5],b[4]);                // c[3] = b[5] / b[4];
  mpf_div(c[4],b[6],b[4]);                // c[4] = b[6] / b[4];
  mpf_sub(mpf_helper1,b[7],b[8]);         // c[5] = (b[7] - b[8]) / b[4];
  mpf_div(c[5],mpf_helper1,b[4]);

#ifdef DEBUG
  if (debug) {
/*
    for(index=0;index<7;index++) gmp_printf(" [I]: a[%d] = %Ff \n",index,lin.a[index]);
    TRACE(" ---- \n");
    for(index=0;index<9;index++) gmp_printf(" [I]: b[%d] = %Ff \n",index,b[index]);
    TRACE(" ---- \n");
    for(index=0;index<6;index++) gmp_printf(" [I]: c[%d] = %Ff \n",index,c[index]);
*/
    TRACE(" [I] raw equations: \n")
    gmp_printf(" => rawx = %Ff * y +  %Ff * x + %Ff \n", c[0],c[1], c[2]);
    gmp_printf(" => rawy = %Ff * y +  %Ff * x + %Ff \n", c[3],c[4],c[5]);
  }
#endif


  while (1) {
    struct ts_sample samp;

    FD_ZERO(&fds);
    FD_SET(hwtsfd,&fds);

    if (vnctssane == 1) {
      FD_SET(vnctsfd,&fds);
    } else {
      TRACE(" [W] vnc ts events will not be processed => transparent mode. \n");
    }
    tv.tv_sec = 5; tv.tv_usec = 0;
    retval = select(FD_SETSIZE,&fds,NULL,NULL,&tv);
    switch (retval) {
      case EBADF:
        TRACE(" [W] An invalid file descriptor was given in one of the sets. \n");
        break;
      case EINTR:
        TRACE(" [W] A non blocked signal was caught. \n");
        break;
      case EINVAL:
        TRACE(" [W] n is negative or the value contained within timeout is invalid. \n");
        break;
      case ENOMEM:
        TRACE(" [W] select() was unable to allocate memory for internal tables. \n");
        break;
      case 0:
        // TRACE(" [W] select () - timeout ... \n");
        // write_to_fifo(NULL,0);
        break;
      case 1:
        TRACE(" [I] event catched ... ");
        if (FD_ISSET(hwtsfd,&fds)) {
          TRACE(" [- HW -] \n");
          retval = ts_read_raw(ts,&samp,1);
          if (retval < 0) {
            perror("ts_read_raw");
            exit;
          }

          tsevent.y = samp.y;
          tsevent.x = samp.x;
          tsevent.pressure = samp.pressure;
          tsevent.millisecs = ((samp.tv.tv_sec * 1000) + samp.tv.tv_usec);

          write_to_fifo((char*) &tsevent,sizeof(tsevent));
        }
        if (vnctssane == 1) {
          if (FD_ISSET(vnctsfd,&fds)) {
            TRACE(" [- VNC -] \n");
            if (vncts(vnctsfd,&samp) == 1) {
              mpf_t tmpy, tmpx;
              mpf_init(tmpx);
              mpf_init(tmpy);

           // tmpx = c[0] * samp.y + c[1] * samp.x + c[2];
              mpf_set_si(mpf_helper1,samp.x);
              mpf_set_si(mpf_helper2,samp.y);
              mpf_mul(mpf_helper2,c[0],mpf_helper2);
              mpf_mul(mpf_helper1,c[1],mpf_helper1);
              mpf_add(tmpx,mpf_helper1,mpf_helper2);
              mpf_add(tmpx,tmpx,c[2]);

          // tmpy = c[3] * samp.y + c[4] * samp.x + c[5];
              mpf_set_si(mpf_helper1,samp.x);
              mpf_set_si(mpf_helper2,samp.y);
              mpf_mul(mpf_helper2,c[3],mpf_helper2);
              mpf_mul(mpf_helper1,c[4],mpf_helper1);
              mpf_add(tmpy,mpf_helper1,mpf_helper2);
              mpf_add(tmpy,tmpy,c[5]);
/*
... this reverts the linear calibration as applied by tslib

(%i1) solve([x=(a2+a0*xtemp+a1*ytemp)/a6, y=(a5+a3*xtemp+a4*ytemp)/a6],[xtemp,ytemp]);

                  - a1 a6 y + a4 a6 x + a1 a5 - a2 a4
(%o1) [[xtemp = - -----------------------------------,
                             a1 a3 - a0 a4

                  - a0 a6 y + a3 a6 x + a0 a5 - a2 a3
        ytemp = -----------------------------------]]
                             a1 a3 - a0 a4

              tmpx = ( -lin.a[1] * lin.a[6] * samp.y +
                        lin.a[4] * lin.a[6] * samp.x +
                        lin.a[1] * lin.a[5] -
                        lin.a[2] * lin.a[4]) / (lin.a[1] * lin.a[3] - lin.a[0] * lin.a[4]);

              tmpy = ( -lin.a[0] * lin.a[6] * samp.y +
                        lin.a[3] * lin.a[6] * samp.x +
                        lin.a[0] * lin.a[5] -
                        lin.a[2] * lin.a[3]) / (lin.a[1] * lin.a[3] - lin.a[0] * lin.a[4]);
*/
              tsevent.y = mpf_get_si(tmpy);
              tsevent.x = -mpf_get_si(tmpx);
#ifdef DEBUG
              if (debug) {
                gmp_printf(" [I]    x: %d,    y: %d \n", samp.x,samp.y);
                gmp_printf(" [I] rawx: %d, rawy: %d \n", tsevent.x, tsevent.y);
              }
#endif
              tsevent.pressure = samp.pressure;
              tsevent.millisecs = ((samp.tv.tv_sec * 1000) + samp.tv.tv_usec);

              if (!inputAPI) {
                write_to_fifo((char*) &tsevent,sizeof(tsevent));
              } else {
                write_to_input(inputAPIfd,&tsevent);
              } // end if [if]
            }
          }
        }
        break;
    }
  }
}

---