public void Pause()
{
OpenAL.DebugFormat("Pausing source {0}", this.sourceID);
alSourcePause(this.sourceID);
OpenAL.ErrorCheck();
}
public static SourceBuffer[] Generate(int count)
{
OpenAL.DebugFormat("Generating {0} source buffers", count);
lock (lck)
{
if (Buffers == null)
{
Buffers = new Dictionary <uint, SourceBuffer> (count);
}
SourceBuffer[] buffers = new SourceBuffer[count];
uint[] bufferIDs = new uint[count];
alGenBuffers(count, bufferIDs);
OpenAL.ErrorCheck();
for (int i = 0; i < count; ++i)
{
OpenAL.DebugFormat("Generated source buffer {0}", bufferIDs[i]);
buffers[i] = new SourceBuffer(bufferIDs[i]);
Buffers.Add(buffers[i].bufferID, buffers[i]);
}
return(buffers);
}
}
private unsafe byte[] GetSamples(int numSamples, bool block)
{
ThrowIfDisposed();
int bytesPerSample = (int)Format.GetBytesPerSample();
byte[] samples = new byte[numSamples * bytesPerSample];
while (this.capturing && block && this.AvailableSamples < numSamples)
{
Thread.Sleep(0);
}
int diff = numSamples - this.AvailableSamples;
if (diff > 0)
{
numSamples -= diff;
for (int i = diff * bytesPerSample; i < samples.Length; i++)
{
samples[i] = 0;
samples[++i] = 0;
}
}
fixed(byte *pcmPtr = pcm)
alcCaptureSamples(this.Handle, new IntPtr(pcmPtr), numSamples);
OpenAL.ErrorCheck(this);
Buffer.BlockCopy(pcm, 0, samples, 0, samples.Length);
return(samples);
}
public static Source[] Generate(int count)
{
OpenAL.DebugFormat("Generating {0} sources", count);
if (count > MaxSources)
{
OpenAL.Log.ErrorFormat("Requested {0} sources which is more than maximum {1}", count, MaxSources);
throw new InvalidOperationException();
}
Source[] sources = new Source[count];
uint[] sourceIDs = new uint[count];
alGenSources(count, sourceIDs);
OpenAL.ErrorCheck();
for (int i = 0; i < count; ++i)
{
OpenAL.DebugFormat("Generated source {0}", sourceIDs[i]);
sources[i] = new Source(sourceIDs[i]);
}
return(sources);
}
internal Context(IntPtr handle, PlaybackDevice device)
{
this.Handle = handle;
this.Device = device;
OpenAL.DebugFormat("Context {0} created for {1}", handle, device.Name);
}
internal static void SetPropertyF(uint sourceID, FloatSourceProperty property, float value)
{
OpenAL.DebugFormat("Setting source {0} property {1} to {2}", sourceID, property, value);
alSourcef(sourceID, property, value);
OpenAL.ErrorCheck();
}
public static IEnumerable <CaptureDevice> GetCaptureDevices(out CaptureDevice defaultDevice)
{
//if (!IsCaptureSupported)
// throw new NotSupportedException();
OpenAL.Debug("Getting capture devices");
defaultDevice = null;
string defaultName = Marshal.PtrToStringAnsi(alcGetString(IntPtr.Zero, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER));
var strings = ReadStringsFromMemory(alcGetString(IntPtr.Zero, ALC_CAPTURE_DEVICE_SPECIFIER));
CaptureDevice[] devices = new CaptureDevice[strings.Length];
for (int i = 0; i < strings.Length; ++i)
{
string s = strings[i];
devices[i] = new CaptureDevice(s);
if (s == defaultName)
{
defaultDevice = devices[i];
}
OpenAL.DebugFormat("Found capture device {0}{1}", s, (s == defaultName) ? " (Default)" : String.Empty);
}
return(devices);
}
public void Stop()
{
OpenAL.DebugFormat("Stopping source {0}", this.sourceID);
alSourceStop(this.sourceID);
OpenAL.ErrorCheck();
}
protected void Queue(uint[] bufferIDs)
{
OpenAL.DebugFormat("Enqueuing buffers {0} to source {1}", bufferIDs.Implode(", "), this.sourceID);
alSourceQueueBuffers(this.sourceID, bufferIDs.Length, bufferIDs);
OpenAL.ErrorCheck();
}
public void Activate()
{
OpenAL.DebugFormat("Activating context {1} for device {0}", this.Device.Name, Handle);
alcMakeContextCurrent(this.Handle);
CurrentContext = this;
OpenAL.ErrorCheck(this.Device);
}
// ReSharper restore InconsistentNaming
internal static float GetPropertyF(uint sourceID, FloatSourceProperty property)
{
float value;
alGetSourcef(sourceID, property, out value);
OpenAL.ErrorCheck();
return(value);
}
private int GetSamplesAvailable()
{
ThrowIfDisposed();
int samples;
OpenAL.alcGetIntegerv(this.Handle, ALCEnum.ALC_CAPTURE_SAMPLES, 4, out samples);
OpenAL.ErrorCheck(this);
return(samples);
}
protected void PlayCore(bool check)
{
if (check && this.IsPlaying)
{
return;
}
OpenAL.DebugFormat("Playing source {0}", this.sourceID);
alSourcePlay(this.sourceID);
OpenAL.ErrorCheck();
}
// ReSharper restore InconsistentNaming
public static Context Create(PlaybackDevice device)
{
OpenAL.DebugFormat("Creating context for {0}", device.Name);
Context c = new Context(alcCreateContext(device.Handle, IntPtr.Zero), device);
OpenAL.ErrorCheck(device);
device.Context = c;
return(c);
}
public void FreeSource(Source source)
{
OpenAL.DebugFormat("SourcePool: Freeing source {0}", source);
lock (owners)
{
owners[source] = default(T);
if (source == lastSource)
{
lastSource = null;
}
}
}
/// <summary>
/// Stops capturing.
/// </summary>
public void StopCapture()
{
if (!IsOpen)
{
throw new InvalidOperationException("Device not open");
}
ThrowIfDisposed();
OpenAL.DebugFormat("Stopping capture for {0}", Name);
this.capturing = false;
alcCaptureStop(this.Handle);
OpenAL.ErrorCheck(this);
}
internal static bool GetIsExtensionPresent(string extension)
{
sbyte result;
if (extension.StartsWith("ALC"))
{
result = alcIsExtensionPresent(IntPtr.Zero, extension);
}
else
{
result = alIsExtensionPresent(extension);
OpenAL.ErrorCheck();
}
return(result == 1);
}
protected void Dispose(bool disposing)
{
if (this.disposed)
{
return;
}
OpenAL.DebugFormat("Destroying source {0}", this.sourceID);
uint[] id = new[] { this.sourceID };
alDeleteSources(1, id);
OpenAL.DebugFormat("Destroyed source {0}", this.sourceID);
this.disposed = true;
}
public void FreeSources(IEnumerable <Source> sources)
{
lock (owners)
{
foreach (Source csource in sources)
{
OpenAL.DebugFormat("SourcePool: Freeing source {0}", csource);
owners[csource] = default(T);
if (csource == lastSource)
{
lastSource = null;
}
}
}
}
internal static bool GetIsExtensionPresent(Device device, string extension)
{
sbyte result;
if (extension.StartsWith("ALC"))
{
result = alcIsExtensionPresent(device.Handle, extension);
OpenAL.ErrorCheck(device);
}
else
{
result = alIsExtensionPresent(extension);
OpenAL.ErrorCheck();
}
return(result == 1);
}
public void Tick()
{
List <KeyValuePair <Source, T> > finished;
lock (owners)
finished = owners.Where(kvp => kvp.Key.IsStopped && kvp.Value != null).ToList();
for (int i = 0; i < finished.Count; ++i)
{
var s = finished[i].Key;
var o = finished[i].Value;
OpenAL.DebugFormat("SourcePool: {0} is stopped, freeing", s);
FreeSource(s);
OnSourceFinished(new SourceFinishedEventArgs <T> (o, s));
}
}
protected override void Dispose(bool disposing)
{
if (Handle == IntPtr.Zero)
{
return;
}
OpenAL.DebugFormat("Destroying capture device {0}", Name);
Close();
Handle = IntPtr.Zero;
this.pcm = null;
this.disposed = true;
OpenAL.DebugFormat("Destroyed capture device {0}", Name);
}
protected virtual void Dispose(bool disposing)
{
lock (lck)
{
if (this.disposed)
{
return;
}
OpenAL.DebugFormat("Destroying source buffer {0}", this.bufferID);
alDeleteBuffers(1, new[] { this.bufferID });
Buffers.Remove(this.bufferID);
this.disposed = true;
}
}
/// <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);
}
public SourceBuffer[] Dequeue(int buffers)
{
OpenAL.DebugFormat("Dequeing {0} buffers for source {1}", buffers, this.sourceID);
uint[] bufferIDs = new uint[buffers];
alSourceUnqueueBuffers(this.sourceID, buffers, bufferIDs);
OpenAL.ErrorCheck();
SourceBuffer[] dequeued = new SourceBuffer[bufferIDs.Length];
for (int i = 0; i < bufferIDs.Length; ++i)
{
OpenAL.DebugFormat("Dequeued source buffer {0} for source {1}", bufferIDs[i], this.sourceID);
dequeued[i] = SourceBuffer.GetBuffer(bufferIDs[i]);
}
return(dequeued);
}
public Source RequestSource(T owner)
{
OpenAL.DebugFormat("SourcePool: Requesting source for {0}", owner);
Source free;
lock (owners)
{
if (owner == lastOwner && lastSource != null)
{
OpenAL.DebugFormat("SourcePool: Returning last source for {0}", owner);
return(lastSource);
}
free = owners.Where(kvp => kvp.Value == owner).Select(kvp => kvp.Key).FirstOrDefault();
if (free == null)
{
free = owners.Where(kvp => kvp.Value == null).Select(kvp => kvp.Key).FirstOrDefault();
if (free == null)
{
free = Source.Generate();
OpenAL.DebugFormat("SourcePool: Couldn't find a free source for {0}, created {1}", owner, free);
}
else
{
OpenAL.DebugFormat("SourcePool: Found free source {0} for {1}", free, owner);
}
owners[free] = owner;
}
else
{
OpenAL.DebugFormat("SourcePool: Found owned source {0} for {1}", free, owner);
}
lastOwner = owner;
lastSource = free;
}
return(free);
}
/// <summary>
/// Opens the device.
/// </summary>
/// <returns>Returns <c>this</c>.</returns>
public PlaybackDevice Open()
{
ThrowIfDisposed();
OpenAL.DebugFormat("Opening playback device {0}", Name);
this.Handle = alcOpenDevice(this.Name);
if (this.Handle == IntPtr.Zero)
{
throw new Exception("Device failed to open for an unknown reason.");
}
else
{
OpenAL.ErrorCheck(this);
}
return(this);
}
public void FreeSource(T sourceOwner)
{
OpenAL.DebugFormat("SourcePool: Freeing source for owner {0}", sourceOwner);
lock (owners)
{
var source = owners.FirstOrDefault(kvp => kvp.Value == sourceOwner).Key;
if (source == null)
{
return;
}
owners[source] = default(T);
if (source == lastSource)
{
lastSource = null;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (this.disposed)
{
return;
}
if (this.Handle != IntPtr.Zero)
{
if (CurrentContext == this)
{
alcMakeContextCurrent(IntPtr.Zero);
CurrentContext = null;
}
alcDestroyContext(this.Handle);
}
OpenAL.DebugFormat("Destroying from {2} context {1} for {0}", Device.Name, Handle, (disposing) ? "Dispose()" : "finalizer");
this.disposed = true;
}
protected override void Dispose(bool disposing)
{
if (Handle == IntPtr.Zero)
{
return;
}
if (disposing)
{
if (Context != null)
{
Context.Dispose();
}
}
OpenAL.DebugFormat("Destroying playback device {0}", Name);
Close();
Handle = IntPtr.Zero;
this.disposed = true;
OpenAL.DebugFormat("Destroyed playback device {0}", Name);
}
