public Context(Device device, Dictionary <int, int> attributes)
: this()
{
if (device == Device.Null)
{
throw new ArgumentNullException("device");
}
unsafe
{
var attribs_length = attributes == null ? 0 : attributes.Count * 2;
int *attribs = stackalloc int[attribs_length + 1];
if (attributes != null)
{
int index = 0;
foreach (var pair in attributes)
{
attribs[index++] = pair.Key;
attribs[index++] = pair.Value;
}
attribs[attribs_length] = 0;
}
else
{
attribs = null;
}
Handle = Alc.CreateContext(device.Handle, attribs);
AlHelper.GetAlcError(Alc.GetError(device.Handle));
}
}
public static void Create(Source[] sources, int index, int count)
{
if (sources == null)
{
throw new ArgumentNullException("sources");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index", index, "index is less than 0.");
}
if (index + count > sources.Length)
{
throw new ArgumentOutOfRangeException("count", count, "index + count is greater than buffers.Length.");
}
unsafe
{
uint *ids = stackalloc uint[count];
Al.GenSources(count, ids);
AlHelper.GetAlError(Al.GetError());
for (int i = 0; i < count; ++i)
{
AlHelper.CheckName(ids[i], "source");
sources[index + i] = new Source(ids[i]);
}
}
}
public void Read(IntPtr buffer, int samples)
{
AlHelper.ThrowNullException(Handle);
unsafe
{
Alc.CaptureSamples(Handle, buffer.ToPointer(), samples);
AlHelper.GetAlcError(Alc.GetError(Handle));
}
}
public override bool Equals(object obj)
{
AlHelper.ThrowNullException(Id);
if (obj is Source)
{
return(Equals((Source)obj));
}
return(false);
}
public override bool Equals(object obj)
{
AlHelper.ThrowNullException(Handle);
if (obj is Device)
{
return(Equals((Device)obj));
}
return(false);
}
public void Delete()
{
AlHelper.ThrowNullException(Id);
unsafe
{
uint id = Id;
Al.DeleteSources(1, &id);
}
}
public static IntPtr GetFunctionPointer(string fname)
{
unsafe
{
int length = Encoding.ASCII.GetByteCount(fname);
byte *chars = stackalloc byte[length];
AlHelper.StringToAnsi(fname, chars, length);
return(new IntPtr(Al.GetProcAddress(chars)));
}
}
public static Source Create()
{
unsafe
{
uint id;
Al.GenSources(1, &id);
AlHelper.GetAlError(Al.GetError());
AlHelper.CheckName(id, "source");
return(new Source(id));
}
}
public static Buffer Create()
{
unsafe
{
uint id;
Al.GenBuffers(1, &id);
AlHelper.GetAlError(Al.GetError());
AlHelper.CheckName(id, "buffer");
return(new Buffer(id));
}
}
public static int GetEnumValue(string enumname)
{
unsafe
{
int length = Encoding.ASCII.GetByteCount(enumname);
byte *chars = stackalloc byte[length];
AlHelper.StringToAnsi(enumname, chars, length);
return(Al.GetEnumValue(chars));
}
}
public Buffer Unqueue()
{
AlHelper.ThrowNullException(Id);
unsafe
{
uint bid;
Al.SourceUnqueueBuffers(Id, 1, &bid);
return(new OpenAL.Buffer(bid));
}
}
public static bool IsExtensionPresent(string extension)
{
unsafe
{
int length = Encoding.ASCII.GetByteCount(extension);
byte *chars = stackalloc byte[length];
AlHelper.StringToAnsi(extension, chars, length);
return(Al.IsExtensionPresent(chars));
}
}
public void Read(byte[] buffer, int samples)
{
AlHelper.ThrowNullException(Handle);
unsafe
{
fixed(byte *pointer = buffer)
{
Alc.CaptureSamples(Handle, pointer, samples);
AlHelper.GetAlcError(Alc.GetError(Handle));
}
}
}
public bool Close()
{
AlHelper.ThrowNullException(Handle);
if (Alc.CloseDevice(Handle) != 0)
{
Handle = IntPtr.Zero;
return(true);
}
else
{
return(false);
}
}
public void Queue(Buffer buffer)
{
AlHelper.ThrowNullException(Id);
if (buffer == Buffer.Null)
{
throw new ArgumentNullException("buffer");
}
unsafe
{
uint bid = buffer.Id;
Al.SourceQueueBuffers(Id, 1, &bid);
}
}
public Context(Device device)
: this()
{
if (device == Device.Null)
{
throw new ArgumentNullException("device");
}
unsafe
{
Handle = Alc.CreateContext(device.Handle, null);
AlHelper.GetAlcError(Alc.GetError(device.Handle));
}
}
public void BufferData(Format format, IntPtr data, int size, int frequency)
{
AlHelper.ThrowNullException(Id);
if (data == IntPtr.Zero)
{
throw new ArgumentNullException("data");
}
unsafe
{
uint id = Id;
Al.BufferData(Id, (int)format, data.ToPointer(), size, frequency);
}
}
public void Queue(Buffer[] buffers)
{
AlHelper.ThrowNullException(Id);
if (buffers == null)
{
throw new ArgumentNullException("buffers");
}
unsafe
{
uint *bids = stackalloc uint[buffers.Length];
for (int i = 0; i < buffers.Length; ++i)
{
bids[i] = buffers[i].Id;
}
Al.SourceQueueBuffers(Id, buffers.Length, bids);
}
}
public CaptureDevice(string name, uint frequency, Format format, int buffersize)
: this()
{
unsafe
{
int name_length = name == null ? 0 : Encoding.ASCII.GetByteCount(name);
byte *name_ansi = stackalloc byte[name_length + 1];
AlHelper.StringToAnsi(name, name_ansi, name_length);
name_ansi = name == null ? null : name_ansi;
Handle = Alc.CaptureOpenDevice(name_ansi, frequency, (int)format, buffersize);
if (Handle == IntPtr.Zero)
{
throw new OpenALException(string.Format(
"CaptureOpenDevice({0}, {1}, {2}, {3}) failed.", name, frequency, format, buffersize));
}
}
}
public Device(string name)
: this()
{
unsafe
{
int name_length = name == null ? 0 : Encoding.ASCII.GetByteCount(name);
byte *name_ansi = stackalloc byte[name_length + 1];
AlHelper.StringToAnsi(name, name_ansi, name_length);
name_ansi = name == null ? null : name_ansi;
Handle = Alc.OpenDevice(name_ansi);
if (Handle == IntPtr.Zero)
{
throw new OpenALException(string.Format(
"OpenDevice({0}) failed.", name));
}
}
}
public void BufferData(Format format, byte[] data, int size, int frequency)
{
AlHelper.ThrowNullException(Id);
if (data == null)
{
throw new ArgumentNullException("data");
}
unsafe
{
fixed(byte *pointer = data)
{
uint id = Id;
Al.BufferData(Id, (int)format, pointer, size, frequency);
}
}
}
public Buffer[] Unqueue(int count)
{
AlHelper.ThrowNullException(Id);
if (count <= 0)
{
throw new ArgumentException("count is less than or equal to 0.", "count");
}
unsafe
{
uint *bids = stackalloc uint[count];
Al.SourceUnqueueBuffers(Id, count, bids);
Buffer[] buffers = new Buffer[count];
for (int i = 0; i < count; ++i)
{
buffers[i] = new Buffer(bids[i]);
}
return(buffers);
}
}
public void Rewind()
{
AlHelper.ThrowNullException(Id);
Al.SourceRewind(Id);
}
public override string ToString()
{
AlHelper.ThrowNullException(Id);
return(string.Format("Source: {0}", Id.ToString()));
}
public bool Equals(Source other)
{
AlHelper.ThrowNullException(Id);
return(Id == other.Id);
}
public override int GetHashCode()
{
AlHelper.ThrowNullException(Id);
return(Id.GetHashCode());
}
public override string ToString()
{
AlHelper.ThrowNullException(Handle);
return(string.Format("Device: {0}", Handle.ToString()));
}
public void Stop()
{
AlHelper.ThrowNullException(Id);
Al.SourceStop(Id);
}
public void Play()
{
AlHelper.ThrowNullException(Id);
Al.SourcePlay(Id);
}
public void Pause()
{
AlHelper.ThrowNullException(Id);
Al.SourcePause(Id);
}
