← Back to branch summary

~ubuntu-branches/debian/jessie/ardour/jessie

« back to all changes in this revision

Viewing changes to libs/surfaces/frontier/tests/tranzport.c

  • Committer: Package Import Robot
  • Author(s): Adrian Knoth, Jaromír Mikeš, Adrian Knoth
  • Date: 2014-01-21 20:35:34 UTC
  • mfrom: (1.3.2)
  • Revision ID: package-import@ubuntu.com-20140121203534-x4o72doetvqg1nml
Tags: 1:2.8.16+git20131003-1
http://bugs.debian.org/733968
[ Jaromír Mikeš ]
* Set priority optional.
* Fix Vcs urls.
* Imported Upstream version 2.8.16+git20131003

[ Adrian Knoth ]
* Remove obsolete 171_lilv-constness.patch
* Generate svn_revision.cc from debian/rules
* Add patch to fix FTBFS with libaubio4 (Closes: #733968)
* Build-depend on libaubio >= 0.4.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/surfaces/frontier/tests/tranzport.c
 
1
/*
 
2
 * tranzport 0.1 <tranzport.sf.net>
 
3
 * oct 18, 2005
 
4
 * arthur@artcmusic.com
 
5
 */
 
6
 
 
7
#include <stdarg.h>
 
8
#include <stdint.h>
 
9
#include <stdio.h>
 
10
#include <string.h>
 
11
#include <usb.h>
 
12
 
 
13
#define VENDORID  0x165b
 
14
#define PRODUCTID 0x8101
 
15
 
 
16
#define READ_ENDPOINT  0x81
 
17
#define WRITE_ENDPOINT 0x02
 
18
 
 
19
enum {
 
20
        LIGHT_RECORD = 0,
 
21
        LIGHT_TRACKREC,
 
22
        LIGHT_TRACKMUTE,
 
23
        LIGHT_TRACKSOLO,
 
24
        LIGHT_ANYSOLO,
 
25
        LIGHT_LOOP,
 
26
        LIGHT_PUNCH
 
27
};
 
28
 
 
29
#define BUTTONMASK_BATTERY     0x00004000
 
30
#define BUTTONMASK_BACKLIGHT   0x00008000
 
31
#define BUTTONMASK_TRACKLEFT   0x04000000
 
32
#define BUTTONMASK_TRACKRIGHT  0x40000000
 
33
#define BUTTONMASK_TRACKREC    0x00040000
 
34
#define BUTTONMASK_TRACKMUTE   0x00400000
 
35
#define BUTTONMASK_TRACKSOLO   0x00000400
 
36
#define BUTTONMASK_UNDO        0x80000000
 
37
#define BUTTONMASK_IN          0x02000000
 
38
#define BUTTONMASK_OUT         0x20000000
 
39
#define BUTTONMASK_PUNCH       0x00800000
 
40
#define BUTTONMASK_LOOP        0x00080000
 
41
#define BUTTONMASK_PREV        0x00020000
 
42
#define BUTTONMASK_ADD         0x00200000
 
43
#define BUTTONMASK_NEXT        0x00000200
 
44
#define BUTTONMASK_REWIND      0x01000000
 
45
#define BUTTONMASK_FASTFORWARD 0x10000000
 
46
#define BUTTONMASK_STOP        0x00010000
 
47
#define BUTTONMASK_PLAY        0x00100000
 
48
#define BUTTONMASK_RECORD      0x00000100
 
49
#define BUTTONMASK_SHIFT       0x08000000
 
50
 
 
51
#define STATUS_OFFLINE 0xff
 
52
#define STATUS_ONLINE  0x01
 
53
 
 
54
struct tranzport_s {
 
55
        struct usb_device *dev;
 
56
        usb_dev_handle *udev;
 
57
};
 
58
 
 
59
typedef struct tranzport_s tranzport_t;
 
60
 
 
61
void log_entry(FILE *fp, char *format, va_list ap)
 
62
{
 
63
        vfprintf(fp, format, ap);
 
64
        fputc('\n', fp);
 
65
}
 
66
 
 
67
void log_error(char *format, ...)
 
68
{
 
69
        va_list ap;
 
70
        va_start(ap, format);
 
71
        log_entry(stderr, format, ap);
 
72
        va_end(ap);
 
73
}
 
74
 
 
75
void vlog_error(char *format, va_list ap)
 
76
{
 
77
        log_entry(stderr, format, ap);
 
78
}
 
79
 
 
80
void die(char *format, ...)
 
81
{
 
82
        va_list ap;
 
83
        va_start(ap, format);
 
84
        vlog_error(format, ap);
 
85
        va_end(ap);
 
86
        exit(1);
 
87
}
 
88
 
 
89
tranzport_t *open_tranzport_core(struct usb_device *dev)
 
90
{
 
91
        tranzport_t *z;
 
92
        int val;
 
93
 
 
94
        z = malloc(sizeof(tranzport_t));
 
95
        if (!z)
 
96
                die("not enough memory");
 
97
        memset(z, 0, sizeof(tranzport_t));
 
98
 
 
99
        z->dev = dev;
 
100
        z->udev = usb_open(z->dev);
 
101
        if (!z->udev)
 
102
                die("unable to open tranzport");
 
103
 
 
104
        val = usb_claim_interface(z->udev, 0);
 
105
        if (val < 0)
 
106
                die("unable to claim tranzport");
 
107
 
 
108
        return z;
 
109
}
 
110
 
 
111
tranzport_t *open_tranzport()
 
112
{
 
113
        struct usb_bus *bus;
 
114
        struct usb_device *dev;
 
115
 
 
116
        usb_init();
 
117
        usb_find_busses();
 
118
        usb_find_devices();
 
119
 
 
120
        for(bus=usb_busses; bus; bus=bus->next) {
 
121
                for(dev=bus->devices; dev; dev=dev->next) {
 
122
                        if (dev->descriptor.idVendor != VENDORID)
 
123
                                continue;
 
124
                        if (dev->descriptor.idProduct != PRODUCTID)
 
125
                                continue;
 
126
 
 
127
                        return open_tranzport_core(dev);
 
128
                }
 
129
        }
 
130
 
 
131
        die("can't find tranzport");
 
132
        return 0;
 
133
}
 
134
 
 
135
void close_tranzport(tranzport_t *z)
 
136
{
 
137
        int val;
 
138
 
 
139
        val = usb_release_interface(z->udev, 0);
 
140
        if (val < 0)
 
141
                log_error("unable to release tranzport");
 
142
 
 
143
        val = usb_close(z->udev);
 
144
        if (val < 0)
 
145
                log_error("unable to close tranzport");
 
146
 
 
147
        free(z);
 
148
}
 
149
 
 
150
int tranzport_write_core(tranzport_t *z, uint8_t *cmd, int timeout)
 
151
{
 
152
        int val;
 
153
        val = usb_interrupt_write(z->udev, WRITE_ENDPOINT, cmd, 8, timeout);
 
154
        if (val < 0)
 
155
                return val;
 
156
        if (val != 8)
 
157
                return -1;
 
158
        return 0;
 
159
}
 
160
 
 
161
int tranzport_lcdwrite(tranzport_t *z, uint8_t cell, char *text, int timeout)
 
162
{
 
163
        uint8_t cmd[8];
 
164
 
 
165
        if (cell > 9) {
 
166
                return -1;
 
167
        }
 
168
 
 
169
        cmd[0] = 0x00;
 
170
        cmd[1] = 0x01;
 
171
        cmd[2] = cell;
 
172
        cmd[3] = text[0];
 
173
        cmd[4] = text[1];
 
174
        cmd[5] = text[2];
 
175
        cmd[6] = text[3];
 
176
        cmd[7] = 0x00;
 
177
 
 
178
        return tranzport_write_core(z, cmd, timeout);
 
179
}
 
180
 
 
181
int tranzport_lighton(tranzport_t *z, uint8_t light, int timeout)
 
182
{
 
183
        uint8_t cmd[8];
 
184
 
 
185
        cmd[0] = 0x00;
 
186
        cmd[1] = 0x00;
 
187
        cmd[2] = light;
 
188
        cmd[3] = 0x01;
 
189
        cmd[4] = 0x00;
 
190
        cmd[5] = 0x00;
 
191
        cmd[6] = 0x00;
 
192
        cmd[7] = 0x00;
 
193
 
 
194
        return tranzport_write_core(z, cmd, timeout);
 
195
}
 
196
 
 
197
int tranzport_lightoff(tranzport_t *z, uint8_t light, int timeout)
 
198
{
 
199
        uint8_t cmd[8];
 
200
 
 
201
        cmd[0] = 0x00;
 
202
        cmd[1] = 0x00;
 
203
        cmd[2] = light;
 
204
        cmd[3] = 0x00;
 
205
        cmd[4] = 0x00;
 
206
        cmd[5] = 0x00;
 
207
        cmd[6] = 0x00;
 
208
        cmd[7] = 0x00;
 
209
 
 
210
        return tranzport_write_core(z, cmd, timeout);
 
211
}
 
212
 
 
213
int tranzport_read(tranzport_t *z, uint8_t *status, uint32_t *buttons, uint8_t *datawheel, int timeout)
 
214
{
 
215
        uint8_t buf[8];
 
216
        int val;
 
217
 
 
218
        memset(buf, 0, 8);
 
219
        val = usb_interrupt_read(z->udev, READ_ENDPOINT, buf, 8, timeout);
 
220
        if (val < 0)
 
221
                return val;
 
222
        if (val != 8)
 
223
                return -1;
 
224
 
 
225
        /*printf("read: %02x %02x %02x %02x %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);*/
 
226
 
 
227
        *status = buf[1];
 
228
 
 
229
        *buttons = 0;
 
230
        *buttons |= buf[2] << 24;
 
231
        *buttons |= buf[3] << 16;
 
232
        *buttons |= buf[4] << 8;
 
233
        *buttons |= buf[5];
 
234
 
 
235
        *datawheel = buf[6];
 
236
 
 
237
        return 0;
 
238
}
 
239
 
 
240
void lights_core(tranzport_t *z, uint32_t buttons, uint32_t buttonmask, uint8_t light)
 
241
{
 
242
        if (buttons & buttonmask) {
 
243
                if (buttons & BUTTONMASK_SHIFT) {
 
244
                        tranzport_lightoff(z, light, 1000);
 
245
                } else {
 
246
                        tranzport_lighton(z, light, 1000);
 
247
                }
 
248
        }
 
249
}
 
250
 
 
251
void do_lights(tranzport_t *z, uint32_t buttons)
 
252
{
 
253
        lights_core(z, buttons, BUTTONMASK_RECORD, LIGHT_RECORD);
 
254
        lights_core(z, buttons, BUTTONMASK_TRACKREC, LIGHT_TRACKREC);
 
255
        lights_core(z, buttons, BUTTONMASK_TRACKMUTE, LIGHT_TRACKMUTE);
 
256
        lights_core(z, buttons, BUTTONMASK_TRACKSOLO, LIGHT_TRACKSOLO);
 
257
        lights_core(z, buttons, BUTTONMASK_TRACKSOLO, LIGHT_ANYSOLO);
 
258
        lights_core(z, buttons, BUTTONMASK_PUNCH, LIGHT_PUNCH);
 
259
        lights_core(z, buttons, BUTTONMASK_LOOP, LIGHT_LOOP);
 
260
}
 
261
 
 
262
void buttons_core(tranzport_t *z, uint32_t buttons, uint32_t buttonmask, char *str)
 
263
{
 
264
        if (buttons & buttonmask)
 
265
                printf(" %s", str);
 
266
}
 
267
 
 
268
void do_buttons(tranzport_t *z, uint32_t buttons, uint8_t datawheel)
 
269
{
 
270
        printf("buttons:");
 
271
        buttons_core(z, buttons, BUTTONMASK_BATTERY, "battery");
 
272
        buttons_core(z, buttons, BUTTONMASK_BACKLIGHT, "backlight");
 
273
        buttons_core(z, buttons, BUTTONMASK_TRACKLEFT, "trackleft");
 
274
        buttons_core(z, buttons, BUTTONMASK_TRACKRIGHT, "trackright");
 
275
        buttons_core(z, buttons, BUTTONMASK_TRACKREC, "trackrec");
 
276
        buttons_core(z, buttons, BUTTONMASK_TRACKMUTE, "trackmute");
 
277
        buttons_core(z, buttons, BUTTONMASK_TRACKSOLO, "tracksolo");
 
278
        buttons_core(z, buttons, BUTTONMASK_UNDO, "undo");
 
279
        buttons_core(z, buttons, BUTTONMASK_IN, "in");
 
280
        buttons_core(z, buttons, BUTTONMASK_OUT, "out");
 
281
        buttons_core(z, buttons, BUTTONMASK_PUNCH, "punch");
 
282
        buttons_core(z, buttons, BUTTONMASK_LOOP, "loop");
 
283
        buttons_core(z, buttons, BUTTONMASK_PREV, "prev");
 
284
        buttons_core(z, buttons, BUTTONMASK_ADD, "add");
 
285
        buttons_core(z, buttons, BUTTONMASK_NEXT, "next");
 
286
        buttons_core(z, buttons, BUTTONMASK_REWIND, "rewind");
 
287
        buttons_core(z, buttons, BUTTONMASK_FASTFORWARD, "fastforward");
 
288
        buttons_core(z, buttons, BUTTONMASK_STOP, "stop");
 
289
        buttons_core(z, buttons, BUTTONMASK_PLAY, "play");
 
290
        buttons_core(z, buttons, BUTTONMASK_RECORD, "record");
 
291
        buttons_core(z, buttons, BUTTONMASK_SHIFT, "shift");
 
292
        if (datawheel)
 
293
                printf(" datawheel=%02x", datawheel);
 
294
        printf("\n");
 
295
}
 
296
 
 
297
void do_lcd(tranzport_t *z)
 
298
{
 
299
        tranzport_lcdwrite(z, 0, "    ", 1000);
 
300
        tranzport_lcdwrite(z, 1, "DISL", 1000);
 
301
        tranzport_lcdwrite(z, 2, "EXIA", 1000);
 
302
        tranzport_lcdwrite(z, 3, " FOR", 1000);
 
303
        tranzport_lcdwrite(z, 4, "    ", 1000);
 
304
 
 
305
        tranzport_lcdwrite(z, 5, "    ", 1000);
 
306
        tranzport_lcdwrite(z, 6, " CUR", 1000);
 
307
        tranzport_lcdwrite(z, 7, "E FO", 1000);
 
308
        tranzport_lcdwrite(z, 8, "UND ", 1000);
 
309
        tranzport_lcdwrite(z, 9, "    ", 1000);
 
310
}
 
311
 
 
312
int main()
 
313
{
 
314
        tranzport_t *z;
 
315
        uint8_t status;
 
316
        uint32_t buttons;
 
317
        uint8_t datawheel;
 
318
        int val;
 
319
 
 
320
        z = open_tranzport();
 
321
 
 
322
        do_lcd(z);
 
323
 
 
324
        for(;;) {
 
325
                val = tranzport_read(z, &status, &buttons, &datawheel, 60000);
 
326
                if (val < 0)
 
327
                        continue;
 
328
 
 
329
                if (status == STATUS_OFFLINE) {
 
330
                        printf("offline\n");
 
331
                        continue;
 
332
                }
 
333
 
 
334
                if (status == STATUS_ONLINE) {
 
335
                        printf("online\n");
 
336
                        do_lcd(z);
 
337
                }
 
338
 
 
339
                do_lights(z, buttons);
 
340
                do_buttons(z, buttons, datawheel);
 
341
        }
 
342
 
 
343
        close_tranzport(z);
 
344
 
 
345
        return 0;
 
346
}
 
347