[PD-cvs] pd/portaudio/pa_asio pa_asio.cpp, 1.8, 1.9 pa_asio.h, 1.8, 1.9

30 May 2005


      Update of /cvsroot/pure-data/pd/portaudio/pa_asio
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1508/pd/portaudio/pa_asio
Modified Files:
    pa_asio.cpp pa_asio.h 
Log Message:
Remembered to update all the edited files.  Should now be in sync... will
have to test it though.
Index: pa_asio.cpp
===================================================================
RCS file: /cvsroot/pure-data/pd/portaudio/pa_asio/pa_asio.cpp,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** pa_asio.cpp	18 May 2005 04:28:32 -0000	1.8
--- pa_asio.cpp	30 May 2005 03:04:07 -0000	1.9
***************
*** 286,290 ****
/* the ASIO C API only allows one ASIO driver to be open at a time,
!         so we kee track of whether we have the driver open here, and
          use this information to return errors from OpenStream if the
          driver is already open.
--- 286,290 ----
/* the ASIO C API only allows one ASIO driver to be open at a time,
!         so we keep track of whether we have the driver open here, and
          use this information to return errors from OpenStream if the
          driver is already open.
***************
*** 365,368 ****
--- 365,393 ----
  }
+ void AsioSampleTypeLOG(ASIOSampleType type)
+ {
+     switch (type) {
+         case ASIOSTInt16MSB:  PA_DEBUG(("ASIOSTInt16MSB\n"));  break;
+         case ASIOSTInt16LSB:  PA_DEBUG(("ASIOSTInt16LSB\n"));  break;
+         case ASIOSTFloat32MSB:PA_DEBUG(("ASIOSTFloat32MSB\n"));break;
+         case ASIOSTFloat32LSB:PA_DEBUG(("ASIOSTFloat32LSB\n"));break;
+         case ASIOSTFloat64MSB:PA_DEBUG(("ASIOSTFloat64MSB\n"));break;
+         case ASIOSTFloat64LSB:PA_DEBUG(("ASIOSTFloat64LSB\n"));break;
+         case ASIOSTInt32MSB:  PA_DEBUG(("ASIOSTInt32MSB\n"));  break;
+         case ASIOSTInt32LSB:  PA_DEBUG(("ASIOSTInt32LSB\n"));  break;
+         case ASIOSTInt32MSB16:PA_DEBUG(("ASIOSTInt32MSB16\n"));break;
+         case ASIOSTInt32LSB16:PA_DEBUG(("ASIOSTInt32LSB16\n"));break;
+         case ASIOSTInt32MSB18:PA_DEBUG(("ASIOSTInt32MSB18\n"));break;
+         case ASIOSTInt32MSB20:PA_DEBUG(("ASIOSTInt32MSB20\n"));break;
+         case ASIOSTInt32MSB24:PA_DEBUG(("ASIOSTInt32MSB24\n"));break;
+         case ASIOSTInt32LSB18:PA_DEBUG(("ASIOSTInt32LSB18\n"));break;
+         case ASIOSTInt32LSB20:PA_DEBUG(("ASIOSTInt32LSB20\n"));break;
+         case ASIOSTInt32LSB24:PA_DEBUG(("ASIOSTInt32LSB24\n"));break;
+         case ASIOSTInt24MSB:  PA_DEBUG(("ASIOSTInt24MSB\n"));  break;
+         case ASIOSTInt24LSB:  PA_DEBUG(("ASIOSTInt24LSB\n"));  break;
+         default:              PA_DEBUG(("Custom Format%d\n",type));break;
+ 
+     }
+ }
static int BytesPerAsioSample( ASIOSampleType sampleType )
***************
*** 868,871 ****
--- 893,898 ----
      long preferredBufferSize;
      long bufferGranularity;
+ 
+     ASIOChannelInfo *asioChannelInfos;
  }
  PaAsioDeviceInfo;
***************
*** 971,975 ****
  static ASIOSampleRate defaultSampleRateSearchOrder_[]
       = {44100.0, 48000.0, 32000.0, 24000.0, 22050.0, 88200.0, 96000.0,
!         192000.0, 16000.0, 12000.0, 11025.0, 96000.0, 8000.0 };
--- 998,1002 ----
  static ASIOSampleRate defaultSampleRateSearchOrder_[]
       = {44100.0, 48000.0, 32000.0, 24000.0, 22050.0, 88200.0, 96000.0,
!         192000.0, 16000.0, 12000.0, 11025.0, 9600.0, 8000.0 };
***************
*** 982,986 ****
      char **names;
      PaAsioDriverInfo paAsioDriverInfo;
-     ASIOChannelInfo asioChannelInfo;
asioHostApi = (PaAsioHostApiRepresentation*)PaUtil_AllocateMemory( sizeof(PaAsioHostApiRepresentation) );
--- 1009,1012 ----
***************
*** 1067,1077 ****
                  deviceInfo->name = names[i];
                  PA_DEBUG(("PaAsio_Initialize: drv:%d name = %s\n",  i,deviceInfo->name));
deviceInfo->maxInputChannels  = paAsioDriverInfo.inputChannelCount;
                  deviceInfo->maxOutputChannels = paAsioDriverInfo.outputChannelCount;
-                 PA_DEBUG(("PaAsio_Initialize: drv:%d inputChannels = %d\n", i, paAsioDriverInfo.inputChannelCount));
-                 PA_DEBUG(("PaAsio_Initialize: drv:%d outputChannels = %d\n", i, paAsioDriverInfo.outputChannelCount));
- 
                  deviceInfo->defaultSampleRate = 0.;
                  bool foundDefaultSampleRate = false;
--- 1093,1106 ----
                  deviceInfo->name = names[i];
                  PA_DEBUG(("PaAsio_Initialize: drv:%d name = %s\n",  i,deviceInfo->name));
+                 PA_DEBUG(("PaAsio_Initialize: drv:%d inputChannels       = %d\n", i, paAsioDriverInfo.inputChannelCount));
+                 PA_DEBUG(("PaAsio_Initialize: drv:%d outputChannels      = %d\n", i, paAsioDriverInfo.outputChannelCount));
+                 PA_DEBUG(("PaAsio_Initialize: drv:%d bufferMinSize       = %d\n", i, paAsioDriverInfo.bufferMinSize));
+                 PA_DEBUG(("PaAsio_Initialize: drv:%d bufferMaxSize       = %d\n", i, paAsioDriverInfo.bufferMaxSize));
+                 PA_DEBUG(("PaAsio_Initialize: drv:%d bufferPreferredSize = %d\n", i, paAsioDriverInfo.bufferPreferredSize));
+                 PA_DEBUG(("PaAsio_Initialize: drv:%d bufferGranularity   = %d\n", i, paAsioDriverInfo.bufferGranularity));
deviceInfo->maxInputChannels  = paAsioDriverInfo.inputChannelCount;
                  deviceInfo->maxOutputChannels = paAsioDriverInfo.outputChannelCount;
deviceInfo->defaultSampleRate = 0.;
                  bool foundDefaultSampleRate = false;
***************
*** 1139,1146 ****
!                 /* We assume that all channels have the same SampleType, so check the first, FIXME, probably shouldn't assume that */
!                 asioChannelInfo.channel = 0;
!                 asioChannelInfo.isInput = 1;
!                 ASIOGetChannelInfo( &asioChannelInfo );  /* FIXME, check return code */
--- 1168,1207 ----
!                 asioDeviceInfo->asioChannelInfos = (ASIOChannelInfo*)PaUtil_GroupAllocateMemory(
!                         asioHostApi->allocations,
!                         sizeof(ASIOChannelInfo) * (deviceInfo->maxInputChannels
!                                 + deviceInfo->maxOutputChannels) );
!                 if( !asioDeviceInfo->asioChannelInfos )
!                 {
!                     result = paInsufficientMemory;
!                     goto error;
!                 }
! 
!                 int a;
! 
!                 for( a=0; a < deviceInfo->maxInputChannels; ++a ){
!                     asioDeviceInfo->asioChannelInfos[a].channel = a;
!                     asioDeviceInfo->asioChannelInfos[a].isInput = ASIOTrue;
!                     ASIOError asioError = ASIOGetChannelInfo( &asioDeviceInfo->asioChannelInfos[a] );
!                     if( asioError != ASE_OK )
!                     {
!                         result = paUnanticipatedHostError;
!                         PA_ASIO_SET_LAST_ASIO_ERROR( asioError );
!                         goto error;
!                     }
!                 }
! 
!                 for( a=0; a < deviceInfo->maxOutputChannels; ++a ){
!                     int b = deviceInfo->maxInputChannels + a;
!                     asioDeviceInfo->asioChannelInfos[b].channel = a;
!                     asioDeviceInfo->asioChannelInfos[b].isInput = ASIOFalse;
!                     ASIOError asioError = ASIOGetChannelInfo( &asioDeviceInfo->asioChannelInfos[b] );
!                     if( asioError != ASE_OK )
!                     {
!                         result = paUnanticipatedHostError;
!                         PA_ASIO_SET_LAST_ASIO_ERROR( asioError );
!                         goto error;
!                     }
!                 }
***************
*** 1257,1262 ****
/* validate inputStreamInfo */
!         if( inputParameters->hostApiSpecificStreamInfo )
!             return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
      }
      else
