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> test(S s,S expected)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*/ 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 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*/ 268 static int ctl_read(int32 *valp) 269 { 270 if(data_fd != -1) 271 do_control_command_nonblock(); 272 return RC_NONE; 273 } 274 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 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 307 static void ctl_event(CtlEvent *e) 308 { 309 } 310 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 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 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 */ 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 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 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 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 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 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 623 int time2tick(double sec) 624 { 625 return (int)(sec * curr_timebase); 626 } 627 628 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 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 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 */ 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 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 */ 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 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 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 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 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 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 1004 static int cmd_time(int argc, char **argv) 1005 { 1006 return send_status(200, "%f sec", (double)aq_samples()); 1007 } 1008 1009 static int cmd_quit(int argc, char **argv) 1010 { 1011 send_status(200, "Bye"); 1012 return 1; 1013 } 1014 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 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 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 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 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 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 1109 static int cmd_nop(int argc, char **argv) 1110 { 1111 return send_status(200, "NOP OK"); 1112 } 1113 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 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 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 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 } 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 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 } 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 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 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 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 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 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 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 */ 1802 ControlMode *interface_r_loader(void) 1803 { 1804 return &ctl; 1805 } 1806