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