Adding upstream version 0.0~git20250520.a1d9079+dfsg.

Signed-off-by: Daniel Baumann <daniel@debian.org>

exp/audio/al/al.go

@@ -0,0 +1,456 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build darwin || linux || windows
+
+// Package al provides OpenAL Soft bindings for Go.
+//
+// Calls are not safe for concurrent use.
+//
+// More information about OpenAL Soft is available at
+// http://www.openal.org/documentation/openal-1.1-specification.pdf.
+//
+// In order to use this package on Linux desktop distros,
+// you will need OpenAL library as an external dependency.
+// On Ubuntu 14.04 'Trusty', you may have to install this library
+// by running the command below.
+//
+//	sudo apt-get install libopenal-dev
+//
+// When compiled for Android, this package uses OpenAL Soft. Please add its
+// license file to the open source notices of your application.
+// OpenAL Soft's license file could be found at
+// http://repo.or.cz/w/openal-soft.git/blob/HEAD:/COPYING.
+package al
+
+// Capability represents OpenAL extension capabilities.
+type Capability int32
+
+// Enable enables a capability.
+func Enable(c Capability) {
+	alEnable(int32(c))
+}
+
+// Disable disables a capability.
+func Disable(c Capability) {
+	alDisable(int32(c))
+}
+
+// Enabled reports whether the specified capability is enabled.
+func Enabled(c Capability) bool {
+	return alIsEnabled(int32(c))
+}
+
+// Vector represents an vector in a Cartesian coordinate system.
+type Vector [3]float32
+
+// Orientation represents the angular position of an object in a
+// right-handed Cartesian coordinate system.
+// A cross product between the forward and up vector returns a vector
+// that points to the right.
+type Orientation struct {
+	// Forward vector is the direction that the object is looking at.
+	Forward Vector
+	// Up vector represents the rotation of the object.
+	Up Vector
+}
+
+func orientationFromSlice(v []float32) Orientation {
+	return Orientation{
+		Forward: Vector{v[0], v[1], v[2]},
+		Up:      Vector{v[3], v[4], v[5]},
+	}
+}
+
+func (v Orientation) slice() []float32 {
+	return []float32{v.Forward[0], v.Forward[1], v.Forward[2], v.Up[0], v.Up[1], v.Up[2]}
+}
+
+// Geti returns the int32 value of the given parameter.
+func Geti(param int) int32 {
+	return alGetInteger(param)
+}
+
+// Getiv returns the int32 vector value of the given parameter.
+func Getiv(param int, v []int32) {
+	alGetIntegerv(param, v)
+}
+
+// Getf returns the float32 value of the given parameter.
+func Getf(param int) float32 {
+	return alGetFloat(param)
+}
+
+// Getfv returns the float32 vector value of the given parameter.
+func Getfv(param int, v []float32) {
+	alGetFloatv(param, v[:])
+}
+
+// Getb returns the bool value of the given parameter.
+func Getb(param int) bool {
+	return alGetBoolean(param)
+}
+
+// Getbv returns the bool vector value of the given parameter.
+func Getbv(param int, v []bool) {
+	alGetBooleanv(param, v)
+}
+
+// GetString returns the string value of the given parameter.
+func GetString(param int) string {
+	return alGetString(param)
+}
+
+// DistanceModel returns the distance model.
+func DistanceModel() int32 {
+	return Geti(paramDistanceModel)
+}
+
+// SetDistanceModel sets the distance model.
+func SetDistanceModel(v int32) {
+	alDistanceModel(v)
+}
+
+// DopplerFactor returns the doppler factor.
+func DopplerFactor() float32 {
+	return Getf(paramDopplerFactor)
+}
+
+// SetDopplerFactor sets the doppler factor.
+func SetDopplerFactor(v float32) {
+	alDopplerFactor(v)
+}
+
+// DopplerVelocity returns the doppler velocity.
+func DopplerVelocity() float32 {
+	return Getf(paramDopplerVelocity)
+}
+
+// SetDopplerVelocity sets the doppler velocity.
+func SetDopplerVelocity(v float32) {
+	alDopplerVelocity(v)
+}
+
+// SpeedOfSound is the speed of sound in meters per second (m/s).
+func SpeedOfSound() float32 {
+	return Getf(paramSpeedOfSound)
+}
+
+// SetSpeedOfSound sets the speed of sound, its unit should be meters per second (m/s).
+func SetSpeedOfSound(v float32) {
+	alSpeedOfSound(v)
+}
+
+// Vendor returns the vendor.
+func Vendor() string {
+	return GetString(paramVendor)
+}
+
+// Version returns the version string.
+func Version() string {
+	return GetString(paramVersion)
+}
+
+// Renderer returns the renderer information.
+func Renderer() string {
+	return GetString(paramRenderer)
+}
+
+// Extensions returns the enabled extensions.
+func Extensions() string {
+	return GetString(paramExtensions)
+}
+
+// Error returns the most recently generated error.
+func Error() int32 {
+	return alGetError()
+}
+
+// Source represents an individual sound source in 3D-space.
+// They take PCM data, apply modifications and then submit them to
+// be mixed according to their spatial location.
+type Source uint32
+
+// GenSources generates n new sources. These sources should be deleted
+// once they are not in use.
+func GenSources(n int) []Source {
+	return alGenSources(n)
+}
+
+// PlaySources plays the sources.
+func PlaySources(source ...Source) {
+	alSourcePlayv(source)
+}
+
+// PauseSources pauses the sources.
+func PauseSources(source ...Source) {
+	alSourcePausev(source)
+}
+
+// StopSources stops the sources.
+func StopSources(source ...Source) {
+	alSourceStopv(source)
+}
+
+// RewindSources rewinds the sources to their beginning positions.
+func RewindSources(source ...Source) {
+	alSourceRewindv(source)
+}
+
+// DeleteSources deletes the sources.
+func DeleteSources(source ...Source) {
+	alDeleteSources(source)
+}
+
+// Gain returns the source gain.
+func (s Source) Gain() float32 {
+	return s.Getf(paramGain)
+}
+
+// SetGain sets the source gain.
+func (s Source) SetGain(v float32) {
+	s.Setf(paramGain, v)
+}
+
+// MinGain returns the source's minimum gain setting.
+func (s Source) MinGain() float32 {
+	return s.Getf(paramMinGain)
+}
+
+// SetMinGain sets the source's minimum gain setting.
+func (s Source) SetMinGain(v float32) {
+	s.Setf(paramMinGain, v)
+}
+
+// MaxGain returns the source's maximum gain setting.
+func (s Source) MaxGain() float32 {
+	return s.Getf(paramMaxGain)
+}
+
+// SetMaxGain sets the source's maximum gain setting.
+func (s Source) SetMaxGain(v float32) {
+	s.Setf(paramMaxGain, v)
+}
+
+// Position returns the position of the source.
+func (s Source) Position() Vector {
+	v := Vector{}
+	s.Getfv(paramPosition, v[:])
+	return v
+}
+
+// SetPosition sets the position of the source.
+func (s Source) SetPosition(v Vector) {
+	s.Setfv(paramPosition, v[:])
+}
+
+// Velocity returns the source's velocity.
+func (s Source) Velocity() Vector {
+	v := Vector{}
+	s.Getfv(paramVelocity, v[:])
+	return v
+}
+
+// SetVelocity sets the source's velocity.
+func (s Source) SetVelocity(v Vector) {
+	s.Setfv(paramVelocity, v[:])
+}
+
+// Orientation returns the orientation of the source.
+func (s Source) Orientation() Orientation {
+	v := make([]float32, 6)
+	s.Getfv(paramOrientation, v)
+	return orientationFromSlice(v)
+}
+
+// SetOrientation sets the orientation of the source.
+func (s Source) SetOrientation(o Orientation) {
+	s.Setfv(paramOrientation, o.slice())
+}
+
+// State returns the playing state of the source.
+func (s Source) State() int32 {
+	return s.Geti(paramSourceState)
+}
+
+// BuffersQueued returns the number of the queued buffers.
+func (s Source) BuffersQueued() int32 {
+	return s.Geti(paramBuffersQueued)
+}
+
+// BuffersProcessed returns the number of the processed buffers.
+func (s Source) BuffersProcessed() int32 {
+	return s.Geti(paramBuffersProcessed)
+}
+
+// OffsetSeconds returns the current playback position of the source in seconds.
+func (s Source) OffsetSeconds() int32 {
+	return s.Geti(paramSecOffset)
+}
+
+// OffsetSample returns the sample offset of the current playback position.
+func (s Source) OffsetSample() int32 {
+	return s.Geti(paramSampleOffset)
+}
+
+// OffsetByte returns the byte offset of the current playback position.
+func (s Source) OffsetByte() int32 {
+	return s.Geti(paramByteOffset)
+}
+
+// Geti returns the int32 value of the given parameter.
+func (s Source) Geti(param int) int32 {
+	return alGetSourcei(s, param)
+}
+
+// Getf returns the float32 value of the given parameter.
+func (s Source) Getf(param int) float32 {
+	return alGetSourcef(s, param)
+}
+
+// Getfv returns the float32 vector value of the given parameter.
+func (s Source) Getfv(param int, v []float32) {
+	alGetSourcefv(s, param, v)
+}
+
+// Seti sets an int32 value for the given parameter.
+func (s Source) Seti(param int, v int32) {
+	alSourcei(s, param, v)
+}
+
+// Setf sets a float32 value for the given parameter.
+func (s Source) Setf(param int, v float32) {
+	alSourcef(s, param, v)
+}
+
+// Setfv sets a float32 vector value for the given parameter.
+func (s Source) Setfv(param int, v []float32) {
+	alSourcefv(s, param, v)
+}
+
+// QueueBuffers adds the buffers to the buffer queue.
+func (s Source) QueueBuffers(buffer ...Buffer) {
+	alSourceQueueBuffers(s, buffer)
+}
+
+// UnqueueBuffers removes the specified buffers from the buffer queue.
+func (s Source) UnqueueBuffers(buffer ...Buffer) {
+	alSourceUnqueueBuffers(s, buffer)
+}
+
+// ListenerGain returns the total gain applied to the final mix.
+func ListenerGain() float32 {
+	return GetListenerf(paramGain)
+}
+
+// ListenerPosition returns the position of the listener.
+func ListenerPosition() Vector {
+	v := Vector{}
+	GetListenerfv(paramPosition, v[:])
+	return v
+}
+
+// ListenerVelocity returns the velocity of the listener.
+func ListenerVelocity() Vector {
+	v := Vector{}
+	GetListenerfv(paramVelocity, v[:])
+	return v
+}
+
+// ListenerOrientation returns the orientation of the listener.
+func ListenerOrientation() Orientation {
+	v := make([]float32, 6)
+	GetListenerfv(paramOrientation, v)
+	return orientationFromSlice(v)
+}
+
+// SetListenerGain sets the total gain that will be applied to the final mix.
+func SetListenerGain(v float32) {
+	SetListenerf(paramGain, v)
+}
+
+// SetListenerPosition sets the position of the listener.
+func SetListenerPosition(v Vector) {
+	SetListenerfv(paramPosition, v[:])
+}
+
+// SetListenerVelocity sets the velocity of the listener.
+func SetListenerVelocity(v Vector) {
+	SetListenerfv(paramVelocity, v[:])
+}
+
+// SetListenerOrientation sets the orientation of the listener.
+func SetListenerOrientation(v Orientation) {
+	SetListenerfv(paramOrientation, v.slice())
+}
+
+// GetListenerf returns the float32 value of the listener parameter.
+func GetListenerf(param int) float32 {
+	return alGetListenerf(param)
+}
+
+// GetListenerfv returns the float32 vector value of the listener parameter.
+func GetListenerfv(param int, v []float32) {
+	alGetListenerfv(param, v)
+}
+
+// SetListenerf sets the float32 value for the listener parameter.
+func SetListenerf(param int, v float32) {
+	alListenerf(param, v)
+}
+
+// SetListenerfv sets the float32 vector value of the listener parameter.
+func SetListenerfv(param int, v []float32) {
+	alListenerfv(param, v)
+}
+
+// A buffer represents a chunk of PCM audio data that could be buffered to an audio
+// source. A single buffer could be shared between multiple sources.
+type Buffer uint32
+
+// GenBuffers generates n new buffers. The generated buffers should be deleted
+// once they are no longer in use.
+func GenBuffers(n int) []Buffer {
+	return alGenBuffers(n)
+}
+
+// DeleteBuffers deletes the buffers.
+func DeleteBuffers(buffer ...Buffer) {
+	alDeleteBuffers(buffer)
+}
+
+// Geti returns the int32 value of the given parameter.
+func (b Buffer) Geti(param int) int32 {
+	return b.Geti(param)
+}
+
+// Frequency returns the frequency of the buffer data in Hertz (Hz).
+func (b Buffer) Frequency() int32 {
+	return b.Geti(paramFreq)
+}
+
+// Bits return the number of bits used to represent a sample.
+func (b Buffer) Bits() int32 {
+	return b.Geti(paramBits)
+}
+
+// Channels return the number of the audio channels.
+func (b Buffer) Channels() int32 {
+	return b.Geti(paramChannels)
+}
+
+// Size returns the size of the data.
+func (b Buffer) Size() int32 {
+	return b.Geti(paramSize)
+}
+
+// BufferData buffers PCM data to the current buffer.
+func (b Buffer) BufferData(format uint32, data []byte, freq int32) {
+	alBufferData(b, format, data, freq)
+}
+
+// Valid reports whether the buffer exists and is valid.
+func (b Buffer) Valid() bool {
+	return alIsBuffer(b)
+}