--- 1318,1324 ----
/* validate inputStreamInfo */
!         /** @todo do more validation here */
!         // if( inputParameters->hostApiSpecificStreamInfo )
!         //    return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
      }
      else
***************
*** 1284,1289 ****
/* validate outputStreamInfo */
!         if( outputParameters->hostApiSpecificStreamInfo )
!             return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
      }
      else
--- 1346,1352 ----
/* validate outputStreamInfo */
!         /** @todo do more validation here */
!         // if( outputParameters->hostApiSpecificStreamInfo )
!         //    return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
      }
      else
***************
*** 1448,1452 ****
while( result < suggestedLatencyFrames )
!                     result *= result;
if( result < (unsigned long)driverInfo->bufferMinSize )
--- 1511,1515 ----
while( result < suggestedLatencyFrames )
!                     result *= 2;
if( result < (unsigned long)driverInfo->bufferMinSize )
***************
*** 1492,1495 ****
--- 1555,1592 ----
+ /* returns channelSelectors if present */
+ 
+ static PaError ValidateAsioSpecificStreamInfo(
+         const PaStreamParameters *streamParameters,
+         const PaAsioStreamInfo *streamInfo,
+         int deviceChannelCount,
+         int **channelSelectors )
+ {
+ 	if( streamInfo )
+ 	{
+ 	    if( streamInfo->size != sizeof( PaAsioStreamInfo )
+ 	            || streamInfo->version != 1 )
+ 	    {
+ 	        return paIncompatibleHostApiSpecificStreamInfo;
+ 	    }
+ 
+ 	    if( streamInfo->flags & paAsioUseChannelSelectors )
+             *channelSelectors = streamInfo->channelSelectors;
+ 
+         if( !(*channelSelectors) )
+             return paIncompatibleHostApiSpecificStreamInfo;
+ 
+         for( int i=0; i < streamParameters->channelCount; ++i ){
+              if( (*channelSelectors)[i] < 0
+                     || (*channelSelectors)[i] >= deviceChannelCount ){
+                 return paInvalidChannelCount;
+              }           
+         }
+ 	}
+ 
+ 	return paNoError;
+ }
+ 
+ 
  /* see pa_hostapi.h for a list of validity guarantees made about OpenStream  parameters */
