summaryrefslogtreecommitdiff
path: root/apps/plugins/pdbox/PDa/src/s_midi_oss.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/plugins/pdbox/PDa/src/s_midi_oss.c')
-rw-r--r--apps/plugins/pdbox/PDa/src/s_midi_oss.c718
1 files changed, 718 insertions, 0 deletions
diff --git a/apps/plugins/pdbox/PDa/src/s_midi_oss.c b/apps/plugins/pdbox/PDa/src/s_midi_oss.c
new file mode 100644
index 0000000000..1adfcd0d0c
--- /dev/null
+++ b/apps/plugins/pdbox/PDa/src/s_midi_oss.c
@@ -0,0 +1,718 @@
1/* Copyright (c) 1997-1999 Guenter Geiger, Miller Puckette, Larry Troxler,
2* Winfried Ritsch, Karl MacMillan, and others.
3* For information on usage and redistribution, and for a DISCLAIMER OF ALL
4* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
5
6/* MIDI I/O for Linux using OSS */
7
8#include <stdio.h>
9#ifdef UNIX
10#include <unistd.h>
11#endif
12#include <stdlib.h>
13#include <sys/types.h>
14#include <sys/stat.h>
15#include <fcntl.h>
16#include <errno.h>
17#include "m_pd.h"
18#include "s_stuff.h"
19
20static int oss_nmidiin;
21static int oss_midiinfd[MAXMIDIINDEV];
22static int oss_nmidiout;
23static int oss_midioutfd[MAXMIDIOUTDEV];
24
25static void oss_midiout(int fd, int n)
26{
27 char b = n;
28 if ((write(fd, (char *) &b, 1)) != 1)
29 perror("midi write");
30}
31
32#define O_MIDIFLAG O_NDELAY
33
34void sys_do_open_midi(int nmidiin, int *midiinvec,
35 int nmidiout, int *midioutvec)
36{
37 int i;
38 for (i = 0; i < nmidiout; i++)
39 oss_midioutfd[i] = -1;
40 for (i = 0, oss_nmidiin = 0; i < nmidiin; i++)
41 {
42 int fd = -1, j, outdevindex = -1;
43 char namebuf[80];
44 int devno = midiinvec[i];
45
46 for (j = 0; j < nmidiout; j++)
47 if (midioutvec[j] == midiinvec[i])
48 outdevindex = j;
49
50 /* try to open the device for read/write. */
51 if (devno == 0 && fd < 0 && outdevindex >= 0)
52 {
53 sys_setalarm(1000000);
54 fd = open("/dev/midi", O_RDWR | O_MIDIFLAG);
55 if (sys_verbose)
56 fprintf(stderr,
57 "device 1: tried /dev/midi READ/WRITE; returned %d\n", fd);
58 if (outdevindex >= 0 && fd >= 0)
59 oss_midioutfd[outdevindex] = fd;
60 }
61 if (fd < 0 && outdevindex >= 0)
62 {
63 sys_setalarm(1000000);
64 sprintf(namebuf, "/dev/midi%2.2d", devno);
65 fd = open(namebuf, O_RDWR | O_MIDIFLAG);
66 if (sys_verbose)
67 fprintf(stderr,
68 "device %d: tried %s READ/WRITE; returned %d\n",
69 devno, namebuf, fd);
70 if (outdevindex >= 0 && fd >= 0)
71 oss_midioutfd[outdevindex] = fd;
72 }
73 if (fd < 0 && outdevindex >= 0)
74 {
75 sys_setalarm(1000000);
76 sprintf(namebuf, "/dev/midi%d", devno);
77 fd = open(namebuf, O_RDWR | O_MIDIFLAG);
78 if (sys_verbose)
79 fprintf(stderr, "device %d: tried %s READ/WRITE; returned %d\n",
80 devno, namebuf, fd);
81 if (outdevindex >= 0 && fd >= 0)
82 oss_midioutfd[outdevindex] = fd;
83 }
84 if (devno == 1 && fd < 0)
85 {
86 sys_setalarm(1000000);
87 fd = open("/dev/midi", O_RDONLY | O_MIDIFLAG);
88 if (sys_verbose)
89 fprintf(stderr,
90 "device 1: tried /dev/midi READONLY; returned %d\n", fd);
91 }
92 if (fd < 0)
93 {
94 sys_setalarm(1000000);
95 sprintf(namebuf, "/dev/midi%2.2d", devno);
96 fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
97 if (sys_verbose)
98 fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
99 devno, namebuf, fd);
100 }
101 if (fd < 0)
102 {
103 sys_setalarm(1000000);
104 sprintf(namebuf, "/dev/midi%d", devno);
105 fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
106 if (sys_verbose)
107 fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
108 devno, namebuf, fd);
109 }
110 if (fd >= 0)
111 oss_midiinfd[oss_nmidiin++] = fd;
112 else post("couldn't open MIDI input device %d", devno);
113 }
114 for (i = 0, oss_nmidiout = 0; i < nmidiout; i++)
115 {
116 int fd = oss_midioutfd[i];
117 char namebuf[80];
118 int devno = midioutvec[i];
119 if (devno == 1 && fd < 0)
120 {
121 sys_setalarm(1000000);
122 fd = open("/dev/midi", O_WRONLY | O_MIDIFLAG);
123 if (sys_verbose)
124 fprintf(stderr,
125 "device 1: tried /dev/midi WRITEONLY; returned %d\n", fd);
126 }
127 if (fd < 0)
128 {
129 sys_setalarm(1000000);
130 sprintf(namebuf, "/dev/midi%2.2d", devno);
131 fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
132 if (sys_verbose)
133 fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
134 devno, namebuf, fd);
135 }
136 if (fd < 0)
137 {
138 sys_setalarm(1000000);
139 sprintf(namebuf, "/dev/midi%d", devno);
140 fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
141 if (sys_verbose)
142 fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
143 devno, namebuf, fd);
144 }
145 if (fd >= 0)
146 oss_midioutfd[oss_nmidiout++] = fd;
147 else post("couldn't open MIDI output device %d", devno);
148 }
149
150 if (oss_nmidiin < nmidiin || oss_nmidiout < nmidiout || sys_verbose)
151 post("opened %d MIDI input device(s) and %d MIDI output device(s).",
152 oss_nmidiin, oss_nmidiout);
153
154 sys_setalarm(0);
155}
156
157#define md_msglen(x) (((x)<0xC0)?2:((x)<0xE0)?1:((x)<0xF0)?2:\
158 ((x)==0xF2)?2:((x)<0xF4)?1:0)
159
160void sys_putmidimess(int portno, int a, int b, int c)
161{
162 if (portno >= 0 && portno < oss_nmidiout)
163 {
164 switch (md_msglen(a))
165 {
166 case 2:
167 oss_midiout(oss_midioutfd[portno],a);
168 oss_midiout(oss_midioutfd[portno],b);
169 oss_midiout(oss_midioutfd[portno],c);
170 return;
171 case 1:
172 oss_midiout(oss_midioutfd[portno],a);
173 oss_midiout(oss_midioutfd[portno],b);
174 return;
175 case 0:
176 oss_midiout(oss_midioutfd[portno],a);
177 return;
178 };
179 }
180}
181
182void sys_putmidibyte(int portno, int byte)
183{
184 if (portno >= 0 && portno < oss_nmidiout)
185 oss_midiout(oss_midioutfd[portno], byte);
186}
187
188#if 0 /* this is the "select" version which doesn't work with OSS
189 driver for emu10k1 (it doesn't implement select.) */
190void sys_poll_midi(void)
191{
192 int i, throttle = 100;
193 struct timeval timout;
194 int did = 1, maxfd = 0;
195 while (did)
196 {
197 fd_set readset, writeset, exceptset;
198 did = 0;
199 if (throttle-- < 0)
200 break;
201 timout.tv_sec = 0;
202 timout.tv_usec = 0;
203
204 FD_ZERO(&writeset);
205 FD_ZERO(&readset);
206 FD_ZERO(&exceptset);
207 for (i = 0; i < oss_nmidiin; i++)
208 {
209 if (oss_midiinfd[i] > maxfd)
210 maxfd = oss_midiinfd[i];
211 FD_SET(oss_midiinfd[i], &readset);
212 }
213 select(maxfd+1, &readset, &writeset, &exceptset, &timout);
214 for (i = 0; i < oss_nmidiin; i++)
215 if (FD_ISSET(oss_midiinfd[i], &readset))
216 {
217 char c;
218 int ret = read(oss_midiinfd[i], &c, 1);
219 if (ret <= 0)
220 fprintf(stderr, "Midi read error\n");
221 else sys_midibytein(i, (c & 0xff));
222 did = 1;
223 }
224 }
225}
226#else
227
228 /* this version uses the asynchronous "read()" ... */
229void sys_poll_midi(void)
230{
231 int i, throttle = 100;
232 struct timeval timout;
233 int did = 1, maxfd = 0;
234 while (did)
235 {
236 fd_set readset, writeset, exceptset;
237 did = 0;
238 if (throttle-- < 0)
239 break;
240 for (i = 0; i < oss_nmidiin; i++)
241 {
242 char c;
243 int ret = read(oss_midiinfd[i], &c, 1);
244 if (ret < 0)
245 {
246 if (errno != EAGAIN)
247 perror("MIDI");
248 }
249 else if (ret != 0)
250 {
251 sys_midibytein(i, (c & 0xff));
252 did = 1;
253 }
254 }
255 }
256}
257#endif
258
259void sys_close_midi()
260{
261 int i;
262 for (i = 0; i < oss_nmidiin; i++)
263 close(oss_midiinfd[i]);
264 for (i = 0; i < oss_nmidiout; i++)
265 close(oss_midioutfd[i]);
266 oss_nmidiin = oss_nmidiout = 0;
267}
268
269#define NSEARCH 10
270static int oss_nmidiindevs, oss_nmidioutdevs, oss_initted;
271
272void midi_oss_init(void)
273{
274 int i;
275 if (oss_initted)
276 return;
277 oss_initted = 1;
278 for (i = 0; i < NSEARCH; i++)
279 {
280 int fd;
281 char namebuf[80];
282
283 oss_nmidiindevs = i;
284 /* try to open the device for reading */
285 if (i == 0)
286 {
287 fd = open("/dev/midi", O_RDONLY | O_NDELAY);
288 if (fd >= 0)
289 {
290 close(fd);
291 continue;
292 }
293 }
294 sprintf(namebuf, "/dev/midi%2.2d", i);
295 fd = open(namebuf, O_RDONLY | O_NDELAY);
296 if (fd >= 0)
297 {
298 close(fd);
299 continue;
300 }
301 sprintf(namebuf, "/dev/midi%d", i);
302 fd = open(namebuf, O_RDONLY | O_NDELAY);
303 if (fd >= 0)
304 {
305 close(fd);
306 continue;
307 }
308 break;
309 }
310 for (i = 0; i < NSEARCH; i++)
311 {
312 int fd;
313 char namebuf[80];
314
315 oss_nmidioutdevs = i;
316 /* try to open the device for writing */
317 if (i == 0)
318 {
319 fd = open("/dev/midi", O_WRONLY | O_NDELAY);
320 if (fd >= 0)
321 {
322 close(fd);
323 continue;
324 }
325 }
326 sprintf(namebuf, "/dev/midi%2.2d", i);
327 fd = open(namebuf, O_WRONLY | O_NDELAY);
328 if (fd >= 0)
329 {
330 close(fd);
331 continue;
332 }
333 sprintf(namebuf, "/dev/midi%d", i);
334 fd = open(namebuf, O_WRONLY | O_NDELAY);
335 if (fd >= 0)
336 {
337 close(fd);
338 continue;
339 }
340 break;
341 }
342}
343
344void midi_getdevs(char *indevlist, int *nindevs,
345 char *outdevlist, int *noutdevs, int maxndev, int devdescsize)
346{
347 int i, ndev;
348 if ((ndev = oss_nmidiindevs) > maxndev)
349 ndev = maxndev;
350 for (i = 0; i < ndev; i++)
351 sprintf(indevlist + i * devdescsize, "OSS MIDI device #%d", i+1);
352 *nindevs = ndev;
353
354 if ((ndev = oss_nmidioutdevs) > maxndev)
355 ndev = maxndev;
356 for (i = 0; i < ndev; i++)
357 sprintf(outdevlist + i * devdescsize, "OSS MIDI device #%d", i+1);
358 *noutdevs = ndev;
359}
360/* Copyright (c) 1997-1999 Guenter Geiger, Miller Puckette, Larry Troxler,
361* Winfried Ritsch, Karl MacMillan, and others.
362* For information on usage and redistribution, and for a DISCLAIMER OF ALL
363* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
364
365/* MIDI I/O for Linux using OSS */
366
367#include <stdio.h>
368#ifdef UNIX
369#include <unistd.h>
370#endif
371#include <stdlib.h>
372#include <sys/types.h>
373#include <sys/stat.h>
374#include <fcntl.h>
375#include <errno.h>
376#include "m_pd.h"
377#include "s_stuff.h"
378
379static int oss_nmidiin;
380static int oss_midiinfd[MAXMIDIINDEV];
381static int oss_nmidiout;
382static int oss_midioutfd[MAXMIDIOUTDEV];
383
384static void oss_midiout(int fd, int n)
385{
386 char b = n;
387 if ((write(fd, (char *) &b, 1)) != 1)
388 perror("midi write");
389}
390
391#define O_MIDIFLAG O_NDELAY
392
393void sys_do_open_midi(int nmidiin, int *midiinvec,
394 int nmidiout, int *midioutvec)
395{
396 int i;
397 for (i = 0; i < nmidiout; i++)
398 oss_midioutfd[i] = -1;
399 for (i = 0, oss_nmidiin = 0; i < nmidiin; i++)
400 {
401 int fd = -1, j, outdevindex = -1;
402 char namebuf[80];
403 int devno = midiinvec[i];
404
405 for (j = 0; j < nmidiout; j++)
406 if (midioutvec[j] == midiinvec[i])
407 outdevindex = j;
408
409 /* try to open the device for read/write. */
410 if (devno == 0 && fd < 0 && outdevindex >= 0)
411 {
412 sys_setalarm(1000000);
413 fd = open("/dev/midi", O_RDWR | O_MIDIFLAG);
414 if (sys_verbose)
415 fprintf(stderr,
416 "device 1: tried /dev/midi READ/WRITE; returned %d\n", fd);
417 if (outdevindex >= 0 && fd >= 0)
418 oss_midioutfd[outdevindex] = fd;
419 }
420 if (fd < 0 && outdevindex >= 0)
421 {
422 sys_setalarm(1000000);
423 sprintf(namebuf, "/dev/midi%2.2d", devno);
424 fd = open(namebuf, O_RDWR | O_MIDIFLAG);
425 if (sys_verbose)
426 fprintf(stderr,
427 "device %d: tried %s READ/WRITE; returned %d\n",
428 devno, namebuf, fd);
429 if (outdevindex >= 0 && fd >= 0)
430 oss_midioutfd[outdevindex] = fd;
431 }
432 if (fd < 0 && outdevindex >= 0)
433 {
434 sys_setalarm(1000000);
435 sprintf(namebuf, "/dev/midi%d", devno);
436 fd = open(namebuf, O_RDWR | O_MIDIFLAG);
437 if (sys_verbose)
438 fprintf(stderr, "device %d: tried %s READ/WRITE; returned %d\n",
439 devno, namebuf, fd);
440 if (outdevindex >= 0 && fd >= 0)
441 oss_midioutfd[outdevindex] = fd;
442 }
443 if (devno == 1 && fd < 0)
444 {
445 sys_setalarm(1000000);
446 fd = open("/dev/midi", O_RDONLY | O_MIDIFLAG);
447 if (sys_verbose)
448 fprintf(stderr,
449 "device 1: tried /dev/midi READONLY; returned %d\n", fd);
450 }
451 if (fd < 0)
452 {
453 sys_setalarm(1000000);
454 sprintf(namebuf, "/dev/midi%2.2d", devno);
455 fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
456 if (sys_verbose)
457 fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
458 devno, namebuf, fd);
459 }
460 if (fd < 0)
461 {
462 sys_setalarm(1000000);
463 sprintf(namebuf, "/dev/midi%d", devno);
464 fd = open(namebuf, O_RDONLY | O_MIDIFLAG);
465 if (sys_verbose)
466 fprintf(stderr, "device %d: tried %s READONLY; returned %d\n",
467 devno, namebuf, fd);
468 }
469 if (fd >= 0)
470 oss_midiinfd[oss_nmidiin++] = fd;
471 else post("couldn't open MIDI input device %d", devno);
472 }
473 for (i = 0, oss_nmidiout = 0; i < nmidiout; i++)
474 {
475 int fd = oss_midioutfd[i];
476 char namebuf[80];
477 int devno = midioutvec[i];
478 if (devno == 1 && fd < 0)
479 {
480 sys_setalarm(1000000);
481 fd = open("/dev/midi", O_WRONLY | O_MIDIFLAG);
482 if (sys_verbose)
483 fprintf(stderr,
484 "device 1: tried /dev/midi WRITEONLY; returned %d\n", fd);
485 }
486 if (fd < 0)
487 {
488 sys_setalarm(1000000);
489 sprintf(namebuf, "/dev/midi%2.2d", devno);
490 fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
491 if (sys_verbose)
492 fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
493 devno, namebuf, fd);
494 }
495 if (fd < 0)
496 {
497 sys_setalarm(1000000);
498 sprintf(namebuf, "/dev/midi%d", devno);
499 fd = open(namebuf, O_WRONLY | O_MIDIFLAG);
500 if (sys_verbose)
501 fprintf(stderr, "device %d: tried %s WRITEONLY; returned %d\n",
502 devno, namebuf, fd);
503 }
504 if (fd >= 0)
505 oss_midioutfd[oss_nmidiout++] = fd;
506 else post("couldn't open MIDI output device %d", devno);
507 }
508
509 if (oss_nmidiin < nmidiin || oss_nmidiout < nmidiout || sys_verbose)
510 post("opened %d MIDI input device(s) and %d MIDI output device(s).",
511 oss_nmidiin, oss_nmidiout);
512
513 sys_setalarm(0);
514}
515
516#define md_msglen(x) (((x)<0xC0)?2:((x)<0xE0)?1:((x)<0xF0)?2:\
517 ((x)==0xF2)?2:((x)<0xF4)?1:0)
518
519void sys_putmidimess(int portno, int a, int b, int c)
520{
521 if (portno >= 0 && portno < oss_nmidiout)
522 {
523 switch (md_msglen(a))
524 {
525 case 2:
526 oss_midiout(oss_midioutfd[portno],a);
527 oss_midiout(oss_midioutfd[portno],b);
528 oss_midiout(oss_midioutfd[portno],c);
529 return;
530 case 1:
531 oss_midiout(oss_midioutfd[portno],a);
532 oss_midiout(oss_midioutfd[portno],b);
533 return;
534 case 0:
535 oss_midiout(oss_midioutfd[portno],a);
536 return;
537 };
538 }
539}
540
541void sys_putmidibyte(int portno, int byte)
542{
543 if (portno >= 0 && portno < oss_nmidiout)
544 oss_midiout(oss_midioutfd[portno], byte);
545}
546
547#if 0 /* this is the "select" version which doesn't work with OSS
548 driver for emu10k1 (it doesn't implement select.) */
549void sys_poll_midi(void)
550{
551 int i, throttle = 100;
552 struct timeval timout;
553 int did = 1, maxfd = 0;
554 while (did)
555 {
556 fd_set readset, writeset, exceptset;
557 did = 0;
558 if (throttle-- < 0)
559 break;
560 timout.tv_sec = 0;
561 timout.tv_usec = 0;
562
563 FD_ZERO(&writeset);
564 FD_ZERO(&readset);
565 FD_ZERO(&exceptset);
566 for (i = 0; i < oss_nmidiin; i++)
567 {
568 if (oss_midiinfd[i] > maxfd)
569 maxfd = oss_midiinfd[i];
570 FD_SET(oss_midiinfd[i], &readset);
571 }
572 select(maxfd+1, &readset, &writeset, &exceptset, &timout);
573 for (i = 0; i < oss_nmidiin; i++)
574 if (FD_ISSET(oss_midiinfd[i], &readset))
575 {
576 char c;
577 int ret = read(oss_midiinfd[i], &c, 1);
578 if (ret <= 0)
579 fprintf(stderr, "Midi read error\n");
580 else sys_midibytein(i, (c & 0xff));
581 did = 1;
582 }
583 }
584}
585#else
586
587 /* this version uses the asynchronous "read()" ... */
588void sys_poll_midi(void)
589{
590 int i, throttle = 100;
591 struct timeval timout;
592 int did = 1, maxfd = 0;
593 while (did)
594 {
595 fd_set readset, writeset, exceptset;
596 did = 0;
597 if (throttle-- < 0)
598 break;
599 for (i = 0; i < oss_nmidiin; i++)
600 {
601 char c;
602 int ret = read(oss_midiinfd[i], &c, 1);
603 if (ret < 0)
604 {
605 if (errno != EAGAIN)
606 perror("MIDI");
607 }
608 else if (ret != 0)
609 {
610 sys_midibytein(i, (c & 0xff));
611 did = 1;
612 }
613 }
614 }
615}
616#endif
617
618void sys_close_midi()
619{
620 int i;
621 for (i = 0; i < oss_nmidiin; i++)
622 close(oss_midiinfd[i]);
623 for (i = 0; i < oss_nmidiout; i++)
624 close(oss_midioutfd[i]);
625 oss_nmidiin = oss_nmidiout = 0;
626}
627
628#define NSEARCH 10
629static int oss_nmidiindevs, oss_nmidioutdevs, oss_initted;
630
631void midi_oss_init(void)
632{
633 int i;
634 if (oss_initted)
635 return;
636 oss_initted = 1;
637 for (i = 0; i < NSEARCH; i++)
638 {
639 int fd;
640 char namebuf[80];
641
642 oss_nmidiindevs = i;
643 /* try to open the device for reading */
644 if (i == 0)
645 {
646 fd = open("/dev/midi", O_RDONLY | O_NDELAY);
647 if (fd >= 0)
648 {
649 close(fd);
650 continue;
651 }
652 }
653 sprintf(namebuf, "/dev/midi%2.2d", i);
654 fd = open(namebuf, O_RDONLY | O_NDELAY);
655 if (fd >= 0)
656 {
657 close(fd);
658 continue;
659 }
660 sprintf(namebuf, "/dev/midi%d", i);
661 fd = open(namebuf, O_RDONLY | O_NDELAY);
662 if (fd >= 0)
663 {
664 close(fd);
665 continue;
666 }
667 break;
668 }
669 for (i = 0; i < NSEARCH; i++)
670 {
671 int fd;
672 char namebuf[80];
673
674 oss_nmidioutdevs = i;
675 /* try to open the device for writing */
676 if (i == 0)
677 {
678 fd = open("/dev/midi", O_WRONLY | O_NDELAY);
679 if (fd >= 0)
680 {
681 close(fd);
682 continue;
683 }
684 }
685 sprintf(namebuf, "/dev/midi%2.2d", i);
686 fd = open(namebuf, O_WRONLY | O_NDELAY);
687 if (fd >= 0)
688 {
689 close(fd);
690 continue;
691 }
692 sprintf(namebuf, "/dev/midi%d", i);
693 fd = open(namebuf, O_WRONLY | O_NDELAY);
694 if (fd >= 0)
695 {
696 close(fd);
697 continue;
698 }
699 break;
700 }
701}
702
703void midi_getdevs(char *indevlist, int *nindevs,
704 char *outdevlist, int *noutdevs, int maxndev, int devdescsize)
705{
706 int i, ndev;
707 if ((ndev = oss_nmidiindevs) > maxndev)
708 ndev = maxndev;
709 for (i = 0; i < ndev; i++)
710 sprintf(indevlist + i * devdescsize, "OSS MIDI device #%d", i+1);
711 *nindevs = ndev;
712
713 if ((ndev = oss_nmidioutdevs) > maxndev)
714 ndev = maxndev;
715 for (i = 0; i < ndev; i++)
716 sprintf(outdevlist + i * devdescsize, "OSS MIDI device #%d", i+1);
717 *noutdevs = ndev;
718}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-12 17:51:08 +0000