Initial release: RadiantWave v1.0

2026-03-12 08:05:10 -05:00
commit 403ec4db89
555 changed files with 437856 additions and 0 deletions
@@ -0,0 +1,651 @@
+package sdl
+
+/*
+#include "sdl_wrapper.h"
+
+#if !(SDL_VERSION_ATLEAST(2,0,4))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_QueueAudio is not supported before SDL 2.0.4")
+#endif
+
+static int SDL_QueueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len)
+{
+	return -1;
+}
+static Uint32 SDL_GetQueuedAudioSize(SDL_AudioDeviceID dev_id)
+{
+	return 0;
+}
+static void SDL_ClearQueuedAudio(SDL_AudioDeviceID dev)
+{
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,5))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_DequeueAudio is not supported before SDL 2.0.5")
+#endif
+
+static int SDL_DequeueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len)
+{
+	return -1;
+}
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,7))
+
+struct _SDL_AudioStream;
+typedef struct _SDL_AudioStream SDL_AudioStream;
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_NewAudioStream is not supported before SDL 2.0.7")
+#endif
+
+static SDL_AudioStream * SDL_NewAudioStream(const SDL_AudioFormat src_format, const Uint8 src_channels, const int src_rate, const SDL_AudioFormat dst_format, const Uint8 dst_channels, const int dst_rate)
+{
+	return 0;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamPut is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, int len)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamGet is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, int len)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamAvailable is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamAvailable(SDL_AudioStream *stream)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamFlush is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamFlush(SDL_AudioStream *stream)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_AudioStreamClear is not supported before SDL 2.0.7")
+#endif
+
+static int SDL_AudioStreamClear(SDL_AudioStream *stream)
+{
+	return -1;
+}
+
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_FreeAudioStream is not supported before SDL 2.0.7")
+#endif
+
+static void SDL_FreeAudioStream(SDL_AudioStream *stream)
+{
+}
+
+#endif
+
+#if !(SDL_VERSION_ATLEAST(2,0,16))
+
+#if defined(WARN_OUTDATED)
+#pragma message("SDL_GetAudioDeviceSpec is not supported before SDL 2.0.16")
+#endif
+
+static int SDL_GetAudioDeviceSpec(int index, int iscapture, SDL_AudioSpec *spec)
+{
+	return -1;
+}
+
+
+#endif
+*/
+import "C"
+import (
+	"reflect"
+	"unsafe"
+)
+
+// Audio format masks.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+const (
+	AUDIO_MASK_BITSIZE  = C.SDL_AUDIO_MASK_BITSIZE  // (0xFF)
+	AUDIO_MASK_DATATYPE = C.SDL_AUDIO_MASK_DATATYPE // (1<<8)
+	AUDIO_MASK_ENDIAN   = C.SDL_AUDIO_MASK_ENDIAN   // (1<<12)
+	AUDIO_MASK_SIGNED   = C.SDL_AUDIO_MASK_SIGNED   // (1<<15)
+)
+
+// Audio format values.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+const (
+	AUDIO_S8 = C.AUDIO_S8 // signed 8-bit samples
+	AUDIO_U8 = C.AUDIO_U8 // unsigned 8-bit samples
+
+	AUDIO_S16LSB = C.AUDIO_S16LSB // signed 16-bit samples in little-endian byte order
+	AUDIO_S16MSB = C.AUDIO_S16MSB // signed 16-bit samples in big-endian byte order
+	AUDIO_S16SYS = C.AUDIO_S16SYS // signed 16-bit samples in native byte order
+	AUDIO_S16    = C.AUDIO_S16    // AUDIO_S16LSB
+	AUDIO_U16LSB = C.AUDIO_U16LSB // unsigned 16-bit samples in little-endian byte order
+	AUDIO_U16MSB = C.AUDIO_U16MSB // unsigned 16-bit samples in big-endian byte order
+	AUDIO_U16SYS = C.AUDIO_U16SYS // unsigned 16-bit samples in native byte order
+	AUDIO_U16    = C.AUDIO_U16    // AUDIO_U16LSB
+
+	AUDIO_S32LSB = C.AUDIO_S32LSB // 32-bit integer samples in little-endian byte order
+	AUDIO_S32MSB = C.AUDIO_S32MSB // 32-bit integer samples in big-endian byte order
+	AUDIO_S32SYS = C.AUDIO_S32SYS // 32-bit integer samples in native byte order
+	AUDIO_S32    = C.AUDIO_S32    // AUDIO_S32LSB
+
+	AUDIO_F32LSB = C.AUDIO_F32LSB // 32-bit floating point samples in little-endian byte order
+	AUDIO_F32MSB = C.AUDIO_F32MSB // 32-bit floating point samples in big-endian byte order
+	AUDIO_F32SYS = C.AUDIO_F32SYS // 32-bit floating point samples in native byte order
+	AUDIO_F32    = C.AUDIO_F32    // AUDIO_F32LSB
+)
+
+// AllowedChanges flags specify how SDL should behave when a device cannot offer a specific feature. If the application requests a feature that the hardware doesn't offer, SDL will always try to get the closest equivalent. Used in OpenAudioDevice().
+// (https://wiki.libsdl.org/SDL_OpenAudioDevice)
+const (
+	AUDIO_ALLOW_FREQUENCY_CHANGE = C.SDL_AUDIO_ALLOW_FREQUENCY_CHANGE
+	AUDIO_ALLOW_FORMAT_CHANGE    = C.SDL_AUDIO_ALLOW_FORMAT_CHANGE
+	AUDIO_ALLOW_CHANNELS_CHANGE  = C.SDL_AUDIO_ALLOW_CHANNELS_CHANGE
+	AUDIO_ALLOW_ANY_CHANGE       = C.SDL_AUDIO_ALLOW_ANY_CHANGE
+)
+
+// An enumeration of audio device states used in GetAudioDeviceStatus() and GetAudioStatus().
+// (https://wiki.libsdl.org/SDL_AudioStatus)
+const (
+	AUDIO_STOPPED AudioStatus = C.SDL_AUDIO_STOPPED // audio device is stopped
+	AUDIO_PLAYING             = C.SDL_AUDIO_PLAYING // audio device is playing
+	AUDIO_PAUSED              = C.SDL_AUDIO_PAUSED  // audio device is paused
+)
+
+// MIX_MAXVOLUME is the full audio volume value used in MixAudioFormat() and AudioFormat().
+// (https://wiki.libsdl.org/SDL_MixAudioFormat)
+const MIX_MAXVOLUME = C.SDL_MIX_MAXVOLUME // full audio volume
+
+// AudioFormat is an enumeration of audio formats.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+type AudioFormat uint16
+
+// AudioCallback is a function to call when the audio device needs more data.`
+// (https://wiki.libsdl.org/SDL_AudioSpec)
+type AudioCallback C.SDL_AudioCallback
+
+// AudioFilter is the filter list used in AudioCVT() (internal use)
+// (https://wiki.libsdl.org/SDL_AudioCVT)
+type AudioFilter C.SDL_AudioFilter
+
+// AudioDeviceID is ID of an audio device previously opened with OpenAudioDevice().
+// (https://wiki.libsdl.org/SDL_OpenAudioDevice)
+type AudioDeviceID uint32
+
+// AudioStatus is an enumeration of audio device states.
+// (https://wiki.libsdl.org/SDL_AudioStatus)
+type AudioStatus uint32
+type cAudioStatus C.SDL_AudioStatus
+
+// AudioSpec contains the audio output format. It also contains a callback that is called when the audio device needs more data.
+// (https://wiki.libsdl.org/SDL_AudioSpec)
+type AudioSpec struct {
+	Freq     int32          // DSP frequency (samples per second)
+	Format   AudioFormat    // audio data format
+	Channels uint8          // number of separate sound channels
+	Silence  uint8          // audio buffer silence value (calculated)
+	Samples  uint16         // audio buffer size in samples (power of 2)
+	_        uint16         // padding
+	Size     uint32         // audio buffer size in bytes (calculated)
+	Callback AudioCallback  // the function to call when the audio device needs more data
+	UserData unsafe.Pointer // a pointer that is passed to callback (otherwise ignored by SDL)
+}
+type cAudioSpec C.SDL_AudioSpec
+
+// AudioCVT contains audio data conversion information.
+// (https://wiki.libsdl.org/SDL_AudioCVT)
+type AudioCVT struct {
+	Needed      int32           // set to 1 if conversion possible
+	SrcFormat   AudioFormat     // source audio format
+	DstFormat   AudioFormat     // target audio format
+	RateIncr    float64         // rate conversion increment
+	Buf         unsafe.Pointer  // the buffer to hold entire audio data. Use AudioCVT.BufAsSlice() for access via a Go slice
+	Len         int32           // length of original audio buffer
+	LenCVT      int32           // length of converted audio buffer
+	LenMult     int32           // buf must be len*len_mult big
+	LenRatio    float64         // given len, final size is len*len_ratio
+	filters     [10]AudioFilter // filter list (internal use)
+	filterIndex int32           // current audio conversion function (internal use)
+}
+type cAudioCVT C.SDL_AudioCVT
+
+// AudioStream is a new audio conversion interface.
+// (https://wiki.libsdl.org/SDL_AudioStream)
+type AudioStream C.SDL_AudioStream
+
+func (fmt AudioFormat) c() C.SDL_AudioFormat {
+	return C.SDL_AudioFormat(fmt)
+}
+
+func (id AudioDeviceID) c() C.SDL_AudioDeviceID {
+	return C.SDL_AudioDeviceID(id)
+}
+
+func (as *AudioSpec) cptr() *C.SDL_AudioSpec {
+	return (*C.SDL_AudioSpec)(unsafe.Pointer(as))
+}
+
+func (cvt *AudioCVT) cptr() *C.SDL_AudioCVT {
+	return (*C.SDL_AudioCVT)(unsafe.Pointer(cvt))
+}
+
+func (stream *AudioStream) cptr() *C.SDL_AudioStream {
+	return (*C.SDL_AudioStream)(unsafe.Pointer(stream))
+}
+
+// BitSize returns audio formats bit size.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) BitSize() uint8 {
+	return uint8(fmt & AUDIO_MASK_BITSIZE)
+}
+
+// IsFloat reports whether audio format is float.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsFloat() bool {
+	return (fmt & AUDIO_MASK_DATATYPE) > 0
+}
+
+// IsBigEndian reports whether audio format is big-endian.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsBigEndian() bool {
+	return (fmt & AUDIO_MASK_ENDIAN) > 0
+}
+
+// IsSigned reports whether audio format is signed.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsSigned() bool {
+	return (fmt & AUDIO_MASK_SIGNED) > 0
+}
+
+// IsInt reports whether audio format is integer.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsInt() bool {
+	return !fmt.IsFloat()
+}
+
+// IsLittleEndian reports whether audio format is little-endian.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsLittleEndian() bool {
+	return !fmt.IsBigEndian()
+}
+
+// IsUnsigned reports whether audio format is unsigned.
+// (https://wiki.libsdl.org/SDL_AudioFormat)
+func (fmt AudioFormat) IsUnsigned() bool {
+	return !fmt.IsSigned()
+}
+
+// AllocBuf allocates the requested memory for AudioCVT buffer.
+func (cvt *AudioCVT) AllocBuf(size uintptr) {
+	cvt.Buf = C.malloc(C.size_t(size))
+}
+
+// FreeBuf deallocates the memory previously allocated from AudioCVT buffer.
+func (cvt *AudioCVT) FreeBuf() {
+	C.free(cvt.Buf)
+}
+
+// BufAsSlice returns AudioCVT.buf as byte slice.
+// NOTE: Must be used after ConvertAudio() because it uses LenCVT as slice length.
+func (cvt AudioCVT) BufAsSlice() []byte {
+	var b []byte
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Len = int(cvt.LenCVT)
+	sliceHeader.Cap = int(cvt.Len * cvt.LenMult)
+	sliceHeader.Data = uintptr(unsafe.Pointer(cvt.Buf))
+	return b
+}
+
+// GetNumAudioDrivers returns the number of built-in audio drivers.
+// (https://wiki.libsdl.org/SDL_GetNumAudioDrivers)
+func GetNumAudioDrivers() int {
+	return int(C.SDL_GetNumAudioDrivers())
+}
+
+// GetAudioDriver returns the name of a built in audio driver.
+// (https://wiki.libsdl.org/SDL_GetAudioDriver)
+func GetAudioDriver(index int) string {
+	return string(C.GoString(C.SDL_GetAudioDriver(C.int(index))))
+}
+
+// AudioInit initializes a particular audio driver.
+// (https://wiki.libsdl.org/SDL_AudioInit)
+func AudioInit(driverName string) error {
+	_driverName := C.CString(driverName)
+	defer C.free(unsafe.Pointer(_driverName))
+	if C.SDL_AudioInit(_driverName) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// AudioQuit shuts down audio if you initialized it with AudioInit().
+// (https://wiki.libsdl.org/SDL_AudioQuit)
+func AudioQuit() {
+	C.SDL_AudioQuit()
+}
+
+// GetCurrentAudioDriver returns the name of the current audio driver.
+// (https://wiki.libsdl.org/SDL_GetCurrentAudioDriver)
+func GetCurrentAudioDriver() string {
+	return string(C.GoString(C.SDL_GetCurrentAudioDriver()))
+}
+
+// OpenAudio opens the audio device. New programs might want to use OpenAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_OpenAudio)
+func OpenAudio(desired, obtained *AudioSpec) error {
+	if C.SDL_OpenAudio(desired.cptr(), obtained.cptr()) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// GetNumAudioDevices returns the number of built-in audio devices.
+// (https://wiki.libsdl.org/SDL_GetNumAudioDevices)
+func GetNumAudioDevices(isCapture bool) int {
+	return int(C.SDL_GetNumAudioDevices(C.int(Btoi(isCapture))))
+}
+
+// GetAudioDeviceName returns the name of a specific audio device.
+// (https://wiki.libsdl.org/SDL_GetAudioDeviceName)
+func GetAudioDeviceName(index int, isCapture bool) string {
+	return string(C.GoString(C.SDL_GetAudioDeviceName(C.int(index), C.int(Btoi(isCapture)))))
+}
+
+// OpenAudioDevice opens a specific audio device.
+// (https://wiki.libsdl.org/SDL_OpenAudioDevice)
+func OpenAudioDevice(device string, isCapture bool, desired, obtained *AudioSpec, allowedChanges int) (AudioDeviceID, error) {
+	_device := C.CString(device)
+	if device == "" {
+		_device = nil
+	}
+	defer C.free(unsafe.Pointer(_device))
+	if id := AudioDeviceID(C.SDL_OpenAudioDevice(_device, C.int(Btoi(isCapture)), desired.cptr(), obtained.cptr(), C.int(allowedChanges))); id > 0 {
+		return id, nil
+	}
+	return 0, GetError()
+}
+
+// GetAudioStatus returns the current audio state of the audio device. New programs might want to use GetAudioDeviceStatus() instead.
+// (https://wiki.libsdl.org/SDL_GetAudioStatus)
+func GetAudioStatus() AudioStatus {
+	return (AudioStatus)(C.SDL_GetAudioStatus())
+}
+
+// GetAudioDeviceStatus returns the current audio state of an audio device.
+// (https://wiki.libsdl.org/SDL_GetAudioDeviceStatus)
+func GetAudioDeviceStatus(dev AudioDeviceID) AudioStatus {
+	return (AudioStatus)(C.SDL_GetAudioDeviceStatus(dev.c()))
+}
+
+// PauseAudio pauses and unpauses the audio device. New programs might want to use SDL_PauseAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_PauseAudio)
+func PauseAudio(pauseOn bool) {
+	C.SDL_PauseAudio(C.int(Btoi(pauseOn)))
+}
+
+// PauseAudioDevice pauses and unpauses audio playback on a specified device.
+// (https://wiki.libsdl.org/SDL_PauseAudioDevice)
+func PauseAudioDevice(dev AudioDeviceID, pauseOn bool) {
+	C.SDL_PauseAudioDevice(dev.c(), C.int(Btoi(pauseOn)))
+}
+
+// LoadWAVRW loads a WAVE from the data source, automatically freeing that source if freeSrc is true.
+// (https://wiki.libsdl.org/SDL_LoadWAV_RW)
+func LoadWAVRW(src *RWops, freeSrc bool) ([]byte, *AudioSpec) {
+	var _audioBuf *C.Uint8
+	var _audioLen C.Uint32
+	audioSpec := (*AudioSpec)(unsafe.Pointer(C.SDL_LoadWAV_RW(src.cptr(), C.int(Btoi(freeSrc)), (&AudioSpec{}).cptr(), &_audioBuf, &_audioLen)))
+
+	var b []byte
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Len = (int)(_audioLen)
+	sliceHeader.Cap = (int)(_audioLen)
+	sliceHeader.Data = uintptr(unsafe.Pointer(_audioBuf))
+	return b, audioSpec
+}
+
+// LoadWAV loads a WAVE from a file.
+// (https://wiki.libsdl.org/SDL_LoadWAV)
+func LoadWAV(file string) ([]byte, *AudioSpec) {
+	_file := C.CString(file)
+	_rb := C.CString("rb")
+	defer C.free(unsafe.Pointer(_file))
+	defer C.free(unsafe.Pointer(_rb))
+
+	var _audioBuf *C.Uint8
+	var _audioLen C.Uint32
+	audioSpec := (*AudioSpec)(unsafe.Pointer(C.SDL_LoadWAV_RW(C.SDL_RWFromFile(_file, _rb), 1, (&AudioSpec{}).cptr(), &_audioBuf, &_audioLen)))
+
+	var b []byte
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	sliceHeader.Len = (int)(_audioLen)
+	sliceHeader.Cap = (int)(_audioLen)
+	sliceHeader.Data = uintptr(unsafe.Pointer(_audioBuf))
+	return b, audioSpec
+}
+
+// FreeWAV frees data previously allocated with LoadWAV() or LoadWAVRW().
+// (https://wiki.libsdl.org/SDL_FreeWAV)
+func FreeWAV(audioBuf []uint8) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&audioBuf))
+	_audioBuf := (*C.Uint8)(unsafe.Pointer(sliceHeader.Data))
+	C.SDL_FreeWAV(_audioBuf)
+}
+
+// BuildAudioCVT initializes an AudioCVT structure for conversion.
+// (https://wiki.libsdl.org/SDL_BuildAudioCVT)
+func BuildAudioCVT(cvt *AudioCVT, srcFormat AudioFormat, srcChannels uint8, srcRate int, dstFormat AudioFormat, dstChannels uint8, dstRate int) (converted bool, err error) {
+	switch int(C.SDL_BuildAudioCVT(cvt.cptr(), srcFormat.c(), C.Uint8(srcChannels), C.int(srcRate), dstFormat.c(), C.Uint8(dstChannels), C.int(dstRate))) {
+	case 1:
+		return true, nil
+	case 0:
+		return false, nil
+	}
+	return false, GetError()
+}
+
+// ConvertAudio converts audio data to a desired audio format.
+// (https://wiki.libsdl.org/SDL_ConvertAudio)
+func ConvertAudio(cvt *AudioCVT) error {
+	_cvt := (*C.SDL_AudioCVT)(unsafe.Pointer(cvt))
+	if C.SDL_ConvertAudio(_cvt) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// QueueAudio queues more audio on non-callback devices.
+// (https://wiki.libsdl.org/SDL_QueueAudio)
+func QueueAudio(dev AudioDeviceID, data []byte) error {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	_data := unsafe.Pointer(sliceHeader.Data)
+	_len := (C.Uint32)(sliceHeader.Len)
+	if C.SDL_QueueAudio(dev.c(), _data, _len) != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// DequeueAudio dequeues more audio on non-callback devices. Returns the number of bytes dequeued, which could be less than requested
+// (https://wiki.libsdl.org/SDL_DequeueAudio)
+func DequeueAudio(dev AudioDeviceID, data []byte) (n int, err error) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	_data := unsafe.Pointer(sliceHeader.Data)
+	_len := (C.Uint32)(sliceHeader.Len)
+	if dequeued := int(C.SDL_DequeueAudio(dev.c(), _data, _len)); dequeued > 0 {
+		return dequeued, nil
+	}
+	return 0, GetError()
+}
+
+// GetQueuedAudioSize returns the number of bytes of still-queued audio.
+// (https://wiki.libsdl.org/SDL_GetQueuedAudioSize)
+func GetQueuedAudioSize(dev AudioDeviceID) uint32 {
+	return uint32(C.SDL_GetQueuedAudioSize(dev.c()))
+}
+
+// ClearQueuedAudio drops any queued audio data waiting to be sent to the hardware.
+// (https://wiki.libsdl.org/SDL_ClearQueuedAudio)
+func ClearQueuedAudio(dev AudioDeviceID) {
+	C.SDL_ClearQueuedAudio(dev.c())
+}
+
+// MixAudio mixes audio data. New programs might want to use MixAudioFormat() instead.
+// (https://wiki.libsdl.org/SDL_MixAudio)
+func MixAudio(dst, src *uint8, len uint32, volume int) {
+	_dst := (*C.Uint8)(unsafe.Pointer(dst))
+	_src := (*C.Uint8)(unsafe.Pointer(src))
+	C.SDL_MixAudio(_dst, _src, C.Uint32(len), C.int(volume))
+}
+
+// MixAudioFormat mixes audio data in a specified format.
+// (https://wiki.libsdl.org/SDL_MixAudioFormat)
+func MixAudioFormat(dst, src *uint8, format AudioFormat, len uint32, volume int) {
+	_dst := (*C.Uint8)(unsafe.Pointer(dst))
+	_src := (*C.Uint8)(unsafe.Pointer(src))
+	C.SDL_MixAudioFormat(_dst, _src, format.c(), C.Uint32(len), C.int(volume))
+}
+
+// LockAudio locks the audio device. New programs might want to use LockAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_LockAudio)
+func LockAudio() {
+	C.SDL_LockAudio()
+}
+
+// LockAudioDevice locks out the audio callback function for a specified device.
+// (https://wiki.libsdl.org/SDL_LockAudioDevice)
+func LockAudioDevice(dev AudioDeviceID) {
+	C.SDL_LockAudioDevice(dev.c())
+}
+
+// UnlockAudio unlocks the audio device. New programs might want to use UnlockAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_UnlockAudio)
+func UnlockAudio() {
+	C.SDL_UnlockAudio()
+}
+
+// UnlockAudioDevice unlocks the audio callback function for a specified device.
+// (https://wiki.libsdl.org/SDL_UnlockAudioDevice)
+func UnlockAudioDevice(dev AudioDeviceID) {
+	C.SDL_UnlockAudioDevice(dev.c())
+}
+
+// CloseAudio closes the audio device. New programs might want to use CloseAudioDevice() instead.
+// (https://wiki.libsdl.org/SDL_CloseAudio)
+func CloseAudio() {
+	C.SDL_CloseAudio()
+}
+
+// CloseAudioDevice shuts down audio processing and closes the audio device.
+// (https://wiki.libsdl.org/SDL_CloseAudioDevice)
+func CloseAudioDevice(dev AudioDeviceID) {
+	C.SDL_CloseAudioDevice(dev.c())
+}
+
+// NewAudioStream creates a new audio stream
+// TODO: (https://wiki.libsdl.org/SDL_NewAudioStream)
+func NewAudioStream(srcFormat AudioFormat, srcChannels uint8, srcRate int, dstFormat AudioFormat, dstChannels uint8, dstRate int) (stream *AudioStream, err error) {
+	_srcFormat := C.SDL_AudioFormat(srcFormat)
+	_srcChannels := C.Uint8(srcChannels)
+	_srcRate := C.int(srcRate)
+	_dstFormat := C.SDL_AudioFormat(dstFormat)
+	_dstChannels := C.Uint8(dstChannels)
+	_dstRate := C.int(dstRate)
+
+	stream = (*AudioStream)(C.SDL_NewAudioStream(_srcFormat, _srcChannels, _srcRate, _dstFormat, _dstChannels, _dstRate))
+	if stream == nil {
+		err = GetError()
+	}
+	return
+}
+
+// Put adds data to be converted/resampled to the stream
+// TODO: (https://wiki.libsdl.org/SDL_AudioStreamPut)
+func (stream *AudioStream) Put(buf []byte) (err error) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_buf := unsafe.Pointer(sliceHeader.Data)
+	_len := C.int(len(buf))
+	ret := int(C.SDL_AudioStreamPut(stream.cptr(), _buf, _len))
+	err = errorFromInt(ret)
+	return
+}
+
+// Get gets converted/resampled data from the stream. Returns the number of bytes read from the stream.
+// (https://wiki.libsdl.org/SDL_AudioStreamGet)
+func (stream *AudioStream) Get(buf []byte) (n int, err error) {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
+	_buf := unsafe.Pointer(sliceHeader.Data)
+	_len := C.int(len(buf))
+	if ret := int(C.SDL_AudioStreamGet(stream.cptr(), _buf, _len)); ret < 0 {
+		return 0, errorFromInt(ret)
+	} else {
+		return ret, nil
+	}
+}
+
+// Available gets the number of converted/resampled bytes available
+// (https://wiki.libsdl.org/SDL_AudioStreamAvailable)
+func (stream *AudioStream) Available() (n int) {
+	n = int(C.SDL_AudioStreamAvailable(stream.cptr()))
+	return
+}
+
+// Flush tells the stream that you're done sending data, and anything being buffered
+// should be converted/resampled and made available immediately.
+// TODO: (https://wiki.libsdl.org/SDL_AudioStreamFlush)
+func (stream *AudioStream) Flush() (err error) {
+	ret := int(C.SDL_AudioStreamFlush(stream.cptr()))
+	err = errorFromInt(ret)
+	return
+}
+
+// Clear clears any pending data in the stream without converting it
+// TODO: (https://wiki.libsdl.org/SDL_AudioStreamClear)
+func (stream *AudioStream) Clear() {
+	C.SDL_AudioStreamClear(stream.cptr())
+}
+
+// Free frees the audio stream
+// TODO: (https://wiki.libsdl.org/SDL_AudoiStreamFree)
+func (stream *AudioStream) Free() {
+	C.SDL_FreeAudioStream(stream.cptr())
+}
+
+// GetAudioDeviceSpec returns the preferred audio format of a specific audio device.
+// (https://wiki.libsdl.org/SDL_GetAudioDeviceSpec)
+func GetAudioDeviceSpec(index int, isCapture bool) (spec *AudioSpec, err error) {
+	spec = &AudioSpec{}
+	err = errorFromInt(int(C.SDL_GetAudioDeviceSpec(C.int(index), C.int(Btoi(isCapture)), spec.cptr())))
+	return
+}