***************
*** 1507,1510 ****
--- 1604,1608 ----
      PaAsioHostApiRepresentation *asioHostApi = (PaAsioHostApiRepresentation*)hostApi;
      PaAsioStream *stream = 0;
+     PaAsioStreamInfo *inputStreamInfo, *outputStreamInfo;
      unsigned long framesPerHostBuffer;
      int inputChannelCount, outputChannelCount;
***************
*** 1520,1528 ****
      int i;
      PaAsioDriverInfo *driverInfo;
/* unless we move to using lower level ASIO calls, we can only have
          one device open at a time */
!     if( asioHostApi->openAsioDeviceIndex != paNoDevice )
          return paDeviceUnavailable;
if( inputParameters && outputParameters )
--- 1618,1630 ----
      int i;
      PaAsioDriverInfo *driverInfo;
+     int *inputChannelSelectors = 0;
+     int *outputChannelSelectors = 0;
/* unless we move to using lower level ASIO calls, we can only have
          one device open at a time */
!     if( asioHostApi->openAsioDeviceIndex != paNoDevice ){
!         PA_DEBUG(("OpenStream paDeviceUnavailable\n"));
          return paDeviceUnavailable;
+     }
if( inputParameters && outputParameters )
***************
*** 1530,1536 ****
          /* full duplex ASIO stream must use the same device for input and output */
