Struct al_sys::AlApi

pub struct AlApi(_);

Methods

impl AlApi

pub fn load_default() -> Result<AlApi>

pub fn load<P: AsRef<Path>>(path: P) -> Result<AlApi>

pub unsafe fn alcCreateContext(
    &self,
    device: *mut ALCdevice,
    attrlist: *const ALCint
) -> *mut ALCcontext

pub unsafe fn alcMakeContextCurrent(
    &self,
    context: *mut ALCcontext
) -> ALCboolean

pub unsafe fn alcProcessContext(&self, context: *mut ALCcontext)

pub unsafe fn alcSuspendContext(&self, context: *mut ALCcontext)

pub unsafe fn alcDestroyContext(&self, context: *mut ALCcontext)

pub unsafe fn alcGetCurrentContext(&self) -> *mut ALCcontext

pub unsafe fn alcGetContextsDevice(
    &self,
    context: *mut ALCcontext
) -> *mut ALCdevice

pub unsafe fn alcOpenDevice(&self, devicename: *const ALCchar) -> *mut ALCdevice

pub unsafe fn alcCloseDevice(&self, device: *mut ALCdevice) -> ALCboolean

pub unsafe fn alcGetError(&self, device: *mut ALCdevice) -> ALCenum

pub unsafe fn alcIsExtensionPresent(
    &self,
    device: *mut ALCdevice,
    extname: *const ALCchar
) -> ALCboolean

pub unsafe fn alcGetProcAddress(
    &self,
    device: *mut ALCdevice,
    funcname: *const ALCchar
) -> *mut c_void

pub unsafe fn alcGetEnumValue(
    &self,
    device: *mut ALCdevice,
    enumname: *const ALCchar
) -> ALCenum

pub unsafe fn alcGetString(
    &self,
    device: *mut ALCdevice,
    param: ALCenum
) -> *const ALCchar

pub unsafe fn alcGetIntegerv(
    &self,
    device: *mut ALCdevice,
    param: ALCenum,
    size: ALCsizei,
    values: *mut ALCint
)

pub unsafe fn alcCaptureOpenDevice(
    &self,
    devicename: *const ALCchar,
    frequency: ALCuint,
    format: ALCenum,
    buffersize: ALCsizei
) -> *mut ALCdevice

pub unsafe fn alcCaptureCloseDevice(&self, device: *mut ALCdevice) -> ALCboolean

pub unsafe fn alcCaptureStart(&self, device: *mut ALCdevice)

pub unsafe fn alcCaptureStop(&self, device: *mut ALCdevice)

pub unsafe fn alcCaptureSamples(
    &self,
    device: *mut ALCdevice,
    buffer: *mut ALCvoid,
    samples: ALCsizei
)

pub unsafe fn alDopplerFactor(&self, value: ALfloat)

pub unsafe fn alDopplerVelocity(&self, value: ALfloat)

pub unsafe fn alSpeedOfSound(&self, value: ALfloat)

pub unsafe fn alDistanceModel(&self, distanceModel: ALenum)

pub unsafe fn alEnable(&self, capability: ALenum)

pub unsafe fn alDisable(&self, capability: ALenum)

pub unsafe fn alIsEnabled(&self, capability: ALenum) -> ALboolean

pub unsafe fn alGetString(&self, param: ALenum) -> *const ALchar

pub unsafe fn alGetBooleanv(&self, param: ALenum, values: *mut ALboolean)

pub unsafe fn alGetIntegerv(&self, param: ALenum, values: *mut ALint)

pub unsafe fn alGetFloatv(&self, param: ALenum, values: *mut ALfloat)

pub unsafe fn alGetDoublev(&self, param: ALenum, values: *mut ALdouble)

pub unsafe fn alGetBoolean(&self, param: ALenum) -> ALboolean

pub unsafe fn alGetInteger(&self, param: ALenum) -> ALint

pub unsafe fn alGetFloat(&self, param: ALenum) -> ALfloat

pub unsafe fn alGetDouble(&self, param: ALenum) -> ALdouble

pub unsafe fn alGetError(&self) -> ALenum

pub unsafe fn alIsExtensionPresent(&self, extname: *const ALchar) -> ALboolean

pub unsafe fn alGetProcAddress(&self, fname: *const ALchar) -> *mut c_void

pub unsafe fn alGetEnumValue(&self, ename: *const ALchar) -> ALenum

pub unsafe fn alListenerf(&self, param: ALenum, value: ALfloat)

pub unsafe fn alListener3f(
    &self,
    param: ALenum,
    value1: ALfloat,
    value2: ALfloat,
    value3: ALfloat
)

pub unsafe fn alListenerfv(&self, param: ALenum, values: *const ALfloat)

pub unsafe fn alListeneri(&self, param: ALenum, value: ALint)

pub unsafe fn alListener3i(
    &self,
    param: ALenum,
    value1: ALint,
    value2: ALint,
    value3: ALint
)

pub unsafe fn alListeneriv(&self, param: ALenum, values: *const ALint)

pub unsafe fn alGetListenerf(&self, param: ALenum, value: *mut ALfloat)

pub unsafe fn alGetListener3f(
    &self,
    param: ALenum,
    value1: *mut ALfloat,
    value2: *mut ALfloat,
    value3: *mut ALfloat
)

pub unsafe fn alGetListenerfv(&self, param: ALenum, values: *mut ALfloat)

pub unsafe fn alGetListeneri(&self, param: ALenum, value: *mut ALint)

