src/tuio.c

   1 /*
   2  * Copyright (c) 2009 Ryan Huffman
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  *
  22  * Authors:
  23  *      Ryan Huffman (ryanhuffman@gmail.com)
  24  */
  25
  26 #include <unistd.h>
  27
  28 #include <xf86Xinput.h>
  29 #include <X11/extensions/XIproto.h>
  30 #include <X11/extensions/XInput2.h>
  31 #include <xf86_OSlib.h>
  32
  33 #include "tuio.h"
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include "config.h"
  37 #endif
  38
  39 /* Module Functions */
  40 static pointer
  41 TuioPlug(pointer, pointer, int *, int *);
  42
  43 static void
  44 TuioUnplug(pointer);
  45
  46 /* Driver Functions */
  47 static InputInfoPtr
  48 TuioPreInit(InputDriverPtr, IDevPtr, int);
  49
  50 static void
  51 TuioUnInit(InputDriverPtr, InputInfoPtr, int);
  52
  53 static void
  54 TuioReadInput(InputInfoPtr);
  55
  56 static int
  57 TuioControl(DeviceIntPtr, int);
  58
  59 /* Internal Functions */
  60 static int
  61 _tuio_init_buttons(DeviceIntPtr device);
  62
  63 static int
  64 _tuio_init_axes(DeviceIntPtr device);
  65
  66 static int
  67 _tuio_lo_cur2d_handle(const char *path,
  68                    const char *types,
  69                    lo_arg **argv,
  70                    int argc,
  71                    void *data,
  72                    void *user_data);
  73
  74 static void
  75 lo_error(int num,
  76          const char *msg,
  77          const char *path);
  78
  79 /* Object list manipulation functions */
  80 static ObjectPtr
  81 _object_get(ObjectList list, int id);
  82
  83 static ObjectPtr
  84 _object_insert(ObjectList list);
  85
  86 static void
  87 _object_remove(ObjectList list, ObjectPtr obj);
  88
  89 /* Driver information */
  90 static XF86ModuleVersionInfo TuioVersionRec =
  91 {
  92     "tuio",
  93     MODULEVENDORSTRING,
  94     MODINFOSTRING1,
  95     MODINFOSTRING2,
  96     XORG_VERSION_CURRENT,
  97     PACKAGE_VERSION_MAJOR, PACKAGE_VERSION_MINOR, PACKAGE_VERSION_PATCHLEVEL,
  98     ABI_CLASS_XINPUT,
  99     ABI_XINPUT_VERSION,
 100     MOD_CLASS_XINPUT,
 101     {0, 0, 0, 0}
 102 };
 103
 104 _X_EXPORT InputDriverRec TUIO =
 105 {
 106     1,
 107     "tuio",
 108     NULL,
 109     TuioPreInit,
 110     TuioUnInit,
 111     NULL,
 112     0
 113 };
 114
 115 _X_EXPORT XF86ModuleData tuioModuleData =
 116 {
 117     &TuioVersionRec,
 118     TuioPlug,
 119     TuioUnplug
 120 };
 121
 122 static pointer
 123 TuioPlug(pointer        module,
 124          pointer        options,
 125          int            *errmaj,
 126          int            *errmin)
 127 {
 128     xf86AddInputDriver(&TUIO, module, 0);
 129     return module;
 130 }
 131
 132 /* Remove this? */
 133 static void
 134 TuioUnplug(pointer      p)
 135 {
 136 }
 137
 138 /**
 139  * Pre-initialization of new device
 140  *
 141  * TODO:
 142  *  - Parse configuration options
 143  */
 144 static InputInfoPtr
 145 TuioPreInit(InputDriverPtr drv,
 146             IDevPtr dev,
 147             int flags)
 148 {
 149     InputInfoPtr  pInfo;
 150     TuioDevicePtr pTuio;
 151
 152     if (!(pInfo = xf86AllocateInput(drv, 0)))
 153         return NULL;
 154
 155     /* The TuioDevicePtr will hold our blobs */
 156     pTuio = xcalloc(1, sizeof(TuioDeviceRec));
 157     if (!pTuio) {
 158             pInfo->private = NULL;
 159             xf86DeleteInput(pInfo, 0);
 160             return NULL;
 161     }
 162
 163     pInfo->private = pTuio;
 164
 165     /* Set up InputInfoPtr */
 166     pInfo->name = xstrdup(dev->identifier);
 167     pInfo->flags = 0;
 168     pInfo->type_name = XI_TOUCHSCREEN; /* FIXME: Correct type? */
 169     pInfo->conf_idev = dev;
 170     pInfo->read_input = TuioReadInput; /* Set callback */
 171     pInfo->device_control = TuioControl; /* Set callback */
 172     pInfo->switch_mode = NULL;
 173
 174     /* Process common device options */
 175     xf86CollectInputOptions(pInfo, NULL, NULL);
 176     xf86ProcessCommonOptions(pInfo, pInfo->options);
 177
 178     pInfo->flags |= XI86_OPEN_ON_INIT;
 179     pInfo->flags |= XI86_CONFIGURED;
 180
 181     return pInfo;
 182 }
 183
 184 /**
 185  * Clean up
 186  */
 187 static void
 188 TuioUnInit(InputDriverPtr drv,
 189            InputInfoPtr pInfo,
 190            int flags)
 191 {
 192     TuioDevicePtr pTuio = pInfo->private;
 193
 194     xfree(pTuio);
 195     xf86DeleteInput(pInfo, 0);
 196 }
 197
 198 /**
 199  * Handle new data on the socket
 200  */
 201 static void
 202 TuioReadInput(InputInfoPtr pInfo)
 203 {
 204     TuioDevicePtr pTuio = pInfo->private;
 205     ObjectList list = pTuio->list;
 206     ObjectPtr obj = *list;
 207     ObjectPtr objtemp;
 208
 209     while(xf86WaitForInput(pInfo->fd, 0) > 0)
 210     {
 211         /* liblo will receive a message and call the appropriate
 212          * handlers (i.e. _tuio_lo_cur2d_hande())
 213          * If nothing is found (this SHOULDN'T happen, but if it did,
 214          * all the objects would be deleted), just return */
 215         if(!lo_server_recv_noblock(pTuio->server, 0))
 216             return;
 217
 218         /* During the processing of the previous message/bundle,
 219          * any "active" messages will be handled by flagging
 220          * the listed object ids.  Now that processing is done,
 221          * remove any dead object ids. */
 222         if (obj != NULL) {
 223             if (!obj->alive) {
 224                 objtemp = obj->next;
 225                 _object_remove(list, obj);
 226                 obj = objtemp;
 227             } else {
 228                 obj->alive = 0; /* Reset for next message */
 229                 obj = obj->next;
 230             }
 231         }
 232     }
 233 }
 234
 235 /**
 236  * Handle device state changes
 237  */
 238 static int
 239 TuioControl(DeviceIntPtr device,
 240             int what)
 241 {
 242     InputInfoPtr pInfo = device->public.devicePrivate;
 243     TuioDevicePtr pTuio = pInfo->private;
 244
 245     switch (what)
 246     {
 247         case DEVICE_INIT:
 248             xf86Msg(X_INFO, "%s: Init\n", pInfo->name);
 249             _tuio_init_buttons(device);
 250             _tuio_init_axes(device);
 251             break;
 252
 253         case DEVICE_ON: /* Open device socket and start listening! */
 254             xf86Msg(X_INFO, "%s: On.\n", pInfo->name);
 255             if (device->public.on) /* already on! */
 256                 break;
 257
 258             /* Setup server */
 259             pTuio->server = lo_server_new_with_proto("3333", LO_UDP, lo_error);
 260             if (pTuio->server == NULL) {
 261                 xf86Msg(X_ERROR, "%s: Error allocating new lo_server\n",
 262                         pInfo->name);
 263                 return BadAlloc;
 264             }
 265             pTuio->list = xcalloc(1, sizeof(ObjectPtr));
 266
 267             /* Register to receive all /tuio/2Dcur messages */
 268             lo_server_add_method(pTuio->server, "/tuio/2Dcur", NULL,
 269                                  _tuio_lo_cur2d_handle, pInfo);
 270
 271             pInfo->fd = lo_server_get_socket_fd(pTuio->server);
 272             xf86Msg(X_INFO, "%s: Socket = %i\n", pInfo->name, pInfo->fd);
 273
 274             xf86AddEnabledDevice(pInfo);
 275             device->public.on = TRUE;
 276             break;
 277
 278         case DEVICE_OFF:
 279             xf86Msg(X_INFO, "%s: Off\n", pInfo->name);
 280             if (!device->public.on)
 281                 break;
 282
 283             xf86RemoveEnabledDevice(pInfo);
 284
 285             lo_server_free(pTuio->server);
 286             pInfo->fd = -1;
 287             device->public.on = FALSE;
 288             break;
 289
 290         case DEVICE_CLOSE:
 291             xf86Msg(X_INFO, "%s: Close\n", pInfo->name);
 292
 293             lo_server_free(pTuio->server);
 294             pInfo->fd = -1;
 295             device->public.on = FALSE;
 296             break;
 297
 298     }
 299     return Success;
 300 }
 301
 302 static int
 303 _tuio_create_master() {
 304     //XICreateMasterInfo ci;
 305     //unsigned int blobid;
 306     //char cur_name[21]; /* Max len: 20 char + \0 */
 307
 308     //sprintf(cur_name, "tuio_blob_%u", blobid);
 309
 310     //c.type = XICreateMaster;
 311     //c.name =  cur_name;
 312 }
 313
 314 /**
 315  * Handles OSC messages in the /tuio/2Dcur address space
 316  */
 317 static int
 318 _tuio_lo_cur2d_handle(const char *path,
 319                       const char *types,
 320                       lo_arg **argv,
 321                       int argc,
 322                       void *data,
 323                       void *user_data)
 324 {
 325     InputInfoPtr pInfo = user_data;
 326     TuioDevicePtr pTuio = pInfo->private;
 327     ObjectList list = pTuio->list;
 328     ObjectPtr obj, objtemp;
 329     int valuators[2];
 330     int i;
 331
 332     if (argc < 1) {
 333         xf86Msg(X_ERROR, "%s: \n", pInfo->name);
 334         return 1;
 335     }
 336
 337     /* Parse message type */
 338
 339     /* Set message type:  */
 340     if (strcmp(argv[0], "set") == 0) {
 341         obj = _object_get(list, argv[1]->i);
 342         if(obj == NULL) {
 343             obj = _object_insert(list);
 344             obj->id = argv[1]->i;
 345         }
 346
 347         obj->x = argv[2]->f;
 348         obj->y = argv[3]->f;
 349
 350         /* THIS NEEDS TO BE FIXED!! */
 351         valuators[0] = obj->x * 0xFFFFFFFF;
 352         valuators[1] = obj->y * 0xFFFFFFFF;
 353
 354         xf86PostMotionEventP(pInfo->dev,
 355                             TRUE, /* is_absolute */
 356                             0, /* first_valuator */
 357                             2, /* num_valuators */
 358                             valuators);
 359
 360     } else if (strcmp(argv[0], "alive") == 0) {
 361         obj = *list;
 362         while (obj != NULL) {
 363             obj->alive = 0;
 364             for (i=1; i<argc; i++) {
 365                 if (argv[i]->i == obj->id) {
 366                     obj->alive = 1;
 367                     break;
 368                 }
 369             }
 370
 371         }
 372
 373     } else if (strcmp(argv[0], "fseq") == 0) {
 374
 375     }
 376     return 0;
 377 }
 378
 379 /**
 380  * liblo error handler
 381  */
 382 static void
 383 lo_error(int num,
 384          const char *msg,
 385          const char *path)
 386 {
 387     xf86Msg(X_ERROR, "liblo: %s\n", msg);
 388 }
 389
 390 /**
 391  * Retrieves an object from a list based on its id.  Returns NULL if
 392  * not found.
 393  */
 394 static ObjectPtr
 395 _object_get(ObjectList list, int id) {
 396     ObjectPtr obj = *list;
 397
 398     while (obj != NULL && obj->id != id) {
 399         obj = obj->next;
 400     }
 401
 402     return obj;
 403 }
 404
 405 /**
 406  * Allocates and inserts a new object at the beginning of a list.
 407  * Pointer to the new object is returned.
 408  */
 409 static ObjectPtr
 410 _object_insert(ObjectList list) {
 411     ObjectPtr obj = xcalloc(1, sizeof(ObjectRec));
 412     obj->previous = NULL;
 413     obj->next = *list;
 414     if (*list != NULL)
 415         (*list)->previous = obj;
 416     *list = obj;
 417     return obj;
 418 }
 419
 420 /**
 421  * Removes an object from a list.  It is assumed that the object
 422  * is in the list
 423  */
 424 static void
 425 _object_remove(ObjectList list, ObjectPtr obj) {
 426     if (obj->next != NULL)
 427         obj->next->previous = obj->previous;
 428
 429     if (obj->previous != NULL)
 430         obj->previous->next = obj->next;
 431     else
 432         *list = obj->next;
 433     free(obj);
 434 }
 435
 436 /**
 437  * Init the button map device.  We only use one button.
 438  */
 439 static int
 440 _tuio_init_buttons(DeviceIntPtr device)
 441 {
 442     InputInfoPtr        pInfo = device->public.devicePrivate;
 443     CARD8               *map;
 444     Atom                *labels;
 445     const int           num_buttons = 1; /* left-click */
 446     int                 ret = Success;
 447     int                 i;
 448
 449     map = xcalloc(num_buttons, sizeof(CARD8));
 450     labels = xcalloc(num_buttons, sizeof(Atom));
 451
 452     for (i = 0; i < num_buttons; i++)
 453         map[i] = i;
 454
 455     if (!InitButtonClassDeviceStruct(device, num_buttons,
 456 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
 457                                      labels,
 458 #endif
 459                                      map)) {
 460         xf86Msg(X_ERROR, "%s: Failed to register buttons.\n", pInfo->name);
 461         ret = BadAlloc;
 462     }
 463
 464     xfree(labels);
 465     xfree(map);
 466     return ret;
 467 }
 468
 469 /**
 470  * Init valuators for device, use x/y coordinates.
 471  */
 472 static int
 473 _tuio_init_axes(DeviceIntPtr device)
 474 {
 475     InputInfoPtr        pInfo = device->public.devicePrivate;
 476     int                 i;
 477     const int           num_axes = 2;
 478     Atom *atoms;
 479
 480     atoms = xcalloc(2, sizeof(Atom));
 481
 482     if (!InitValuatorClassDeviceStruct(device,
 483                                        num_axes,
 484 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
 485                                        atoms,
 486 #endif
 487 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
 488                                        GetMotionHistory,
 489 #endif
 490                                        GetMotionHistorySize(),
 491                                        0))
 492         return BadAlloc;
 493
 494     /* Use absolute mode.  Currently, TUIO coords are mapped to the
 495      * full screen area */
 496     pInfo->dev->valuator->mode = Absolute;
 497     if (!InitAbsoluteClassDeviceStruct(device))
 498         return BadAlloc;
 499
 500     for (i = 0; i < num_axes; i++)
 501     {
 502         xf86InitValuatorAxisStruct(device, i,
 503 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
 504                                    atoms[i],
 505 #endif
 506                                    0, 0xFFFFFFFF, 1, 1, 1);
 507         xf86InitValuatorDefaults(device, i);
 508     }
 509     return Success;
 510 }