jog/shuttle et cinelerra

[Michel Campfort <cft1@free.fr>]

Bonjour,

Je viens de recevoir un jog/shuttle Contour ShuttleXpress, celui avec
5 boutons.

J'ai trouvé un programme en C écrit par Arendt David pour le gérer,
mais pour les [ et ],ça ne fonctionnait pas ( à cause du clavier
français ).

J'ai modifié cette fonction et maintenant, de gauche à droite, les
boutons sont: undo, [, cut, ], redo.

J'en ai profité pour mettre 3 vitesses avant et arrière sur le shuttle
à la place des deux initialement programmées.

Pour utiliser ce soft avec cinelerra ( avec kino il n'est pas utile )
il suffit de déterminer l'event utilisé par ce shuttle, et de le rendre
"readable" par tous ( /dev/input/eventX , ou X est 1,2,3... )

Ensuite, lancer cshuttle par: ./cshuttle /dev/input/eventX &

Voici le source, à compiler par:
gcc -Wall cshuttle.c -o cshuttle -L/usr/X11R6/lib -lX11 -lXtst

Il y a quelques warnings sans conséquences.

---------------------------

#define DELAY 10

#define KEY 1
#define KEY1 256
#define KEY2 257
#define KEY3 258
#define KEY4 259
#define KEY5 260
#define KEY6 261
#define KEY7 262
#define KEY8 263
#define KEY9 264
#define KEY10 265
#define KEY11 266
#define KEY12 267
#define KEY13 268

#define JOGSHUTTLE 2
#define JOG 7
#define SHUTTLE 8

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <linux/input.h>
#include <X11/Xlib.h>
#include <X11/extensions/XTest.h>
#include <X11/keysym.h>

typedef struct input_event EV;

unsigned short jogvalue = 0xffff;
int shuttlevalue = 0xffff;

Display *display;

void initdisplay()
{
  int event, error, major, minor;
  display = XOpenDisplay(0);
  if (!display)
  {
    fprintf(stderr, "unable to open X display\n");
    exit(1);
  }
  if (!XTestQueryExtension(display, &event, &error, &major, &minor))
  {
    fprintf(stderr, "Xtest extensions not supported\n");
    XCloseDisplay(display);
    exit(1);
  }
}

void sendkey(KeySym modifier, KeySym key)
{
  KeyCode modifiercode;
  KeyCode keycode;
  if (modifier != 0)
  {
    modifiercode = XKeysymToKeycode(display, modifier);
    XTestFakeKeyEvent(display, modifiercode, True, DELAY);
  }
  keycode = XKeysymToKeycode(display, key);
  XTestFakeKeyEvent(display, keycode, True, DELAY);
  XTestFakeKeyEvent(display, keycode, False, DELAY);
  if (modifier != 0)
    XTestFakeKeyEvent(display, modifiercode, False, DELAY);
  XFlush(display);
}

void key(unsigned short code, unsigned int value)
{
  if (value == 0)
    return;
  switch (code)
  {
    case KEY5 : sendkey(0, 'z'); break;         //undo
    case KEY6 : sendkey(0xfe03, '['); break;    //point d'entree
    case KEY7 : sendkey(0, 'x'); break;         //coupe
    case KEY8 : sendkey(0xfe03, ']'); break;    //point de sortie
    case KEY9 : sendkey(0xffe1, 'z'); break;    //redo
  }
}

void jog(unsigned int value)
{
  if (jogvalue != 0xffff)
  {
    if (value < jogvalue)
      sendkey(0, XK_KP_4);
    else if (value > jogvalue)
      sendkey(0, XK_KP_1);
  }
  jogvalue = value;
}

void shuttle(int value)
{
  int i = value/2;
  if (i == shuttlevalue)
    return;
  switch(i)
  {
    case -3 : sendkey(0, XK_KP_Add); break;     // recul double vitesse
    case -2 : sendkey(0, XK_KP_6); break;       // recul vitesse normale
    case -1 : sendkey(0, XK_KP_5); break;       // recul demi vitesse
    case  0 : sendkey(0, XK_KP_0); break;       // stop
    case  1 : sendkey(0, XK_KP_2); break;       // avance demi vitesse
    case  2 : sendkey(0, XK_KP_3); break;       // avance vitesse normale
    case  3 : sendkey(0, XK_KP_Enter); break;   // avance double vitesse
  }
  shuttlevalue = i;
}

void jogshuttle(unsigned short code, unsigned int value)
{
  switch (code)
  {
    case JOG     : jog(value); break;
    case SHUTTLE : shuttle(value); break;
  }
}

void handle_event(EV ev)
{
  switch (ev.type)
  {
    case KEY        : key(ev.code, ev.value);
    case JOGSHUTTLE : jogshuttle(ev.code, ev.value);
  }
}

int main(int argc, char **argv)
{
  int fd;
  char name[256] = "unknown";
  EV ev;
  if (argc < 2)
  {
    fprintf(stderr, "syntax: cshuttle <device>\n");
    return 1;
  }
  printf("cshuttle 0.1beta written by Arendt David 
admin-/LHdS3kC8BfYtjvyW6yDsg@xxxxxxxxxxxxxxxx)v1.1 \n");
  fd = open(argv[1], O_RDONLY);
  if (fd < 0)
  {
    fprintf(stderr, "unable to open %s\n", argv[1]);
    return 1;
  }
  if (ioctl(fd, EVIOCGNAME(sizeof(name)), name) < 0)
  {
    perror("evdev ioctl");
  }
  printf("device name: %s\n", name);
  initdisplay();
  while (1)
  {
    read(fd, &ev, sizeof(ev));
    handle_event(ev);
  }
  close(fd);
  return 0;
}

----------------------------------------------

Il fout parfois le bronx lorsque l'on manipule le shuttle dans d'autres
programmes.

En espérant avoir interessé quelqu'un.

--
Amicalement

Michel