implement -nomusic for linux hmiplay (d1x r1.8)
[btb/d2x.git] / arch / linux / hmiplay.c
1 /* $Id: hmiplay.c,v 1.8 2004-05-19 19:14:52 btb Exp $ */
2 /*
3  * HMI midi playing routines by Jani Frilander
4  *
5  * External device support by Patrick McCarthy
6  *
7  * Ported to d1x/sdl_threads by Matthew Mueller
8  *
9  */
10
11 #include <errno.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <unistd.h>
16 #include <signal.h>
17 #include <linux/soundcard.h>
18 #include <sys/ioctl.h>
19 #include <fcntl.h>
20 #include <sys/types.h>
21 #include <sys/ipc.h>
22 #define __USE_GNU //in recent glibc versions msgbuf is only defined if you have __USE_GNU defined
23 #include <sys/msg.h>
24 #include "music.h"
25 #include "cfile.h"
26
27 #include <SDL/SDL_thread.h>
28
29 //#define WANT_AWE32 1
30
31 #ifdef WANT_AWE32
32 #include <linux/awe_voice.h>
33 #endif
34
35 //#define WANT_MPU401 1
36
37 #ifdef WANT_MPU401
38
39 unsigned char reset_genmidi[5] =
40         { 0x7e, 0x7f, 0x09, 0x01, 0xf7 };
41
42 #define MIDI_RESET {                            \
43         SEQ_MIDIOUT(synth_dev,MIDI_SYSTEM_PREFIX);  \
44         SEQ_MIDIOUT(synth_dev,reset_genmidi[0]);    \
45         SEQ_MIDIOUT(synth_dev,reset_genmidi[1]);    \
46         SEQ_MIDIOUT(synth_dev,reset_genmidi[2]);    \
47         SEQ_MIDIOUT(synth_dev,reset_genmidi[3]);    \
48         SEQ_MIDIOUT(synth_dev,reset_genmidi[4]);    \
49 }
50
51 #define MIDI_MESSAGE2(a,b) {            \
52         SEQ_MIDIOUT(synth_dev,a);       \
53         SEQ_MIDIOUT(synth_dev,b);       \
54 }
55
56 #define MIDI_MESSAGE3(a,b,c) {          \
57         SEQ_MIDIOUT(synth_dev,a);       \
58         SEQ_MIDIOUT(synth_dev,b);       \
59         SEQ_MIDIOUT(synth_dev,c);       \
60 }
61 #endif
62
63 SEQ_DEFINEBUF(1024);
64
65 int drumflag = 1<<9;
66 int seqfd;
67 int synth_dev;
68 int program[16];
69 int stop;
70 double volume=1;
71
72 int ipc_queue_id = -1;
73 struct msgbuf *snd;
74
75 SDL_Thread *player_thread=NULL;
76
77 Voice_info *voices;
78 unsigned char *data=NULL;
79 char digi_last_midi_song[16] = "";
80
81 struct synth_info card_info;
82
83 void seqbuf_dump()
84 {
85         if (_seqbufptr)
86         {
87                 if (write(seqfd, _seqbuf, _seqbufptr) == -1)
88                 {
89                         perror ("Error writing sequencer device");
90                         SDL_KillThread(player_thread);
91                 }
92         }
93         _seqbufptr = 0;
94 }
95               
96 void my_quit()
97 {
98 //      printf("goodbye\n");//#####
99 //      exit(0);
100 }
101
102 int seq_init()
103 {
104         int nrmidis,nrsynths,i;
105         
106         if ((seqfd = open(SEQ_DEV, O_WRONLY, 0)) < 0)
107         {
108                 perror ("Error opening sequencer device");
109                 return (-1);
110         }
111         
112         if (ioctl(seqfd, SNDCTL_SEQ_NRSYNTHS, &nrsynths) == -1)
113         {
114                 perror ("There is no soundcard");
115                 return (-1);
116         }
117         
118         if (ioctl(seqfd, SNDCTL_SEQ_NRMIDIS, &nrmidis) == -1)
119         {
120                 perror ("There is no soundcard");
121                 return (-1);
122         }
123         
124         
125         if(nrsynths < 1 && nrmidis < 1)
126         {
127                 printf("No synth or midi device!\n");
128                 return -1;
129         }
130         
131         synth_dev = 0;
132         
133         //Check if we have wavetable synth device
134         for (i=0; i < nrsynths; i++)
135         {
136                 card_info.device = i;
137                 if (ioctl(seqfd, SNDCTL_SYNTH_INFO, &card_info) == -1)
138                 {
139                         perror("cannot get info on soundcard");
140                         return (-1);
141                 }
142                 
143                 if (card_info.synth_type == SYNTH_TYPE_SAMPLE)
144                 {    
145                         synth_dev = i;
146                         break;
147                 }
148         }
149         
150 #ifdef WANT_AWE32
151         for (i=0; i < nrsynths; i++)
152         {
153                 card_info.device = i;
154                 if (ioctl(seqfd, SNDCTL_SYNTH_INFO, &card_info) == -1)
155                 {
156                         perror("cannot get info on soundcard");
157                         return (-1);
158                 }
159                 
160                 if (card_info.synth_type==SYNTH_TYPE_SAMPLE
161                     &&card_info.synth_subtype==SAMPLE_TYPE_AWE32) {
162                         synth_dev = i;
163                         break;
164                 }
165         }
166 #endif
167         
168 #ifdef WANT_MPU401
169         for (i=0; i < nrmidis; i++)
170         {
171                 struct midi_info cinfo;
172                 cinfo.device = i;
173                 if (ioctl(seqfd, SNDCTL_MIDI_INFO, &cinfo) == -1)
174                 {
175                         perror("cannot get info on soundcard");
176                         return (-1);
177                 }
178                 
179                 // Just take first available for now.
180                 card_info.synth_type=SYNTH_TYPE_MIDI;
181                 card_info.device=i;
182                 synth_dev=i;
183                 break;
184         }
185         
186         if (card_info.synth_type!=SYNTH_TYPE_MIDI) {
187 #endif
188                 
189                 card_info.device = synth_dev;
190                 if (ioctl(seqfd, SNDCTL_SYNTH_INFO, &card_info) == -1)
191                 {
192                         perror("cannot get info on soundcard");
193                         return (-1);
194                 }
195                 
196 #ifdef WANT_MPU401
197         }
198         
199         if (card_info.synth_type==SYNTH_TYPE_MIDI) {
200                 MIDI_RESET;
201                 SEQ_DUMPBUF();
202         } else
203 #endif
204 #ifdef WANT_AWE32    
205           if (card_info.synth_type == SYNTH_TYPE_SAMPLE
206               && card_info.synth_subtype == SAMPLE_TYPE_AWE32)
207         {
208                 AWE_SET_CHANNEL_MODE(synth_dev,1);
209                 AWE_DRUM_CHANNELS(synth_dev,drumflag);
210         }
211         else
212 #endif
213         {
214                 voices = malloc(sizeof(Voice_info)*card_info.nr_voices);
215                 for (i=0;i<card_info.nr_voices;i++)
216                 {
217                         voices[i].note = -1;
218                         voices[i].channel = -1;
219                 }
220         }
221         
222         return(0);
223 }
224
225 void seq_close()
226 {
227         SEQ_DUMPBUF();
228         ioctl(seqfd,SNDCTL_SEQ_SYNC);
229         close(seqfd);
230         free(voices);
231 }
232
233 void set_program(int channel, int pgm)
234 {
235 #ifdef WANT_AWE32
236         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
237             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)
238         {
239                 SEQ_SET_PATCH(synth_dev,channel,pgm);
240         }
241         else
242 #endif
243           program[channel]=pgm;
244 }
245
246 void start_note(int channel, int note, int vel)
247 {
248         int i;
249         
250 #ifdef WANT_AWE32
251         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
252             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)
253         {
254                 SEQ_START_NOTE(synth_dev,channel,note,vel);
255         }
256         else
257 #endif
258         {
259                 for (i=0; i<card_info.nr_voices;i++)
260                   if ((voices[i].note == -1) && (voices[i].channel == -1))
261                     break;
262                 if (i != card_info.nr_voices)
263                 {
264                         voices[i].note = note;
265                         voices[i].channel = channel;
266                         if (((1<<channel) & drumflag))         /* drum note */
267                         {       
268                                 SEQ_SET_PATCH(synth_dev, i, note + 128);
269                         }
270                         else
271                         {
272                                 SEQ_SET_PATCH(synth_dev, i, program[channel]);
273                         }
274                         SEQ_START_NOTE(synth_dev, i, note, vel);
275                 }
276         }
277 }
278
279 void stop_note(int channel, int note, int vel)
280 {
281         int i;
282         
283 #ifdef WANT_AWE32
284         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
285             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)
286         {
287                 SEQ_STOP_NOTE(synth_dev,channel,note,vel);
288         }
289         else
290 #endif
291         {      
292                 for (i=0; i<card_info.nr_voices;i++)
293                   if ((voices[i].note == note) && (voices[i].channel == channel))
294                     break;
295                 if (i != card_info.nr_voices)
296                 {
297                         voices[i].note = -1;
298                         voices[i].channel = -1;
299                         SEQ_STOP_NOTE(synth_dev,i,note,vel);
300                 }
301         }
302 }
303
304 void set_control(int channel,int ctrl,int value)
305 {
306         int i;
307         
308 #ifdef WANT_AWE32
309         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
310             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)
311         {
312                 SEQ_CONTROL(synth_dev,channel,ctrl,value);
313         }
314         else
315 #endif
316         {
317                 for (i=0; i<card_info.nr_voices;i++)
318                   if (voices[i].channel == channel)
319                     if (ctrl == CTL_MAIN_VOLUME)
320                       SEQ_MAIN_VOLUME(synth_dev,i,value);
321         }
322 }
323
324 void set_pitchbend(int channel, int bend)
325 {
326         int i;
327         
328 #ifdef WANT_AWE32
329         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
330             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)
331         {
332                 SEQ_BENDER(synth_dev,channel,bend);
333         }
334         else
335 #endif
336         {
337                 for (i=0; i<card_info.nr_voices;i++)
338                   if (voices[i].channel == channel)
339                 {
340                         /*SEQ_BENDER_RANGE(synth_dev, i, 200);*/
341                         SEQ_BENDER(synth_dev, i, bend);
342                 }    
343         }
344 }
345
346 void set_key_pressure(int channel, int note, int vel)
347 {
348         int i;
349         
350 #ifdef WANT_AWE32
351         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
352             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)
353         {
354                 AWE_KEY_PRESSURE(synth_dev,channel,note,vel);
355         }
356         else
357 #endif
358         {
359                 for (i=0; i<card_info.nr_voices;i++)
360                   if ((voices[i].note == note) && (voices[i].channel == channel))
361                     SEQ_KEY_PRESSURE(synth_dev,i,note,vel);
362         }
363 }
364
365 void set_chn_pressure(int channel, int vel)
366 {    
367         int i;
368         
369 #ifdef WANT_AWE32
370         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
371             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)    
372         {
373                 AWE_CHN_PRESSURE(synth_dev,channel,vel);
374         }
375         else
376 #endif
377         {
378                 for (i=0; i<card_info.nr_voices;i++)
379                   if (voices[i].channel == channel)
380                     SEQ_CHN_PRESSURE(synth_dev,i,vel);
381         }    
382 }
383
384 void stop_all()
385 {
386         int i;
387         
388 #ifdef WANT_AWE32
389         int j;
390         if (card_info.synth_type == SYNTH_TYPE_SAMPLE
391             && card_info.synth_subtype == SAMPLE_TYPE_AWE32)    
392         {
393                 for (i=0; i<16;i++)
394                   for (j=0;j<128;j++)
395                     SEQ_STOP_NOTE(synth_dev,i,j,0);
396         }
397         else
398 #endif
399 #ifdef WANT_MPU401
400           if (card_info.synth_type==SYNTH_TYPE_MIDI) {
401                 MIDI_RESET;
402                 SEQ_DUMPBUF();
403           } else
404 #endif
405         {
406                 for (i=0; i<card_info.nr_voices;i++)
407                   SEQ_STOP_NOTE(synth_dev,i,voices[i].note,0);
408         }    
409 }
410
411 int get_dtime(unsigned char *data, int *pos)
412 {
413         char buf;
414         int result;
415         result =0;
416         
417         buf = data[*pos];
418         *pos +=1;
419         result = (0x7f & buf);
420         
421         if (!(buf & 0x80))
422         {
423                 buf = data[*pos];
424                 *pos +=1;
425                 result |=(int) (((int) 0x7f & (int) buf)<<7);
426                 if (!(buf & 0x80))
427                 {
428                         buf = data[*pos];
429                         *pos +=1;
430                         result |=(int) (((int) 0x7f & (int) buf)<<14);
431                         if (!(buf & 0x80))
432                         {
433                                 buf = data[*pos];
434                                 *pos +=1;
435                                 result |=(int) (((int) 0x7f & (int) buf)<<21);
436                         }
437                 }
438         }
439         
440         return result;
441 }
442
443 int do_track_event(unsigned char *data, int *pos)
444 {
445         char channel;
446         unsigned char buf[5];
447         
448         buf[0]=data[*pos];
449         *pos +=1;
450         channel = buf[0] & 0xf;
451 #ifdef WANT_MPU401
452         if (card_info.synth_type==SYNTH_TYPE_MIDI) {
453                 switch((buf[0]&0xf0)) {
454                  case 0x80:
455                  case 0x90:
456                  case 0xa0:
457                  case 0xb0:
458                  case 0xe0:
459                         buf[1]=data[*pos]; *pos+=1;
460                         buf[2]=data[*pos]; *pos+=1;
461                         MIDI_MESSAGE3(buf[0],buf[1],buf[2]);
462                         break;
463                  case 0xc0:
464                  case 0xd0:
465                         buf[1]=data[*pos]; *pos+=1;
466                         MIDI_MESSAGE3(buf[0],0,buf[1]);
467                         break;
468                  case 0xf0:
469                         return 1;
470                  default:
471                         return 3;
472                 }
473                 seqbuf_dump();
474                 return 0;
475         }
476 #endif
477         
478         switch((buf[0] & 0xf0))
479         {
480          case 0x80:
481                 buf[1]=data[*pos];
482                 *pos +=1;
483                 buf[2]=data[*pos];
484                 *pos +=1;
485                 stop_note((int) channel, (int) buf[1], (int) buf[2]);
486                 break;
487          case 0x90:
488                 buf[1]=data[*pos];
489                 *pos +=1;
490                 buf[2]=data[*pos];
491                 *pos +=1;
492                 if(buf[2] == 0)
493                 {
494                         stop_note((int) channel, (int) buf[1], (int) buf[2]);
495                 }
496                 else
497                 {
498                         start_note((int) channel, (int) buf[1], (int) buf[2]);
499                 }
500                 break;
501          case 0xa0:
502                 buf[1]=data[*pos];
503                 *pos +=1;
504                 buf[2]=data[*pos];
505                 *pos +=1;
506                 set_key_pressure((int) channel, (int) buf[1], (int) buf[2]);
507                 break;
508          case 0xb0:
509                 buf[1]=data[*pos];
510                 *pos +=1;
511                 buf[2]=data[*pos];
512                 *pos +=1;
513                 set_control((int) channel, (int) buf[1], (int) buf[2]);
514                 break;
515          case 0xe0:
516                 buf[1]=data[*pos];
517                 *pos +=1;
518                 buf[2]=data[*pos];
519                 *pos +=1;
520                 set_pitchbend((int) channel, (int) ((buf[2] << 7) + buf[1]));
521                 break;
522          case 0xc0:
523                 buf[1]=data[*pos];
524                 *pos +=1;
525                 set_program((int) channel, (int) buf[1] );
526                 break;
527          case 0xd0:
528                 buf[1]=data[*pos];
529                 *pos +=1;
530                 set_chn_pressure((int) channel, (int) buf[1]);
531                 break;
532          case 0xf0:
533                 return 1;
534          default:
535                 return 3;
536         }
537         seqbuf_dump();
538         return 0;
539 }
540
541 void send_ipc(char *message)
542 {
543         printf ("sendipc %s\n", message);//##########3
544         if (ipc_queue_id<0)
545         {
546                 ipc_queue_id=msgget ((key_t) ('l'<<24) | ('d'<<16) | ('e'<<8) | 's', 
547                                      IPC_CREAT | 0660);
548                 snd=malloc(sizeof(long) + 32);
549                 snd->mtype=1;
550                 player_thread=SDL_CreateThread((int (*)(void *))play_hmi, NULL);
551 //              player_pid = play_hmi();
552         }    
553         if (strlen(message) < 16)
554         {
555                 sprintf(snd->mtext,"%s",message);
556                 msgsnd(ipc_queue_id,snd,16,0);
557         }
558 }
559
560 void kill_ipc()
561 {
562 //      send_ipc("q");
563 //      kill(player_pid,SIGTERM);
564         msgctl( ipc_queue_id, IPC_RMID, 0);
565         free(snd);
566         ipc_queue_id = -1;
567 //      player_pid = 0;
568 }
569
570 int do_ipc(int qid, struct msgbuf *buf, int flags)
571 {
572         int ipc_read;
573         CFILE *fptr = NULL;
574         float last_volume = volume;
575         int l=0;
576         
577         ipc_read = msgrcv(qid,buf,16,0,flags | MSG_NOERROR);
578         
579         switch (ipc_read)
580         {
581          case -1:
582                 if (errno == ENOMSG)
583                   break;
584                 perror("IPC trouble");
585                 break;
586          case 0:
587                 break;
588          default:
589                 printf ("do_ipc %s\n", buf->mtext);//##########3
590                 switch (buf->mtext[0])
591                 {
592                 case 'v':
593                         volume = (double)(atof(buf->mtext + 1) / 128.0);
594                         printf("vol %f->%f\n", last_volume, volume);
595                         if (last_volume <= 0 && volume > 0)
596                         {
597                                 buf->mtext[0] = 'p'; // start playing again if volume raised above 0
598                                 strcpy(buf->mtext + 1, digi_last_midi_song);
599                                 // fall through to case 'p'
600                         }
601                         else if (last_volume > 0 && volume <= 0)
602                         {
603                                 strcpy(buf->mtext, "s"); // stop playing if volume reduced to 0
604                                 stop = 2;
605                                 break;
606                         }
607                         else
608                                 break;
609                 case 'p':
610                         if (buf->mtext[1])
611                         {
612                                 strcpy(digi_last_midi_song, buf->mtext + 1);
613                                 if (volume > 0)
614                                         fptr = cfopen((buf->mtext + 1), "rb");
615                         }
616                         if(fptr != NULL)
617                         {
618                                 l = cfilelength(fptr);
619                                 data=realloc(data,(size_t) l);
620                                 cfread(data, l, 1, fptr);
621                                 cfclose(fptr);
622                                 printf ("good. fpr=%p l=%i data=%p\n", fptr, l, data);//##########3
623                                 stop = 0;
624                         }
625                         else
626                         {
627                                 strcpy(buf->mtext, "s"); // not playing, thus "stop".
628                                 stop = 2;
629                         }
630                         break;
631                  case 's':
632                         stop = 2;
633                         break;
634                  case 'q':
635 //                      SDL_KillThread(player_thread);
636                         break;  
637                 }
638                 //printf("do_ipc %s ret %i\n", buf->mtext, ipc_read); // ##########3
639         }
640         
641         return ipc_read;
642 }
643
644 void play_hmi (void * arg)
645 {
646         int i;
647         int pos = 0x308;
648         int n_chunks = 0;
649         int low_dtime;
650         int low_chunk;
651         int csec, lcsec;
652 //      pid_t loc_pid;
653         int qid;
654         int ipc_read = 0;
655         int k=0;
656         
657         struct msgbuf *rcv;
658         
659         Track_info *t_info;
660
661         printf ("play_hmi\n");//#########
662         
663         stop = 0;
664         ipc_read=0;
665 //      loc_pid=fork();
666     
667 /*      switch (loc_pid)
668         {
669          case 0:
670                 break;
671          case -1:
672                 return -1;
673          default:
674                 atexit(kill_ipc);
675                 return loc_pid;
676         }*/
677         
678 //      signal(SIGTERM, my_quit);
679         rcv=malloc(sizeof(long) + 16);
680         
681         rcv->mtype=1;
682         rcv->mtext[0]='0';
683
684         qid=msgget ((key_t) ('l'<<24) | ('d'<<16) | ('e'<<8) | 's', 0660);
685         if(qid == -1)
686         {       
687                 return;
688         }
689         
690         do
691         {
692                 ipc_read=do_ipc(qid,rcv,0);
693         }
694         while(rcv->mtext[0] != 'p');
695         
696         stop=0;
697         rcv->mtext[0] = '0';
698         
699         seq_init();
700         
701         n_chunks=data[0x30];
702         
703         t_info = malloc(sizeof(Track_info)*n_chunks);
704         
705         while(1)
706         {
707                 
708                 for(i=0;i<n_chunks;i++)
709                 {
710                         t_info[i].position = pos + 12;
711                         t_info[i].status = PLAYING;
712                         t_info[i].time = get_dtime(data,&t_info[i].position);
713                         pos += (( (0xff & data[pos + 5]) << 8 ) + (0xff & data[pos + 4]));
714                 }
715
716                 lcsec = 0;
717
718                 SEQ_START_TIMER();
719                 do
720                 {
721                         low_chunk = -1;
722                         k++;
723                         i=0;
724                         do
725                         {
726                                 if (t_info[i].status == PLAYING)
727                                   low_chunk = i;
728                                 i++;
729                         }
730                         while((low_chunk <=0) && (i<n_chunks));
731                         
732                         if (low_chunk == -1)
733                           break;
734                         
735                         low_dtime = t_info[low_chunk].time;
736                         
737                         for(i=1;i<n_chunks;i++)
738                         {
739                                 if ((t_info[i].time < low_dtime) && 
740                                     (t_info[i].status == PLAYING))
741                                 {
742                                         low_dtime = t_info[i].time;
743                                         low_chunk = i;
744                                 }
745                         }
746                         
747                         if (low_dtime < 0)
748                           printf("Serious warning: d_time negative!!!!!!\n");
749                         
750                         csec = 0.86 * low_dtime;
751                         
752                         //flush sequencer buffer after 20 events
753                         if (k == 20)
754                         {
755                                 ioctl(seqfd, SNDCTL_SEQ_SYNC);
756                                 k = 0;
757                         }
758                         
759                         if (csec != lcsec) {
760                                 SEQ_WAIT_TIME(csec);
761                         }
762                         
763                         lcsec = csec;
764                         
765                         t_info[low_chunk].status = do_track_event(data,&t_info[low_chunk].position);
766                         
767                         if (t_info[low_chunk].status == 3)
768                         {
769                                 printf("Error playing data in chunk %d\n",low_chunk);
770                                 t_info[low_chunk].status = STOPPED;
771                         }
772                         
773                         if (t_info[low_chunk].status == PLAYING)
774                           t_info[low_chunk].time += get_dtime(data,&t_info[low_chunk].position);
775                         
776                         //Check if the song has reached the end
777                         stop = t_info[0].status;
778                         for(i=1;i<n_chunks;i++)
779                           stop &= t_info[i].status;
780                         
781                         if((do_ipc(qid,rcv,IPC_NOWAIT) > 0) && (rcv->mtext[0]=='p'))
782                         {
783                                 n_chunks=data[0x30];
784                                 t_info = realloc(t_info,sizeof(Track_info)*n_chunks);
785                                 stop = 1;
786                                 rcv->mtext[0] = '0';  
787                                 stop_all();
788                         }
789                 }
790                 while(!stop);
791                 SEQ_STOP_TIMER();
792                 if( stop == 2)
793                 {
794                         stop_all();         
795                         do
796                         {
797                                 ipc_read=do_ipc(qid,rcv,0);
798                         }
799                         while(rcv->mtext[0] != 'p');
800                         rcv->mtext[0] = '0';
801                         n_chunks=data[0x30];
802                         t_info = realloc(t_info,sizeof(Track_info)*n_chunks);
803                         stop = 0;
804                 }
805                 pos=0x308;
806         }
807         free(data);
808         free(t_info);
809         free(rcv);
810         
811 }
812
813 void digi_play_midi_song(char *filename, char *melodic_bank, char *drum_bank, int loop)
814 {
815         if (FindArg("-nomusic"))
816                 return;
817
818         if (!filename)
819                 send_ipc("p");
820         else
821         {
822                 char buf[128];
823                 sprintf(buf, "p%s", filename);
824                 send_ipc(buf);
825         }
826 }
827
828 void digi_set_midi_volume( int mvolume ) { 
829         char buf[128];
830         if(FindArg("-nomusic"))
831                 return;
832
833         sprintf(buf,"v%i",mvolume);
834         send_ipc(buf);
835 }