!         if( inputParameters->device != outputParameters->device )
              return paBadIODeviceCombination;
      }
if( inputParameters )
--- 1632,1640 ----
          /* full duplex ASIO stream must use the same device for input and output */
!         if( inputParameters->device != outputParameters->device ){
!             PA_DEBUG(("OpenStream paBadIODeviceCombination\n"));
              return paBadIODeviceCombination;
      }
+     }
if( inputParameters )
***************
*** 1538,1544 ****
          inputChannelCount = inputParameters->channelCount;
          inputSampleFormat = inputParameters->sampleFormat;
!         suggestedInputLatencyFrames = (unsigned long)(inputParameters->suggestedLatency * sampleRate);
! 
!         asioDeviceIndex = inputParameters->device;
/* unless alternate device specification is supported, reject the use of
--- 1642,1646 ----
          inputChannelCount = inputParameters->channelCount;
          inputSampleFormat = inputParameters->sampleFormat;
!         suggestedInputLatencyFrames = (unsigned long)((inputParameters->suggestedLatency * sampleRate)+0.5f);
/* unless alternate device specification is supported, reject the use of
***************
*** 1547,1553 ****
              return paInvalidDevice;
/* validate hostApiSpecificStreamInfo */
!         if( inputParameters->hostApiSpecificStreamInfo )
!             return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
      }
      else
--- 1649,1663 ----
              return paInvalidDevice;
+         asioDeviceIndex = inputParameters->device;
+ 
+         PaAsioDeviceInfo *asioDeviceInfo = (PaAsioDeviceInfo*)hostApi->deviceInfos[asioDeviceIndex];
+ 
          /* validate hostApiSpecificStreamInfo */
!         inputStreamInfo = (PaAsioStreamInfo*)inputParameters->hostApiSpecificStreamInfo;
!         result = ValidateAsioSpecificStreamInfo( inputParameters, inputStreamInfo,
!             asioDeviceInfo->commonDeviceInfo.maxInputChannels,
!             &inputChannelSelectors
!         );
!         if( result != paNoError ) return result;
      }
      else
***************
*** 1562,1568 ****
          outputChannelCount = outputParameters->channelCount;
          outputSampleFormat = outputParameters->sampleFormat;
!         suggestedOutputLatencyFrames = (unsigned long)(outputParameters->suggestedLatency * sampleRate);
! 
!         asioDeviceIndex = outputParameters->device;
/* unless alternate device specification is supported, reject the use of
--- 1672,1676 ----
          outputChannelCount = outputParameters->channelCount;
          outputSampleFormat = outputParameters->sampleFormat;
!         suggestedOutputLatencyFrames = (unsigned long)((outputParameters->suggestedLatency * sampleRate)+0.5f);
/* unless alternate device specification is supported, reject the use of
***************
*** 1571,1577 ****
              return paInvalidDevice;
/* validate hostApiSpecificStreamInfo */
!         if( outputParameters->hostApiSpecificStreamInfo )
!             return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
      }
      else
--- 1679,1693 ----
              return paInvalidDevice;
+         asioDeviceIndex = outputParameters->device;
+ 
+         PaAsioDeviceInfo *asioDeviceInfo = (PaAsioDeviceInfo*)hostApi->deviceInfos[asioDeviceIndex];
+ 
          /* validate hostApiSpecificStreamInfo */
!         outputStreamInfo = (PaAsioStreamInfo*)outputParameters->hostApiSpecificStreamInfo;
!         result = ValidateAsioSpecificStreamInfo( outputParameters, outputStreamInfo,
!             asioDeviceInfo->commonDeviceInfo.maxOutputChannels,
!             &outputChannelSelectors
!         );
!         if( result != paNoError ) return result;
      }
      else
