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