# libkmid Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Source Files

# deviceman.cc

    00001 /**************************************************************************
    00002
    00003     deviceman.cc  - The device manager, that hides the use of midiOut
    00004     This file is part of LibKMid 0.9.5
    00005     Copyright (C) 1997,98,99,2000  Antonio Larrosa Jimenez
    00006     LibKMid's homepage : http://www.arrakis.es/~rlarrosa/libkmid.html
    00007
    00008     This library is free software; you can redistribute it and/or
    00009     modify it under the terms of the GNU Library General Public
    00010     License as published by the Free Software Foundation; either
    00011     version 2 of the License, or (at your option) any later version.
    00012
    00013     This library is distributed in the hope that it will be useful,
    00014     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00015     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00016     Library General Public License for more details.
    00017
    00018     You should have received a copy of the GNU Library General Public License
    00019     along with this library; see the file COPYING.LIB.  If not, write to
    00020     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00021     Boston, MA 02111-1307, USA.
    00022
    00023     $Id: deviceman.cc,v 1.48.2.3 2003/06/29 21:43:02 deller Exp $
    00024
    00025     Send comments and bug fixes to Antonio Larrosa <larrosa@kde.org>
    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 //#define DEVICEMANDEBUG
    00075 //#define GENERAL_DEBUG_MESSAGES
    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)  // We are using OSS
    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       /* This could be a problem if the user don't have a synth neither,
    00228          but not having any of both things is unusual */
    00229       //    _ok=0;
    00230       //    return 1;
    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       // It must be one of those systems coolo is using :-)
    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   {  // We are using ALSA
    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     // Note: Please don't add i18n for the text below, thanks :)
    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     //ioctl(seqfd,SNDCTL_SEQ_PANIC);
    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; // ALSA
    00428
    00429 //  DEBUGPRINTF("Opening devices : ");
    00430   for (int i=0;i<n_total;i++)
    00431   {
    00432     device[i]->openDev(seqfd);
    00433 //    DEBUGPRINTF("%s ",device[i]->deviceName());
    00434   }
    00435 //  DEBUGPRINTF("\n");
    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 //    DEBUGPRINTF("DeviceMan :: ERROR : Closing devices\n");
    00441     return;
    00442   }
    00443
    00444 //  DEBUGPRINTF("Devices opened\n");
    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      DEBUGPRINTF("Closing devices : ");
    00466      if (device!=NULL) for (int i=0;i<n_total;i++)
    00467      {
    00468        device[i]->initDev();
    00469        DEBUGPRINTF("%s ",device[i]->deviceName());
    00470
    00471   //    device[i]->closeDev();
    00472   };
    00473   DEBUGPRINTF("\n");
    00474    */
    00475   close(seqfd);
    00476   seqfd=-1;
    00477 #endif
    00478 }
    00479
    00480 void DeviceManager::initDev(void)
    00481 {
    00482   if (device!=0L)
    00483   {
    00484 //    DEBUGPRINTF("Initializing devices :");
    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 //void DeviceManager::tmrSetTempo(int v)
    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 /*name the argument only if it is used*/
    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     /* If you have any problem, try removing the next 2 lines,
    00644        I though they would be useful here but the may have side effects */
    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      *   if (_seqbufptr)
    00691      *       if (write (seqfd, _seqbuf, _seqbufptr) == -1)
    00692      *       {
    00693      *           printf("Error writing to /dev/sequencer in deviceManager::seqbuf_dump\n");
    00694      *           perror ("write /dev/sequencer in seqbuf_dump\n");
    00695      *           exit (-1);
    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 }

This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:28:28 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001