Minimal bindings for OpenAL

OpenAL.cs

using System;
using System.Diagnostics.CodeAnalysis;
using System.Numerics;
using System.Runtime.InteropServices;
using System.Security;

namespace MyNamespace
{
    [SuppressUnmanagedCodeSecurity]
    [SuppressMessage("ReSharper", "IdentifierTypo")]
    [SuppressMessage("ReSharper", "InconsistentNaming")]
    internal static class OpenAL
    {
        private const string LIBRARY = "openal";

        public const int AL_NONE = 0x0000;
        public const int AL_FALSE = 0x0000;
        public const int AL_TRUE = 0x0001;
        public const int AL_SOURCE_RELATIVE = 0x0202;
        public const int AL_CONE_INNER_ANGLE = 0x1001;
        public const int AL_CONE_OUTER_ANGLE = 0x1002;
        public const int AL_PITCH = 0x1003;
        public const int AL_POSITION = 0x1004;
        public const int AL_DIRECTION = 0x1005;
        public const int AL_VELOCITY = 0x1006;
        public const int AL_LOOPING = 0x1007;
        public const int AL_BUFFER = 0x1009;
        public const int AL_GAIN = 0x100A;
        public const int AL_MIN_GAIN = 0x100D;
        public const int AL_MAX_GAIN = 0x100E;
        public const int AL_ORIENTATION = 0x100F;
        public const int AL_SOURCE_STATE = 0x1010;
        public const int AL_INITIAL = 0x1011;
        public const int AL_PLAYING = 0x1012;
        public const int AL_PAUSED = 0x1013;
        public const int AL_STOPPED = 0x1014;
        public const int AL_BUFFERS_QUEUED = 0x1015;
        public const int AL_BUFFERS_PROCESSED = 0x1016;
        public const int AL_REFERENCE_DISTANCE = 0x1020;
        public const int AL_ROLLOFF_FACTOR = 0x1021;
        public const int AL_CONE_OUTER_GAIN = 0x1022;
        public const int AL_MAX_DISTANCE = 0x1023;
        public const int AL_SOURCE_TYPE = 0x1027;
        public const int AL_STATIC = 0x1028;
        public const int AL_STREAMING = 0x1029;
        public const int AL_UNDETERMINED = 0x1030;
        public const int AL_FREQUENCY = 0x2001;
        public const int AL_BITS = 0x2002;
        public const int AL_CHANNELS = 0x2003;
        public const int AL_SIZE = 0x2004;
        public const int AL_NO_ERROR = 0x0000;
        public const int AL_INVALID_NAME = 0xA001;
        public const int AL_INVALID_ENUM = 0xA002;
        public const int AL_INVALID_VALUE = 0xA003;
        public const int AL_INVALID_OPERATION = 0xA004;
        public const int AL_OUT_OF_MEMORY = 0xA005;
        public const int AL_VENDOR = 0xB001;
        public const int AL_VERSION = 0xB002;
        public const int AL_RENDERER = 0xB003;
        public const int AL_EXTENSIONS = 0xB004;
        public const int AL_DOPPLER_FACTOR = 0xC000;
        public const int AL_DOPPLER_VELOCITY = 0xC001;
        public const int AL_DISTANCE_MODEL = 0xD000;
        public const int AL_INVERSE_DISTANCE = 0xD001;
        public const int AL_INVERSE_DISTANCE_CLAMPED = 0xD002;
        public const int AL_SEC_OFFSET = 0x1024;
        public const int AL_SAMPLE_OFFSET = 0x1025;
        public const int AL_BYTE_OFFSET = 0x1026;
        public const int AL_SPEED_OF_SOUND = 0xC003;
        public const int AL_LINEAR_DISTANCE = 0xD003;
        public const int AL_LINEAR_DISTANCE_CLAMPED = 0xD004;
        public const int AL_EXPONENT_DISTANCE = 0xD005;
        public const int AL_EXPONENT_DISTANCE_CLAMED = 0xD006;
        