pub unsafe fn alGetListener3i(
    &self,
    param: ALenum,
    value1: *mut ALint,
    value2: *mut ALint,
    value3: *mut ALint
)

pub unsafe fn alGetListeneriv(&self, param: ALenum, values: *mut ALint)

pub unsafe fn alGenSources(&self, n: ALsizei, sources: *mut ALuint)

pub unsafe fn alDeleteSources(&self, n: ALsizei, sources: *const ALuint)

pub unsafe fn alIsSource(&self, source: ALuint) -> ALboolean

pub unsafe fn alSourcef(&self, source: ALuint, param: ALenum, value: ALfloat)

pub unsafe fn alSource3f(
    &self,
    source: ALuint,
    param: ALenum,
    value1: ALfloat,
    value2: ALfloat,
    value3: ALfloat
)

pub unsafe fn alSourcefv(
    &self,
    source: ALuint,
    param: ALenum,
    values: *const ALfloat
)

pub unsafe fn alSourcei(&self, source: ALuint, param: ALenum, value: ALint)

pub unsafe fn alSource3i(
    &self,
    source: ALuint,
    param: ALenum,
    value1: ALint,
    value2: ALint,
    value3: ALint
)

pub unsafe fn alSourceiv(
    &self,
    source: ALuint,
    param: ALenum,
    values: *const ALint
)

pub unsafe fn alGetSourcef(
    &self,
    source: ALuint,
    param: ALenum,
    value: *mut ALfloat
)

pub unsafe fn alGetSource3f(
    &self,
    source: ALuint,
    param: ALenum,
    value1: *mut ALfloat,
    value2: *mut ALfloat,
    value3: *mut ALfloat
)

pub unsafe fn alGetSourcefv(
    &self,
    source: ALuint,
    param: ALenum,
    values: *mut ALfloat
)

pub unsafe fn alGetSourcei(
    &self,
    source: ALuint,
    param: ALenum,
    value: *mut ALint
)

pub unsafe fn alGetSource3i(
    &self,
    source: ALuint,
    param: ALenum,
    value1: *mut ALint,
    value2: *mut ALint,
    value3: *mut ALint
)

pub unsafe fn alGetSourceiv(
    &self,
    source: ALuint,
    param: ALenum,
    values: *mut ALint
)

pub unsafe fn alSourcePlayv(&self, n: ALsizei, sources: *const ALuint)

pub unsafe fn alSourceStopv(&self, n: ALsizei, sources: *const ALuint)

pub unsafe fn alSourceRewindv(&self, n: ALsizei, sources: *const ALuint)

pub unsafe fn alSourcePausev(&self, n: ALsizei, sources: *const ALuint)

pub unsafe fn alSourcePlay(&self, source: ALuint)

pub unsafe fn alSourceStop(&self, source: ALuint)

pub unsafe fn alSourceRewind(&self, source: ALuint)

pub unsafe fn alSourcePause(&self, source: ALuint)

pub unsafe fn alSourceQueueBuffers(
    &self,
    source: ALuint,
    nb: ALsizei,
    buffers: *const ALuint
)

pub unsafe fn alSourceUnqueueBuffers(
    &self,
    source: ALuint,
    nb: ALsizei,
    buffers: *mut ALuint
)

pub unsafe fn alGenBuffers(&self, n: ALsizei, buffers: *mut ALuint)

pub unsafe fn alDeleteBuffers(&self, n: ALsizei, buffers: *const ALuint)

pub unsafe fn alIsBuffer(&self, buffer: ALuint) -> ALboolean

pub unsafe fn alBufferData(
    &self,
    buffer: ALuint,
    format: ALenum,
    data: *const ALvoid,
    size: ALsizei,
    freq: ALsizei
)

pub unsafe fn alBufferf(&self, buffer: ALuint, param: ALenum, value: ALfloat)

pub unsafe fn alBuffer3f(
    &self,
    buffer: ALuint,
    param: ALenum,
    value1: ALfloat,
    value2: ALfloat,
    value3: ALfloat
)

pub unsafe fn alBufferfv(
    &self,
    buffer: ALuint,
    param: ALenum,
    values: *const ALfloat
)

pub unsafe fn alBufferi(&self, buffer: ALuint, param: ALenum, value: ALint)

pub unsafe fn alBuffer3i(
    &self,
    buffer: ALuint,
    param: ALenum,
    value1: ALint,
    value2: ALint,
    value3: ALint
)

pub unsafe fn alBufferiv(
    &self,
    buffer: ALuint,
    param: ALenum,
    values: *const ALint
)

pub unsafe fn alGetBufferf(
    &self,
    buffer: ALuint,
    param: ALenum,
    value: *mut ALfloat
)

pub unsafe fn alGetBuffer3f(
    &self,
    buffer: ALuint,
    param: ALenum,
    value1: *mut ALfloat,
    value2: *mut ALfloat,
    value3: *mut ALfloat
)

pub unsafe fn alGetBufferfv(
    &self,
    buffer: ALuint,
    param: ALenum,
    values: *mut ALfloat
)

pub unsafe fn alGetBufferi(
    &self,
    buffer: ALuint,
    param: ALenum,
    value: *mut ALint
)

pub unsafe fn alGetBuffer3i(
    &self,
    buffer: ALuint,
    param: ALenum,
    value1: *mut ALint,
    value2: *mut ALint,
    value3: *mut ALint
)

pub unsafe fn alGetBufferiv(
    &self,
    buffer: ALuint,
    param: ALenum,
    values: *mut ALint
)