ASIOPROC Delegate

public delegate int ASIOPROC(
	bool input,
	int channel,
	IntPtr buffer,
	int length,
	IntPtr user
)

Public Delegate Function ASIOPROC ( 
	input As Boolean,
	channel As Integer,
	buffer As IntPtr,
	length As Integer,
	user As IntPtr
) As Integer

int stream = Bass.BASS_StreamCreateFile(fileName, 0, 0, 
                  BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT);
if (stream != 0)
{
  // now setup ASIO
  _myAsioProc = new ASIOPROC(AsioCallback);
  // get the stream channel info
  BASS_CHANNELINFO info = Bass.BASS_ChannelGetInfo(stream);
  // enable 1st output channel...(0=first)
  BassAsio.BASS_ASIO_ChannelEnable(false, 0, _myAsioProc, new IntPtr(stream));
  // and join the next channels to it
  for (int a=1; a<info.chans; a++)
    BassAsio.BASS_ASIO_ChannelJoin(false, a, 0);
  // since we joined the channels, the next commands will apply to all channles joined
  // so setting the values to the first channels changes them all automatically
  // set the source format (float, as the decoding channel is)
  BassAsio.BASS_ASIO_ChannelSetFormat(false, 0, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT);
  // set the source rate
  BassAsio.BASS_ASIO_ChannelSetRate(false, 0, (double)info.freq);
  // try to set the device rate too (saves resampling)
  BassAsio.BASS_ASIO_SetRate( (double)info.freq );
  // and start playing it...start output using default buffer/latency
  BassAsio.BASS_ASIO_Start(0);
}
...
private ASIOPROC _myAsioProc; // make it global, so that it can not be removed by the GC
private int AsioCallback(bool input, int channel, IntPtr buffer, int length, IntPtr user)
{
  // Note: 'user' contains the underlying stream channel (see above)
  // We can simply use the bass method to get some data from a decoding channel 
  // and store it to the asio buffer in the same moment...
  return Bass.BASS_ChannelGetData(user.ToInt32(), buffer, length);
}

Dim stream As Integer = Bass.BASS_StreamCreateFile(fileName, 0, 0, 
                             BASSFlag.BASS_STREAM_DECODE Or BASSFlag.BASS_SAMPLE_FLOAT)
If stream <> 0 Then
  ' now setup ASIO
  _myAsioProc = New ASIOPROC(AsioCallback)
  ' get the stream channel info
  Dim info As BASS_CHANNELINFO = Bass.BASS_ChannelGetInfo(stream)
  ' enable 1st output channel...(0=first)
  BassAsio.BASS_ASIO_ChannelEnable(False, 0, _myAsioProc, New IntPtr(stream))
  ' and join the next channels to it
  Dim a As Integer
  For a = 1 To info.chans - 1
    BassAsio.BASS_ASIO_ChannelJoin(False, a, 0)
  Next a
  ' since we joined the channels, the next commands will apply to all channles joined
  ' so setting the values to the first channels changes them all automatically
  ' set the source format (float, as the decoding channel is)
  BassAsio.BASS_ASIO_ChannelSetFormat(False, 0, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT)
  ' set the source rate
  BassAsio.BASS_ASIO_ChannelSetRate(False, 0, CDbl(info.freq))
  ' try to set the device rate too (saves resampling)
  BassAsio.BASS_ASIO_SetRate(CDbl(info.freq))
  ' and start playing it...start output using default buffer/latency
  BassAsio.BASS_ASIO_Start(0)
End If
...
Private _myAsioProc As ASIOPROC ' make it global, so that it can not be removed by the GC
Private Function AsioCallback(input As Boolean, channel As Integer, 
                              buffer As IntPtr, length As Integer, user As IntPtr) As Integer
  ' Note: 'user' contains the underlying stream channel (see above)
  ' We can simply use the bass method to get some data from a decoding channel 
  ' and store it to the asio buffer in the same moment...
  Return Bass.BASS_ChannelGetData(user.ToInt32(), buffer, length)
End Function

private byte[] _fullDuplexAsioBuffer;
private int _numchans = 2;

private void SetFullDuplex()
{
    BASS_ASIO_INFO info = BassAsio.BASS_ASIO_GetInfo();
    _fullDuplexAsioBuffer = new byte[info.bufmax * _numchans * 4];
    ...
}

private int AsioToAsioFullDuplexCallback(bool input, int channel, IntPtr buffer, int length, IntPtr user)
{
    if (input)
    {
        if (_fullDuplexAsioBuffer.Length < length)
            _fullDuplexAsioBuffer = new byte[length];
        Marshal.Copy(buffer, _fullDuplexAsioBuffer, 0, length);
        return 0;
    }
    else
    {
        if (length > _fullDuplexAsioBuffer.Length)
            length = _fullDuplexAsioBuffer.Length;
        Marshal.Copy(_fullDuplexAsioBuffer, 0, buffer, length);
        return length;
    }
}

Private _fullDuplexAsioBuffer As Byte()
Private _numchans As Integer = 2

Private Sub SetFullDuplex() 
    Dim info As BASS_ASIO_INFO = BassAsio.BASS_ASIO_GetInfo() 
    _fullDuplexAsioBuffer = New Byte(info.bufmax * _numchans * 4 - 1) {}
    ...
End Sub 

Private Function AsioToAsioFullDuplexCallback(ByVal input As Boolean, ByVal channel As Integer, 
                                              ByVal buffer As IntPtr, ByVal length As Integer, 
                                              ByVal user As IntPtr) As Integer 
    If input Then 
        If _fullDuplexAsioBuffer.Length < length Then
           _fullDuplexAsioBuffer = New Byte(length - 1) {} 
        End If 
        Marshal.Copy(buffer, _fullDuplexAsioBuffer, 0, length) 
        Return 0 
    Else 
        If length > _fullDuplexAsioBuffer.Length Then 
           length = _fullDuplexAsioBuffer.Length 
        End If 
        Marshal.Copy(_fullDuplexAsioBuffer, 0, buffer, length) 
        Return length 
    End If 
End Function