func (s *Surface) SaveBMP(_file string) {
cfile := C.CString(_file)
defer C.free(unsafe.Pointer(cfile))
cparams := C.CString("wb")
defer C.free(unsafe.Pointer(cparams))
C.SDL_SaveBMP_RW(s.Get(), C.SDL_RWFromFile(cfile, cparams), C.int(1))
}
func LoadBMP(_file string) *Surface {
cfile := C.CString(_file)
defer C.free(unsafe.Pointer(cfile))
cparams := C.CString("rb")
defer C.free(unsafe.Pointer(cparams))
return (*Surface)(C.SDL_LoadBMP_RW(C.SDL_RWFromFile(cfile, cparams), C.int(1)))
}
func LoadWAV(file string) *Chunk {
_file := C.CString(file)
defer C.free(unsafe.Pointer(_file))
_rb := C.CString("rb")
defer C.free(unsafe.Pointer(_rb))
return (*Chunk)(unsafe.Pointer(C.Mix_LoadWAV_RW(C.SDL_RWFromFile(_file, _rb), 1)))
}
func RWFromFile(file, mode string) *RWops {
_file := C.CString(file)
defer C.free(unsafe.Pointer(_file))
_mode := C.CString(mode)
defer C.free(unsafe.Pointer(_mode))
return (*RWops)(unsafe.Pointer(C.SDL_RWFromFile(_file, _mode)))
}
// Functions to create SDL_RWops structures from various data sources
// Creates an RWOPS from a file
func RWFromFile(file, mode string) *C.SDL_RWops {
cfile := cstr(file)
defer cfile.free()
cmode := cstr(mode)
defer cmode.free()
rw := C.SDL_RWFromFile(cfile, cmode)
return rw
}
func LoadWAV(file string, spec *AudioSpec, audio_buf **uint8, audio_len *uint32) *AudioSpec {
_file := (C.CString)(file)
_spec := (*C.SDL_AudioSpec)(unsafe.Pointer(spec))
_audio_buf := (**C.Uint8)(unsafe.Pointer(audio_buf))
_audio_len := (*C.Uint32)(unsafe.Pointer(audio_len))
return (*AudioSpec)(unsafe.Pointer(C.SDL_LoadWAV_RW(C.SDL_RWFromFile(_file, C.CString("rb")),
1, _spec, _audio_buf, _audio_len)))
}
// LoadWAV (https://wiki.libsdl.org/SDL_LoadWAV)
func LoadWAV(file string, spec *AudioSpec, audioBuf **uint8, audioLen *uint32) *AudioSpec {
_file := C.CString(file)
_rb := C.CString("rb")
defer C.free(unsafe.Pointer(_file))
defer C.free(unsafe.Pointer(_rb))
_audioBuf := (**C.Uint8)(unsafe.Pointer(audioBuf))
_audioLen := (*C.Uint32)(unsafe.Pointer(audioLen))
return (*AudioSpec)(unsafe.Pointer(C.SDL_LoadWAV_RW(C.SDL_RWFromFile(_file, _rb), 1, spec.cptr(), _audioBuf, _audioLen)))
}
func loadSound(name string) *C.Mix_Chunk {
cfile, rb := C.CString(name), C.CString("rb")
rwop := C.SDL_RWFromFile(cfile, rb)
C.free(unsafe.Pointer(cfile))
C.free(unsafe.Pointer(rb))
chunk := C.Mix_LoadWAV_RW(rwop, 1)
if chunk == nil {
panic(fmt.Sprintf("Unable to load Sound file (%v): %v", name, util.GetMixError()))
}
return chunk
}
func LoadWAV(file string) *Chunk {
cfile := C.CString(file)
cchunk := C.Mix_LoadWAV_RW(C.SDL_RWFromFile(cfile, C.CString("rb")), 1)
C.free(unsafe.Pointer(cfile))
if cchunk == nil {
return nil
}
return &Chunk{cchunk}
}
func LoadWAV(file string) (chunk *Chunk, err error) {
_file := C.CString(file)
defer C.free(unsafe.Pointer(_file))
_rb := C.CString("rb")
defer C.free(unsafe.Pointer(_rb))
// why doesn't this call Mix_LoadWAV ?
chunk = (*Chunk)(unsafe.Pointer(C.Mix_LoadWAV_RW(C.SDL_RWFromFile(_file, _rb), 1)))
if chunk == nil {
err = sdl.GetError()
}
return
}
func RWFromFile(file string, mode int) *RWops {
cfile := C.CString(file)
defer C.free(unsafe.Pointer(cfile))
cmode := modeFromFlags(mode)
if cmode == nil {
return nil
}
defer C.free(unsafe.Pointer(cmode))
return (*RWops)(C.SDL_RWFromFile(cfile, cmode))
}
func RWFromFile(file string, mode string) (*RWops, error) {
cfile := C.CString(file)
defer C.free(unsafe.Pointer(cfile))
cmode := C.CString(mode)
defer C.free(unsafe.Pointer(cmode))
rw := C.SDL_RWFromFile(cfile, cmode)
if rw == nil {
return nil, getError()
}
return &RWops{rw}, nil
}
// LoadWAV (https://wiki.libsdl.org/SDL_LoadWAV)
func LoadWAV(file string, spec *AudioSpec) ([]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, spec.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
}
func loadWAV(path string) (*audioData, error) {
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
var data *C.Uint8
var len C.Uint32
var s C.SDL_AudioSpec // Apparently just a buffer? SDL just zeroes it, fills it, and returns it.
spec := C.SDL_LoadWAV_RW(C.SDL_RWFromFile(cpath, rb), 1, &s, &data, &len)
if spec == nil {
return nil, sdlError()
}
var err error
data, len, err = convert(spec, data, len)
if err != nil {
return nil, err
}
return &audioData{
path: path,
data: unsafe.Pointer(data),
len: uintptr(len),
}, nil
}
func LoadWAV(file string) *Chunk {
_file := (C.CString)(file)
return (*Chunk)(unsafe.Pointer(C.Mix_LoadWAV_RW(C.SDL_RWFromFile(_file,
C.CString("rb")), 1)))
}
func RWFromFile(file, mode string) *RWops {
_file := (C.CString)(file)
_mode := (C.CString)(mode)
return (*RWops)(unsafe.Pointer(C.SDL_RWFromFile(_file, _mode)))
}
func RWFromFile(file string, mode string) *RWops {
cfile, cmode := C.CString(file), C.CString(mode)
defer C.free(unsafe.Pointer(cfile))
defer C.free(unsafe.Pointer(cmode))
return wrapRWops(C.SDL_RWFromFile(cfile, cmode))
}