public static OpenALAudioFormat ToOpenALFormat(this AudioFormat format)
{
OpenALAudioFormat oalFormat = OpenALAudioFormat.Unknown;
if (format.Channels == 1)
{
if (format.BitsPerSample == 8)
{
oalFormat = OpenALAudioFormat.Mono8Bit;
}
else if (format.BitsPerSample == 16)
{
oalFormat = OpenALAudioFormat.Mono16Bit;
}
}
else if (format.Channels == 2)
{
if (format.BitsPerSample == 8)
{
oalFormat = OpenALAudioFormat.Stereo8Bit;
}
else if (format.BitsPerSample == 16)
{
oalFormat = OpenALAudioFormat.Stereo16Bit;
}
}
return(oalFormat);
}
public void QueuePlayback(AudioSource audioSource, byte[] data)
{
if (this.isDisposed)
{
throw new ObjectDisposedException("OpenALPlaybackProvider");
}
if (audioSource == null)
{
throw new ArgumentNullException("audioSource");
}
Stack <SourceBuffer> bufferStack;
if (!this.buffers.TryGetValue(audioSource, out bufferStack))
{
this.buffers[audioSource] = bufferStack = new Stack <SourceBuffer>();
}
lock (this.pool.SyncRoot)
{
Source source = this.pool.RequestSource(audioSource);
Tuple <float, float> gain;
if (this.gains.TryGetValue(audioSource, out gain))
{
source.Gain = gain.Item2;
}
else
{
source.Gain = this.normalGain;
}
const int bufferLen = 4;
if (data.Length == 0)
{
return;
}
if (!source.IsPlaying)
{
OpenAL.DebugFormat("{0} bound to {1} isn't playing, inserting silent buffers", audioSource, source);
RequireBuffers(bufferStack, source, bufferLen);
for (int i = 0; i < bufferLen; ++i)
{
OpenALAudioFormat format = audioSource.CodecSettings.ToOpenALFormat();
SourceBuffer wait = bufferStack.Pop();
wait.Buffer(new byte[format.GetBytes((uint)audioSource.CodecSettings.FrameSize)], format, (uint)audioSource.CodecSettings.SampleRate);
source.QueueAndPlay(wait);
}
}
RequireBuffers(bufferStack, source, 1);
SourceBuffer buffer = bufferStack.Pop();
buffer.Buffer(data, audioSource.CodecSettings.ToOpenALFormat(), (uint)audioSource.CodecSettings.SampleRate);
source.QueueAndPlay(buffer);
}
}
/// <summary>
/// Create a capture stream on given device.
/// </summary>
/// <param name="sampleRate">Audio sample rate.</param>
/// <param name="format">Capture format.</param>
/// <param name="deviceName">Name of device to capture audio from.</param>
/// <param name="bufferSizeMs">Size of the audio buffer in milliseconds.</param>
internal CaptureStream(int sampleRate, OpenALAudioFormat format, string deviceName, int bufferSizeMs)
{
if (deviceName == null)
{
throw new ArgumentNullException("deviceName");
}
var samplesPerBuffer = sampleRate / (1000 / bufferSizeMs);
_samplesPerBuffer = samplesPerBuffer;
_bytesPerSample = 1;
switch (format)
{
case OpenALAudioFormat.Mono16Bit:
_bytesPerSample = 2;
break;
case OpenALAudioFormat.Stereo8Bit:
_bytesPerSample = 2;
break;
case OpenALAudioFormat.Stereo16Bit:
_bytesPerSample = 4;
break;
}
var bufferSize = samplesPerBuffer * _bytesPerSample;
_device = API.alcCaptureOpenDevice(deviceName, (uint)sampleRate, format, bufferSize * 4);
}
public PlaybackStream OpenStream(uint sampleRate, OpenALAudioFormat format)
{
EnsureDeviceIsOpen();
var ret = new PlaybackStream(sampleRate, format, this, _context);
lock(_streams)
_streams.Add(ret);
return ret;
}
/// <summary>
/// Initializes a new OpenALAudioBuffer class.
/// </summary>
public OpenALAudioBuffer(OpenALAudioFormat format, OpenALDevice device)
{
Format = format;
Owner = device;
_locker = new object();
_audioMixer = new AudioMixer();
PlaybackState = PlaybackState.Stopped;
_source = Owner.SourcePool.RequestSource();
}
public PlaybackStream OpenStream(uint sampleRate, OpenALAudioFormat format)
{
EnsureDeviceIsOpen();
var ret = new PlaybackStream(sampleRate, format, this, _context);
lock (_streams)
_streams.Add(ret);
return(ret);
}
internal PlaybackStream(uint sampleRate, OpenALAudioFormat format, PlaybackDevice device, IntPtr context)
{
_sampleRate = sampleRate;
_format = format;
_device = device;
_context = context;
CreateSource();
Listener = new Listener(_context);
}
/// <summary>
/// Initializes a new OpenALAudioBuffer class.
/// </summary>
public OpenALAudioBuffer(OpenALAudioFormat format, OpenALDevice device)
{
Format = format;
Owner = device;
_locker = new object();
_audioMixer = new AudioMixer();
PlaybackState = PlaybackState.Stopped;
_source = Owner.SourcePool.RequestSource();
}
internal PlaybackStream(uint sampleRate, OpenALAudioFormat format, PlaybackDevice device, IntPtr context)
{
_sampleRate = sampleRate;
_format = format;
_device = device;
_context = context;
CreateSource();
Listener = new Listener(_context);
}
/// <summary>
/// Creates a new AudioBuffer.
/// </summary>
/// <param name="format">The AudioFormat.</param>
/// <returns>OpenALAudioBuffer.</returns>
internal OpenALAudioBuffer CreateAudioBuffer(OpenALAudioFormat format)
{
var audioBuffer = new OpenALAudioBuffer(format, this);
lock (_audioBuffers)
{
_audioBuffers.Add(audioBuffer);
}
return(audioBuffer);
}
public static uint GetSamplesPerSecond(this OpenALAudioFormat self, uint frequency)
{
switch (self)
{
default:
case OpenALAudioFormat.Mono8Bit:
case OpenALAudioFormat.Mono16Bit:
return(frequency);
case OpenALAudioFormat.Stereo8Bit:
case OpenALAudioFormat.Stereo16Bit:
return(frequency * 2);
}
}
public static uint GetBytesPerSample(this OpenALAudioFormat self)
{
switch (self)
{
default:
case OpenALAudioFormat.Mono8Bit:
return(1);
case OpenALAudioFormat.Mono16Bit:
case OpenALAudioFormat.Stereo8Bit:
return(2);
case OpenALAudioFormat.Stereo16Bit:
return(4);
}
}
/// <summary>
/// Opens the capture device with the specified <paramref name="frequency"/> and <paramref name="format"/>.
/// </summary>
/// <param name="frequency">The frequency to open the capture device with.</param>
/// <param name="format">The audio format to open the device with.</param>
/// <returns>Returns <c>this</c>.</returns>
public CaptureDevice Open(uint frequency, OpenALAudioFormat format)
{
ThrowIfDisposed();
OpenAL.DebugFormat("Opening capture device {0} at {1} {2}", Name, frequency, format);
this.Format = format;
this.Frequency = frequency;
uint bufferSize = format.GetBytes(format.GetSamplesPerSecond(frequency)) * 2;
this.Handle = alcCaptureOpenDevice(this.Name, frequency, format, (int)bufferSize);
OpenAL.ErrorCheck(this);
pcm = new byte[bufferSize];
return(this);
}
/// <summary>
/// Create a capture stream on given device.
/// </summary>
/// <param name="sampleRate">Audio sample rate.</param>
/// <param name="format">Capture format.</param>
/// <param name="deviceName">Name of device to capture audio from.</param>
/// <param name="bufferSizeMs">Size of the audio buffer in milliseconds.</param>
internal CaptureStream(int sampleRate, OpenALAudioFormat format, string deviceName, int bufferSizeMs)
{
if (deviceName == null) throw new ArgumentNullException("deviceName");
var samplesPerBuffer = sampleRate / (1000 / bufferSizeMs);
_samplesPerBuffer = samplesPerBuffer;
_bytesPerSample = 1;
switch (format)
{
case OpenALAudioFormat.Mono16Bit:
_bytesPerSample = 2;
break;
case OpenALAudioFormat.Stereo8Bit:
_bytesPerSample = 2;
break;
case OpenALAudioFormat.Stereo16Bit:
_bytesPerSample = 4;
break;
}
var bufferSize = samplesPerBuffer * _bytesPerSample;
_device = API.alcCaptureOpenDevice(deviceName, (uint)sampleRate, format, bufferSize * 4);
}
private static extern void alBufferData(uint bufferID, OpenALAudioFormat format, byte[] data, int byteSize, uint frequency);
public static uint GetBytes(this OpenALAudioFormat self, uint samples)
{
return(self.GetBytesPerSample() * samples);
}
internal static extern void alBufferData(uint bufferID, OpenALAudioFormat format, byte[] data, int byteSize, uint frequency);
/// <summary>
/// Open a capture stream to capture audio from the device.
/// </summary>
/// <param name="sampleRate">Audio sample rate.</param>
/// <param name="format">Audio format.</param>
/// <param name="bufferSizeMs">Buffer size in milliseconds. Read operations will provide data in mulitples of this (ie. 10ms would provide data in multiples of 10 like 10ms, 20ms, 30ms depending on how often data is read).</param>
/// <returns></returns>
public CaptureStream OpenStream(int sampleRate, OpenALAudioFormat format, int bufferSizeMs)
{
return new CaptureStream(sampleRate, format, DeviceName, bufferSizeMs);
}
/// <summary>
/// Opens the capture device with the specified <paramref name="frequency"/> and <paramref name="format"/>.
/// </summary>
/// <param name="frequency">The frequency to open the capture device with.</param>
/// <param name="format">The audio format to open the device with.</param>
/// <returns>Returns <c>this</c>.</returns>
public CaptureDevice Open(uint frequency, OpenALAudioFormat format)
{
ThrowIfDisposed();
OpenAL.DebugFormat ("Opening capture device {0} at {1} {2}", Name, frequency, format);
this.Format = format;
this.Frequency = frequency;
uint bufferSize = format.GetBytes (format.GetSamplesPerSecond (frequency)) * 2;
this.Handle = alcCaptureOpenDevice (this.Name, frequency, format, (int)bufferSize);
OpenAL.ErrorCheck (this);
pcm = new byte[bufferSize];
return this;
}
private static extern IntPtr alcCaptureOpenDevice(string deviceName, uint frequency, OpenALAudioFormat format, int bufferSize);
/// <summary>
/// Open a capture stream to capture audio from the device.
/// </summary>
/// <param name="sampleRate">Audio sample rate.</param>
/// <param name="format">Audio format.</param>
/// <param name="bufferSizeMs">Buffer size in milliseconds. Read operations will provide data in mulitples of this (ie. 10ms would provide data in multiples of 10 like 10ms, 20ms, 30ms depending on how often data is read).</param>
/// <returns></returns>
public CaptureStream OpenStream(int sampleRate, OpenALAudioFormat format, int bufferSizeMs)
{
return(new CaptureStream(sampleRate, format, DeviceName, bufferSizeMs));
}
internal static extern IntPtr alcCaptureOpenDevice(string deviceName, uint frequency, OpenALAudioFormat format, int bufferSize);
/// <summary>
/// Creates a new AudioBuffer.
/// </summary>
/// <param name="format">The AudioFormat.</param>
/// <returns>OpenALAudioBuffer.</returns>
internal OpenALAudioBuffer CreateAudioBuffer(OpenALAudioFormat format)
{
var audioBuffer = new OpenALAudioBuffer(format, this);
lock (_audioBuffers)
{
_audioBuffers.Add(audioBuffer);
}
return audioBuffer;
}
public void Buffer(byte[] data, OpenALAudioFormat format, uint frequency)
{
alBufferData(this.bufferID, format, data, data.Length, frequency);
OpenAL.ErrorCheck();
}