***************
*** 1591,1596 ****
      if( result == paNoError )
          asioIsInitialized = 1;
!     else
          goto error;
/* check that input device can support inputChannelCount */
--- 1707,1714 ----
      if( result == paNoError )
          asioIsInitialized = 1;
!     else{
!         PA_DEBUG(("OpenStream ERROR1\n"));
          goto error;
+     }
/* check that input device can support inputChannelCount */
***************
*** 1600,1603 ****
--- 1718,1722 ----
          {
              result = paInvalidChannelCount;
+             PA_DEBUG(("OpenStream ERROR2\n"));
              goto error;
          }
***************
*** 1610,1624 ****
          {
              result = paInvalidChannelCount;
              goto error;
          }
      }
/* Set sample rate */
!     if( ASIOSetSampleRate( sampleRate ) != ASE_OK )
      {
          result = paInvalidSampleRate;
          goto error;
      }
! 
      /*
          IMPLEMENT ME:
--- 1729,1747 ----
          {
              result = paInvalidChannelCount;
+             PA_DEBUG(("OpenStream ERROR3\n"));
              goto error;
          }
      }
+     PA_DEBUG(("before ASIOSetSampleRate(%f)\n",sampleRate));
+     asioError = ASIOSetSampleRate( sampleRate );
      /* Set sample rate */
!     if( asioError != ASE_OK )
      {
          result = paInvalidSampleRate;
+         PA_DEBUG(("ERROR: ASIOSetSampleRate: %s\n", PaAsio_GetAsioErrorText(asioError) ));
          goto error;
      }
!     PA_DEBUG(("after ASIOSetSampleRate(%f)\n",sampleRate));
      /*
          IMPLEMENT ME:
***************
*** 1628,1633 ****
/* validate platform specific flags */
!     if( (streamFlags & paPlatformSpecificFlags) != 0 )
          return paInvalidFlag; /* unexpected platform specific flag */
--- 1751,1758 ----
/* validate platform specific flags */
!     if( (streamFlags & paPlatformSpecificFlags) != 0 ){
!         PA_DEBUG(("OpenStream invalid flags!!\n"));
          return paInvalidFlag; /* unexpected platform specific flag */
+     }
***************
*** 1636,1639 ****
--- 1761,1765 ----
      {
          result = paInsufficientMemory;
+         PA_DEBUG(("OpenStream ERROR5\n"));
          goto error;
      }
***************
*** 1644,1647 ****
--- 1770,1774 ----
          result = paUnanticipatedHostError;
          PA_ASIO_SET_LAST_SYSTEM_ERROR( GetLastError() );
+         PA_DEBUG(("OpenStream ERROR6\n"));
          goto error;
      }
***************
*** 1673,1676 ****
--- 1800,1804 ----
      {
          result = paInsufficientMemory;
+         PA_DEBUG(("OpenStream ERROR7\n"));
          goto error;
      }
***************
*** 1682,1686 ****
info->isInput = ASIOTrue;
!         info->channelNum = i;
          info->buffers[0] = info->buffers[1] = 0;
      }
--- 1810,1822 ----
info->isInput = ASIOTrue;
! 
!         if( inputChannelSelectors ){
!             // inputChannelSelectors values have already been validated in
!             // ValidateAsioSpecificStreamInfo() above
!             info->channelNum = inputChannelSelectors[i];
!         }else{
!             info->channelNum = i;
!         }
! 
          info->buffers[0] = info->buffers[1] = 0;
      }
***************
*** 1690,1694 ****
info->isInput = ASIOFalse;
!         info->channelNum = i;
          info->buffers[0] = info->buffers[1] = 0;
      }
--- 1826,1838 ----
info->isInput = ASIOFalse;
! 
!         if( outputChannelSelectors ){
!             // outputChannelSelectors values have already been validated in
!             // ValidateAsioSpecificStreamInfo() above
!             info->channelNum = outputChannelSelectors[i];
!         }else{
!             info->channelNum = i;
!         }
!         
          info->buffers[0] = info->buffers[1] = 0;
      }
