00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #include "deviceman.h"
00029 #include "midiout.h"
00030 #include <stdio.h>
00031 #include <fcntl.h>
00032 #include <unistd.h>
00033 #include <sys/ioctl.h>
00034 #include <errno.h>
00035 #include "sndcard.h"
00036 #include "synthout.h"
00037 #include "fmout.h"
00038 #include "gusout.h"
00039 #include "alsaout.h"
00040 #include "midimapper.h"
00041 #include "midispec.h"
00042
00043 #ifdef HAVE_CONFIG_H
00044 #include <config.h>
00045 #endif
00046
00047 #ifdef HAVE_SYS_STAT_H
00048 #include <sys/stat.h>
00049 #endif
00050
00051 #ifdef HAVE_ALSA_ASOUNDLIB_H
00052 # define HAVE_ALSA_SUPPORT
00053 # include <alsa/asoundlib.h>
00054 #elif defined(HAVE_SYS_ASOUNDLIB_H)
00055 # define HAVE_ALSA_SUPPORT
00056 # include <sys/asoundlib.h>
00057 #else
00058 #ifdef HAVE_LIBASOUND2
00059 # define HAVE_ALSA_SUPPORT
00060 # include <sound/asound.h>
00061 # include <sound/asequencer.h>
00062 #elif defined(HAVE_LIBASOUND)
00063 # define HAVE_ALSA_SUPPORT
00064 # include <linux/asequencer.h>
00065 #endif
00066 #endif
00067
00068 #if 1
00069 #include <kinstance.h>
00070 #include <kglobal.h>
00071 #include <kconfig.h>
00072 #endif
00073
00074
00075
00076
00077 SEQ_DEFINEBUF (4096);
00078
00079 #define CONTROLTIMER
00080
00081 #ifdef GENERAL_DEBUG_MESSAGES
00082 void DEBUGPRINTF(const char *format)
00083 {
00084 printf(format);
00085 }
00086
00087 void DEBUGPRINTF(const char *format,int i)
00088 {
00089 printf(format,i);
00090 }
00091
00092 void DEBUGPRINTF(const char *format,const char *s)
00093 {
00094 printf(format,s);
00095 }
00096
00097 #else
00098
00099 void DEBUGPRINTF(const char *) { }
00100 void DEBUGPRINTF(const char *,int ) { }
00101 void DEBUGPRINTF(const char *,const char * ) { }
00102
00103 #endif
00104
00105
00106 DeviceManager::DeviceManager(int def)
00107 {
00108 #if 1
00109 if (def==-1)
00110 {
00111 KInstance *tmp_instance=0L;
00112 if (!KGlobal::_instance) tmp_instance=new KInstance("nonKDEapp");
00113 KConfig *config = new KConfig("kcmmidirc", true);
00114
00115 config->setGroup("Configuration");
00116 default_dev=config->readNumEntry("midiDevice",0);
00117 QString mapurl(config->readPathEntry("mapFilename"));
00118 if ((config->readBoolEntry("useMidiMapper", false))&&(!mapurl.isEmpty()))
00119 {
00120 mapper_tmp = new MidiMapper( mapurl.mid(mapurl.find(":")+1 ).local8Bit() );
00121 }
00122 else
00123 mapper_tmp = 0L;
00124
00125 delete config;
00126 delete tmp_instance;
00127 }
00128 else
00129 #endif
00130 {
00131 default_dev = def;
00132 mapper_tmp = 0L;
00133 }
00134
00135 initialized=0;
00136 _ok=1;
00137 alsa=false;
00138 device = 0L;
00139 m_rate=0;
00140 convertrate=10;
00141 seqfd=-1;
00142 timerstarted=0;
00143 n_midi=0;
00144 n_synths=0;
00145 n_total=0;
00146 midiinfo=0L;
00147 synthinfo=0L;
00148 for (int i=0;i<16;i++) chn2dev[i]=default_dev;
00149 }
00150
00151 DeviceManager::~DeviceManager(void)
00152 {
00153 closeDev();
00154 if (device)
00155 {
00156 for (int i=0;i<n_total;i++)
00157 delete device[i];
00158 delete[] device;
00159 device=0L;
00160 }
00161 #ifdef HAVE_OSS_SUPPORT
00162 delete[] midiinfo;
00163 delete[] synthinfo;
00164 #endif
00165 }
00166
00167 int DeviceManager::ok(void)
00168 {
00169 int r=_ok;
00170 _ok=1;
00171 return r;
00172 }
00173
00174 int DeviceManager::checkInit(void)
00175 {
00176 if (initialized==0)
00177 {
00178 int r=initManager();
00179 if (default_dev>=n_total) default_dev=0;
00180 DEBUGPRINTF("check : %d\n",r);
00181 return r;
00182 }
00183 return 0;
00184 }
00185
00186 void DeviceManager::checkAlsa(void)
00187 {
00188 #ifdef HAVE_SYS_STAT_H
00189 struct stat buf;
00190 stat("/proc/asound", &buf);
00191 if ((stat("/proc/asound", &buf) == 0 ) && (S_ISDIR(buf.st_mode)))
00192 alsa=true;
00193 else
00194 alsa=false;
00195 #else
00196 #warning "ALSA won't be found at runtime"
00197 alsa=false;
00198 #endif
00199 }
00200
00201 int DeviceManager::initManager(void)
00202 {
00203 checkAlsa();
00204
00205 if (!alsa)
00206 {
00207 #ifdef HAVE_OSS_SUPPORT
00208 n_synths=0;
00209 n_midi=0;
00210 n_total=0;
00211
00212 seqfd = open("/dev/sequencer", O_WRONLY | O_NONBLOCK, 0);
00213 if (seqfd==-1)
00214 {
00215 fprintf(stderr,"ERROR: Couldn't open /dev/sequencer to get some information\n");
00216 _ok=0;
00217 return -1;
00218 }
00219 ioctl(seqfd,SNDCTL_SEQ_NRSYNTHS,&n_synths);
00220 ioctl(seqfd,SNDCTL_SEQ_NRMIDIS,&n_midi);
00221 n_total=n_midi+n_synths;
00222
00223
00224 if (n_midi==0)
00225 {
00226 fprintf(stderr,"ERROR: There's no midi port\n");
00227
00228
00229
00230
00231 }
00232
00233 device=new MidiOut*[n_total];
00234 midiinfo=new midi_info[n_midi];
00235 synthinfo=new synth_info[n_synths];
00236
00237 int i;
00238 for (i=0;i<n_midi;i++)
00239 {
00240 midiinfo[i].device=i;
00241 if (ioctl(seqfd,SNDCTL_MIDI_INFO,&midiinfo[i])!=-1)
00242 {
00243 #ifdef GENERAL_DEBUG_MESSAGES
00244 printf("----\n");
00245 printf("Device : %d\n",i);
00246 printf("Name : %s\n",midiinfo[i].name);
00247 printf("Device type : %d\n",midiinfo[i].dev_type);
00248 #endif
00249 }
00250 device[i]=new MidiOut(i);
00251 }
00252
00253 for (i=0;i<n_synths;i++)
00254 {
00255 synthinfo[i].device=i;
00256 if (ioctl(seqfd,SNDCTL_SYNTH_INFO,&synthinfo[i])!=-1)
00257 {
00258 #ifdef GENERAL_DEBUG_MESSAGES
00259 printf("----\n");
00260 printf("Device : %d\n",i);
00261 printf("Name : %s\n",synthinfo[i].name);
00262 switch (synthinfo[i].synth_type)
00263 {
00264 case (SYNTH_TYPE_FM) : printf("FM\n");break;
00265 case (SYNTH_TYPE_SAMPLE) : printf("Sample\n");break;
00266 case (SYNTH_TYPE_MIDI) : printf("Midi\n");break;
00267 default : printf("default type\n");break;
00268 };
00269 switch (synthinfo[i].synth_subtype)
00270 {
00271 case (FM_TYPE_ADLIB) : printf("Adlib\n");break;
00272 case (FM_TYPE_OPL3) : printf("Opl3\n");break;
00273 case (MIDI_TYPE_MPU401) : printf("Mpu-401\n");break;
00274 case (SAMPLE_TYPE_GUS) : printf("Gus\n");break;
00275 default : printf("default subtype\n");break;
00276 }
00277 #endif
00278 if (synthinfo[i].synth_type==SYNTH_TYPE_FM)
00279 device[i+n_midi]=new FMOut(i,synthinfo[i].nr_voices);
00280 else if ((synthinfo[i].synth_type==SYNTH_TYPE_SAMPLE)&&
00281 (synthinfo[i].synth_subtype==SAMPLE_TYPE_GUS))
00282 device[i+n_midi]=new GUSOut(i,synthinfo[i].nr_voices);
00283 else
00284 device[i+n_midi]=new SynthOut(i);
00285 }
00286 }
00287
00288 close(seqfd);
00289 #else // There's no OSS support and ALSA wasn't detected
00290
00291
00292 n_synths=0;
00293 n_midi=0;
00294 n_total=0;
00295 device=0L;
00296 midiinfo=0L;
00297 synthinfo=0L;
00298
00299 #endif
00300
00301 }
00302 else
00303 {
00304
00305 #ifdef HAVE_ALSA_SUPPORT
00306 int client, port;
00307 #ifdef HAVE_LIBASOUND2
00308 snd_seq_t *handle=0;
00309 snd_seq_client_info_t *clienti;
00310 snd_seq_client_info_malloc(&clienti);
00311 snd_seq_port_info_t *porti;
00312 snd_seq_port_info_malloc(&porti);
00313
00314 snd_seq_open(&handle, "hw", SND_SEQ_OPEN_DUPLEX, 0);
00315 if (!handle) { printf("handle==0\n"); return -1; };
00316 snd_seq_system_info_t *info;
00317 snd_seq_system_info_malloc(&info);
00318 if (!info) { printf("info==0\n"); return -1; };
00319 snd_seq_system_info(handle, info);
00320
00321 n_total=0;
00322 n_midi=0;
00323 n_synths=0;
00324
00325 device=new MidiOut*[snd_seq_system_info_get_clients(info)*snd_seq_system_info_get_ports(info)];
00326 unsigned int k=SND_SEQ_PORT_CAP_SUBS_WRITE | SND_SEQ_PORT_CAP_WRITE ;
00327 for (client=0 ; client<snd_seq_system_info_get_clients(info) ; client++)
00328 {
00329 snd_seq_get_any_client_info(handle, client, clienti);
00330 for (port=0 ; port<snd_seq_client_info_get_num_ports(clienti) ; port++)
00331 {
00332 snd_seq_get_any_port_info(handle, client, port, porti);
00333 if (( snd_seq_port_info_get_capability(porti) & k ) == k)
00334 {
00335 device[n_midi]=new AlsaOut(n_midi,client, port, snd_seq_client_info_get_name(clienti), snd_seq_port_info_get_name(porti));
00336 n_midi++;
00337 };
00338 }
00339 }
00340 snd_seq_client_info_free(clienti);
00341 snd_seq_port_info_free(porti);
00342 snd_seq_system_info_free(info);
00343 #else
00344 snd_seq_t *handle=0;
00345 snd_seq_client_info_t clienti;
00346 snd_seq_port_info_t porti;
00347
00348 snd_seq_open(&handle, SND_SEQ_OPEN);
00349 if (!handle) { printf("handle(2)==0\n"); return -1; };
00350
00351 snd_seq_system_info_t info;
00352 info.clients=info.ports=0;
00353 snd_seq_system_info(handle, &info);
00354
00355 n_total=0;
00356 n_midi=0;
00357 n_synths=0;
00358
00359 device=new MidiOut*[info.clients*info.ports];
00360 unsigned int k=SND_SEQ_PORT_CAP_SUBS_WRITE | SND_SEQ_PORT_CAP_WRITE ;
00361 for (client=0 ; client<info.clients ; client++)
00362 {
00363 snd_seq_get_any_client_info(handle, client, &clienti);
00364 for (port=0 ; port<clienti.num_ports ; port++)
00365 {
00366 snd_seq_get_any_port_info(handle, client, port, &porti);
00367 if (( porti.capability & k ) == k)
00368 {
00369 device[n_midi]=new AlsaOut(n_midi,client, port, clienti.name, porti.name);
00370 n_midi++;
00371 };
00372 }
00373 }
00374 #endif
00375 n_total=n_midi;
00376
00377 snd_seq_close(handle);
00378 #else
00379
00380
00381
00382 fprintf(stderr,"Sorry, this KMid version was compiled without \n");
00383 fprintf(stderr,"ALSA support but you're using ALSA . \n");
00384 fprintf(stderr,"Please compile KMid for yourself or tell the people\n");
00385 fprintf(stderr,"at your Linux distribution to compile it themselves\n");
00386 #endif
00387 }
00388
00389 if (mapper_tmp!=0L) setMidiMap(mapper_tmp);
00390
00391 initialized=1;
00392
00393 return 0;
00394 }
00395
00396 void DeviceManager::openDev(void)
00397 {
00398 if (checkInit()<0)
00399 {
00400 DEBUGPRINTF("DeviceManager::openDev : Not initialized\n");
00401 _ok = 0;
00402 return;
00403 }
00404 _ok=1;
00405
00406 if (!alsa)
00407 {
00408 #ifdef HAVE_OSS_SUPPORT
00409 seqfd = open("/dev/sequencer", O_WRONLY | O_NONBLOCK, 0);
00410 if (seqfd==-1)
00411 {
00412 fprintf(stderr,"Couldn't open the MIDI sequencer device (/dev/sequencer)\n");
00413 _ok=0;
00414 return;
00415 }
00416 _seqbufptr = 0;
00417 ioctl(seqfd,SNDCTL_SEQ_RESET);
00418
00419 m_rate=0;
00420 int r=ioctl(seqfd,SNDCTL_SEQ_CTRLRATE,&m_rate);
00421 if ((r==-1)||(m_rate<=0)) m_rate=HZ;
00422
00423 convertrate=1000/m_rate;
00424
00425 #endif
00426 }
00427 else seqfd=0L;
00428
00429
00430 for (int i=0;i<n_total;i++)
00431 {
00432 device[i]->openDev(seqfd);
00433
00434 }
00435
00436 for (int i=0;i<n_total;i++) if (!device[i]->ok()) _ok=0;
00437 if (_ok==0)
00438 {
00439 for (int i=0;i<n_total;i++) device[i]->closeDev();
00440
00441 return;
00442 }
00443
00444
00445 }
00446
00447 void DeviceManager::closeDev(void)
00448 {
00449 if (alsa)
00450 {
00451 if (device)
00452 for (int i=0;i<n_total;i++)
00453 if (device[i]) device[i]->closeDev();
00454
00455 return;
00456 }
00457
00458 #ifdef HAVE_OSS_SUPPORT
00459 if (seqfd==-1) return;
00460 tmrStop();
00461 if (device)
00462 for (int i=0;i<n_total;i++)
00463 if (device[i]) device[i]->closeDev();
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475 close(seqfd);
00476 seqfd=-1;
00477 #endif
00478 }
00479
00480 void DeviceManager::initDev(void)
00481 {
00482 if (device!=0L)
00483 {
00484
00485 for (int i=0;i<n_total;i++)
00486 {
00487 device[i]->initDev();
00488 DEBUGPRINTF("%s ",device[i]->deviceName());
00489 }
00490 DEBUGPRINTF("\n");
00491 }
00492 }
00493
00494 void DeviceManager::noteOn ( uchar chn, uchar note, uchar vel )
00495 {
00496 MidiOut *midi=chntodev(chn);
00497 if (midi) midi->noteOn(chn,note,vel);
00498 }
00499 void DeviceManager::noteOff ( uchar chn, uchar note, uchar vel )
00500 {
00501 MidiOut *midi=chntodev(chn);
00502 if (midi) midi->noteOff(chn,note,vel);
00503 }
00504 void DeviceManager::keyPressure ( uchar chn, uchar note, uchar vel )
00505 {
00506 MidiOut *midi=chntodev(chn);
00507 if (midi) midi->keyPressure(chn,note,vel);
00508 }
00509 void DeviceManager::chnPatchChange ( uchar chn, uchar patch )
00510 {
00511 MidiOut *midi=chntodev(chn);
00512 if (midi) midi->chnPatchChange(chn,patch);
00513 }
00514 void DeviceManager::chnPressure ( uchar chn, uchar vel )
00515 {
00516 MidiOut *midi=chntodev(chn);
00517 if (midi) midi->chnPressure(chn,vel);
00518 }
00519 void DeviceManager::chnPitchBender ( uchar chn, uchar lsb, uchar msb )
00520 {
00521 MidiOut *midi=chntodev(chn);
00522 if (midi) midi->chnPitchBender(chn,lsb,msb);
00523 }
00524 void DeviceManager::chnController ( uchar chn, uchar ctl , uchar v )
00525 {
00526 MidiOut *midi=chntodev(chn);
00527 if (midi) midi->chnController(chn,ctl,v);
00528 }
00529 void DeviceManager::sysEx ( uchar *data,ulong size)
00530 {
00531 for (int i=0;i<n_midi;i++)
00532 device[i]->sysex(data,size);
00533 }
00534
00535 void DeviceManager::wait (double ticks)
00536 {
00537 #ifdef HAVE_ALSA_SUPPORT
00538 if (alsa) { ((AlsaOut *)device[default_dev])->wait(ticks); return; };
00539 #endif
00540
00541 #ifdef HAVE_OSS_SUPPORT
00542 unsigned long int t=(unsigned long int)(ticks/convertrate);
00543 if (lastwaittime==t) return;
00544 lastwaittime=t;
00545 SEQ_WAIT_TIME(t);
00546 SEQ_DUMPBUF();
00547 #endif
00548 }
00549
00550
00551 void DeviceManager::tmrSetTempo(int v)
00552 {
00553 #ifdef HAVE_ALSA_SUPPORT
00554 if (alsa) { ((AlsaOut *)device[default_dev])->tmrSetTempo(v); return; }
00555 #endif
00556
00557 #ifdef HAVE_OSS_SUPPORT
00558 SEQ_SET_TEMPO(v);
00559 SEQ_DUMPBUF();
00560 #endif
00561 }
00562
00563 void DeviceManager::tmrStart(long int
00564 #ifdef HAVE_ALSA_SUPPORT
00565 tpcn
00566 #endif
00567 )
00568 {
00569 #ifdef HAVE_ALSA_SUPPORT
00570 if (alsa) { ((AlsaOut *)device[default_dev])->tmrStart(tpcn); return; }
00571 #endif
00572
00573 #ifdef HAVE_OSS_SUPPORT
00574 #ifdef CONTROLTIMER
00575 if (!timerstarted)
00576 {
00577 SEQ_START_TIMER();
00578 SEQ_DUMPBUF();
00579 timerstarted=1;
00580 }
00581 lastwaittime=0;
00582 #else
00583 SEQ_START_TIMER();
00584 SEQ_DUMPBUF();
00585 #endif
00586 #endif
00587 }
00588
00589 void DeviceManager::tmrStop(void)
00590 {
00591 #ifdef HAVE_ALSA_SUPPORT
00592 if (alsa) { ((AlsaOut *)device[default_dev])->tmrStop(); return; }
00593 #endif
00594
00595 #ifdef HAVE_OSS_SUPPORT
00596 #ifdef CONTROLTIMER
00597 if (timerstarted)
00598 {
00599 SEQ_STOP_TIMER();
00600 SEQ_DUMPBUF();
00601 timerstarted=0;
00602 }
00603 #else
00604 SEQ_STOP_TIMER();
00605 SEQ_DUMPBUF();
00606 #endif
00607 #endif
00608 }
00609
00610 void DeviceManager::tmrContinue(void)
00611 {
00612 #ifdef HAVE_ALSA_SUPPORT
00613 if (alsa) { ((AlsaOut *)device[default_dev])->tmrContinue(); return; }
00614 #endif
00615
00616 #ifdef HAVE_OSS_SUPPORT
00617 #ifdef CONTROLTIMER
00618 if (timerstarted)
00619 {
00620 SEQ_CONTINUE_TIMER();
00621 SEQ_DUMPBUF();
00622 }
00623 #else
00624 SEQ_CONTINUE_TIMER();
00625 SEQ_DUMPBUF();
00626 #endif
00627 #endif
00628 }
00629
00630 void DeviceManager::sync(bool f)
00631 {
00632 #ifdef HAVE_ALSA_SUPPORT
00633 if (alsa) { ((AlsaOut *)device[default_dev])->sync(f); return ; };
00634 #endif
00635
00636 #ifdef HAVE_OSS_SUPPORT
00637 #ifdef DEVICEMANDEBUG
00638 printf("Sync %d\n",f);
00639 #endif
00640 if (f)
00641 {
00642 seqbuf_clean();
00643
00644
00645 ioctl(seqfd,SNDCTL_SEQ_RESET);
00646 ioctl(seqfd,SNDCTL_SEQ_PANIC);
00647 }
00648 else
00649 {
00650 seqbuf_dump();
00651 ioctl(seqfd, SNDCTL_SEQ_SYNC);
00652 };
00653 #endif
00654 }
00655
00656 void DeviceManager::seqbuf_dump (void)
00657 {
00658 if (!alsa)
00659 {
00660 #ifdef HAVE_OSS_SUPPORT
00661 if (_seqbufptr)
00662 {
00663 int r=0;
00664 unsigned char *sb=_seqbuf;
00665 int w=_seqbufptr;
00666 r=write (seqfd, _seqbuf, _seqbufptr);
00667 #ifdef DEVICEMANDEBUG
00668 printf("%d == %d\n",r,w);
00669 printf("%d\n",(errno==EAGAIN)? 1 : 0);
00670 #endif
00671 while (((r == -1)&&(errno==EAGAIN))||(r != w))
00672 {
00673 if ((r==-1)&&(errno==EAGAIN))
00674 {
00675 usleep(1);
00676 }
00677 else if ((r>0)&&(r!=w))
00678 {
00679 w-=r;
00680 sb+=r;
00681 }
00682 r=write (seqfd, sb, w);
00683 #ifdef DEVICEMANDEBUG
00684 printf("%d == %d\n",r,w);
00685 printf("%d\n",(errno==EAGAIN)? 1 : 0);
00686 #endif
00687 }
00688 }
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698 _seqbufptr = 0;
00699 #endif
00700 }
00701 }
00702
00703 void DeviceManager::seqbuf_clean(void)
00704 {
00705 #ifdef HAVE_ALSA_SUPPORT
00706 if (alsa)
00707 ((AlsaOut *)device[default_dev])->seqbuf_clean();
00708 else
00709 #endif
00710 #ifdef HAVE_OSS_SUPPORT
00711 _seqbufptr=0;
00712 #endif
00713 }
00714
00715
00716 const char *DeviceManager::name(int i)
00717 {
00718 #ifdef HAVE_OSS_SUPPORT
00719 if (checkInit()<0) {_ok = 0; return NULL;}
00720
00721 if (alsa)
00722 {
00723 if (i<n_midi) return device[i]->deviceName();
00724 }
00725 else
00726 {
00727 if (i<n_midi) return midiinfo[i].name;
00728 if (i<n_midi+n_synths) return synthinfo[i-n_midi].name;
00729 };
00730 #endif
00731 return (char *)"";
00732 }
00733
00734 const char *DeviceManager::type(int i)
00735 {
00736 #ifdef HAVE_OSS_SUPPORT
00737 if (checkInit()<0) {_ok = 0; return NULL;}
00738
00739 if (alsa)
00740 {
00741 if (i<n_midi) return "ALSA device";
00742 }
00743 else
00744 {
00745 if (i<n_midi)
00746 {
00747 return "External Midi Port";
00748 }
00749 if (i<n_midi+n_synths)
00750 {
00751 switch (synthinfo[i-n_midi].synth_subtype)
00752 {
00753 case (FM_TYPE_ADLIB) : return "Adlib";break;
00754 case (FM_TYPE_OPL3) : return "FM";break;
00755 case (MIDI_TYPE_MPU401) : return "MPU 401";break;
00756 case (SAMPLE_TYPE_GUS) : return "GUS";break;
00757 }
00758 }
00759 }
00760 #endif
00761 return "";
00762 }
00763
00764 int DeviceManager::defaultDevice(void)
00765 {
00766 return default_dev;
00767 }
00768
00769 void DeviceManager::setDefaultDevice(int i)
00770 {
00771 if (i>=n_total) return;
00772 default_dev=i;
00773 for (int i=0;i<16;i++) chn2dev[i]=default_dev;
00774 }
00775
00776 const char *DeviceManager::midiMapFilename(void)
00777 {
00778 if (device==0L) return "";
00779 if (default_dev>=n_total) return "";
00780 return (device[default_dev]!=NULL) ?
00781 device[default_dev]->midiMapFilename() : "";
00782 }
00783
00784 void DeviceManager::setMidiMap(MidiMapper *map)
00785 {
00786 if (map==NULL) return;
00787 mapper_tmp=map;
00788 if (default_dev>=n_total) {default_dev=0;return;};
00789 if ((device==0L)||(device[default_dev]==NULL))
00790 return;
00791 device[default_dev]->setMidiMapper(map);
00792 }
00793
00794 int DeviceManager::setPatchesToUse(int *patchesused)
00795 {
00796 if (checkInit()<0) return -1;
00797 if ((device==0L)||(device[default_dev]==NULL))
00798 return 0;
00799
00800 if ((device[default_dev]->deviceType())==KMID_GUS)
00801 {
00802 GUSOut *gus=(GUSOut *)device[default_dev];
00803 gus->setPatchesToUse(patchesused);
00804 }
00805 return 0;
00806 }
00807
00808 void DeviceManager::setVolumePercentage(int v)
00809 {
00810 if (device!=0L)
00811 {
00812 for (int i=0;i<n_total;i++)
00813 {
00814 device[i]->setVolumePercentage(v);
00815 }
00816 }
00817 }
00818
00819 void DeviceManager::setDeviceNumberForChannel(int chn, int dev)
00820 {
00821 chn2dev[chn]=dev;
00822 }
00823
00824 void DeviceManager::allNotesOff(void)
00825 {
00826 for (int i=0;i<n_midi;i++)
00827 device[i]->allNotesOff();
00828 }