source/modules/rtaudio/include/asiodrivers.cpp

   1 #include <string.h>
   2 #include "asiodrivers.h"
   3
   4 AsioDrivers* asioDrivers = 0;
   5
   6 bool loadAsioDriver(char *name);
   7
   8 bool loadAsioDriver(char *name)
   9 {
  10         if(!asioDrivers)
  11                 asioDrivers = new AsioDrivers();
  12         if(asioDrivers)
  13                 return asioDrivers->loadDriver(name);
  14         return false;
  15 }
  16
  17 //------------------------------------------------------------------------------------
  18
  19 #if MAC
  20
  21 bool resolveASIO(unsigned long aconnID);
  22
  23 AsioDrivers::AsioDrivers() : CodeFragments("ASIO Drivers", 'AsDr', 'Asio')
  24 {
  25         connID = -1;
  26         curIndex = -1;
  27 }
  28
  29 AsioDrivers::~AsioDrivers()
  30 {
  31         removeCurrentDriver();
  32 }
  33
  34 bool AsioDrivers::getCurrentDriverName(char *name)
  35 {
  36         if(curIndex >= 0)
  37                 return getName(curIndex, name);
  38         return false;
  39 }
  40
  41 long AsioDrivers::getDriverNames(char **names, long maxDrivers)
  42 {
  43         for(long i = 0; i < getNumFragments() && i < maxDrivers; i++)
  44                 getName(i, names[i]);
  45         return getNumFragments() < maxDrivers ? getNumFragments() : maxDrivers;
  46 }
  47
  48 bool AsioDrivers::loadDriver(char *name)
  49 {
  50         char dname[64];
  51         unsigned long newID;
  52
  53         for(long i = 0; i < getNumFragments(); i++)
  54         {
  55                 if(getName(i, dname) && !strcmp(name, dname))
  56                 {
  57                         if(newInstance(i, &newID))
  58                         {
  59                                 if(resolveASIO(newID))
  60                                 {
  61                                         if(connID != -1)
  62                                                 removeInstance(curIndex, connID);
  63                                         curIndex = i;
  64                                         connID = newID;
  65                                         return true;
  66                                 }
  67                         }
  68                         break;
  69                 }
  70         }
  71         return false;
  72 }
  73
  74 void AsioDrivers::removeCurrentDriver()
  75 {
  76         if(connID != -1)
  77                 removeInstance(curIndex, connID);
  78         connID = -1;
  79         curIndex = -1;
  80 }
  81
  82 //------------------------------------------------------------------------------------
  83
  84 #elif WINDOWS
  85
  86 #include "iasiodrv.h"
  87
  88 extern IASIO* theAsioDriver;
  89
  90 AsioDrivers::AsioDrivers() : AsioDriverList()
  91 {
  92         curIndex = -1;
  93 }
  94
  95 AsioDrivers::~AsioDrivers()
  96 {
  97 }
  98
  99 bool AsioDrivers::getCurrentDriverName(char *name)
 100 {
 101         if(curIndex >= 0)
 102                 return asioGetDriverName(curIndex, name, 32) == 0 ? true : false;
 103         name[0] = 0;
 104         return false;
 105 }
 106
 107 long AsioDrivers::getDriverNames(char **names, long maxDrivers)
 108 {
 109         for(long i = 0; i < asioGetNumDev() && i < maxDrivers; i++)
 110                 asioGetDriverName(i, names[i], 32);
 111         return asioGetNumDev() < maxDrivers ? asioGetNumDev() : maxDrivers;
 112 }
 113
 114 bool AsioDrivers::loadDriver(char *name)
 115 {
 116         char dname[64];
 117         char curName[64];
 118
 119         for(long i = 0; i < asioGetNumDev(); i++)
 120         {
 121                 if(!asioGetDriverName(i, dname, 32) && !strcmp(name, dname))
 122                 {
 123                         curName[0] = 0;
 124                         getCurrentDriverName(curName);  // in case we fail...
 125                         removeCurrentDriver();
 126
 127                         if(!asioOpenDriver(i, (void **)&theAsioDriver))
 128                         {
 129                                 curIndex = i;
 130                                 return true;
 131                         }
 132                         else
 133                         {
 134                                 theAsioDriver = 0;
 135                                 if(curName[0] && strcmp(dname, curName))
 136                                         loadDriver(curName);    // try restore
 137                         }
 138                         break;
 139                 }
 140         }
 141         return false;
 142 }
 143
 144 void AsioDrivers::removeCurrentDriver()
 145 {
 146         if(curIndex != -1)
 147                 asioCloseDriver(curIndex);
 148         curIndex = -1;
 149 }
 150
 151 #elif SGI || BEOS
 152
 153 #include "asiolist.h"
 154
 155 AsioDrivers::AsioDrivers()
 156         : AsioDriverList()
 157 {
 158         curIndex = -1;
 159 }
 160
 161 AsioDrivers::~AsioDrivers()
 162 {
 163 }
 164
 165 bool AsioDrivers::getCurrentDriverName(char *name)
 166 {
 167         return false;
 168 }
 169
 170 long AsioDrivers::getDriverNames(char **names, long maxDrivers)
 171 {
 172         return 0;
 173 }
 174
 175 bool AsioDrivers::loadDriver(char *name)
 176 {
 177         return false;
 178 }
 179
 180 void AsioDrivers::removeCurrentDriver()
 181 {
 182 }
 183
 184 #else
 185 #error implement me
 186 #endif