***************
*** 1700,1703 ****
--- 1844,1850 ----
              driverInfo );
+ 
+ 	PA_DEBUG(("PaAsioOpenStream: framesPerHostBuffer :%d\n",  framesPerHostBuffer));
+ 
      asioError = ASIOCreateBuffers( stream->asioBufferInfos,
              inputChannelCount+outputChannelCount,
***************
*** 1707,1710 ****
--- 1854,1858 ----
              && framesPerHostBuffer != (unsigned long)driverInfo->bufferPreferredSize )
      {
+         PA_DEBUG(("ERROR: ASIOCreateBuffers: %s\n", PaAsio_GetAsioErrorText(asioError) ));
          /*
              Some buggy drivers (like the Hoontech DSP24) give incorrect
***************
*** 1716,1719 ****
--- 1864,1869 ----
          framesPerHostBuffer = driverInfo->bufferPreferredSize;
+         PA_DEBUG(("PaAsioOpenStream: CORRECTED framesPerHostBuffer :%d\n",  framesPerHostBuffer));
+ 
          ASIOError asioError2 = ASIOCreateBuffers( stream->asioBufferInfos,
                  inputChannelCount+outputChannelCount,
***************
*** 1727,1730 ****
--- 1877,1881 ----
          result = paUnanticipatedHostError;
          PA_ASIO_SET_LAST_ASIO_ERROR( asioError );
+         PA_DEBUG(("OpenStream ERROR9\n"));
          goto error;
      }
***************
*** 1737,1740 ****
--- 1888,1892 ----
      {
          result = paInsufficientMemory;
+         PA_DEBUG(("OpenStream ERROR10\n"));
          goto error;
      }
***************
*** 1749,1752 ****
--- 1901,1905 ----
              result = paUnanticipatedHostError;
              PA_ASIO_SET_LAST_ASIO_ERROR( asioError );
+             PA_DEBUG(("OpenStream ERROR11\n"));
              goto error;
          }
***************
*** 1758,1761 ****
--- 1911,1915 ----
      {
          result = paInsufficientMemory;
+         PA_DEBUG(("OpenStream ERROR12\n"));
          goto error;
      }
***************
*** 1800,1803 ****
--- 1954,1959 ----
          ASIOSampleType inputType = stream->asioChannelInfos[0].type;
+         PA_DEBUG(("ASIO Input  type:%d",inputType));
+         AsioSampleTypeLOG(inputType);
          hostInputSampleFormat = AsioSampleTypeToPaNativeSampleFormat( inputType );
***************
*** 1815,1818 ****
--- 1971,1976 ----
          ASIOSampleType outputType = stream->asioChannelInfos[inputChannelCount].type;
+         PA_DEBUG(("ASIO Output type:%d",outputType));
+         AsioSampleTypeLOG(outputType);
          hostOutputSampleFormat = AsioSampleTypeToPaNativeSampleFormat( outputType );
***************
*** 1831,1836 ****
                      framesPerHostBuffer, paUtilFixedHostBufferSize,
                      streamCallback, userData );
!     if( result != paNoError )
          goto error;
--- 1989,1996 ----
                      framesPerHostBuffer, paUtilFixedHostBufferSize,
                      streamCallback, userData );
!     if( result != paNoError ){
!         PA_DEBUG(("OpenStream ERROR13\n"));
          goto error;
+     }
***************
*** 1846,1856 ****
// the code below prints the ASIO latency which doesn't include the
!     // buffer processor latency.
!     PA_DEBUG(("PaAsio : ASIO InputLatency = %ld latency = %ld msec \n",
              stream->inputLatency,
!             (long)((stream->inputLatency*1000)/ sampleRate)));
!     PA_DEBUG(("PaAsio : ASIO OuputLatency = %ld latency = %ld msec \n",
              stream->outputLatency,
!             (long)((stream->outputLatency*1000)/ sampleRate)));
stream->asioHostApi = asioHostApi;
--- 2006,2023 ----
// the code below prints the ASIO latency which doesn't include the
!     // buffer processor latency. it reports the added latency separately
!     PA_DEBUG(("PaAsio : ASIO InputLatency = %ld (%ld ms), added buffProc:%ld (%ld ms)\n",
              stream->inputLatency,
!             (long)((stream->inputLatency*1000)/ sampleRate),  
!             PaUtil_GetBufferProcessorInputLatency(&stream->bufferProcessor),
!             (long)((PaUtil_GetBufferProcessorInputLatency(&stream->bufferProcessor)*1000)/ sampleRate)
!             ));
! 
!     PA_DEBUG(("PaAsio : ASIO OuputLatency = %ld (%ld ms), added buffProc:%ld (%ld ms)\n",
              stream->outputLatency,
!             (long)((stream->outputLatency*1000)/ sampleRate), 
!             PaUtil_GetBufferProcessorOutputLatency(&stream->bufferProcessor),
!             (long)((PaUtil_GetBufferProcessorOutputLatency(&stream->bufferProcessor)*1000)/ sampleRate)
!             ));
stream->asioHostApi = asioHostApi;
***************
*** 2130,2136 ****
                  // clock as timeGetTime
                  paTimeInfo.currentTime = (ASIO64toDouble( timeInfo->timeInfo.systemTime ) * .000000001);
                  paTimeInfo.inputBufferAdcTime = paTimeInfo.currentTime - theAsioStream->streamRepresentation.streamInfo.inputLatency;
                  paTimeInfo.outputBufferDacTime = paTimeInfo.currentTime + theAsioStream->streamRepresentation.streamInfo.outputLatency;
! 
  #if 1
  // detect underflows by checking inter-callback time > 2 buffer period
--- 2297,2312 ----
                  // clock as timeGetTime
                  paTimeInfo.currentTime = (ASIO64toDouble( timeInfo->timeInfo.systemTime ) * .000000001);
+ 
+                 /* patch from Paul Boege */
+                 paTimeInfo.inputBufferAdcTime = paTimeInfo.currentTime -
+                     ((double)theAsioStream->inputLatency/theAsioStream->streamRepresentation.streamInfo.sampleRate);
+ 
+                 paTimeInfo.outputBufferDacTime = paTimeInfo.currentTime +
+                     ((double)theAsioStream->outputLatency/theAsioStream->streamRepresentation.streamInfo.sampleRate);
+ 
+                 /* old version is buggy because the buffer processor also adds in its latency to the time parameters
                  paTimeInfo.inputBufferAdcTime = paTimeInfo.currentTime - theAsioStream->streamRepresentation.streamInfo.inputLatency;
                  paTimeInfo.outputBufferDacTime = paTimeInfo.currentTime + theAsioStream->streamRepresentation.streamInfo.outputLatency;
!                 */
  #if 1
  // detect underflows by checking inter-callback time > 2 buffer period
***************
*** 2219,2223 ****
                      theAsioStream->stopProcessing = true;
!                     if( PaUtil_IsBufferProcessorOuputEmpty( &theAsioStream->bufferProcessor ) )
                      {
                          theAsioStream->zeroOutput = true;
--- 2395,2399 ----
                      theAsioStream->stopProcessing = true;
!                     if( PaUtil_IsBufferProcessorOutputEmpty( &theAsioStream->bufferProcessor ) )
                      {
                          theAsioStream->zeroOutput = true;
***************
*** 2246,2249 ****
--- 2422,2426 ----
(void) sRate; /* unused parameter */
+     PA_DEBUG( ("sampleRateChanged : %d \n", sRate));
  }
***************
*** 2257,2260 ****
--- 2434,2439 ----
      (void) opt;
+     PA_DEBUG( ("asioMessages : %d , %d \n", selector, value));
+ 
      switch(selector)
      {
***************
*** 2655,2656 ****
--- 2834,2901 ----
  }
+ 
+ PaError PaAsio_GetInputChannelName( PaDeviceIndex device, int channelIndex,
+         const char** channelName )
+ {
+     PaError result = paNoError;
+     PaUtilHostApiRepresentation *hostApi;
+     PaDeviceIndex hostApiDevice;
+     PaAsioDeviceInfo *asioDeviceInfo;
+ 
+ 
+     result = PaUtil_GetHostApiRepresentation( &hostApi, paASIO );
+     if( result != paNoError )
+         goto error;
+ 
+     result = PaUtil_DeviceIndexToHostApiDeviceIndex( &hostApiDevice, device, hostApi );
+     if( result != paNoError )
+         goto error;
+ 
+     asioDeviceInfo = (PaAsioDeviceInfo*)hostApi->deviceInfos[hostApiDevice];
+ 
+     if( channelIndex < 0 || channelIndex >= asioDeviceInfo->commonDeviceInfo.maxInputChannels ){
+         result = paInvalidChannelCount;
+         goto error;
+     }
+ 
+     *channelName = asioDeviceInfo->asioChannelInfos[channelIndex].name;
+ 
+     return paNoError;
+     
+ error:
+     return result;
+ }
+ 
+ 
+ PaError PaAsio_GetOutputChannelName( PaDeviceIndex device, int channelIndex,
+         const char** channelName )
+ {
+     PaError result = paNoError;
+     PaUtilHostApiRepresentation *hostApi;
+     PaDeviceIndex hostApiDevice;
+     PaAsioDeviceInfo *asioDeviceInfo;
+ 
+ 
+     result = PaUtil_GetHostApiRepresentation( &hostApi, paASIO );
+     if( result != paNoError )
+         goto error;
+ 
+     result = PaUtil_DeviceIndexToHostApiDeviceIndex( &hostApiDevice, device, hostApi );
+     if( result != paNoError )
+         goto error;
+ 
+     asioDeviceInfo = (PaAsioDeviceInfo*)hostApi->deviceInfos[hostApiDevice];
+ 
+     if( channelIndex < 0 || channelIndex >= asioDeviceInfo->commonDeviceInfo.maxOutputChannels ){
+         result = paInvalidChannelCount;
+         goto error;
+     }
+ 
+     *channelName = asioDeviceInfo->asioChannelInfos[
+             asioDeviceInfo->commonDeviceInfo.maxInputChannels + channelIndex].name;
+ 
+     return paNoError;
+     
+ error:
+     return result;
+ }
Index: pa_asio.h
===================================================================
RCS file: /cvsroot/pure-data/pd/portaudio/pa_asio/pa_asio.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** pa_asio.h	18 May 2005 04:28:33 -0000	1.8
--- pa_asio.h	30 May 2005 03:04:08 -0000	1.9
***************
*** 73,76 ****
--- 73,119 ----
+ 
+ 
+ /** Retrieve a pointer to a string containing the name of the specified
+  input channel. The string is valid until Pa_Terminate is called.
+ 
+  The string will be no longer than 32 characters including the null terminator.
+ */
+ PaError PaAsio_GetInputChannelName( PaDeviceIndex device, int channelIndex,
+         const char** channelName );
+ 
+         
+ /** Retrieve a pointer to a string containing the name of the specified
+  input channel. The string is valid until Pa_Terminate is called.
+ 
+  The string will be no longer than 32 characters including the null terminator.
+ */
+ PaError PaAsio_GetOutputChannelName( PaDeviceIndex device, int channelIndex,
+         const char** channelName );
+ 
+ 
+ #define paAsioUseChannelSelectors      (0x01)
+ 
+ typedef struct PaAsioStreamInfo{
+     unsigned long size;             /**< sizeof(PaAsioStreamInfo) */
+     PaHostApiTypeId hostApiType;    /**< paASIO */
+     unsigned long version;          /**< 1 */
+ 
+     unsigned long flags;
+ 
+     /* Support for opening only specific channels of an ASIO device.
+         If the paAsioUseChannelSelectors flag is set, channelSelectors is a
+         pointer to an array of integers specifying the device channels to use.
+         When used, the length of the channelSelectors array must match the
+         corresponding channelCount parameter to Pa_OpenStream() otherwise a
+         crash may result.
+         The values in the selectors array must specify channels within the
+         range of supported channels for the device or paInvalidChannelCount will
+         result.
+     */
+     int *channelSelectors;
+ }PaAsioStreamInfo;
+ 
+ 
  #ifdef __cplusplus
  }

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

[PD-cvs] pd/portaudio/pa_asio pa_asio.cpp, 1.8, 1.9 pa_asio.h, 1.8, 1.9