source/modules/rtaudio/include/asio.cpp

   1 /*
   2         Steinberg Audio Stream I/O API
   3         (c) 1996, Steinberg Soft- und Hardware GmbH
   4
   5         asio.cpp
   6
   7         asio functions entries which translate the
   8         asio interface to the asiodrvr class methods
   9 */
  10
  11 #include <string.h>
  12 #include "asiosys.h"            // platform definition
  13 #include "asio.h"
  14
  15 #if MAC
  16 #include "asiodrvr.h"
  17
  18 #pragma export on
  19
  20 AsioDriver *theAsioDriver = 0;
  21
  22 extern "C"
  23 {
  24
  25 long main()
  26 {
  27         return 'ASIO';
  28 }
  29
  30 #elif WINDOWS
  31
  32 #include "windows.h"
  33 #include "iasiodrv.h"
  34 #include "asiodrivers.h"
  35
  36 IASIO *theAsioDriver = 0;
  37 extern AsioDrivers *asioDrivers;
  38
  39 #elif SGI || SUN || BEOS || LINUX
  40 #include "asiodrvr.h"
  41 static AsioDriver *theAsioDriver = 0;
  42 #endif
  43
  44 //-----------------------------------------------------------------------------------------------------
  45 ASIOError ASIOInit(ASIODriverInfo *info)
  46 {
  47 #if MAC || SGI || SUN || BEOS || LINUX
  48         if(theAsioDriver)
  49         {
  50                 delete theAsioDriver;
  51                 theAsioDriver = 0;
  52         }
  53         info->driverVersion = 0;
  54         strcpy(info->name, "No ASIO Driver");
  55         theAsioDriver = getDriver();
  56         if(!theAsioDriver)
  57         {
  58                 strcpy(info->errorMessage, "Not enough memory for the ASIO driver!");
  59                 return ASE_NotPresent;
  60         }
  61         if(!theAsioDriver->init(info->sysRef))
  62         {
  63                 theAsioDriver->getErrorMessage(info->errorMessage);
  64                 delete theAsioDriver;
  65                 theAsioDriver = 0;
  66                 return ASE_NotPresent;
  67         }
  68         strcpy(info->errorMessage, "No ASIO Driver Error");
  69         theAsioDriver->getDriverName(info->name);
  70         info->driverVersion = theAsioDriver->getDriverVersion();
  71         return ASE_OK;
  72
  73 #else
  74
  75         info->driverVersion = 0;
  76         strcpy(info->name, "No ASIO Driver");
  77         if(theAsioDriver)       // must be loaded!
  78         {
  79                 if(!theAsioDriver->init(info->sysRef))
  80                 {
  81                         theAsioDriver->getErrorMessage(info->errorMessage);
  82                         theAsioDriver = 0;
  83                         return ASE_NotPresent;
  84                 }
  85
  86                 strcpy(info->errorMessage, "No ASIO Driver Error");
  87                 theAsioDriver->getDriverName(info->name);
  88                 info->driverVersion = theAsioDriver->getDriverVersion();
  89                 return ASE_OK;
  90         }
  91         return ASE_NotPresent;
  92
  93 #endif  // !MAC
  94 }
  95
  96 ASIOError ASIOExit(void)
  97 {
  98         if(theAsioDriver)
  99         {
 100 #if WINDOWS
 101                 asioDrivers->removeCurrentDriver();
 102 #else
 103                 delete theAsioDriver;
 104 #endif
 105         }
 106         theAsioDriver = 0;
 107         return ASE_OK;
 108 }
 109
 110 ASIOError ASIOStart(void)
 111 {
 112         if(!theAsioDriver)
 113                 return ASE_NotPresent;
 114         return theAsioDriver->start();
 115 }
 116
 117 ASIOError ASIOStop(void)
 118 {
 119         if(!theAsioDriver)
 120                 return ASE_NotPresent;
 121         return theAsioDriver->stop();
 122 }
 123
 124 ASIOError ASIOGetChannels(long *numInputChannels, long *numOutputChannels)
 125 {
 126         if(!theAsioDriver)
 127         {
 128                 *numInputChannels = *numOutputChannels = 0;
 129                 return ASE_NotPresent;
 130         }
 131         return theAsioDriver->getChannels(numInputChannels, numOutputChannels);
 132 }
 133
 134 ASIOError ASIOGetLatencies(long *inputLatency, long *outputLatency)
 135 {
 136         if(!theAsioDriver)
 137         {
 138                 *inputLatency = *outputLatency = 0;
 139                 return ASE_NotPresent;
 140         }
 141         return theAsioDriver->getLatencies(inputLatency, outputLatency);
 142 }
 143
 144 ASIOError ASIOGetBufferSize(long *minSize, long *maxSize, long *preferredSize, long *granularity)
 145 {
 146         if(!theAsioDriver)
 147         {
 148                 *minSize = *maxSize = *preferredSize = *granularity = 0;
 149                 return ASE_NotPresent;
 150         }
 151         return theAsioDriver->getBufferSize(minSize, maxSize, preferredSize, granularity);
 152 }
 153
 154 ASIOError ASIOCanSampleRate(ASIOSampleRate sampleRate)
 155 {
 156         if(!theAsioDriver)
 157                 return ASE_NotPresent;
 158         return theAsioDriver->canSampleRate(sampleRate);
 159 }
 160
 161 ASIOError ASIOGetSampleRate(ASIOSampleRate *currentRate)
 162 {
 163         if(!theAsioDriver)
 164                 return ASE_NotPresent;
 165         return theAsioDriver->getSampleRate(currentRate);
 166 }
 167
 168 ASIOError ASIOSetSampleRate(ASIOSampleRate sampleRate)
 169 {
 170         if(!theAsioDriver)
 171                 return ASE_NotPresent;
 172         return theAsioDriver->setSampleRate(sampleRate);
 173 }
 174
 175 ASIOError ASIOGetClockSources(ASIOClockSource *clocks, long *numSources)
 176 {
 177         if(!theAsioDriver)
 178         {
 179                 *numSources = 0;
 180                 return ASE_NotPresent;
 181         }
 182         return theAsioDriver->getClockSources(clocks, numSources);
 183 }
 184
 185 ASIOError ASIOSetClockSource(long reference)
 186 {
 187         if(!theAsioDriver)
 188                 return ASE_NotPresent;
 189         return theAsioDriver->setClockSource(reference);
 190 }
 191
 192 ASIOError ASIOGetSamplePosition(ASIOSamples *sPos, ASIOTimeStamp *tStamp)
 193 {
 194         if(!theAsioDriver)
 195                 return ASE_NotPresent;
 196         return theAsioDriver->getSamplePosition(sPos, tStamp);
 197 }
 198
 199 ASIOError ASIOGetChannelInfo(ASIOChannelInfo *info)
 200 {
 201         if(!theAsioDriver)
 202         {
 203                 info->channelGroup = -1;
 204                 info->type = ASIOSTInt16MSB;
 205                 strcpy(info->name, "None");
 206                 return ASE_NotPresent;
 207         }
 208         return theAsioDriver->getChannelInfo(info);
 209 }
 210
 211 ASIOError ASIOCreateBuffers(ASIOBufferInfo *bufferInfos, long numChannels,
 212         long bufferSize, ASIOCallbacks *callbacks)
 213 {
 214         if(!theAsioDriver)
 215         {
 216                 ASIOBufferInfo *info = bufferInfos;
 217                 for(long i = 0; i < numChannels; i++, info++)
 218                         info->buffers[0] = info->buffers[1] = 0;
 219                 return ASE_NotPresent;
 220         }
 221         return theAsioDriver->createBuffers(bufferInfos, numChannels, bufferSize, callbacks);
 222 }
 223
 224 ASIOError ASIODisposeBuffers(void)
 225 {
 226         if(!theAsioDriver)
 227                 return ASE_NotPresent;
 228         return theAsioDriver->disposeBuffers();
 229 }
 230
 231 ASIOError ASIOControlPanel(void)
 232 {
 233         if(!theAsioDriver)
 234                 return ASE_NotPresent;
 235         return theAsioDriver->controlPanel();
 236 }
 237
 238 ASIOError ASIOFuture(long selector, void *opt)
 239 {
 240         if(!theAsioDriver)
 241                 return ASE_NotPresent;
 242         return theAsioDriver->future(selector, opt);
 243 }
 244
 245 ASIOError ASIOOutputReady(void)
 246 {
 247         if(!theAsioDriver)
 248                 return ASE_NotPresent;
 249         return theAsioDriver->outputReady();
 250 }
 251
 252 #if MAC
 253 }       // extern "C"
 254 #pragma export off
 255 #endif
 256
 257