        public const int AL_FORMAT_MONO8 = 0x1100;
        public const int AL_FORMAT_MONO16 = 0x1101;
        public const int AL_FORMAT_STEREO8 = 0x1102;
        public const int AL_FORMAT_STEREO16 = 0x1103;
        public const int AL_FORMAT_MONO_FLOAT32 = 0x10010;
        public const int AL_FORMAT_STEREO_FLOAT32 = 0x10011;
        public const int AL_FORMAT_MONO_DOUBLE = 0x10012;
        public const int AL_FORMAT_STEREO_DOUBLE = 0x10013;
        public const int AL_FORMAT_MONO_MSADPCM_SOFT = 0x1302;
        public const int AL_FORMAT_STEREO_MSADPCM_SOFT = 0x1303;
        
        public const int AL_LOOP_POINTS_SOFT = 0x2015;
        public const int AL_UNPACK_BLOCK_ALIGNMENT_SOFT = 0x200C;
        public const int AL_PACK_BLOCK_ALIGNMENT_SOFT = 0x200D;
        public const int AL_BYTE_SOFT = 0x1400;
        public const int AL_SHORT_SOFT = 0x1402;
        public const int AL_FLOAT_SOFT = 0x1406;
        public const int AL_MONO_SOFT = 0x1500;
        public const int AL_STEREO_SOFT = 0x1501;
        public const int AL_GAIN_LIMIT_SOFT = 0x200E;
        public const int AL_METERS_PER_UNIT = 0x20004;
        public const int AL_DIRECT_FILTER = 0x20005;
        public const int AL_AUXILIARY_SEND_FILTER = 0x20006;
        public const int AL_AIR_ABSORPTION_FACTOR = 0x20007;
        public const int AL_ROOM_ROLLOFF_FACTOR = 0x20008;
        public const int AL_CONE_OUTER_GAINHF = 0x20009;
        public const int AL_DIRECT_FILTER_GAINHF_AUTO = 0x2000A;
        public const int AL_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x2000B;
        public const int AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x2000C;
        public const int AL_REVERB_DENSITY = 0x0001;
        public const int AL_REVERB_DIFFUSION = 0x0002;
        public const int AL_REVERB_GAIN = 0x0003;
        public const int AL_REVERB_GAINHF = 0x0004;
        public const int AL_REVERB_DECAY_TIME = 0x0005;
        public const int AL_REVERB_DECAY_HFRATIO = 0x0006;
        public const int AL_REVERB_REFLECTIONS_GAIN = 0x0007;
        public const int AL_REVERB_REFLECTIONS_DELAY = 0x0008;
        public const int AL_REVERB_LATE_REVERB_GAIN = 0x0009;
        public const int AL_REVERB_LATE_REVERB_DELAY = 0x000A;
        public const int AL_REVERB_AIR_ABSORPTION_FACTOR = 0x000B;
        public const int AL_REVERB_ROOM_ROLLOFF_FACTOR = 0x000C;
        public const int AL_REVERB_DECAY_HFLIMIT = 0x000D;
        public const int AL_EAXREVERB_DENSITY = 0x0001;
        public const int AL_EAXREVERB_DIFFUSION = 0x0002;
        public const int AL_EAXREVERB_GAIN = 0x0003;
        public const int AL_EAXREVERB_GAINHF = 0x0004;
        public const int AL_EAXREVERB_GAINLF = 0x0005;
        public const int AL_EAXREVERB_DECAY_TIME = 0x0006;
        public const int AL_EAXREVERB_DECAY_HFRATIO = 0x0007;
        public const int AL_EAXREVERB_DECAY_LFRATIO = 0x0008;
        public const int AL_EAXREVERB_REFLECTIONS_GAIN = 0x0009;
        public const int AL_EAXREVERB_REFLECTIONS_DELAY = 0x000A;
        public const int AL_EAXREVERB_REFLECTIONS_PAN = 0x000B;
        public const int AL_EAXREVERB_LATE_REVERB_GAIN = 0x000C;
        public const int AL_EAXREVERB_LATE_REVERB_DELAY = 0x000D;
        public const int AL_EAXREVERB_LATE_REVERB_PAN = 0x000E;
        public const int AL_EAXREVERB_ECHO_TIME = 0x000F;
        public const int AL_EAXREVERB_ECHO_DEPTH = 0x0010;
        public const int AL_EAXREVERB_MODULATION_TIME = 0x0011;
        public const int AL_EAXREVERB_MODULATION_DEPTH = 0x0012;
        public const int AL_EAXREVERB_AIR_ABSORPTION_GAINHF = 0x0013;
        public const int AL_EAXREVERB_HFREFERENCE = 0x0014;
        public const int AL_EAXREVERB_LFREFERENCE = 0x0015;
        public const int AL_EAXREVERB_ROOM_ROLLOFF_FACTOR = 0x0016;
        public const int AL_EAXREVERB_DECAY_HFLIMIT = 0x0017;
        public const int AL_CHORUS_WAVEFORM = 0x0001;
        public const int AL_CHORUS_PHASE = 0x0002;
        public const int AL_CHORUS_RATE = 0x0003;
        public const int AL_CHORUS_DEPTH = 0x0004;
        public const int AL_CHORUS_FEEDBACK = 0x0005;
        public const int AL_CHORUS_DELAY = 0x0006;
        public const int AL_DISTORTION_EDGE = 0x0001;
        public const int AL_DISTORTION_GAIN = 0x0002;
        public const int AL_DISTORTION_LOWPASS_CUTOFF = 0x0003;
        public const int AL_DISTORTION_EQCENTER = 0x0004;
        public const int AL_DISTORTION_EQBANDWIDTH = 0x0005;
        public const int AL_ECHO_DELAY = 0x0001;
        public const int AL_ECHO_LRDELAY = 0x0002;
        public const int AL_ECHO_DAMPING = 0x0003;
        public const int AL_ECHO_FEEDBACK = 0x0004;
        public const int AL_ECHO_SPREAD = 0x0005;
        public const int AL_FLANGER_WAVEFORM = 0x0001;
        public const int AL_FLANGER_PHASE = 0x0002;
        public const int AL_FLANGER_RATE = 0x0003;
        public const int AL_FLANGER_DEPTH = 0x0004;
        public const int AL_FLANGER_FEEDBACK = 0x0005;
        public const int AL_FLANGER_DELAY = 0x0006;
        public const int AL_FREQUENCY_SHIFTER_FREQUENCY = 0x0001;
        public const int AL_FREQUENCY_SHIFTER_LEFT_DIRECTION = 0x0002;
        public const int AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION = 0x0003;
        public const int AL_VOCAL_MORPHER_PHONEMEA = 0x0001;
        public const int AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING = 0x0002;
        public const int AL_VOCAL_MORPHER_PHONEMEB = 0x0003;
        public const int AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING = 0x0004;
        public const int AL_VOCAL_MORPHER_WAVEFORM = 0x0005;
        public const int AL_VOCAL_MORPHER_RATE = 0x0006;
        public const int AL_PITCH_SHIFTER_COARSE_TUNE = 0x0001;
        public const int AL_PITCH_SHIFTER_FINE_TUNE = 0x0002;
        public const int AL_RING_MODULATOR_FREQUENCY = 0x0001;
        public const int AL_RING_MODULATOR_HIGHPASS_CUTOFF = 0x0002;
        public const int AL_RING_MODULATOR_WAVEFORM = 0x0003;
        public const int AL_AUTOWAH_ATTACK_TIME = 0x0001;
        public const int AL_AUTOWAH_RELEASE_TIME = 0x0002;
        public const int AL_AUTOWAH_RESONANCE = 0x0003;
        public const int AL_AUTOWAH_PEAK_GAIN = 0x0004;
        public const int AL_COMPRESSOR_ONOFF = 0x0001;
        public const int AL_EQUALIZER_LOW_GAIN = 0x0001;
        public const int AL_EQUALIZER_LOW_CUTOFF = 0x0002;
        public const int AL_EQUALIZER_MID1_GAIN = 0x0003;
        public const int AL_EQUALIZER_MID1_CENTER = 0x0004;
        public const int AL_EQUALIZER_MID1_WIDTH = 0x0005;
        public const int AL_EQUALIZER_MID2_GAIN = 0x0006;
        public const int AL_EQUALIZER_MID2_CENTER = 0x0007;
        public const int AL_EQUALIZER_MID2_WIDTH = 0x0008;
        public const int AL_EQUALIZER_HIGH_GAIN = 0x0009;
        public const int AL_EQUALIZER_HIGH_CUTOFF = 0x000A;
        public const int AL_EFFECT_FIRST_PARAMETER = 0x0000;
        public const int AL_EFFECT_LAST_PARAMETER = 0x8000;
        public const int AL_EFFECT_TYPE = 0x8001;
        public const int AL_EFFECTSLOT_EFFECT = 0x0001;
        public const int AL_EFFECTSLOT_GAIN = 0x0002;
        public const int AL_EFFECTSLOT_AUXILIARY_SEND_AUTO = 0x0003;
        public const int AL_EFFECTSLOT_NULL = 0x0000;
        public const int AL_LOWPASS_GAIN = 0x0001;
        public const int AL_LOWPASS_GAINHF = 0x0002;
        public const int AL_HIGHPASS_GAIN = 0x0001;
        public const int AL_HIGHPASS_GAINLF = 0x0002;
        public const int AL_BANDPASS_GAIN = 0x0001;
        public const int AL_BANDPASS_GAINLF = 0x0002;
        public const int AL_BANDPASS_GAINHF = 0x0003;
        public const int AL_FILTER_FIRST_PARAMETER = 0x0000;
        public const int AL_FILTER_LAST_PARAMETER = 0x8000;
        public const int AL_FILTER_TYPE = 0x8001;
        public const int AL_FILTER_NULL = 0x0000;
        public const int AL_FILTER_LOWPASS = 0x0001;
        public const int AL_FILTER_HIGHPASS = 0x0002;
        public const int AL_FILTER_BANDPASS = 0x0003;
        public const int ALC_FALSE = 0x0000;
        public const int ALC_TRUE = 0x0001;
        public const int ALC_FREQUENCY = 0x1007;
        public const int ALC_REFRESH = 0x1008;
        public const int ALC_SYNC = 0x1009;
        public const int ALC_NO_ERROR = 0x0000;
        public const int ALC_INVALID_DEVICE = 0xA001;
        public const int ALC_INVALID_CONTEXT = 0xA002;
        public const int ALC_INVALID_ENUM = 0xA003;
        public const int ALC_INVALID_VALUE = 0xA004;
        public const int ALC_OUT_OF_MEMORY = 0xA005;
        public const int ALC_ATTRIBUTES_SIZE = 0x1002;
        public const int ALC_ALL_ATTRIBUTES = 0x1003;
        public const int ALC_DEFAULT_DEVICE_SPECIFIER = 0x1004;
        public const int ALC_DEVICE_SPECIFIER = 0x1005;
        public const int ALC_EXTENSIONS = 0x1006;
        public const int ALC_MONO_SOURCES = 0x1010;
        public const int ALC_STEREO_SOURCES = 0x1011;
        public const int ALC_CAPTURE_DEVICE_SPECIFIER = 0x0310;
        public const int ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER = 0x0311;
        public const int ALC_CAPTURE_SAMPLES = 0x0312;
        public const int ALC_DEFAULT_ALL_DEVICES_SPECIFIER = 0x1012;
        public const int ALC_ALL_DEVICES_SPECIFIER = 0x1013;

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDopplerFactor(float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDistanceModel(int distanceModel);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alEnable(int capability);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDisable(int capability);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alIsEnabled(int capability);

        [DllImport(LIBRARY, EntryPoint = "alGetString", CallingConvention = CallingConvention.Cdecl)]
        private static extern IntPtr alGetStringPrivate(int param);

        public static string alGetString(int param) => Marshal.PtrToStringUTF8(alGetStringPrivate(param));

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBooleanv(int param, bool[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetIntegerv(int param, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetFloatv(int param, float[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetDoublev(int param, double[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alGetBoolean(int param);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern int alGetInteger(int param);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern float alGetFloat(int param);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern double alGetDouble(int param);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern int alGetError();

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alIsExtensionPresent([In] [MarshalAs(UnmanagedType.LPStr)] string extName);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alGetProcAddress([In] [MarshalAs(UnmanagedType.LPStr)] string fname);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern int alGetEnumValue([In] [MarshalAs(UnmanagedType.LPStr)] string ename);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alListenerf(int param, float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alListener3f(int param, float v1, float v2, float v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alListenerfv(int param, float[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alListeneri(int param, int value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alListener3i(int param, int v1, int v2, int v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alListeneriv(int param, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetListenerf(int param, out float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetListener3f(int param, out float v1, out float v2, out float v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetListenerfv(int param, float[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetListeneri(int param, out int value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetListener3i(int param, out int v1, out int v2, out int v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetListeneriv(int param, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenSources(int n, uint[] sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenSources(int n, out uint sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteSources(int n, uint[] sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteSources(int n, ref uint sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alIsSource(uint source);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourcef(uint source, int param, float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSource3f(uint source, int param, float v1, float v2, float v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourcefv(uint source, int param, float[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourcei(uint source, int param, int value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSource3i(uint source, int param, int v1, int v2, int v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceiv(uint source, int param, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetSourcef(uint source, int param, out float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetSource3f(uint source, int param, out float v1, out float v2, out float v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetSourcefv(uint source, int param, float[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetSourcei(uint source, int param, out int value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetSource3i(uint source, int param, out int v1, out int v2, out int v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetSourceiv(uint source, int param, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourcePlayv(int n, uint[] sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceStopv(int n, uint[] sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceRewindv(int n, uint[] sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourcePausev(int n, uint[] sources);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourcePlay(uint source);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceStop(uint source);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceRewind(uint source);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourcePause(uint source);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceQueueBuffers(uint source, int nb, uint[] buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceQueueBuffers(uint source, int nb, ref uint buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceUnqueueBuffers(uint source, int nb, uint[] buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSourceUnqueueBuffers(uint source, int nb, ref uint buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenBuffers(int n, uint[] buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenBuffers(int n, out uint buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteBuffers(int n, uint[] buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteBuffers(int n, ref uint buffers);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alIsBuffer(uint buffer);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, int format, IntPtr data, int size, int freq);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, int format, byte[] data, int size, int freq);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, int format, short[] data, int size, int freq);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, int format, float[] data, int size, int freq);
        
        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, SampleFormat format, IntPtr data, int size, int freq);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, SampleFormat format, byte[] data, int size, int freq);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, SampleFormat format, short[] data, int size, int freq);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferData(uint buffer, SampleFormat format, float[] data, int size, int freq);
        
        

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferf(uint buffer, int param, float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBuffer3f(uint buffer, int param, float v1, float v2, float v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferfv(uint buffer, int param, float[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferi(uint buffer, int param, int value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBuffer3i(uint buffer, int param, int v1, int v2, int v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alBufferiv(uint buffer, int param, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBufferf(uint buffer, int param, out float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBuffer3f(uint buffer, int param, out float v1, out float v2, out float v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBufferfv(uint buffer, int param, float[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBufferi(uint buffer, int param, out int value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBuffer3i(uint buffer, int param, out int v1, out int v2, out int v3);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBufferiv(uint buffer, int param, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alSpeedOfSound(float value);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetBufferSamplesSOFT(uint buffer, int offset, int samples, int channels, int type,
            IntPtr data);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenEffects(int n, uint[] effects);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenEffects(int n, out uint effects);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteEffects(int n, uint[] effects);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteEffects(int n, ref uint effects);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alIsEffect(uint effect);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alEffecti(uint effect, int param, int iValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alEffectiv(uint effect, int param, int[] iValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alEffectf(uint effect, int param, float flValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alEffectfv(uint effect, int param, float[] flValues);
        
        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alEffectfv(uint effect, int param, ref Vector3 values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetEffecti(uint effect, int param, out int piValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetEffectiv(uint effect, int param, int[] piValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetEffectf(uint effect, int param, out float pflValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetEffectfv(uint effect, int param, float[] pflValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenFilters(int n, uint[] filters);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenFilters(int n, out uint filters);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteFilters(int n, uint[] filters);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteFilters(int n, ref uint filters);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alIsFilter(uint filter);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alFilteri(uint filter, int param, int iValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alFilteriv(uint filter, int param, int[] iValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alFilterf(uint filter, int param, float flValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alFilterfv(uint filter, int param, float[] flValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetFilteri(uint filter, int param, out int piValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetFilteriv(uint filter, int param, int[] piValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetFilterf(uint filter, int param, out float pflValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetFilterfv(uint filter, int param, float[] pflValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenAuxiliaryEffectSlots(int n, uint[] effectslots);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGenAuxiliaryEffectSlots(int n, out uint effectslots);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteAuxiliaryEffectSlots(int n, uint[] effectslots);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alDeleteAuxiliaryEffectSlots(int n, ref uint effectslots);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alIsAuxiliaryEffectSlot(uint effectslot);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alAuxiliaryEffectSloti(uint effectslot, int param, int iValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alAuxiliaryEffectSlotiv(uint effectslot, int param, int[] iValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alAuxiliaryEffectSlotf(uint effectslot, int param, float flValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alAuxiliaryEffectSlotfv(uint effectslot, int param, float[] flValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetAuxiliaryEffectSloti(uint effectslot, int param, out int piValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetAuxiliaryEffectSlotiv(uint effectslot, int param, int[] piValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetAuxiliaryEffectSlotf(uint effectslot, int param, out float pflValue);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alGetAuxiliaryEffectSlotfv(uint effectslot, int param, float[] pflValues);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alcCreateContext(IntPtr device, int[] attrList);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alcMakeContextCurrent(IntPtr context);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alcDestroyContext(IntPtr context);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alcGetCurrentContext();

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alcGetContextsDevice(IntPtr context);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alcOpenDevice([In] [MarshalAs(UnmanagedType.LPStr)] string deviceName);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alcCloseDevice(IntPtr device);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern int alcGetError(IntPtr device);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alcGetProcAddress(IntPtr device,
            [In] [MarshalAs(UnmanagedType.LPStr)] string funcName);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern int alcGetEnumValue(IntPtr device, [In] [MarshalAs(UnmanagedType.LPStr)] string enumName);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alcGetString(IntPtr device, int param);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alcGetIntegerv(IntPtr device, int param, int size, int[] values);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alcProcessContext(IntPtr context);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alcSuspendContext(IntPtr context);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alcIsExtensionPresent(IntPtr device,
            [In] [MarshalAs(UnmanagedType.LPStr)] string extName);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr alcCaptureOpenDevice([In] [MarshalAs(UnmanagedType.LPStr)] string deviceName,
            uint frequency, int format, int bufferSize);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern bool alcCaptureCloseDevice(IntPtr device);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alcCaptureStart(IntPtr device);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alcCaptureStop(IntPtr device);

        [DllImport(LIBRARY, CallingConvention = CallingConvention.Cdecl)]
        public static extern void alcCaptureSamples(IntPtr device, IntPtr buffer, int samples);
    }
}