public static ALCdevice create(java.nio.ByteBuffer buf) { return new ALCdevice(buf); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCproc alcGetProcAddress(ALCdevice * device, const ALCchar * funcname)</code><br> */ long alcGetProcAddress(ALCdevice device, String funcname) { final long __addr_ = alcProcAddressTable._addressof_alcGetProcAddress; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcGetProcAddress")); } return dispatch_alcGetProcAddress1(((device == null) ? null : device.getBuffer()), funcname, __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCdevice * alcCaptureOpenDevice(const ALCchar * devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize)</code><br> */ public ALCdevice alcCaptureOpenDevice(String devicename, int frequency, int format, int buffersize) { final long __addr_ = alcProcAddressTable._addressof_alcCaptureOpenDevice; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcCaptureOpenDevice")); } final ByteBuffer _res; _res = dispatch_alcCaptureOpenDevice1(devicename, frequency, format, buffersize, __addr_); if (_res == null) return null; return ALCdevice.create(Buffers.nativeOrder(_res)); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCdevice * alcOpenDevice(const ALCchar * devicename)</code><br> */ public ALCdevice alcOpenDevice(String devicename) { final long __addr_ = alcProcAddressTable._addressof_alcOpenDevice; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcOpenDevice")); } final ByteBuffer _res; _res = dispatch_alcOpenDevice1(devicename, __addr_); if (_res == null) return null; return ALCdevice.create(Buffers.nativeOrder(_res)); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCproc alcGetProcAddress(ALCdevice * device, const ALCchar * funcname)</code><br> */ long alcGetProcAddress(ALCdevice device, String funcname) { final long __addr_ = alExtProcAddressTable._addressof_alcGetProcAddress; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcGetProcAddress")); } return dispatch_alcGetProcAddress1(((device == null) ? null : device.getBuffer()), funcname, __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCdevice * alcLoopbackOpenDeviceSOFT(const ALCchar * deviceName)</code><br> */ public ALCdevice alcLoopbackOpenDeviceSOFT(String deviceName) { final long __addr_ = alExtProcAddressTable._addressof_alcLoopbackOpenDeviceSOFT; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcLoopbackOpenDeviceSOFT")); } final ByteBuffer _res; _res = dispatch_alcLoopbackOpenDeviceSOFT1(deviceName, __addr_); if (_res == null) return null; return ALCdevice.create(Buffers.nativeOrder(_res)); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCenum alcGetError(ALCdevice * device)</code><br> */ public int alcGetError(ALCdevice device) { final long __addr_ = alcProcAddressTable._addressof_alcGetError; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcGetError")); } return dispatch_alcGetError1(((device == null) ? null : device.getBuffer()), __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCdevice * alcGetContextsDevice(ALCcontext * context)</code><br> */ public ALCdevice alcGetContextsDevice(ALCcontext context) { final long __addr_ = alcProcAddressTable._addressof_alcGetContextsDevice; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcGetContextsDevice")); } final ByteBuffer _res; _res = dispatch_alcGetContextsDevice1(((context == null) ? null : context.getBuffer()), __addr_); if (_res == null) return null; return ALCdevice.create(Buffers.nativeOrder(_res)); }
/** Entry point (through function pointer) to C language function: <br> <code>void alcCaptureStart(ALCdevice * device)</code><br> */ public void alcCaptureStart(ALCdevice device) { final long __addr_ = alcProcAddressTable._addressof_alcCaptureStart; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcCaptureStart")); } dispatch_alcCaptureStart1(((device == null) ? null : device.getBuffer()), __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCboolean alcCloseDevice(ALCdevice * device)</code><br> */ public boolean alcCloseDevice(ALCdevice device) { final long __addr_ = alcProcAddressTable._addressof_alcCloseDevice; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcCloseDevice")); } return dispatch_alcCloseDevice1(((device == null) ? null : device.getBuffer()), __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCenum alcGetEnumValue(ALCdevice * device, const ALCchar * enumname)</code><br> */ public int alcGetEnumValue(ALCdevice device, String enumname) { final long __addr_ = alcProcAddressTable._addressof_alcGetEnumValue; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcGetEnumValue")); } return dispatch_alcGetEnumValue1(((device == null) ? null : device.getBuffer()), enumname, __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCboolean alcCaptureCloseDevice(ALCdevice * device)</code><br> */ public boolean alcCaptureCloseDevice(ALCdevice device) { final long __addr_ = alcProcAddressTable._addressof_alcCaptureCloseDevice; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcCaptureCloseDevice")); } return dispatch_alcCaptureCloseDevice1(((device == null) ? null : device.getBuffer()), __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>void alcCaptureStop(ALCdevice * device)</code><br> */ public void alcCaptureStop(ALCdevice device) { final long __addr_ = alcProcAddressTable._addressof_alcCaptureStop; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcCaptureStop")); } dispatch_alcCaptureStop1(((device == null) ? null : device.getBuffer()), __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCboolean alcIsRenderFormatSupportedSOFT(ALCdevice * device, ALCsizei freq, ALCenum channels, ALCenum type)</code><br> */ public boolean alcIsRenderFormatSupportedSOFT(ALCdevice device, int freq, int channels, int type) { final long __addr_ = alExtProcAddressTable._addressof_alcIsRenderFormatSupportedSOFT; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcIsRenderFormatSupportedSOFT")); } return dispatch_alcIsRenderFormatSupportedSOFT1(((device == null) ? null : device.getBuffer()), freq, channels, type, __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>ALCboolean alcIsExtensionPresent(ALCdevice * device, const ALCchar * extname)</code><br> */ public boolean alcIsExtensionPresent(ALCdevice device, String extname) { final long __addr_ = alcProcAddressTable._addressof_alcIsExtensionPresent; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcIsExtensionPresent")); } return dispatch_alcIsExtensionPresent1(((device == null) ? null : device.getBuffer()), extname, __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code>void alcGetIntegerv(ALCdevice * device, ALCenum param, ALCsizei size, ALCint * values)</code><br> */ public void alcGetIntegerv(ALCdevice device, int param, int size, int[] values, int values_offset) { if(values != null && values.length <= values_offset) throw new ALException("array offset argument \"values_offset\" (" + values_offset + ") equals or exceeds array length (" + values.length + ")"); final long __addr_ = alcProcAddressTable._addressof_alcGetIntegerv; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcGetIntegerv")); } dispatch_alcGetIntegerv1(((device == null) ? null : device.getBuffer()), param, size, values, Buffers.SIZEOF_INT * values_offset, false, __addr_); }
/** Entry point (through function pointer) to C language function: <br> <code> const ALCchar * alcGetString(ALCdevice * device, ALCenum param); </code> */ public ByteBuffer alcGetStringImpl(final ALCdevice device, final int param) { final long __addr_ = getALCProcAddressTable()._addressof_alcGetString; if (__addr_ == 0) { throw new UnsupportedOperationException("Method \"alcGetStringImpl\" not available"); } ByteBuffer _res; _res = dispatch_alcGetStringImpl1(((device == null) ? null : device.getBuffer()), param, __addr_); if (_res == null) { return null; } Buffers.nativeOrder(_res); return _res; } private native java.nio.ByteBuffer dispatch_alcGetStringImpl1(ByteBuffer deviceBuffer, int param, long addr);
/** Entry point (through function pointer) to C language function: <br> <code>ALCcontext * alcCreateContext(ALCdevice * device, const ALCint * attrlist)</code><br> */ public ALCcontext alcCreateContext(ALCdevice device, int[] attrlist, int attrlist_offset) { if(attrlist != null && attrlist.length <= attrlist_offset) throw new ALException("array offset argument \"attrlist_offset\" (" + attrlist_offset + ") equals or exceeds array length (" + attrlist.length + ")"); final long __addr_ = alcProcAddressTable._addressof_alcCreateContext; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcCreateContext")); } final ByteBuffer _res; _res = dispatch_alcCreateContext1(((device == null) ? null : device.getBuffer()), attrlist, Buffers.SIZEOF_INT * attrlist_offset, false, __addr_); if (_res == null) return null; return ALCcontext.create(Buffers.nativeOrder(_res)); }
/** Entry point (through function pointer) to C language function: <br> <code>void alcCaptureSamples(ALCdevice * device, ALCvoid * buffer, ALCsizei samples)</code><br> @param buffer a direct or array-backed {@link java.nio.Buffer} */ public void alcCaptureSamples(ALCdevice device, Buffer buffer, int samples) { final boolean buffer_is_direct = Buffers.isDirect(buffer); final long __addr_ = alcProcAddressTable._addressof_alcCaptureSamples; if (__addr_ == 0) { throw new UnsupportedOperationException(String.format("Method \"%s\" not available", "alcCaptureSamples")); } dispatch_alcCaptureSamples1(((device == null) ? null : device.getBuffer()), buffer_is_direct ? buffer : Buffers.getArray(buffer), buffer_is_direct ? Buffers.getDirectBufferByteOffset(buffer) : Buffers.getIndirectBufferByteOffset(buffer), buffer_is_direct, samples, __addr_); }