1 /*
2 TiMidity++ -- MIDI to WAVE converter and player
3 Copyright (C) 1999-2004 Masanao Izumo <iz@onicos.co.jp>
4 Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20 server_c.c - TiMidity server written by Masanao Izumo <iz@onicos.co.jp>
21 Mon Apr 5 1999: Initial created.
22
23 Launch TiMidity server: (example)
24 % timidity -ir 7777
25
26 Protcol note:
27 The protocol is based on OSS interface.
28 TiMidity server has 2 TCP/IP connection. They are control port and
29 data port.
30 Control port:
31 ASCII text protocol like FTP control port. See command_help for
32 control protocol in this source code.
33 Data port:
34 One way Binary stream data from client to server. The format of
35 stream is same as OSS sequencer stream.
36
37 TODO:
38 Protocol specification to be documented.
39 */
40
41 #ifdef HAVE_CONFIG_H
42 #include "config.h"
43 #endif /* HAVE_CONFIG_H */
44
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <stdarg.h>
48 #include <unistd.h>
49 #include <sys/types.h>
50 #include <sys/socket.h>
51 #include <sys/time.h>
52 #include <netinet/in.h>
53 #include <netdb.h>
54 #ifndef NO_STRING_H
55 #include <string.h>
56 #else
57 #include <strings.h>
58 #endif
59 #include <signal.h>
60
61 #include "server_defs.h"
62
63 #include "timidity.h"
64 #include "common.h"
65 #include "controls.h"
66 #include "instrum.h"
67 #include "playmidi.h"
68 #include "readmidi.h"
69 #include "recache.h"
70 #include "output.h"
71 #include "aq.h"
72 #include "timer.h"
73
74 #define SERVER_VERSION "1.0.4"
75
76 /* #define DEBUG_DUMP_SEQ 1 */
77 #define MIDI_COMMAND_PER_SEC 100
78 #define DEFAULT_LOW_TIMEAT 0.4
79 #define DEFAULT_HIGH_TIMEAT 0.6
80 #define DEFAULT_TIMEBASE 100 /* HZ? */
81 #define SIG_TIMEOUT_SEC 3
82
83
84 static int cmd_help(int argc, char **argv);
85 static int cmd_open(int argc, char **argv);
86 static int cmd_close(int argc, char **argv);
87 static int cmd_timebase(int argc, char **argv);
88 static int cmd_reset(int argc, char **argv);
89 static int cmd_patch(int argc, char **argv);
90 static int cmd_quit(int argc, char **argv);
91 static int cmd_queue(int argc, char **argv);
92 static int cmd_maxqueue(int argc, char **argv);
93 static int cmd_time(int argc, char **argv);
94 static int cmd_nop(int argc, char **argv);
95 static int cmd_autoreduce(int argc, char **argv);
96 static int cmd_setbuf(int argc, char **argv);
97 static int cmd_protocol(int argc, char **argv);
98
99 struct
100 {
101 char *cmd, *help;
102 int minarg, maxarg;
103 int (* proc)(int argc, char **argv); /* argv[0] is command name
104 * argv[1..argc-1] is the arg.
105 * return: 0=success, -1=fatal-error,
106 * 1=connection-closed
107 */
108 } cmd_table[] =
109 {
110 {"HELP",
111 "HELP\tDisplay this message",
112 1, 1, cmd_help},
113 {"OPEN",
114 "OPEN {lsb|msb}\n"
115 "\tOpen data connection\n"
116 "\tlsb: The byte order of data stream is LSB\n"
117 "\tmsb: The byte order of data stream is MSB",
118 2, 2, cmd_open},
119 {"CLOSE",
120 "CLOSE\tShutdown current data connection",
121 1, 1, cmd_close},
122 {"TIMEBASE",
123 "TIMEBASE [timebase]\n\tSet time base",
124 1, 2, cmd_timebase},
125 {"RESET",
126 "RESET\tInitialize all of MIDI status",
127 1, 1, cmd_reset},
128 {"PATCH",
129 "PATCH {drumset|bank} <bank-no> <prog-no>\n\tLoad specified patch",
130 4, 4, cmd_patch},
131 {"QUIT",
132 "QUIT\tClose control connection",
133 1, 1, cmd_quit},
134 {"QUEUE",
135 "QUEUE\tTiMidity tells the time of audio buffer queue in second",
136 1, 1, cmd_queue},
137 {"MAXQUEUE",
138 "MAXQUEUE\n"
139 "\tTiMidity tells the maxmum time of audio buffer queue in second",
140 1, 1, cmd_maxqueue},
141 {"TIME",
142 "TIME\tTiMidity tells the current playing time in second",
143 1, 1, cmd_time},
144 {"NOP",
145 "NOP\tDo nothing",
146 1, 1, cmd_nop},
147 {"AUTOREDUCE",
148 "AUTOREDUCE {on|off} [msec]\n\tEnable/Disable auto voice reduction",
149 2, 3, cmd_autoreduce},
150 {"SETBUF",
151 "SETBUF low hi\n\tSpecify low/hi sec of buffer queue",
152 3, 3, cmd_setbuf},
153 {"PROTOCOL",
154 "PROTOCOL [sequencer|midi]\n\tSpecify the protocol to use",
155 1, 2, cmd_protocol},
156
157 {NULL, NULL, 0, 0, NULL} /* terminate */
158 };
159
160 /*
161 TEMPO [<tempo>]\n\
162 Change the tempo. If the argument is omitted, TiMidity tells the\n\
163 current tempo.\n\
164 KEYSHIFT <{+|-}offs>\n\
165 Change the base key. (0 to reset)\n\
166 SPEED <{+|-}offs>\n\
167 Change the play speed. (0 to reset)\n\
168 MODE {gs|xg|gm}\n\
169 Specify default MIDI system mode\n\
170 SYNTH [gus|awe]\n\
171 Specify Synth type emulation. (no argument to default)\n\
172 */
173
174
175 static int ctl_open(int using_stdin, int using_stdout);
176 static void ctl_close(void);
177 static int ctl_read(int32 *valp);
178 static int ctl_write(char *buffer, int32 size);
179 static int cmsg(int type, int verbosity_level, char *fmt, ...);
180 static void ctl_event(CtlEvent *e);
181 static int ctl_pass_playing_list(int n, char *args[]);
182
183 /**********************************/
184 /* export the interface functions */
185
186 #define ctl server_control_mode
187
188 ControlMode ctl=
189 {
190 "remote interface", 'r',
191 "server",
192 1,0,0,
193 0,
194 ctl_open,
195 ctl_close,
196 ctl_pass_playing_list,
197 ctl_read,
198 ctl_write,
199 cmsg,
200 ctl_event
201 };
202
203
204 struct fd_read_buffer
205 {
206 char buff[BUFSIZ];
207 /* count: beginning of read pointer
208 * size: end of read pointer
209 * fd: file descripter for input
210 */
211 int count, size, fd;
212 };
213 static int fdgets(char *buff, size_t buff_size, struct fd_read_buffer *p);
214 static int fdputs(char *s, int fd);
215 static uint32 data2long(uint8* data);
216 static uint16 data2short(uint8* data);
217 static int do_control_command_nonblock(void);
218
219 static struct fd_read_buffer control_fd_buffer;
220 static int data_fd = -1, control_fd = -1;
221 static int data_port, control_port;
222 static int is_lsb_data = 1;
223 static int curr_timebase = DEFAULT_TIMEBASE;
224 static int32 sample_correction;
225 static int32 sample_increment;
226 static int32 sample_correction;
227 static int32 sample_cum;
228 static int32 curr_event_samples, event_time_offset;
229 static int32 curr_tick, tick_offs;
230 static double start_time;
231 static int tmr_running, notmr_running;
232 enum { PROTO_SEQ, PROTO_MIDI };
233 static int proto;
234 static int is_system_prefix, rstatus;
235 static struct sockaddr_storage control_client;
236 static double low_time_at = DEFAULT_LOW_TIMEAT;
237 static double high_time_at = DEFAULT_HIGH_TIMEAT;
238 static FILE *outfp = NULL;
239
240 #define CONTROL_FD_OUT (control_port ? control_fd : STDOUT_FILENO)
241
242 /*ARGSUSED*/
ctl_open(int using_stdin,int using_stdout)243 static int ctl_open(int using_stdin, int using_stdout)
244 {
245 ctl.opened = 1;
246 ctl.flags &= ~(CTLF_LIST_RANDOM|CTLF_LIST_SORT);
247 outfp = stderr;
248 return 0;
249 }
250
ctl_close(void)251 static void ctl_close(void)
252 {
253 if(!ctl.opened)
254 return;
255 if(data_fd != -1)
256 {
257 close(data_fd);
258 data_fd = -1;
259 }
260 if(control_fd != -1)
261 {
262 close(control_fd);
263 control_fd = -1;
264 }
265 }
266
267 /*ARGSUSED*/
ctl_read(int32 * valp)268 static int ctl_read(int32 *valp)
269 {
270 if(data_fd != -1)
271 do_control_command_nonblock();
272 return RC_NONE;
273 }
274
ctl_write(char * buffer,int32 size)275 static int ctl_write(char *buffer, int32 size)
276 {
277 static int warned = 0;
278 if (!warned) {
279 fprintf(stderr, "Warning: STDOUT redirected to data socket\n");
280 warned = 1;
281 }
282 if(data_fd != -1)
283 return send(data_fd, buffer, size, MSG_DONTWAIT);
284 return -1;
285 }
286
cmsg(int type,int verbosity_level,char * fmt,...)287 static int cmsg(int type, int verbosity_level, char *fmt, ...)
288 {
289 va_list ap;
290
291 if((type==CMSG_TEXT || type==CMSG_INFO || type==CMSG_WARNING) &&
292 ctl.verbosity < verbosity_level)
293 return 0;
294
295 if(outfp == NULL)
296 outfp = stderr;
297
298 va_start(ap, fmt);
299 vfprintf(outfp, fmt, ap);
300 fputs(NLS, outfp);
301 fflush(outfp);
302 va_end(ap);
303
304 return 0;
305 }
306
ctl_event(CtlEvent * e)307 static void ctl_event(CtlEvent *e)
308 {
309 }
310
pasv_open(int * port)311 static int pasv_open(int *port)
312 {
313 int sfd, s;
314 struct addrinfo hints, *result, *rp;
315 char service[NI_MAXSERV];
316
317 memset(&hints, 0, sizeof(struct addrinfo));
318 hints.ai_family = AF_UNSPEC;
319 hints.ai_socktype = SOCK_STREAM;
320 hints.ai_flags = AI_PASSIVE;
321
322 snprintf(service, sizeof(service), "%d", *port);
323
324 s = getaddrinfo(NULL, service, &hints, &result);
325 if (s)
326 {
327 fprintf(stderr, "getaddrinfo %s", gai_strerror(s));
328 return -1;
329 }
330
331 for (rp = result; rp != NULL; rp = rp->ai_next)
332 {
333 if (rp->ai_family != AF_INET && rp->ai_family != AF_INET6)
334 continue;
335
336 sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
337
338 if (sfd == -1)
339 continue;
340
341 #ifdef SO_REUSEADDR
342 {
343 int on = 1;
344 setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (caddr_t)&on, sizeof(on));
345 }
346 #endif /* SO_REUSEADDR */
347
348 ctl.cmsg(CMSG_INFO, VERB_DEBUG, "Bind TCP/IP port=%d", *port);
349 if (bind(sfd, rp->ai_addr, rp->ai_addrlen) != 0) {
350 perror("bind");
351 close(sfd);
352 } else
353 break;
354
355 close(sfd);
356 }
357
358 if (rp == NULL)
359 {
360 fprintf(stderr, "Could not bind\n");
361 freeaddrinfo(result);
362 return -1;
363 }
364
365 freeaddrinfo(result);
366
367 if(*port == 0)
368 {
369 struct sockaddr_storage server;
370 socklen_t len = sizeof(server);
371
372 if(getsockname(sfd, (struct sockaddr *)&server, &len) < 0)
373 {
374 perror("getsockname");
375 close(sfd);
376 return -1;
377 }
378
379 /* Not quite protocol independent */
380 switch (((struct sockaddr *) &server)->sa_family)
381 {
382 case AF_INET:
383 *port = ntohs(((struct sockaddr_in *) &server)->sin_port);
384 break;
385 case AF_INET6:
386 *port = ntohs(((struct sockaddr_in6 *) &server)->sin6_port);
387 break;
388 }
389 }
390
391 /* Set it up to wait for connections. */
392 if(listen(sfd, 1) < 0)
393 {
394 perror("listen");
395 close(sfd);
396 return -1;
397 }
398
399 return sfd;
400 }
401
sig_timeout(int sig)402 static RETSIGTYPE sig_timeout(int sig)
403 {
404 signal(SIGALRM, sig_timeout); /* For SysV base */
405 /* Expect EINTR */
406 }
407
408 static void doit(void);
409 static int send_status(int status, char *message, ...);
410 static void compute_sample_increment(void);
411 static void server_reset(void);
412
ctl_pass_playing_list(int n,char * args[])413 static int ctl_pass_playing_list(int n, char *args[])
414 {
415 int sock = 0;
416
417 if(n != 2 && n != 1)
418 {
419 fprintf(stderr, "Usage: timidity -ir control-port [data-port]\n");
420 return 1;
421 }
422
423 control_port = atoi(args[0]);
424 if(n == 2)
425 data_port = atoi(args[1]);
426 else
427 data_port = 0;
428
429 if (control_port) {
430 #ifdef SIGPIPE
431 signal(SIGPIPE, SIG_IGN); /* Handle broken pipe */
432 #endif /* SIGPIPE */
433 sock = pasv_open(&control_port);
434 if(sock == -1)
435 return 1;
436 }
437 opt_realtime_playing = 1; /* Enable loading patch while playing */
438 allocate_cache_size = 0; /* Don't use pre-calclated samples */
439 /* aq_set_soft_queue(-1.0, 0.0); */
440 alarm(0);
441 signal(SIGALRM, sig_timeout);
442
443 while(1)
444 {
445 socklen_t addrlen;
446
447 addrlen = sizeof(control_client);
448 memset(&control_client, 0, addrlen);
449
450 if (control_port) {
451 if((control_fd = accept(sock,
452 (struct sockaddr *)&control_client,
453 &addrlen)) < 0)
454 {
455 if(errno == EINTR)
456 continue;
457 perror("accept");
458 close(sock);
459 return 1;
460 }
461 }
462 else control_fd = 0;
463
464 if (play_mode->acntl(PM_REQ_PLAY_START, NULL) < 0)
465 {
466 ctl.cmsg(CMSG_FATAL, VERB_NORMAL,
467 "Couldn't start %s (`%c')",
468 play_mode->id_name, play_mode->id_character);
469 send_status(510, "Couldn't start %s (`%c')",
470 play_mode->id_name, play_mode->id_character);
471 if (control_port) {
472 close(control_fd);
473 control_fd = -1;
474 }
475 break;
476 }
477
478 server_reset();
479
480 ctl.cmsg(CMSG_INFO, VERB_NOISY, "Connected");
481 doit();
482 ctl.cmsg(CMSG_INFO, VERB_NOISY, "Connection closed");
483
484 play_mode->acntl(PM_REQ_PLAY_END, NULL);
485
486 if(control_fd != -1 && control_port)
487 {
488 close(control_fd);
489 control_fd = -1;
490 }
491 if(data_fd != -1)
492 {
493 close(data_fd);
494 data_fd = -1;
495 }
496 free_instruments(0);
497 free_global_mblock();
498 if (!control_port)
499 break;
500 }
501 return 0;
502 }
503
504 #define MAX_GETCMD_PARAMS 8
505 /* return:
506 * 0: success
507 * 1: error
508 *-1: fatal error (will be close the connection)
509 */
control_getcmd(char ** params,int * nparams)510 static int control_getcmd(char **params, int *nparams)
511 {
512 static char buff[BUFSIZ];
513 int n;
514
515 /* read line */
516 n = fdgets(buff, sizeof(buff), &control_fd_buffer);
517 if(n == -1)
518 {
519 perror("read");
520 return -1;
521 }
522 if(n == 0)
523 return 1;
524 *nparams = 0;
525 do {
526 params[*nparams] = strtok(*nparams ? NULL : buff, " \t\r\n\240");
527 if (!params[*nparams])
528 break;
529 (*nparams)++;
530 } while (*nparams < MAX_GETCMD_PARAMS);
531 return 0;
532 }
533
send_status(int status,char * message,...)534 static int send_status(int status, char *message, ...)
535 {
536 va_list ap;
537 char buff[BUFSIZ];
538
539 va_start(ap, message);
540 sprintf(buff, "%03d ", status);
541 vsnprintf(buff + 4, sizeof(buff) - 5, message, ap);
542 va_end(ap);
543 strncat(buff, "\n", BUFSIZ - strlen(buff) - 1);
544 buff[BUFSIZ-1] = '\0'; /* force terminate */
545 if(write(CONTROL_FD_OUT, buff, strlen(buff)) == -1)
546 return -1;
547 return 0;
548 }
549
seq_play_event(MidiEvent * ev)550 static void seq_play_event(MidiEvent *ev)
551 {
552 if(tmr_running)
553 ev->time = curr_event_samples;
554 else
555 {
556 if(IS_STREAM_TRACE)
557 {
558 event_time_offset += play_mode->rate / MIDI_COMMAND_PER_SEC;
559 ev->time = curr_event_samples;
560 }
561 else
562 {
563 double past_time = get_current_calender_time() - start_time -
564 (double)(curr_event_samples + event_time_offset) / play_mode->rate;
565 ev->time = (int32)(past_time * play_mode->rate);
566 }
567 }
568 ev->time += event_time_offset;
569 play_event(ev);
570 }
571
tmr_reset(void)572 static void tmr_reset(void)
573 {
574 curr_event_samples =
575 event_time_offset =
576 sample_cum = 0;
577 playmidi_tmr_reset();
578 curr_timebase = DEFAULT_TIMEBASE;
579 curr_tick = tick_offs = 0;
580 start_time = get_current_calender_time();
581 }
582
compute_sample_increment(void)583 static void compute_sample_increment(void)
584 {
585 double a;
586 a = (double)current_play_tempo * (double)play_mode->rate
587 * (65536.0/500000.0) / (double)curr_timebase,
588 sample_correction = (int32)(a) & 0xFFFF;
589 sample_increment = (int32)(a) >> 16;
590 }
591
add_tick(int tick)592 static void add_tick(int tick)
593 {
594 int32 samples_to_do;
595 MidiEvent ev;
596
597 samples_to_do = sample_increment * tick;
598 sample_cum += sample_correction * tick;
599 if(sample_cum & 0xFFFF0000)
600 {
601 samples_to_do += ((sample_cum >> 16) & 0xFFFF);
602 sample_cum &= 0x0000FFFF;
603 }
604 curr_event_samples += samples_to_do;
605 curr_tick += tick;
606 ev.type = ME_NONE;
607 seq_play_event(&ev);
608 }
609
610 #if 0
611 static int tick2sample(int tick)
612 {
613 int32 samples, cum;
614
615 samples = sample_increment * tick;
616 cum = sample_correction * tick;
617 if(cum & 0xFFFF0000)
618 samples += ((sample_cum >> 16) & 0xFFFF);
619 return samples;
620 }
621 #endif
622
time2tick(double sec)623 int time2tick(double sec)
624 {
625 return (int)(sec * curr_timebase);
626 }
627
628
stop_playing(void)629 static void stop_playing(void)
630 {
631 if(upper_voices)
632 {
633 MidiEvent ev;
634 ev.type = ME_EOT;
635 ev.a = 0;
636 ev.b = 0;
637 seq_play_event(&ev);
638 aq_flush(0);
639 }
640
641 notmr_running = 0;
642 }
643
644 static int do_control_command(void);
645 static int do_control_command_nonblock(void);
646 static int do_sequencer(void);
647 static void do_chn_voice(uint8 *);
648 static void do_chn_common(uint8 *);
649 static void do_timing(uint8 *);
650 static void do_sysex(uint8 *, int len);
651 static void do_extended(uint8 *);
652 static void do_timeout(void);
653
654 static uint8 data_buffer[BUFSIZ];
655 static int data_buffer_len;
656
doit(void)657 static void doit(void)
658 {
659 memset(&control_fd_buffer, 0, sizeof(control_fd_buffer));
660 control_fd_buffer.fd = control_fd;
661
662 send_status(220, "TiMidity++ %s%s ready (Server Version %s)",
663 (strcmp(timidity_version, "current")) ? "v" : "",
664 timidity_version, SERVER_VERSION);
665
666 /* while(data_fd != -1 && control_fd != -1) */
667 while(control_fd != -1)
668 {
669 fd_set fds;
670 int n, maxfd;
671
672 if(data_fd == -1)
673 {
674 if(do_control_command())
675 break;
676 }
677 else
678 {
679 long usec;
680
681 FD_ZERO(&fds);
682 FD_SET(control_fd, &fds);
683 FD_SET(data_fd, &fds);
684 if(control_fd > data_fd)
685 maxfd = control_fd;
686 else
687 maxfd = data_fd;
688
689 if(data_fd != -1 && (tmr_running || notmr_running))
690 {
691 double wait_time, filled;
692
693 if (IS_STREAM_TRACE)
694 filled = aq_filled();
695 else
696 filled = high_time_at * play_mode->rate;
697
698 wait_time = filled / play_mode->rate - low_time_at;
699 if(wait_time <= 0)
700 usec = 0;
701 else
702 usec = (long)(wait_time * 1000000);
703 }
704 else
705 usec = -1;
706
707 if(usec >= 0)
708 {
709 struct timeval timeout;
710 timeout.tv_sec = usec / 1000000;
711 timeout.tv_usec = usec % 1000000;
712 n = select(maxfd + 1, &fds, NULL, NULL, &timeout);
713 }
714 else
715 n = select(maxfd + 1, &fds, NULL, NULL, NULL);
716
717 if(n < 0)
718 {
719 perror("select");
720 break;
721 }
722
723 if(n == 0)
724 {
725 do_timeout();
726 continue;
727 }
728
729 if(control_fd != -1 && FD_ISSET(control_fd, &fds))
730 {
731 if(do_control_command())
732 {
733 close(control_fd);
734 control_fd = -1;
735 }
736 }
737 else if(data_fd != -1 && FD_ISSET(data_fd, &fds))
738 {
739 notmr_running = !tmr_running;
740 if(do_sequencer())
741 {
742 close(data_fd);
743 data_fd = -1;
744 send_status(403, "Data connection is closed");
745 }
746 }
747 }
748 }
749
750 if(data_fd != -1)
751 stop_playing();
752 }
753
do_timeout(void)754 static void do_timeout(void)
755 {
756 double fill_time;
757
758 if(data_fd == -1)
759 return;
760 aq_add(NULL, 0);
761 if (IS_STREAM_TRACE)
762 fill_time = high_time_at - (double)aq_filled() / play_mode->rate;
763 else
764 fill_time = get_current_calender_time() - start_time -
765 (double)(curr_event_samples + event_time_offset) / play_mode->rate;
766 if(fill_time <= 0)
767 return;
768
769 if(tmr_running)
770 add_tick(time2tick(fill_time));
771 else
772 {
773 MidiEvent ev;
774 event_time_offset += (int32)(fill_time *
775 play_mode->rate);
776 ev.time = curr_event_samples + event_time_offset;
777 ev.type = ME_NONE;
778 play_event(&ev);
779 }
780 }
781
782 /* -1=error, 0=success, 1=connection-closed */
data_flush(int discard)783 static int data_flush(int discard)
784 {
785 fd_set fds;
786 char buff[BUFSIZ];
787 struct timeval timeout;
788 int n;
789
790 while(1)
791 {
792 FD_ZERO(&fds);
793 FD_SET(data_fd, &fds);
794 timeout.tv_sec = 0;
795 if(discard)
796 timeout.tv_usec = 100000;
797 else
798 timeout.tv_usec = 0;
799 if((n = select(data_fd + 1, &fds, NULL, NULL, &timeout)) < 0)
800 {
801 perror("select");
802 return -1;
803 }
804 if(n == 0)
805 break;
806 if(discard)
807 {
808 if((n = read(data_fd, buff, sizeof(buff))) < 0)
809 {
810 perror("read");
811 return -1;
812 }
813 if(n == 0)
814 return 1;
815 }
816 else
817 {
818 int status;
819 if((status = do_sequencer()) != 0)
820 return status;
821 }
822 }
823 return 0;
824 }
825
826 #if 0
827 static void server_seq_sync(double tm)
828 {
829 double t;
830 aq_soft_flush();
831 t = (double)aq_filled() / play_mode->rate;
832 if(t > tm)
833 usleep((unsigned long)((t - tm) * 1000000));
834 }
835 #endif
836
server_reset(void)837 static void server_reset(void)
838 {
839 playmidi_stream_init();
840 if(free_instruments_afterwards)
841 free_instruments(0);
842 data_buffer_len = 0;
843 rstatus = 0;
844 do_sysex(NULL, 0); /* Initialize SysEx buffer */
845 low_time_at = DEFAULT_LOW_TIMEAT;
846 high_time_at = DEFAULT_HIGH_TIMEAT;
847 reduce_voice_threshold = 0; /* Disable auto reduction voice */
848 compute_sample_increment();
849 tmr_reset();
850 tmr_running = notmr_running = 0;
851 start_time = get_current_calender_time();
852 proto = PROTO_SEQ;
853 }
854
855 /* -1=error, 0=success, 1=connection-closed */
do_control_command(void)856 static int do_control_command(void)
857 {
858 int status;
859 char *params[MAX_GETCMD_PARAMS];
860 int nparams = 0;
861 int i;
862
863 if((status = control_getcmd(params, &nparams)) == -1)
864 return -1;
865 if(status == 1)
866 {
867 send_status(500, "Error");
868 return 1;
869 }
870
871 if(nparams == 0 || *params == NULL || **params == '\0')
872 return 0;
873
874 for(i = 0; cmd_table[i].cmd; i++)
875 if(strcasecmp(params[0], cmd_table[i].cmd) == 0)
876 {
877 if(nparams < cmd_table[i].minarg)
878 return send_status(501, "'%s': Arguments is too few",
879 params[0]);
880 if(nparams > cmd_table[i].maxarg)
881 return send_status(501, "'%s': Arguments is too many",
882 params[0]);
883 return cmd_table[i].proc(nparams, params);
884 }
885 return send_status(500, "'%s': command not understood.", params[0]);
886 }
887
cmd_help(int argc,char ** argv)888 static int cmd_help(int argc, char **argv)
889 {
890 int i;
891
892 if(send_status(200, "Help ok"))
893 return -1;
894
895 for(i = 0; cmd_table[i].cmd; i++)
896 {
897 if(fdputs(cmd_table[i].help, CONTROL_FD_OUT))
898 return -1;
899 if(fdputs("\n", CONTROL_FD_OUT))
900 return -1;
901 }
902 return fdputs(".\n", CONTROL_FD_OUT);
903 }
904
cmd_open(int argc,char ** argv)905 static int cmd_open(int argc, char **argv)
906 {
907 int sock;
908 struct sockaddr_storage in;
909 socklen_t addrlen;
910 int port;
911
912 if(data_fd != -1)
913 return send_status(125, "Data connection is already opened");
914
915 if(strcasecmp(argv[1], "lsb") == 0)
916 is_lsb_data = 1;
917 else if(strcasecmp(argv[1], "msb") == 0)
918 is_lsb_data = 0;
919 else
920 return send_status(502, "OPEN: Invalid argument: %s", argv[1]);
921
922 port = data_port;
923 if((sock = pasv_open(&port)) == -1)
924 return send_status(511, "Can't open data connection");
925
926 addrlen = sizeof(in);
927 memset(&in, 0, addrlen);
928 send_status(200, "%d is ready acceptable", port);
929
930 alarm(SIG_TIMEOUT_SEC);
931 data_fd = accept(sock, (struct sockaddr *)&in, &addrlen);
932 alarm(0);
933
934 if(data_fd < 0)
935 {
936 send_status(512, "Accept error");
937 close(sock);
938 return 0;
939 }
940 close(sock);
941
942 /* Not quite protocol independent */
943 if(control_port) switch (((struct sockaddr *) &control_client)->sa_family)
944 {
945 case AF_INET:
946 if (((struct sockaddr_in *) &control_client)->sin_addr.s_addr !=
947 ((struct sockaddr_in *) &in)->sin_addr.s_addr)
948 {
949 close(data_fd);
950 data_fd = -1;
951 return send_status(513, "Security violation: Address mismatch" );
952 }
953 break;
954 case AF_INET6:
955 if (memcmp(
956 ((struct sockaddr_in6 *) &control_client)->sin6_addr.s6_addr,
957 ((struct sockaddr_in6 *) &in)->sin6_addr.s6_addr, 16))
958 {
959 close(data_fd);
960 data_fd = -1;
961 return send_status(513, "Security violation: Address mismatch" );
962 }
963 break;
964 }
965
966
967 data_buffer_len = 0;
968 do_sysex(NULL, 0); /* Initialize SysEx buffer */
969 tmr_reset();
970 send_status(200, "Ready data connection");
971
972 return 0;
973 }
974
cmd_close(int argc,char ** argv)975 static int cmd_close(int argc, char **argv)
976 {
977 if(data_fd != -1)
978 {
979 close(data_fd);
980 data_fd = -1;
981 return send_status(302, "Data connection is closed");
982 }
983 return send_status(302, "Data connection is already closed");
984 }
985
cmd_queue(int argc,char ** argv)986 static int cmd_queue(int argc, char **argv)
987 {
988 int32 qsamples;
989
990 aq_add(NULL, 0); /* Update software queue */
991 if(!aq_fill_buffer_flag)
992 qsamples = aq_soft_filled() + aq_filled();
993 else
994 qsamples = 0;
995 return send_status(200, "%f sec", (double)qsamples / play_mode->rate);
996 }
997
cmd_maxqueue(int argc,char ** argv)998 static int cmd_maxqueue(int argc, char **argv)
999 {
1000 return send_status(200, "%f sec",
1001 (double)aq_get_dev_queuesize() / play_mode->rate);
1002 }
1003
cmd_time(int argc,char ** argv)1004 static int cmd_time(int argc, char **argv)
1005 {
1006 return send_status(200, "%f sec", (double)aq_samples());
1007 }
1008
cmd_quit(int argc,char ** argv)1009 static int cmd_quit(int argc, char **argv)
1010 {
1011 send_status(200, "Bye");
1012 return 1;
1013 }
1014
cmd_timebase(int argc,char ** argv)1015 static int cmd_timebase(int argc, char **argv)
1016 {
1017 int i;
1018
1019 if(argc == 1)
1020 return send_status(200, "%d OK", curr_timebase);
1021 i = atoi(argv[1]);
1022 if(i < 1)
1023 i = 1;
1024 else if(i > 1000)
1025 i = 1000;
1026 if(i != curr_timebase)
1027 {
1028 curr_timebase = i;
1029 compute_sample_increment();
1030 tick_offs = curr_tick;
1031 start_time = get_current_calender_time();
1032 }
1033 return send_status(200, "OK");
1034 }
1035
cmd_patch(int argc,char ** argv)1036 static int cmd_patch(int argc, char **argv)
1037 {
1038 int dr, bank, prog;
1039
1040 if(strcasecmp(argv[1], "drumset") == 0)
1041 dr = 1;
1042 else if(strcasecmp(argv[1], "bank") == 0)
1043 dr = 0;
1044 else
1045 return send_status(502, "PATCH: Invalid argument: %s", argv[1]);
1046
1047 bank = atoi(argv[2]);
1048 prog = atoi(argv[3]);
1049 if(bank < 0 || bank > 127 || prog < 0 || prog > 127)
1050 return send_status(502, "PATCH: Invalid argument");
1051 if(play_midi_load_instrument(dr, bank, prog) == NULL)
1052 return send_status(514, "PATCH: Can't load the patch");
1053 return send_status(200, "OK");
1054 }
1055
cmd_reset(int argc,char ** argv)1056 static int cmd_reset(int argc, char **argv)
1057 {
1058 int status;
1059
1060 if(data_fd >= 0)
1061 {
1062 stop_playing();
1063 if((status = data_flush(1)) != 0)
1064 return status;
1065 }
1066 server_reset();
1067 return send_status(200, "OK");
1068 }
1069
cmd_autoreduce(int argc,char ** argv)1070 static int cmd_autoreduce(int argc, char **argv)
1071 {
1072 if(strcasecmp(argv[1], "on") == 0)
1073 {
1074 if(argc == 3)
1075 reduce_voice_threshold = atoi(argv[2]);
1076 else
1077 reduce_voice_threshold = -1;
1078 }
1079 else if(strcasecmp(argv[1], "off") == 0)
1080 reduce_voice_threshold = 0;
1081 else
1082 return send_status(502, "AUTOREDUCE: Invalid argument: %s",
1083 argv[1]);
1084 return send_status(200, "OK");
1085 }
1086
cmd_setbuf(int argc,char ** argv)1087 static int cmd_setbuf(int argc, char **argv)
1088 {
1089 low_time_at = atof(argv[1]);
1090 high_time_at = atof(argv[2]);
1091 return send_status(200, "OK");
1092 }
1093
cmd_protocol(int argc,char ** argv)1094 static int cmd_protocol(int argc, char **argv)
1095 {
1096 if (argc < 2)
1097 return send_status(200, "Current protocol is %s",
1098 proto == PROTO_SEQ ? "sequencer" : "midi");
1099 if (strcasecmp(argv[1], "sequencer") == 0)
1100 proto = PROTO_SEQ;
1101 else if (strcasecmp(argv[1], "midi") == 0)
1102 proto = PROTO_MIDI;
1103 else return send_status(500, "Invalid protocol name %s", argv[1]);
1104
1105 return send_status(200, "Protocol set to %s",
1106 proto == PROTO_SEQ ? "sequencer" : "midi");
1107 }
1108
cmd_nop(int argc,char ** argv)1109 static int cmd_nop(int argc, char **argv)
1110 {
1111 return send_status(200, "NOP OK");
1112 }
1113
do_control_command_nonblock(void)1114 static int do_control_command_nonblock(void)
1115 {
1116 struct timeval timeout;
1117 int n;
1118 fd_set fds;
1119
1120 if(control_fd == -1)
1121 return 1;
1122 FD_ZERO(&fds);
1123 FD_SET(control_fd, &fds);
1124 timeout.tv_sec = 0;
1125 timeout.tv_usec = 0;
1126 n = select(control_fd + 1, &fds, NULL, NULL, &timeout);
1127 if(n > 0 && FD_ISSET(control_fd, &fds))
1128 return do_control_command();
1129 return 0;
1130 }
1131
fdgets(char * buff,size_t buff_size,struct fd_read_buffer * p)1132 static int fdgets(char *buff, size_t buff_size, struct fd_read_buffer *p)
1133 {
1134 int n, count, size, fd;
1135 char *buff_endp = buff + buff_size - 1, *pbuff, *beg;
1136
1137 fd = p->fd;
1138 if(buff_size == 0)
1139 return 0;
1140 else if(buff_size == 1) /* buff == buff_endp */
1141 {
1142 *buff = '\0';
1143 return 0;
1144 }
1145
1146 count = p->count;
1147 size = p->size;
1148 pbuff = p->buff;
1149 beg = buff;
1150 do
1151 {
1152 if(count == size)
1153 {
1154 if((n = read(fd, pbuff, BUFSIZ)) <= 0)
1155 {
1156 *buff = '\0';
1157 if(n == 0)
1158 {
1159 p->count = p->size = 0;
1160 return buff - beg;
1161 }
1162 return -1; /* < 0 error */
1163 }
1164 count = p->count = 0;
1165 size = p->size = n;
1166 }
1167 *buff++ = pbuff[count++];
1168 } while(*(buff - 1) != '\n' && buff != buff_endp);
1169 *buff = '\0';
1170 p->count = count;
1171 return buff - beg;
1172 }
1173
fdputs(char * s,int fd)1174 static int fdputs(char *s, int fd)
1175 {
1176 if(write(fd, s, strlen(s)) == -1)
1177 return -1;
1178 return 0;
1179 }
1180
1181 #ifdef LITTLE_ENDIAN
data2long(uint8 * data)1182 static uint32 data2long(uint8* data)
1183 {
1184 uint32 x;
1185 memcpy(&x, data, sizeof(x));
1186 if(!is_lsb_data)
1187 x = XCHG_LONG(x);
1188 return x;
1189 }
data2short(uint8 * data)1190 static uint16 data2short(uint8* data)
1191 {
1192 uint16 x;
1193 memcpy(&x, data, sizeof(x));
1194 if(!is_lsb_data)
1195 x = XCHG_SHORT(x);
1196 return x;
1197 }
1198 #else
data2long(uint8 * data)1199 static uint32 data2long(uint8* data)
1200 {
1201 uint32 x;
1202 memcpy(&x, data, sizeof(x));
1203 if(is_lsb_data)
1204 x = XCHG_LONG(x);
1205 return x;
1206 }
data2short(uint8 * data)1207 static uint16 data2short(uint8* data)
1208 {
1209 uint16 x;
1210 memcpy(&x, data, sizeof(x));
1211 if(is_lsb_data)
1212 x = XCHG_SHORT(x);
1213 return x;
1214 }
1215 #endif
1216
do_sequencer(void)1217 static int do_sequencer(void)
1218 {
1219 int n, offset, frame_size, data_offs, data_frame_num;
1220 unsigned char status;
1221 MidiEvent ev;
1222
1223 n = read(data_fd, data_buffer + data_buffer_len,
1224 sizeof(data_buffer) - data_buffer_len);
1225
1226 if(n <= 0)
1227 {
1228 stop_playing();
1229 return n;
1230 }
1231
1232 #ifdef DEBUG_DUMP_SEQ
1233 {
1234 int i;
1235 for(i = 0; i < n; i++)
1236 fprintf(stderr, "%02x", data_buffer[data_buffer_len + i]);
1237 fprintf(stderr, "\n");
1238 }
1239 #endif /* DEBUG_DUMP_SEQ */
1240
1241 data_buffer_len += n;
1242 offset = 0;
1243 frame_size = (proto == PROTO_SEQ ? 4 : 1);
1244 while(offset < data_buffer_len)
1245 {
1246 int cmd;
1247 cmd = (proto == PROTO_SEQ ? data_buffer[offset] : SEQ_MIDIPUTC);
1248
1249 #define READ_NEEDBUF(x) if(offset + (x) > data_buffer_len) goto done;
1250 #define READ_ADVBUF(x) offset += (x);
1251 switch(cmd)
1252 {
1253 case EV_CHN_VOICE:
1254 READ_NEEDBUF(8);
1255 do_chn_voice(data_buffer + offset);
1256 READ_ADVBUF(8);
1257 break;
1258 case EV_CHN_COMMON:
1259 READ_NEEDBUF(8);
1260 do_chn_common(data_buffer + offset);
1261 READ_ADVBUF(8);
1262 break;
1263 case EV_TIMING:
1264 READ_NEEDBUF(8);
1265 do_timing(data_buffer + offset);
1266 READ_ADVBUF(8);
1267 break;
1268 case EV_SYSEX:
1269 READ_NEEDBUF(8);
1270 do_sysex(data_buffer + offset + 2, 6);
1271 READ_ADVBUF(8);
1272 break;
1273 case SEQ_MIDIPUTC:
1274 READ_NEEDBUF(proto == PROTO_SEQ ? 2 : 1);
1275 data_offs = (proto == PROTO_SEQ ? 1 : 0);
1276 data_frame_num = 0;
1277
1278 if(is_system_prefix)
1279 {
1280 READ_NEEDBUF(frame_size);
1281 do_sysex(data_buffer + offset + data_offs, 1);
1282 if(data_buffer[offset + data_offs] == 0xf7)
1283 is_system_prefix = 0; /* End SysEX */
1284 READ_ADVBUF(frame_size);
1285 break;
1286 }
1287
1288 status = data_buffer[offset + data_offs];
1289 if (status & 0x80) {
1290 /* data bytes follows status byte */
1291 data_frame_num++;
1292 } else {
1293 /* use "running status" */
1294 status = rstatus;
1295 if (!(status & 0x80)) {
1296 /* no status byte, skip this crap */
1297 READ_NEEDBUF(frame_size);
1298 ctl.cmsg(CMSG_INFO, VERB_NORMAL, "no status byte for %#x, skipping",
1299 data_buffer[offset + data_offs]);
1300 READ_ADVBUF(frame_size);
1301 break;
1302 }
1303 }
1304 #define DATA_BYTE(num) (data_buffer[offset + data_offs + \
1305 ((num) + data_frame_num) * frame_size])
1306 switch(status & 0xf0)
1307 {
1308 case MIDI_NOTEON:
1309 READ_NEEDBUF((data_frame_num + 2) * frame_size);
1310 ev.channel = status & 0x0f;
1311 ev.a = DATA_BYTE(0) & 0x7f;
1312 ev.b = DATA_BYTE(1) & 0x7f;
1313 if(ev.b != 0)
1314 ev.type = ME_NOTEON;
1315 else
1316 ev.type = ME_NOTEOFF;
1317 seq_play_event(&ev);
1318 READ_ADVBUF((data_frame_num + 2) * frame_size);
1319 break;
1320
1321 case MIDI_NOTEOFF:
1322 READ_NEEDBUF((data_frame_num + 2) * frame_size);
1323 ev.type = ME_NOTEOFF;
1324 ev.channel = status & 0x0f;
1325 ev.a = DATA_BYTE(0) & 0x7f;
1326 ev.b = DATA_BYTE(1) & 0x7f;
1327 seq_play_event(&ev);
1328 READ_ADVBUF((data_frame_num + 2) * frame_size);
1329 break;
1330
1331 case MIDI_KEY_PRESSURE:
1332 READ_NEEDBUF((data_frame_num + 2) * frame_size);
1333 ev.type = ME_KEYPRESSURE;
1334 ev.channel = status & 0x0f;
1335 ev.a = DATA_BYTE(0) & 0x7f;
1336 ev.b = DATA_BYTE(1) & 0x7f;
1337 seq_play_event(&ev);
1338 READ_ADVBUF((data_frame_num + 2) * frame_size);
1339 break;
1340
1341 case MIDI_CTL_CHANGE:
1342 READ_NEEDBUF((data_frame_num + 2) * frame_size);
1343 if(convert_midi_control_change(status & 0x0f,
1344 DATA_BYTE(0),
1345 DATA_BYTE(1),
1346 &ev))
1347 seq_play_event(&ev);
1348 READ_ADVBUF((data_frame_num + 2) * frame_size);
1349 break;
1350
1351 case MIDI_PGM_CHANGE:
1352 READ_NEEDBUF((data_frame_num + 1) * frame_size);
1353 ev.type = ME_PROGRAM;
1354 ev.channel = status & 0x0f;
1355 ev.a = DATA_BYTE(0) & 0x7f;
1356 ev.b = 0;
1357 seq_play_event(&ev);
1358 READ_ADVBUF((data_frame_num + 1) * frame_size);
1359 break;
1360
1361 case MIDI_CHN_PRESSURE:
1362 READ_NEEDBUF((data_frame_num + 1) * frame_size);
1363 ev.type = ME_CHANNEL_PRESSURE;
1364 ev.channel = status & 0x0f;
1365 ev.a = DATA_BYTE(0) & 0x7f;
1366 ev.b = 0;
1367 seq_play_event(&ev);
1368 READ_ADVBUF((data_frame_num + 1) * frame_size);
1369 break;
1370
1371 case MIDI_PITCH_BEND:
1372 READ_NEEDBUF((data_frame_num + 2) * frame_size);
1373 ev.type = ME_PITCHWHEEL;
1374 ev.channel = status & 0x0f;
1375 ev.a = DATA_BYTE(0) & 0x7f;
1376 ev.b = DATA_BYTE(1) & 0x7f;
1377 seq_play_event(&ev);
1378 READ_ADVBUF((data_frame_num + 2) * frame_size);
1379 break;
1380
1381 case MIDI_SYSTEM_PREFIX:
1382 switch (status & 0x0f) {
1383 /* Common System Messages */
1384 case 0x00: /* SysEx */
1385 READ_NEEDBUF(frame_size);
1386 do_sysex(data_buffer + offset + data_offs, 1);
1387 is_system_prefix = 1; /* Start SysEX */
1388 READ_ADVBUF(frame_size);
1389 break;
1390
1391 case 0x01: /* Quarter Frame */
1392 READ_NEEDBUF(frame_size * 2);
1393 READ_ADVBUF(frame_size * 2);
1394 break;
1395
1396 case 0x02: /* Song Position */
1397 READ_NEEDBUF(frame_size * 3);
1398 READ_ADVBUF(frame_size * 3);
1399 break;
1400
1401 case 0x03: /* Song Select */
1402 READ_NEEDBUF(frame_size * 2);
1403 READ_ADVBUF(frame_size * 2);
1404 break;
1405
1406 case 0x04:
1407 case 0x05: /* Undef */
1408 ctl.cmsg(CMSG_ERROR, VERB_NORMAL,
1409 "Undefined Common system message %x\n", status & 0x0f);
1410 READ_NEEDBUF(frame_size);
1411 READ_ADVBUF(frame_size);
1412 break;
1413
1414 case 0x06: /* Tune Request */
1415 READ_NEEDBUF(frame_size);
1416 READ_ADVBUF(frame_size);
1417 break;
1418
1419 case 0x07: /* EOX */
1420 ctl.cmsg(CMSG_ERROR, VERB_NORMAL, "Unexpected EOX\n");
1421 READ_NEEDBUF(frame_size);
1422 READ_ADVBUF(frame_size);
1423 break;
1424
1425 /* System Real Time Messages */
1426 case 0x08: /* MIDI Clock */
1427 READ_NEEDBUF(frame_size);
1428 READ_ADVBUF(frame_size);
1429 break;
1430
1431 case 0x09: /* MIDI Tick */
1432 READ_NEEDBUF(frame_size);
1433 READ_ADVBUF(frame_size);
1434 break;
1435
1436 case 0x0A: /* MIDI Start */
1437 READ_NEEDBUF(frame_size);
1438 READ_ADVBUF(frame_size);
1439 break;
1440
1441 case 0x0B: /* MIDI Continue */
1442 READ_NEEDBUF(frame_size);
1443 READ_ADVBUF(frame_size);
1444 break;
1445
1446 case 0x0C: /* MIDI Stop */
1447 READ_NEEDBUF(frame_size);
1448 stop_playing();
1449 READ_ADVBUF(frame_size);
1450 break;
1451
1452 case 0x0D: /* Undef */
1453 ctl.cmsg(CMSG_ERROR, VERB_NORMAL,
1454 "Undefined Real-Time system message %x\n", status & 0x0f);
1455 READ_NEEDBUF(frame_size);
1456 READ_ADVBUF(frame_size);
1457 break;
1458
1459 case 0x0E: /* Active Sensing */
1460 READ_NEEDBUF(frame_size);
1461 READ_ADVBUF(frame_size);
1462 break;
1463
1464 case 0x0F: /* Reset */
1465 ctl.cmsg(CMSG_ERROR, VERB_NORMAL, "MIDI Reset\n");
1466 READ_NEEDBUF(frame_size);
1467 tmr_reset();
1468 READ_ADVBUF(frame_size);
1469 break;
1470 }
1471 status = 0;
1472 break;
1473
1474 default:
1475 ctl.cmsg(CMSG_ERROR, VERB_NORMAL,
1476 "Undefined SEQ_MIDIPUTC 0x%02x",
1477 data_buffer[offset + data_offs]);
1478 send_status(402, "Undefined SEQ_MIDIPUTC 0x%02x",
1479 data_buffer[offset + data_offs]);
1480 return 1;
1481 }
1482 rstatus = status;
1483 break;
1484
1485 case SEQ_FULLSIZE:
1486 /* WARNING: This data may be devided into some socket fragments. */
1487 offset = data_buffer_len;
1488 ctl.cmsg(CMSG_WARNING, VERB_NORMAL,
1489 "SEQ_FULLSIZE is received. This command is not safety.");
1490 break;
1491
1492 case SEQ_EXTENDED:
1493 READ_NEEDBUF(8);
1494 do_extended(data_buffer + offset);
1495 READ_ADVBUF(8);
1496 break;
1497
1498 case EV_SEQ_LOCAL:
1499 case SEQ_PRIVATE:
1500 READ_NEEDBUF(8);
1501 /* Ignore */
1502 READ_ADVBUF(8);
1503 break;
1504
1505 default:
1506 ctl.cmsg(CMSG_ERROR, VERB_NORMAL,
1507 "Undefined data 0x%02x", data_buffer[offset - 1]);
1508 send_status(401, "Wrong data is recieved (seqcmd=0x%02x)",
1509 cmd);
1510 stop_playing();
1511 return 1;
1512 }
1513 #undef READ_NEEDBUF
1514 #undef READ_ADVBUF
1515 #undef DATA_BYTE
1516 }
1517
1518 done:
1519 if(offset)
1520 {
1521 data_buffer_len -= offset;
1522 memmove(data_buffer, data_buffer + offset, data_buffer_len);
1523 }
1524 return 0;
1525 }
1526
1527
do_chn_voice(uint8 * data)1528 static void do_chn_voice(uint8 *data)
1529 {
1530 int type, chn, note, parm;
1531 MidiEvent ev;
1532
1533 type = data[2];
1534 chn = data[3] % MAX_CHANNELS;
1535 note = data[4] & 0x7f;
1536 parm = data[5] & 0x7f;
1537
1538 ev.channel = chn;
1539 ev.a = note;
1540 ev.b = parm;
1541 switch(type)
1542 {
1543 case MIDI_NOTEON:
1544 if(parm > 0)
1545 {
1546 ev.type = ME_NOTEON;
1547 seq_play_event(&ev);
1548 break;
1549 }
1550 /* FALLTHROUGH */
1551 case MIDI_NOTEOFF:
1552 ev.type = ME_NOTEOFF;
1553 seq_play_event(&ev);
1554 break;
1555 case MIDI_KEY_PRESSURE:
1556 ev.type = ME_KEYPRESSURE;
1557 seq_play_event(&ev);
1558 break;
1559 }
1560 }
1561
do_chn_common(uint8 * data)1562 static void do_chn_common(uint8 *data)
1563 {
1564 int type, chn, p1, p2, w14;
1565 MidiEvent ev;
1566
1567 type = data[2];
1568 chn = data[3] % MAX_CHANNELS;
1569 p1 = data[4] & 0x7f;
1570 p2 = data[5] & 0x7f;
1571 w14 = data2short(data + 6) & 0x3fff;
1572
1573 if(type == 0xff) /* Meta event */
1574 {
1575 /* This event is special event for timidity. (not OSS compatible) */
1576 switch(data[3])
1577 {
1578 case 0x2f: /* End of midi */
1579 stop_playing();
1580 tmr_reset();
1581 break;
1582
1583 case 0x7f: /* Sequencer-Specific Meta-Event */
1584 switch(data[4])
1585 {
1586 case 0x01: /* MIDI Reset */
1587 ev.type = ME_RESET;
1588 ev.a = DEFAULT_SYSTEM_MODE;
1589 ev.b = 0;
1590 seq_play_event(&ev);
1591 break;
1592
1593 case 0x02: { /* Used to sync. */
1594 double target_time, queue_time, sleep_time;
1595 if(w14 == 0)
1596 {
1597 aq_flush(0); /* wait until playout */
1598 send_status(301, "0 Sync OK");
1599 break;
1600 }
1601
1602 aq_soft_flush();
1603 target_time = (double)w14 / curr_timebase;
1604 queue_time = (double)aq_filled() / play_mode->rate;
1605 sleep_time = queue_time - target_time;
1606 if(sleep_time > 0)
1607 {
1608 send_status(301, "%g Sync OK", sleep_time);
1609 usleep((unsigned long)(sleep_time * 1000000));
1610 }
1611 else
1612 send_status(301, "0 Sync OK");
1613 }
1614 break;
1615 }
1616 }
1617 return;
1618 }
1619
1620 ev.channel = chn;
1621 switch(type)
1622 {
1623 case MIDI_CTL_CHANGE:
1624 if(convert_midi_control_change(chn, p1, w14, &ev))
1625 seq_play_event(&ev);
1626 break;
1627 case MIDI_PGM_CHANGE:
1628 ev.type = ME_PROGRAM;
1629 ev.a = p1;
1630 ev.b = 0;
1631 seq_play_event(&ev);
1632 break;
1633 case MIDI_CHN_PRESSURE:
1634 ev.type = ME_CHANNEL_PRESSURE;
1635 ev.a = p1;
1636 ev.b = p2;
1637 seq_play_event(&ev);
1638 break;
1639 case MIDI_PITCH_BEND:
1640 ev.type = ME_PITCHWHEEL;
1641 ev.a = w14 & 0x7f;
1642 ev.b = (w14>>7) & 0x7f;
1643 seq_play_event(&ev);
1644 break;
1645 }
1646 }
1647
1648
do_timing(uint8 * data)1649 static void do_timing(uint8 *data)
1650 {
1651 int32 val;
1652
1653 val = data2long(data + 4);
1654 switch(data[1])
1655 {
1656 case TMR_START:
1657 tmr_running = 1;
1658 tmr_reset();
1659 event_time_offset = (int32)(play_mode->rate * high_time_at);
1660 break;
1661
1662 case TMR_STOP:
1663 tmr_running = 0;
1664 break;
1665
1666 case TMR_CONTINUE:
1667 if(!tmr_running)
1668 {
1669 tmr_running = 1;
1670 tick_offs = curr_tick;
1671 start_time = get_current_calender_time();
1672 }
1673 break;
1674
1675 case TMR_TEMPO:
1676 #if 0 /* What should TMR_TEMPO work ? */
1677 if(val < 8)
1678 val = 8;
1679 else if(val > 250)
1680 val = 250;
1681 current_play_tempo = 60 * 1000000 / val;
1682 compute_sample_increment();
1683 #endif
1684 break;
1685
1686 case TMR_WAIT_ABS:
1687
1688 /*
1689 fprintf(stderr, "## TMR_WAIT_ABS: %d %d %d %g\n",
1690 curr_tick,
1691 curr_tick - (time2tick(get_current_calender_time()
1692 - start_time) + tick_offs),
1693 event_time_offset,
1694 (double)aq_filled() / play_mode->rate);
1695 */
1696
1697 val -= curr_tick;
1698 /*FALLTHROUGH*/
1699 case TMR_WAIT_REL:
1700 if(val <= 0)
1701 break;
1702 add_tick(val);
1703 break;
1704
1705 #if 0
1706 case TMR_ECHO:
1707 case TMR_SPP:
1708 #endif
1709 default:
1710 /* fprintf(stderr, "## TMR=0x%02x is not supported\n", data[1]); */
1711 break;
1712 }
1713 }
1714
1715
do_sysex(uint8 * data,int n)1716 static void do_sysex(uint8 *data, int n)
1717 {
1718 static uint8 sysexbuf[BUFSIZ];
1719 static int buflen;
1720 static int fillflag;
1721 int i;
1722
1723 if(data == NULL)
1724 {
1725 buflen = fillflag = 0;
1726 is_system_prefix = 0;
1727 return;
1728 }
1729
1730 for(i = 0; i < n; i++)
1731 {
1732 /* SysEx := /\xf0([^\xf7]*\xf7)/ */
1733 if(!fillflag)
1734 {
1735 if(data[i] == 0xf0)
1736 {
1737 fillflag = 1;
1738 continue;
1739 }
1740 }
1741 if(fillflag)
1742 {
1743 if(buflen < sizeof(sysexbuf))
1744 sysexbuf[buflen++] = data[i];
1745 if(data[i] == 0xf7)
1746 {
1747 MidiEvent ev;
1748 if(parse_sysex_event(sysexbuf, buflen, &ev))
1749 seq_play_event(&ev);
1750 buflen = 0;
1751 fillflag = 0;
1752 }
1753 }
1754 }
1755 }
1756
do_extended(uint8 * data)1757 static void do_extended(uint8 *data)
1758 {
1759 int value;
1760 MidiEvent ev;
1761
1762 value = data[5] | data[6] * 256;
1763 switch(data[1])
1764 {
1765 case SEQ_CONTROLLER:
1766 switch(data[4])
1767 {
1768 case CTRL_PITCH_BENDER: /* ?? */
1769 break;
1770 case CTRL_PITCH_BENDER_RANGE: /* ?? */
1771 ev.channel = data[3] % MAX_CHANNELS;
1772 ev.b = 0;
1773 ev.a = 0;
1774
1775 /* LSB */
1776 ev.type = ME_NRPN_LSB;
1777 seq_play_event(&ev);
1778
1779 /* MSB */
1780 ev.type = ME_NRPN_MSB;
1781 seq_play_event(&ev);
1782
1783 /* Data entry */
1784 ev.type = ME_DATA_ENTRY_MSB;
1785 ev.a = value / 100; /* ?? */
1786 seq_play_event(&ev);
1787
1788 break;
1789 default:
1790 break;
1791 }
1792 break;
1793 default:
1794 break;
1795 }
1796 }
1797
1798
1799 /*
1800 * interface_<id>_loader();
1801 */
interface_r_loader(void)1802 ControlMode *interface_r_loader(void)
1803 {
1804 return &ctl;
1805 }
1806