openal C function stubs for calling function pointers

audio/al/al.go

@@ -326,40 +326,40 @@ func CreateContext(dev *Device, attrlist []int) (*Context, error) {
 	if len(attrlist) != 0 {
 		plist = (unsafe.Pointer)(&attrlist[0])
 	}
-	ctx := C.alcCreateContext(dev.cdev, (*C.ALCint)(plist))
+	ctx := C._alcCreateContext(dev.cdev, (*C.ALCint)(plist))
 	if ctx != nil {
 		return &Context{ctx}, nil
 	}
-	return nil, fmt.Errorf("%s", errCodes[uint(C.alcGetError(dev.cdev))])
+	return nil, fmt.Errorf("%s", errCodes[uint(C._alcGetError(dev.cdev))])
 }
 
 func MakeContextCurrent(ctx *Context) error {
 
-	cres := C.alcMakeContextCurrent(ctx.cctx)
+	cres := C._alcMakeContextCurrent(ctx.cctx)
 	if cres == C.ALC_TRUE {
 		return nil
 	}
-	return fmt.Errorf("%s", errCodes[uint(C.alGetError())])
+	return fmt.Errorf("%s", errCodes[uint(C._alGetError())])
 }
 
 func ProcessContext(ctx *Context) {
 
-	C.alcProcessContext(ctx.cctx)
+	C._alcProcessContext(ctx.cctx)
 }
 
 func SuspendContext(ctx *Context) {
 
-	C.alcSuspendContext(ctx.cctx)
+	C._alcSuspendContext(ctx.cctx)
 }
 
 func DestroyContext(ctx *Context) {
 
-	C.alcDestroyContext(ctx.cctx)
+	C._alcDestroyContext(ctx.cctx)
 }
 
 func GetContextsDevice(ctx *Context) *Device {
 
-	cdev := C.alcGetContextsDevice(ctx.cctx)
+	cdev := C._alcGetContextsDevice(ctx.cctx)
 	if cdev == nil {
 		return nil
 	}
@@ -370,28 +370,28 @@ func OpenDevice(name string) (*Device, error) {
 
 	cstr := (*C.ALCchar)(C.CString(name))
 	defer C.free(unsafe.Pointer(cstr))
-	cdev := C.alcOpenDevice(cstr)
+	cdev := C._alcOpenDevice(cstr)
 	if cdev != nil {
 		dev := &Device{cdev}
 		mapDevice[cdev] = dev
 		return dev, nil
 	}
-	return nil, fmt.Errorf("%s", errCodes[uint(C.alGetError())])
+	return nil, fmt.Errorf("%s", errCodes[uint(C._alGetError())])
 }
 
 func CloseDevice(dev *Device) error {
 
-	cres := C.alcCloseDevice(dev.cdev)
+	cres := C._alcCloseDevice(dev.cdev)
 	if cres == C.ALC_TRUE {
 		delete(mapDevice, dev.cdev)
 		return nil
 	}
-	return fmt.Errorf("%s", errCodes[uint(C.alGetError())])
+	return fmt.Errorf("%s", errCodes[uint(C._alGetError())])
 }
 
 func CtxGetError(dev *Device) error {
 
-	cerr := C.alcGetError(dev.cdev)
+	cerr := C._alcGetError(dev.cdev)
 	if cerr == C.AL_NONE {
 		return nil
 	}
@@ -402,7 +402,7 @@ func CtxIsExtensionPresent(dev *Device, extname string) bool {
 
 	cname := (*C.ALCchar)(C.CString(extname))
 	defer C.free(unsafe.Pointer(cname))
-	cres := C.alcIsExtensionPresent(dev.cdev, cname)
+	cres := C._alcIsExtensionPresent(dev.cdev, cname)
 	if cres == C.AL_TRUE {
 		return true
 	}
@@ -413,71 +413,71 @@ func CtxGetEnumValue(dev *Device, enumName string) uint32 {
 
 	cname := (*C.ALCchar)(C.CString(enumName))
 	defer C.free(unsafe.Pointer(cname))
-	cres := C.alcGetEnumValue(dev.cdev, cname)
+	cres := C._alcGetEnumValue(dev.cdev, cname)
 	return uint32(cres)
 }
 
 func CtxGetString(dev *Device, param uint) string {
 
-	cstr := C.alcGetString(dev.cdev, C.ALCenum(param))
+	cstr := C._alcGetString(dev.cdev, C.ALCenum(param))
 	return C.GoString((*C.char)(cstr))
 }
 
 func CtxGetIntegerv(dev *Device, param uint32, values []int32) {
 
-	C.alcGetIntegerv(dev.cdev, C.ALCenum(param), C.ALCsizei(len(values)), (*C.ALCint)(unsafe.Pointer(&values[0])))
+	C._alcGetIntegerv(dev.cdev, C.ALCenum(param), C.ALCsizei(len(values)), (*C.ALCint)(unsafe.Pointer(&values[0])))
 }
 
 func CaptureOpenDevice(devname string, frequency uint32, format uint32, buffersize uint32) (*Device, error) {
 
 	cstr := (*C.ALCchar)(C.CString(devname))
 	defer C.free(unsafe.Pointer(cstr))
-	cdev := C.alcCaptureOpenDevice(cstr, C.ALCuint(frequency), C.ALCenum(format), C.ALCsizei(buffersize))
+	cdev := C._alcCaptureOpenDevice(cstr, C.ALCuint(frequency), C.ALCenum(format), C.ALCsizei(buffersize))
 	if cdev != nil {
 		dev := &Device{cdev}
 		mapDevice[cdev] = dev
 		return dev, nil
 	}
-	return nil, fmt.Errorf("%s", errCodes[uint(C.alGetError())])
+	return nil, fmt.Errorf("%s", errCodes[uint(C._alGetError())])
 }
 
 func CaptureCloseDevice(dev *Device) error {
 
-	cres := C.alcCaptureCloseDevice(dev.cdev)
+	cres := C._alcCaptureCloseDevice(dev.cdev)
 	if cres == C.AL_TRUE {
 		return nil
 	}
-	return fmt.Errorf("%s", errCodes[uint(C.alGetError())])
+	return fmt.Errorf("%s", errCodes[uint(C._alGetError())])
 }
 
 func CaptureStart(dev *Device) {
 
-	C.alcCaptureStart(dev.cdev)
+	C._alcCaptureStart(dev.cdev)
 }
 
 func CaptureStop(dev *Device) {
 
-	C.alcCaptureStop(dev.cdev)
+	C._alcCaptureStop(dev.cdev)
 }
 
 func CaptureSamples(dev *Device, buffer []byte) {
 
-	C.alcCaptureSamples(dev.cdev, unsafe.Pointer(&buffer[0]), C.ALCsizei(len(buffer)))
+	C._alcCaptureSamples(dev.cdev, unsafe.Pointer(&buffer[0]), C.ALCsizei(len(buffer)))
 }
 
 func Enable(capability uint) {
 
-	C.alEnable(C.ALenum(capability))
+	C._alEnable(C.ALenum(capability))
 }
 
 func Disable(capability uint) {
 
-	C.alDisable(C.ALenum(capability))
+	C._alDisable(C.ALenum(capability))
 }
 
 func IsEnabled(capability uint) bool {
 
-	cres := C.alIsEnabled(C.ALenum(capability))
+	cres := C._alIsEnabled(C.ALenum(capability))
 	if cres == C.AL_TRUE {
 		return true
 	}
@@ -486,14 +486,14 @@ func IsEnabled(capability uint) bool {
 
 func GetString(param uint32) string {
 
-	cstr := C.alGetString(C.ALenum(param))
+	cstr := C._alGetString(C.ALenum(param))
 	return C.GoString((*C.char)(cstr))
 }
 
 func GetBooleanv(param uint32, values []bool) {
 
 	cvals := make([]C.ALboolean, len(values))
-	C.alGetBooleanv(C.ALenum(param), &cvals[0])
+	C._alGetBooleanv(C.ALenum(param), &cvals[0])
 	for i := 0; i < len(cvals); i++ {
 		if cvals[i] == C.AL_TRUE {
 			values[i] = true
@@ -505,22 +505,22 @@ func GetBooleanv(param uint32, values []bool) {
 
 func GetIntegerv(param uint32, values []int32) {
 
-	C.alGetIntegerv(C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
+	C._alGetIntegerv(C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
 }
 
 func GetFloatv(param uint32, values []float32) {
 
-	C.alGetFloatv(C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
+	C._alGetFloatv(C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
 }
 
 func GetDoublev(param uint32, values []float64) {
 
-	C.alGetDoublev(C.ALenum(param), (*C.ALdouble)(unsafe.Pointer(&values[0])))
+	C._alGetDoublev(C.ALenum(param), (*C.ALdouble)(unsafe.Pointer(&values[0])))
 }
 
 func GetBoolean(param uint32) bool {
 
-	cres := C.alGetBoolean(C.ALenum(param))
+	cres := C._alGetBoolean(C.ALenum(param))
 	if cres == C.AL_TRUE {
 		return true
 	}
@@ -529,25 +529,25 @@ func GetBoolean(param uint32) bool {
 
 func GetInteger(param uint32) int32 {
 
-	cres := C.alGetInteger(C.ALenum(param))
+	cres := C._alGetInteger(C.ALenum(param))
 	return int32(cres)
 }
 
 func GetFloat(param uint32) float32 {
 
-	cres := C.alGetFloat(C.ALenum(param))
+	cres := C._alGetFloat(C.ALenum(param))
 	return float32(cres)
 }
 
 func GetDouble(param uint32) float64 {
 
-	cres := C.alGetDouble(C.ALenum(param))
+	cres := C._alGetDouble(C.ALenum(param))
 	return float64(cres)
 }
 
 func GetError() error {
 
-	cerr := C.alGetError()
+	cerr := C._alGetError()
 	if cerr == C.AL_NONE {
 		return nil
 	}
@@ -558,7 +558,7 @@ func IsExtensionPresent(extName string) bool {
 
 	cstr := (*C.ALchar)(C.CString(extName))
 	defer C.free(unsafe.Pointer(cstr))
-	cres := C.alIsExtensionPresent(cstr)
+	cres := C._alIsExtensionPresent(cstr)
 	if cres == 0 {
 		return false
 	}
@@ -569,44 +569,44 @@ func GetEnumValue(enam string) uint32 {
 
 	cenam := (*C.ALchar)(C.CString(enam))
 	defer C.free(unsafe.Pointer(cenam))
-	cres := C.alGetEnumValue(cenam)
+	cres := C._alGetEnumValue(cenam)
 	return uint32(cres)
 }
 
 func Listenerf(param uint32, value float32) {
 
-	C.alListenerf(C.ALenum(param), C.ALfloat(value))
+	C._alListenerf(C.ALenum(param), C.ALfloat(value))
 }
 
 func Listener3f(param uint32, value1, value2, value3 float32) {
 
-	C.alListener3f(C.ALenum(param), C.ALfloat(value1), C.ALfloat(value2), C.ALfloat(value3))
+	C._alListener3f(C.ALenum(param), C.ALfloat(value1), C.ALfloat(value2), C.ALfloat(value3))
 }
 
 func Listenerfv(param uint32, values []float32) {
 
-	C.alListenerfv(C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
+	C._alListenerfv(C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
 }
 
 func Listeneri(param uint32, value int32) {
 
-	C.alListeneri(C.ALenum(param), C.ALint(value))
+	C._alListeneri(C.ALenum(param), C.ALint(value))
 }
 
 func Listener3i(param uint32, value1, value2, value3 int32) {
 
-	C.alListener3i(C.ALenum(param), C.ALint(value1), C.ALint(value2), C.ALint(value3))
+	C._alListener3i(C.ALenum(param), C.ALint(value1), C.ALint(value2), C.ALint(value3))
 }
 
 func Listeneriv(param uint32, values []int32) {
 
-	C.alListeneriv(C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
+	C._alListeneriv(C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
 }
 
 func GetListenerf(param uint32) float32 {
 
 	var cval C.ALfloat
-	C.alGetListenerf(C.ALenum(param), &cval)
+	C._alGetListenerf(C.ALenum(param), &cval)
 	return float32(cval)
 }
 
@@ -615,19 +615,19 @@ func GetListener3f(param uint32) (float32, float32, float32) {
 	var cval1 C.ALfloat
 	var cval2 C.ALfloat
 	var cval3 C.ALfloat
-	C.alGetListener3f(C.ALenum(param), &cval1, &cval2, &cval3)
+	C._alGetListener3f(C.ALenum(param), &cval1, &cval2, &cval3)
 	return float32(cval1), float32(cval2), float32(cval3)
 }
 
 func GetListenerfv(param uint32, values []uint32) {
 
-	C.alGetListenerfv(C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
+	C._alGetListenerfv(C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
 }
 
 func GetListeneri(param uint32) int32 {
 
 	var cval C.ALint
-	C.alGetListeneri(C.ALenum(param), &cval)
+	C._alGetListeneri(C.ALenum(param), &cval)
 	return int32(cval)
 }
 
@@ -636,7 +636,7 @@ func GetListener3i(param uint32) (int32, int32, int32) {
 	var cval1 C.ALint
 	var cval2 C.ALint
 	var cval3 C.ALint
-	C.alGetListener3i(C.ALenum(param), &cval1, &cval2, &cval3)
+	C._alGetListener3i(C.ALenum(param), &cval1, &cval2, &cval3)
 	return int32(cval1), int32(cval2), int32(cval3)
 }
 
@@ -645,38 +645,38 @@ func GetListeneriv(param uint32, values []int32) {
 	if len(values) < 3 {
 		panic("Slice length less than minimum")
 	}
-	C.alGetListeneriv(C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
+	C._alGetListeneriv(C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
 }
 
 func GenSource() uint32 {
 
 	var csource C.ALuint
-	C.alGenSources(1, &csource)
+	C._alGenSources(1, &csource)
 	stats.Sources++
 	return uint32(csource)
 }
 
 func GenSources(sources []uint32) {
 
-	C.alGenSources(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
+	C._alGenSources(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
 	stats.Sources += len(sources)
 }
 
 func DeleteSource(source uint32) {
 
-	C.alDeleteSources(1, (*C.ALuint)(unsafe.Pointer(&source)))
+	C._alDeleteSources(1, (*C.ALuint)(unsafe.Pointer(&source)))
 	stats.Sources--
 }
 
 func DeleteSources(sources []uint32) {
 
-	C.alDeleteSources(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
+	C._alDeleteSources(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
 	stats.Sources -= len(sources)
 }
 
 func IsSource(source uint32) bool {
 
-	cres := C.alIsSource(C.ALuint(source))
+	cres := C._alIsSource(C.ALuint(source))
 	if cres == C.AL_TRUE {
 		return true
 	}
@@ -685,12 +685,12 @@ func IsSource(source uint32) bool {
 
 func Sourcef(source uint32, param uint32, value float32) {
 
-	C.alSourcef(C.ALuint(source), C.ALenum(param), C.ALfloat(value))
+	C._alSourcef(C.ALuint(source), C.ALenum(param), C.ALfloat(value))
 }
 
 func Source3f(source uint32, param uint32, value1, value2, value3 float32) {
 
-	C.alSource3f(C.ALuint(source), C.ALenum(param), C.ALfloat(value1), C.ALfloat(value2), C.ALfloat(value3))
+	C._alSource3f(C.ALuint(source), C.ALenum(param), C.ALfloat(value1), C.ALfloat(value2), C.ALfloat(value3))
 }
 
 func Sourcefv(source uint32, param uint32, values []float32) {
@@ -698,17 +698,17 @@ func Sourcefv(source uint32, param uint32, values []float32) {
 	if len(values) < 3 {
 		panic("Slice length less than minimum")
 	}
-	C.alSourcefv(C.ALuint(source), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
+	C._alSourcefv(C.ALuint(source), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
 }
 
 func Sourcei(source uint32, param uint32, value int32) {
 
-	C.alSourcei(C.ALuint(source), C.ALenum(param), C.ALint(value))
+	C._alSourcei(C.ALuint(source), C.ALenum(param), C.ALint(value))
 }
 
 func Source3i(source uint32, param uint32, value1, value2, value3 int32) {
 
-	C.alSource3i(C.ALuint(source), C.ALenum(param), C.ALint(value1), C.ALint(value2), C.ALint(value3))
+	C._alSource3i(C.ALuint(source), C.ALenum(param), C.ALint(value1), C.ALint(value2), C.ALint(value3))
 }
 
 func Sourceiv(source uint32, param uint32, values []int32) {
@@ -716,13 +716,13 @@ func Sourceiv(source uint32, param uint32, values []int32) {
 	if len(values) < 3 {
 		panic("Slice length less than minimum")
 	}
-	C.alSourceiv(C.ALuint(source), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
+	C._alSourceiv(C.ALuint(source), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
 }
 
 func GetSourcef(source uint32, param uint32) float32 {
 
 	var value C.ALfloat
-	C.alGetSourcef(C.ALuint(source), C.ALenum(param), &value)
+	C._alGetSourcef(C.ALuint(source), C.ALenum(param), &value)
 	return float32(value)
 }
 
@@ -731,7 +731,7 @@ func GetSource3f(source uint32, param uint32) (float32, float32, float32) {
 	var cval1 C.ALfloat
 	var cval2 C.ALfloat
 	var cval3 C.ALfloat
-	C.alGetSource3f(C.ALuint(source), C.ALenum(param), &cval1, &cval2, &cval3)
+	C._alGetSource3f(C.ALuint(source), C.ALenum(param), &cval1, &cval2, &cval3)
 	return float32(cval1), float32(cval2), float32(cval3)
 }
 
@@ -740,13 +740,13 @@ func GetSourcefv(source uint32, param uint32, values []float32) {
 	if len(values) < 3 {
 		panic("Slice length less than minimum")
 	}
-	C.alGetSourcefv(C.ALuint(source), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
+	C._alGetSourcefv(C.ALuint(source), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
 }
 
 func GetSourcei(source uint32, param uint32) int32 {
 
 	var value C.ALint
-	C.alGetSourcei(C.ALuint(source), C.ALenum(param), &value)
+	C._alGetSourcei(C.ALuint(source), C.ALenum(param), &value)
 	return int32(value)
 }
 
@@ -755,7 +755,7 @@ func GetSource3i(source uint32, param uint32) (int32, int32, int32) {
 	var cval1 C.ALint
 	var cval2 C.ALint
 	var cval3 C.ALint
-	C.alGetSource3i(C.ALuint(source), C.ALenum(param), &cval1, &cval2, &cval3)
+	C._alGetSource3i(C.ALuint(source), C.ALenum(param), &cval1, &cval2, &cval3)
 	return int32(cval1), int32(cval2), int32(cval3)
 }
 
@@ -764,75 +764,75 @@ func GetSourceiv(source uint32, param uint32, values []int32) {
 	if len(values) < 3 {
 		panic("Slice length less than minimum")
 	}
-	C.alGetSourceiv(C.ALuint(source), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
+	C._alGetSourceiv(C.ALuint(source), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
 }
 
 func SourcePlayv(sources []uint32) {
 
-	C.alSourcePlayv(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
+	C._alSourcePlayv(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
 }
 
 func SourceStopv(sources []uint32) {
 
-	C.alSourceStopv(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
+	C._alSourceStopv(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
 }
 
 func SourceRewindv(sources []uint32) {
 
-	C.alSourceRewindv(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
+	C._alSourceRewindv(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
 }
 
 func SourcePausev(sources []uint32) {
 
-	C.alSourcePausev(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
+	C._alSourcePausev(C.ALsizei(len(sources)), (*C.ALuint)(unsafe.Pointer(&sources[0])))
 }
 
 func SourcePlay(source uint32) {
 
-	C.alSourcePlay(C.ALuint(source))
+	C._alSourcePlay(C.ALuint(source))
 }
 
 func SourceStop(source uint32) {
 
-	C.alSourceStop(C.ALuint(source))
+	C._alSourceStop(C.ALuint(source))
 }
 
 func SourceRewind(source uint32) {
 
-	C.alSourceRewind(C.ALuint(source))
+	C._alSourceRewind(C.ALuint(source))
 }
 
 func SourcePause(source uint32) {
 
-	C.alSourcePause(C.ALuint(source))
+	C._alSourcePause(C.ALuint(source))
 }
 
 func SourceQueueBuffers(source uint32, buffers ...uint32) {
 
-	C.alSourceQueueBuffers(C.ALuint(source), C.ALsizei(len(buffers)), (*C.ALuint)(unsafe.Pointer(&buffers[0])))
+	C._alSourceQueueBuffers(C.ALuint(source), C.ALsizei(len(buffers)), (*C.ALuint)(unsafe.Pointer(&buffers[0])))
 }
 
 func SourceUnqueueBuffers(source uint32, n uint32, buffers []uint32) {
 
 	removed := make([]C.ALuint, n)
-	C.alSourceUnqueueBuffers(C.ALuint(source), C.ALsizei(n), &removed[0])
+	C._alSourceUnqueueBuffers(C.ALuint(source), C.ALsizei(n), &removed[0])
 }
 
 func GenBuffers(n uint32) []uint32 {
 
 	buffers := make([]uint32, n)
-	C.alGenBuffers(C.ALsizei(len(buffers)), (*C.ALuint)(unsafe.Pointer(&buffers[0])))
+	C._alGenBuffers(C.ALsizei(len(buffers)), (*C.ALuint)(unsafe.Pointer(&buffers[0])))
 	return buffers
 }
 
 func DeleteBuffers(buffers []uint32) {
 
-	C.alDeleteBuffers(C.ALsizei(len(buffers)), (*C.ALuint)(unsafe.Pointer(&buffers[0])))
+	C._alDeleteBuffers(C.ALsizei(len(buffers)), (*C.ALuint)(unsafe.Pointer(&buffers[0])))
 }
 
 func IsBuffer(buffer uint32) bool {
 
-	cres := C.alIsBuffer(C.ALuint(buffer))
+	cres := C._alIsBuffer(C.ALuint(buffer))
 	if cres == C.AL_TRUE {
 		return true
 	}
@@ -841,73 +841,73 @@ func IsBuffer(buffer uint32) bool {
 
 func BufferData(buffer uint32, format uint32, data unsafe.Pointer, size uint32, freq uint32) {
 
-	C.alBufferData(C.ALuint(buffer), C.ALenum(format), data, C.ALsizei(size), C.ALsizei(freq))
+	C._alBufferData(C.ALuint(buffer), C.ALenum(format), data, C.ALsizei(size), C.ALsizei(freq))
 }
 
 func Bufferf(buffer uint32, param uint32, value float32) {
 
-	C.alBufferf(C.ALuint(buffer), C.ALenum(param), C.ALfloat(value))
+	C._alBufferf(C.ALuint(buffer), C.ALenum(param), C.ALfloat(value))
 }
 
 func Buffer3f(buffer uint32, param uint32, value1, value2, value3 float32) {
 
-	C.alBuffer3f(C.ALuint(buffer), C.ALenum(param), C.ALfloat(value1), C.ALfloat(value2), C.ALfloat(value3))
+	C._alBuffer3f(C.ALuint(buffer), C.ALenum(param), C.ALfloat(value1), C.ALfloat(value2), C.ALfloat(value3))
 }
 
 func Bufferfv(buffer uint32, param uint32, values []float32) {
 
-	C.alBufferfv(C.ALuint(buffer), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
+	C._alBufferfv(C.ALuint(buffer), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
 }
 
 func Bufferi(buffer uint32, param uint32, value int32) {
 
-	C.alBufferi(C.ALuint(buffer), C.ALenum(param), C.ALint(value))
+	C._alBufferi(C.ALuint(buffer), C.ALenum(param), C.ALint(value))
 }
 
 func Buffer3i(buffer uint32, param uint32, value1, value2, value3 int32) {
 
-	C.alBuffer3i(C.ALuint(buffer), C.ALenum(param), C.ALint(value1), C.ALint(value2), C.ALint(value3))
+	C._alBuffer3i(C.ALuint(buffer), C.ALenum(param), C.ALint(value1), C.ALint(value2), C.ALint(value3))
 }
 
 func Bufferiv(buffer uint32, param uint32, values []int32) {
 
-	C.alBufferiv(C.ALuint(buffer), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
+	C._alBufferiv(C.ALuint(buffer), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
 }
 
 func GetBufferf(buffer uint32, param uint32) float32 {
 
 	var value C.ALfloat
-	C.alGetBufferf(C.ALuint(buffer), C.ALenum(param), &value)
+	C._alGetBufferf(C.ALuint(buffer), C.ALenum(param), &value)
 	return float32(value)
 }
 
 func GetBuffer3f(buffer uint32, param uint32) (v1 float32, v2 float32, v3 float32) {
 
 	var value1, value2, value3 C.ALfloat
-	C.alGetBuffer3f(C.ALuint(buffer), C.ALenum(param), &value1, &value2, &value3)
+	C._alGetBuffer3f(C.ALuint(buffer), C.ALenum(param), &value1, &value2, &value3)
 	return float32(value1), float32(value2), float32(value3)
 }
 
 func GetBufferfv(buffer uint32, param uint32, values []float32) {
 
-	C.alGetBufferfv(C.ALuint(buffer), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
+	C._alGetBufferfv(C.ALuint(buffer), C.ALenum(param), (*C.ALfloat)(unsafe.Pointer(&values[0])))
 }
 
 func GetBufferi(buffer uint32, param uint32) int32 {
 
 	var value C.ALint
-	C.alGetBufferi(C.ALuint(buffer), C.ALenum(param), &value)
+	C._alGetBufferi(C.ALuint(buffer), C.ALenum(param), &value)
 	return int32(value)
 }
 
 func GetBuffer3i(buffer uint32, param uint32) (int32, int32, int32) {
 
 	var value1, value2, value3 C.ALint
-	C.alGetBuffer3i(C.ALuint(buffer), C.ALenum(param), &value1, &value2, &value3)
+	C._alGetBuffer3i(C.ALuint(buffer), C.ALenum(param), &value1, &value2, &value3)
 	return int32(value1), int32(value2), int32(value3)
 }
 
 func GetBufferiv(buffer uint32, param uint32, values []int32) {
 
-	C.alGetBufferiv(C.ALuint(buffer), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
+	C._alGetBufferiv(C.ALuint(buffer), C.ALenum(param), (*C.ALint)(unsafe.Pointer(&values[0])))
 }

audio/al/loader.c

@@ -389,364 +389,362 @@ static void load_efx_procs(void) {
 //
 // alc.h
 //
-
-ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint* attrlist) {
+ALCcontext* _alcCreateContext(ALCdevice *device, const ALCint* attrlist) {
     return palcCreateContext(device, attrlist);
 }
 
-ALC_API ALCboolean  ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context) {
+ALCboolean _alcMakeContextCurrent(ALCcontext *context) {
     return palcMakeContextCurrent(context);
 }
 
-ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context) {
-        palcProcessContext(context);
+void _alcProcessContext(ALCcontext *context) {
+    palcProcessContext(context);
 }
 
-ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context) {
+void _alcSuspendContext(ALCcontext *context) {
     palcSuspendContext(context);
 }
 
-ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context) {
+void _alcDestroyContext(ALCcontext *context) {
     palcDestroyContext(context);
 }
 
-ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void) {
+ALCcontext* _alcGetCurrentContext(void) {
     return palcGetCurrentContext();
 }
 
-ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *context) {
+ALCdevice* _alcGetContextsDevice(ALCcontext *context) {
     return palcGetContextsDevice(context);
 }
 
-ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename) {
+ALCdevice* _alcOpenDevice(const ALCchar *devicename) {
     return palcOpenDevice(devicename);
 }
 
-ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device) {
+ALCboolean _alcCloseDevice(ALCdevice *device) {
     return palcCloseDevice(device);
 }
 
-ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device) {
+ALCenum _alcGetError(ALCdevice *device) {
     return palcGetError(device);
 }
 
-ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname) {
+ALCboolean _alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname) {
     return palcIsExtensionPresent(device, extname);
 }
 
-ALC_API void* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname) {
+void* _alcGetProcAddress(ALCdevice *device, const ALCchar *funcname) {
     return palcGetProcAddress(device, funcname);
 }
 
-ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname) {
+ALCenum _alcGetEnumValue(ALCdevice *device, const ALCchar *enumname) {
     return palcGetEnumValue(device, enumname);
 }
 
-ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param) {
+const ALCchar* _alcGetString(ALCdevice *device, ALCenum param) {
     return palcGetString(device, param);
 }
 
-ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values) {
+void _alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values) {
     return palcGetIntegerv(device, param, size, values);
 }
 
-ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize) {
+ALCdevice* _alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize) {
     return palcCaptureOpenDevice(devicename, frequency, format, buffersize);
 }
 
-ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device) {
+ALCboolean _alcCaptureCloseDevice(ALCdevice *device) {
     return palcCaptureCloseDevice(device);
 }
 
-ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device) {
+void _alcCaptureStart(ALCdevice *device) {
     palcCaptureStart(device);
 }
 
-ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device) {
+void _alcCaptureStop(ALCdevice *device) {
     palcCaptureStop(device);
 }
 
-ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) {
+void _alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) {
     palcCaptureSamples(device, buffer, samples);
 }
 
 //
 // al.h
 //
-
-AL_API void AL_APIENTRY alEnable(ALenum capability) {
+void _alEnable(ALenum capability) {
     palEnable(capability);
 }
 
-AL_API void AL_APIENTRY alDisable(ALenum capability) {
+void _alDisable(ALenum capability) {
     palDisable(capability);
 }
 
-AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability) {
+ALboolean _alIsEnabled(ALenum capability) {
     return palIsEnabled(capability);
 }
 
-AL_API const ALchar* AL_APIENTRY alGetString(ALenum param) {
+const ALchar* _alGetString(ALenum param) {
     return palGetString(param);
 }
 
-AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean *values) {
+void _alGetBooleanv(ALenum param, ALboolean *values) {
     palGetBooleanv(param, values);
 }
 
-AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint *values) {
+void _alGetIntegerv(ALenum param, ALint *values) {
     palGetIntegerv(param, values);
 }
 
-AL_API void AL_APIENTRY alGetFloatv(ALenum param, ALfloat *values) {
+void _alGetFloatv(ALenum param, ALfloat *values) {
     palGetFloatv(param, values);
 }
 
-AL_API void AL_APIENTRY alGetDoublev(ALenum param, ALdouble *values) {
+void _alGetDoublev(ALenum param, ALdouble *values) {
     palGetDoublev(param, values);
 }
 
-AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum param) {
+ALboolean _alGetBoolean(ALenum param) {
     return palGetBoolean(param);
 }
 
-AL_API ALint AL_APIENTRY alGetInteger(ALenum param) {
+ALint _alGetInteger(ALenum param) {
     return palGetInteger(param);
 }
 
-AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param) {
+ALfloat _alGetFloat(ALenum param) {
     return palGetFloat(param);
 }
 
-AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param) {
+ALdouble _alGetDouble(ALenum param) {
     return palGetDouble(param);
 }
 
-AL_API ALenum AL_APIENTRY alGetError(void) {
+ALenum _alGetError(void) {
     return palGetError();
 }
 
-AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname) {
+ALboolean _alIsExtensionPresent(const ALchar *extname) {
     return palIsExtensionPresent(extname);
 }
 
-AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname) {
+void* _alGetProcAddress(const ALchar *fname) {
     return palGetProcAddress(fname);
 }
 
-AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename) {
+ALenum _alGetEnumValue(const ALchar *ename) {
     return palGetEnumValue(ename);
 }
 
-AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value) {
+void _alListenerf(ALenum param, ALfloat value) {
     palListenerf(param, value);
 }
 
-AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) {
+void _alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) {
     palListener3f(param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values) {
+void _alListenerfv(ALenum param, const ALfloat *values) {
     palListenerfv(param, values);
 }
 
-AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value) {
+void _alListeneri(ALenum param, ALint value) {
     palListeneri(param, value);
 }
 
-AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3) {
+void _alListener3i(ALenum param, ALint value1, ALint value2, ALint value3) {
     palListener3i(param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values) {
+void _alListeneriv(ALenum param, const ALint *values) {
     palListeneriv(param, values);
 }
 
-AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value) {
+void  _alGetListenerf(ALenum param, ALfloat *value) {
     palGetListenerf(param, value);
 }
 
-AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) {
+void  _alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) {
     palGetListener3f(param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values) {
+void _alGetListenerfv(ALenum param, ALfloat *values) {
     palGetListenerfv(param, values);
 }
 
-AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value) {
+void _alGetListeneri(ALenum param, ALint *value) {
     palGetListeneri(param, value);
 }
 
-AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3) {
+void _alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3) {
     palGetListener3i(param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint *values) {
+void _alGetListeneriv(ALenum param, ALint *values) {
     palGetListeneriv(param, values);
 }
 
-AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources) {
+void _alGenSources(ALsizei n, ALuint *sources) {
     palGenSources(n, sources);
 }
 
-AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources) {
+void  _alDeleteSources(ALsizei n, const ALuint *sources) {
     palDeleteSources(n, sources);
 }
 
-AL_API ALboolean AL_APIENTRY alIsSource(ALuint source) {
+ALboolean _alIsSource(ALuint source) {
     return palIsSource(source);
 }
 
-AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value) {
+void _alSourcef(ALuint source, ALenum param, ALfloat value) {
     palSourcef(source, param, value);
 }
 
-AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) {
+void _alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) {
     palSource3f(source, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values) {
+void _alSourcefv(ALuint source, ALenum param, const ALfloat *values) {
     palSourcefv(source, param, values);
 }
 
-AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value) {
+void _alSourcei(ALuint source, ALenum param, ALint value) {
     palSourcei(source, param, value);
 }
 
-AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3) {
+void _alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3) {
     palSource3i(source, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values) {
+void _alSourceiv(ALuint source, ALenum param, const ALint *values) {
     palSourceiv(source, param, values);
 }
 
-AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value) {
+void _alGetSourcef(ALuint source, ALenum param, ALfloat *value) {
     palGetSourcef(source, param, value);
 }
 
-AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) {
+void _alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) {
     palGetSource3f(source, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values) {
+void _alGetSourcefv(ALuint source, ALenum param, ALfloat *values) {
     palGetSourcefv(source, param, values);
 }
 
-AL_API void AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value) {
+void _alGetSourcei(ALuint source, ALenum param, ALint *value) {
     palGetSourcei(source, param, value);
 }
 
-AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3) {
+void _alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3) {
     palGetSource3i(source, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param, ALint *values) {
+void _alGetSourceiv(ALuint source, ALenum param, ALint *values) {
     palGetSourceiv(source, param, values);
 }
 
-AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources) {
+void _alSourcePlayv(ALsizei n, const ALuint *sources) {
     palSourcePlayv(n, sources);
 }
 
-AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources) {
+void _alSourceStopv(ALsizei n, const ALuint *sources) {
     palSourceStopv(n, sources);
 }
 
-AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources) {
+void _alSourceRewindv(ALsizei n, const ALuint *sources) {
     palSourceRewindv(n, sources);
 }
 
-AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources) {
+void _alSourcePausev(ALsizei n, const ALuint *sources) {
     palSourcePausev(n, sources);
 }
 
-AL_API void AL_APIENTRY alSourcePlay(ALuint source) {
+void _alSourcePlay(ALuint source) {
     palSourcePlay(source);
 }
 
-AL_API void AL_APIENTRY alSourceStop(ALuint source) {
+void _alSourceStop(ALuint source) {
     palSourceStop(source);
 }
 
-AL_API void AL_APIENTRY alSourceRewind(ALuint source) {
+void _alSourceRewind(ALuint source) {
     palSourceRewind(source);
 }
 
-AL_API void AL_APIENTRY alSourcePause(ALuint source) {
+void _alSourcePause(ALuint source) {
     palSourcePause(source);
 }
 
-AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers) {
+void _alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers) {
     palSourceQueueBuffers(source, nb, buffers);
 }
 
-AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers) {
+void _alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers) {
     palSourceUnqueueBuffers(source, nb, buffers);
 }
 
-AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers) {
+void _alGenBuffers(ALsizei n, ALuint *buffers) {
     palGenBuffers(n, buffers);
 }
 
-AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers) {
+void _alDeleteBuffers(ALsizei n, const ALuint *buffers) {
     palDeleteBuffers(n, buffers);
 }
 
-AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer) {
+ALboolean _alIsBuffer(ALuint buffer) {
     return palIsBuffer(buffer);
 }
 
-AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq) {
+void _alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq) {
     palBufferData(buffer, format, data, size, freq);
 }
 
-AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value) {
+void _alBufferf(ALuint buffer, ALenum param, ALfloat value) {
     palBufferf(buffer, param, value);
 }
 
-AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) {
+void _alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3) {
     palBuffer3f(buffer, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values) {
+void _alBufferfv(ALuint buffer, ALenum param, const ALfloat *values) {
     palBufferfv(buffer, param, values);
 }
 
-AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value) {
+void _alBufferi(ALuint buffer, ALenum param, ALint value) {
     palBufferi(buffer, param, value);
 }
 
-AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3) {
+void _alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3) {
     palBuffer3i(buffer, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values) {
+void _alBufferiv(ALuint buffer, ALenum param, const ALint *values) {
     palBufferiv(buffer, param, values);
 }
 
-AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value) {
+void _alGetBufferf(ALuint buffer, ALenum param, ALfloat *value) {
     palGetBufferf(buffer, param, value);
 }
 
-AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) {
+void _alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3) {
     palGetBuffer3f(buffer, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values) {
+void _alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values) {
     palGetBufferfv(buffer, param, values);
 }
 
-AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value) {
+void _alGetBufferi(ALuint buffer, ALenum param, ALint *value) {
     palGetBufferi(buffer, param, value);
 }
 
-AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3) {
+void _alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3) {
     palGetBuffer3i(buffer, param, value1, value2, value3);
 }
 
-AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values) {
+void _alGetBufferiv(ALuint buffer, ALenum param, ALint *values) {
     palGetBufferiv(buffer, param, values);
 }
 

audio/al/loader.h

@@ -1,7 +1,6 @@
 #ifndef LOADER_H
 #define LOADER_H
 
-
 #ifdef _WIN32
 #include <stdlib.h>
 #include <stdio.h>
@@ -21,9 +20,101 @@
 #include "AL/efx.h"
 #endif
 
-
+// Function declarations
 int al_load();
 
+ALCcontext* _alcCreateContext(ALCdevice *device, const ALCint* attrlist);
+ALCboolean _alcMakeContextCurrent(ALCcontext *context);
+void _alcProcessContext(ALCcontext *context);
+void _alcSuspendContext(ALCcontext *context);
+void _alcDestroyContext(ALCcontext *context);
+ALCcontext* _alcGetCurrentContext(void);
+ALCdevice* _alcGetContextsDevice(ALCcontext *context);
+ALCdevice* _alcOpenDevice(const ALCchar *devicename);
+ALCboolean _alcCloseDevice(ALCdevice *device);
+ALCenum _alcGetError(ALCdevice *device);
+ALCboolean _alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname);
+void* _alcGetProcAddress(ALCdevice *device, const ALCchar *funcname);
+ALCenum _alcGetEnumValue(ALCdevice *device, const ALCchar *enumname);
+const ALCchar* _alcGetString(ALCdevice *device, ALCenum param);
+void _alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
+ALCdevice* _alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
+ALCboolean _alcCaptureCloseDevice(ALCdevice *device);
+void _alcCaptureStart(ALCdevice *device);
+void _alcCaptureStop(ALCdevice *device);
+void _alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
+
+void _alEnable(ALenum capability);
+void _alDisable(ALenum capability);
+ALboolean _alIsEnabled(ALenum capability);
+const ALchar* _alGetString(ALenum param);
+void _alGetBooleanv(ALenum param, ALboolean *values);
+void _alGetIntegerv(ALenum param, ALint *values);
+void _alGetFloatv(ALenum param, ALfloat *values);
+void _alGetDoublev(ALenum param, ALdouble *values);
+ALboolean _alGetBoolean(ALenum param);
+ALint _alGetInteger(ALenum param);
+ALfloat _alGetFloat(ALenum param);
+ALdouble _alGetDouble(ALenum param);
+ALenum _alGetError(void);
+ALboolean _alIsExtensionPresent(const ALchar *extname);
+void* _alGetProcAddress(const ALchar *fname);
+ALenum _alGetEnumValue(const ALchar *ename);
+void _alListenerf(ALenum param, ALfloat value);
+void _alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+void _alListenerfv(ALenum param, const ALfloat *values);
+void _alListeneri(ALenum param, ALint value);
+void _alListener3i(ALenum param, ALint value1, ALint value2, ALint value3);
+void _alListeneriv(ALenum param, const ALint *values);
+void  _alGetListenerf(ALenum param, ALfloat *value);
+void  _alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+void _alGetListenerfv(ALenum param, ALfloat *values);
+void _alGetListeneri(ALenum param, ALint *value);
+void _alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3);
+void _alGetListeneriv(ALenum param, ALint *values);
+void _alGenSources(ALsizei n, ALuint *sources);
+void  _alDeleteSources(ALsizei n, const ALuint *sources);
+ALboolean _alIsSource(ALuint source);
+void _alSourcef(ALuint source, ALenum param, ALfloat value);
+void _alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+void _alSourcefv(ALuint source, ALenum param, const ALfloat *values);
+void _alSourcei(ALuint source, ALenum param, ALint value);
+void _alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
+void _alSourceiv(ALuint source, ALenum param, const ALint *values);
+void _alGetSourcef(ALuint source, ALenum param, ALfloat *value);
+void _alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+void _alGetSourcefv(ALuint source, ALenum param, ALfloat *values);
+void _alGetSourcei(ALuint source, ALenum param, ALint *value);
+void _alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
+void _alGetSourceiv(ALuint source, ALenum param, ALint *values);
+void _alSourcePlayv(ALsizei n, const ALuint *sources);
+void _alSourceStopv(ALsizei n, const ALuint *sources);
+void _alSourceRewindv(ALsizei n, const ALuint *sources);
+void _alSourcePausev(ALsizei n, const ALuint *sources);
+void _alSourcePlay(ALuint source);
+void _alSourceStop(ALuint source);
+void _alSourceRewind(ALuint source);
+void _alSourcePause(ALuint source);
+void _alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers);
+void _alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers);
+void _alGenBuffers(ALsizei n, ALuint *buffers);
+void _alDeleteBuffers(ALsizei n, const ALuint *buffers);
+ALboolean _alIsBuffer(ALuint buffer);
+void _alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
+void _alBufferf(ALuint buffer, ALenum param, ALfloat value);
+void _alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+void _alBufferfv(ALuint buffer, ALenum param, const ALfloat *values);
+void _alBufferi(ALuint buffer, ALenum param, ALint value);
+void _alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
+void _alBufferiv(ALuint buffer, ALenum param, const ALint *values);
+void _alGetBufferf(ALuint buffer, ALenum param, ALfloat *value);
+void _alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+void _alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values);
+void _alGetBufferi(ALuint buffer, ALenum param, ALint *value);
+void _alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
+void _alGetBufferiv(ALuint buffer, ALenum param, ALint *values);
+
+// Function pointers declarations
 extern LPALENABLE                  palEnable;
 extern LPALDISABLE                 palDisable;
 extern LPALISENABLED               palIsEnabled;