path: root/src/audio.c

#include "main.h"
#include "state.h"
#include "audio.h"
#include "lua_core.h"

/*
## Audio - Audio device management functions
*/

/*
> RL.InitAudioDevice()

Initialize audio device and context
*/
int laudioInitAudioDevice( lua_State* L ) {
	InitAudioDevice();

	return 0;
}

/*
> RL.CloseAudioDevice()

Close the audio device and context
*/
int laudioCloseAudioDevice( lua_State* L ) {
	CloseAudioDevice();

	return 0;
}

/*
> isReady = RL.IsAudioDeviceReady()

Check if audio device has been initialized successfully

- Success return bool
*/
int laudioIsAudioDeviceReady( lua_State* L ) {
	lua_pushboolean( L, IsAudioDeviceReady() );

	return 1;
}

/*
> RL.SetMasterVolume( float volume )

Set master volume (listener)
*/
int laudioSetMasterVolume( lua_State* L ) {
	float volume = luaL_checknumber( L, 1 );

	SetMasterVolume( volume );

	return 0;
}

/*
> volume = RL.GetMasterVolume()

Get master volume (listener)

- Success return float
*/
int laudioGetMasterVolume( lua_State* L ) {
	lua_pushnumber( L, GetMasterVolume() );

	return 1;
}

/*
## Audio - Wave/Sound loading/unloading functions
*/

/*
> sound = RL.LoadSound( string fileName )

Load sound from file

- Failure return nil
- Success return Sound
*/
int laudioLoadSound( lua_State* L ) {
	if ( FileExists( luaL_checkstring( L, 1 ) ) ) {
		uluaPushSound( L, LoadSound( lua_tostring( L, 1 ) ) );

		return 1;
	}
	TraceLog( state->logLevelInvalid, "Invalid file '%s'", lua_tostring( L, 1 ) );
	lua_pushnil( L );

	return 1;
}

/*
> wave = RL.LoadWave( string fileName )

Load wave data from file

- Failure return nil
- Success return Wave
*/
int laudioLoadWave( lua_State* L ) {
	if ( FileExists( luaL_checkstring( L, 1 ) ) ) {
		uluaPushWave( L, LoadWave( lua_tostring( L, 1 ) ) );

		return 1;
	}
	TraceLog( state->logLevelInvalid, "Invalid file '%s'", lua_tostring( L, 1 ) );
	lua_pushnil( L );

	return 1;
}

/*
> wave = RL.LoadWaveFromMemory( string fileType, Buffer data )

Load wave from memory buffer, fileType refers to extension: i.e. '.wav'

- Success return Wave
*/
int laudioLoadWaveFromMemory( lua_State* L ) {
	const char* fileType = luaL_checkstring( L, 1 );
	Buffer* buffer = uluaGetBuffer( L, 2 );

	uluaPushWave( L, LoadWaveFromMemory( fileType, buffer->data, buffer->size ) );

	return 1;
}

/*
> isValid = RL.IsWaveValid( Wave wave )

Checks if wave data is valid (data loaded and parameters)

- Success return bool
*/
int laudioIsWaveValid( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );

	lua_pushboolean( L, IsWaveValid( *wave ) );

	return 1;
}

/*
> sound = RL.LoadSoundFromWave( Wave wave )

Load sound from wave data

- Success return Sound
*/
int laudioLoadSoundFromWave( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );

	uluaPushSound( L, LoadSoundFromWave( *wave ) );

	return 1;
}

/*
> sound = RL.LoadSoundAlias( Sound source )

Create a new sound that shares the same sample data as the source sound, does not own the sound data

- Success return Sound
*/
int laudioLoadSoundAlias( lua_State* L ) {
	Sound* source = uluaGetSound( L, 1 );

	// uluaPushSound( L, LoadSoundAlias( *source ) );
	uluaPushSoundAlias( L, LoadSoundAlias( *source ) );

	return 1;
}

/*
> isValid = RL.IsSoundValid( Sound sound )

Checks if a sound is valid (data loaded and buffers initialized)

- Success return bool
*/
int laudioIsSoundValid( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	lua_pushboolean( L, IsSoundValid( *sound ) );

	return 1;
}

/*
> RL.UpdateSound( Sound sound, Buffer data, int sampleCount )

Update sound buffer with new data
*/
int laudioUpdateSound( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );
	Buffer* buffer = uluaGetBuffer( L, 2 );
	int sampleCount = luaL_checkinteger( L, 3 );

	UpdateSound( *sound, buffer->data, sampleCount );

	return 0;
}

/*
> RL.UnloadWave( Wave wave )

Unload wave data
*/
int laudioUnloadWave( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );

	uluaUnloadWave( wave );

	return 0;
}

/*
> RL.UnloadSound( Sound sound )

Unload sound
*/
int laudioUnloadSound( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	uluaUnloadSound( sound );

	return 0;
}

/*
> RL.UnloadSoundAlias( Sound alias )

Unload a sound alias (does not deallocate sample data)
*/
int laudioUnloadSoundAlias( lua_State* L ) {
	Sound* alias = uluaGetSound( L, 1 );

	uluaUnloadSoundAlias( alias );

	return 0;
}

/*
> success = RL.ExportWave( Wave wave, string fileName )

Export wave data to file, returns true on success

- Success return bool
*/
int laudioExportWave( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );

	lua_pushboolean( L, ExportWave( *wave, luaL_checkstring( L, 2 ) ) );

	return 1;
}

/*
> success = RL.ExportWaveAsCode( Wave wave, string fileName )

Export wave sample data to code (.h), returns true on success

- Success return true
*/
int laudioExportWaveAsCode( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );

	lua_pushboolean( L, ExportWaveAsCode( *wave, luaL_checkstring( L, 2 ) ) );

	return 1;
}

/*
## Audio - Wave/Sound management functions
*/

/*
> RL.PlaySound( Sound sound )

Play a sound
*/
int laudioPlaySound( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	PlaySound( *sound );

	return 0;
}

/*
> RL.StopSound( Sound sound )

Stop playing a sound
*/
int laudioStopSound( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	StopSound( *sound );

	return 0;
}

/*
> RL.PauseSound( Sound sound )

Pause a sound
*/
int laudioPauseSound( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	PauseSound( *sound );

	return 0;
}

/*
> RL.ResumeSound( Sound sound )

Resume a paused sound
*/
int laudioResumeSound( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	ResumeSound( *sound );

	return 0;
}

/*
> playing = RL.IsSoundPlaying( Sound sound )

Check if a sound is currently playing

- Success return bool
*/
int laudioIsSoundPlaying( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	lua_pushboolean( L, IsSoundPlaying( *sound ) );

	return 1;
}

/*
> RL.SetSoundVolume( Sound sound, float volume )

Set volume for a sound (1.0 is max level)
*/
int laudioSetSoundVolume( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );
	float volume = luaL_checknumber( L, 2 );

	SetSoundVolume( *sound, volume );

	return 0;
}

/*
> RL.SetSoundPitch( Sound sound, float pitch )

Set pitch for a sound (1.0 is base level)
*/
int laudioSetSoundPitch( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );
	float pitch = luaL_checknumber( L, 2 );

	SetSoundPitch( *sound, pitch );

	return 0;
}

/*
> RL.SetSoundPan( Sound sound, float pan )

Set pan for a sound (0.5 is center)
*/
int laudioSetSoundPan( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );
	float pan = luaL_checknumber( L, 2 );

	SetSoundPan( *sound, pan );

	return 0;
}

/*
> stream = RL.GetSoundStream( Sound sound )

Get sound audio stream. Return as lightuserdata

- Success return AudioStream
*/
int laudioGetSoundStream( lua_State* L ) {
	Sound* sound = uluaGetSound( L, 1 );

	lua_pushlightuserdata( L, &sound->stream );

	return 1;
}

/*
> RL.WaveFormat( Wave wave, int sampleRate, int sampleSize, int channels )

Convert wave data to desired format
*/
int laudioWaveFormat( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );
	int sampleRate = luaL_checkinteger( L, 2 );
	int sampleSize = luaL_checkinteger( L, 3 );
	int channels = luaL_checkinteger( L, 4 );

	WaveFormat( wave, sampleRate, sampleSize, channels );

	return 0;
}

/*
> samples = RL.LoadWaveSamples( Wave wave )

Load samples data from wave as a 32bit float data array

- Success return float{}
*/
int laudioLoadWaveSamples( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );

	float* samples = LoadWaveSamples( *wave );

	lua_createtable( L, wave->frameCount * wave->channels, 0 );

	for ( int i = 0; i < wave->frameCount * wave->channels; ++i ) {
		lua_pushnumber( L, samples[i] );
    	lua_rawseti( L, -2, i+1 );
	}
	UnloadWaveSamples( samples );

	return 1;
}

/*
> wave = RL.WaveCopy( Wave wave )

Copy a wave to a new wave

- Success return Wave
*/
int laudioWaveCopy( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );

	uluaPushWave( L, WaveCopy( *wave ) );

	return 1;
}

/*
> RL.WaveCrop( Wave wave, int initSample, int finalSample )

Crop a wave to defined samples range
*/
int laudioWaveCrop( lua_State* L ) {
	Wave* wave = uluaGetWave( L, 1 );
	int initSample = luaL_checkinteger( L, 2 );
	int finalSample = luaL_checkinteger( L, 3 );

	WaveCrop( wave, initSample, finalSample );

	return 0;
}

/*
## Audio - Music management functions
*/

/*
> music = RL.LoadMusicStream( string fileName )

Load music stream from file

- Success return Music
*/
int laudioLoadMusicStream( lua_State* L ) {
	if ( FileExists( luaL_checkstring( L, 1 ) ) ) {
		uluaPushMusic( L, LoadMusicStream( lua_tostring( L, 1 ) ) );

		return 1;
	}
	TraceLog( state->logLevelInvalid, "Invalid file '%s'", lua_tostring( L, 1 ) );
	lua_pushnil( L );

	return 1;
}

/*
> music = RL.LoadMusicStreamFromMemory( string fileType, Buffer data )

Load music stream from data

- Success return Music
*/
int laudioLoadMusicStreamFromMemory( lua_State* L ) {
	const char* fileType = luaL_checkstring( L, 1 );
	Buffer* buffer = uluaGetBuffer( L, 2 );

	uluaPushMusic( L, LoadMusicStreamFromMemory( fileType, buffer->data, buffer->size ) );

	return 1;
}

/*
> isValid = RL.IsMusicValid( Music music )

Checks if a music stream is valid (context and buffers initialized)

- Success return bool
*/
int laudioIsMusicValid( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	lua_pushboolean( L, IsMusicValid( *music ) );

	return 1;
}

/*
> RL.UnloadMusicStream( Music music )

Unload music stream
*/
int laudioUnloadMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	uluaUnloadMusic( music );

	return 0;
}

/*
> RL.PlayMusicStream( Music music )

Start music playing
*/
int laudioPlayMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	PlayMusicStream( *music );

	return 0;
}

/*
> playing = RL.IsMusicStreamPlaying( Music music )

Check if music is playing

- Success return bool
*/
int laudioIsMusicStreamPlaying( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	lua_pushboolean( L, IsMusicStreamPlaying( *music ) );

	return 1;
}

/*
> RL.UpdateMusicStream( Music music )

Updates buffers for music streaming
*/
int laudioUpdateMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	UpdateMusicStream( *music );

	return 0;
}

/*
> RL.StopMusicStream( Music music )

Stop music playing
*/
int laudioStopMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	StopMusicStream( *music );

	return 0;
}

/*
> RL.PauseMusicStream( Music music )

Pause music playing
*/
int laudioPauseMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	PauseMusicStream( *music );

	return 0;
}

/*
> RL.ResumeMusicStream( Music music )

Resume playing paused music
*/
int laudioResumeMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	ResumeMusicStream( *music );

	return 0;
}

/*
> RL.SeekMusicStream( Music music, float position )

Seek music to a position (in seconds)
*/
int laudioSeekMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );
	float position = luaL_checknumber( L, 2 );

	SeekMusicStream( *music, position );

	return 0;
}

/*
> RL.SetMusicVolume( Music music, float volume )

Set volume for music (1.0 is max level)
*/
int laudioSetMusicVolume( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );
	float volume = luaL_checknumber( L, 2 );

	SetMusicVolume( *music, volume );

	return 0;
}

/*
> RL.SetMusicPitch( Music music, float pitch )

Set pitch for a music (1.0 is base level)
*/
int laudioSetMusicPitch( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );
	float pitch = luaL_checknumber( L, 2 );

	SetMusicPitch( *music, pitch );

	return 0;
}

/*
> RL.SetMusicPan( Music music, float pan )

Set pan for a music (0.5 is center)
*/
int laudioSetMusicPan( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );
	float pan = luaL_checknumber( L, 2 );

	SetMusicPan( *music, pan );

	return 0;
}

/*
> RL.SetMusicLooping( Music music, bool looping )

Set looping for a music
*/
int laudioSetMusicLooping( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );
	bool looping = uluaGetBoolean( L, 2 );

	music->looping = looping;

	return 0;
}

/*
> looping = RL.GetMusicLooping( Music music )

Get looping of a music

- Success return bool
*/
int laudioGetMusicLooping( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	lua_pushboolean( L, music->looping );

	return 1;
}

/*
> length = RL.GetMusicTimeLength( Music music )

Get music time length (in seconds)

- Success return float
*/
int laudioGetMusicTimeLength( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	lua_pushnumber( L, GetMusicTimeLength( *music ) );

	return 1;
}

/*
> timePlayed = RL.GetMusicTimePlayed( Music music )

Get current music time played (in seconds)

- Success return float
*/
int laudioGetMusicTimePlayed( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	lua_pushnumber( L, GetMusicTimePlayed( *music ) );

	return 1;
}

static float arr[10] = {};

/*
> stream = RL.GetMusicStream( Music music )

Get music audio stream. Return as lightuserdata

- Success return AudioStream
*/
int laudioGetMusicStream( lua_State* L ) {
	Music* music = uluaGetMusic( L, 1 );

	lua_pushlightuserdata( L, &music->stream );

	return 1;
}

/*
## Audio - AudioStream management functions
*/

/*
> audioStream = RL.LoadAudioStream( int sampleRate, int sampleSize, int channels )

Load audio stream (to stream raw audio pcm data)

- Success return AudioStream
*/
int laudioLoadAudioStream( lua_State* L ) {
	int sampleRate = luaL_checkinteger( L, 1 );
	int sampleSize = luaL_checkinteger( L, 2 );
	int channels = luaL_checkinteger( L, 3 );

	uluaPushAudioStream( L, LoadAudioStream( sampleRate, sampleSize, channels ) );

	return 1;
}

/*
> isValid = RL.IsAudioStreamValid( AudioStream stream )

Checks if an audio stream is valid (buffers initialized)

- Success return bool
*/
int laudioIsAudioStreamValid( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	lua_pushboolean( L, IsAudioStreamValid( *stream ) );

	return 1;
}

/*
> RL.UnloadAudioStream( AudioStream stream )

Unload audio stream and free memory
*/
int laudioUnloadAudioStream( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	uluaUnloadAudioStream( stream );

	return 0;
}

/*
> RL.UpdateAudioStream( AudioStream stream, Buffer data, int frameCount )

Update audio stream buffers with data
*/
int laudioUpdateAudioStream( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );
	Buffer* buffer = uluaGetBuffer( L, 2 );
	int frameCount = luaL_checkinteger( L, 3 );

	UpdateAudioStream( *stream, buffer->data, frameCount );

	return 0;
}

/*
> isProcessed = RL.IsAudioStreamProcessed( AudioStream stream )

Check if any audio stream buffers requires refill

- Success return bool
*/
int laudioIsAudioStreamProcessed( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	lua_pushboolean( L, IsAudioStreamProcessed( *stream ) );

	return 1;
}

/*
> RL.PlayAudioStream( AudioStream stream )

Play audio stream
*/
int laudioPlayAudioStream( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	PlayAudioStream( *stream );

	return 0;
}

/*
> RL.PauseAudioStream( AudioStream stream )

Pause audio stream
*/
int laudioPauseAudioStream( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	PauseAudioStream( *stream );

	return 0;
}

/*
> RL.ResumeAudioStream( AudioStream stream )

Resume audio stream
*/
int laudioResumeAudioStream( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	ResumeAudioStream( *stream );

	return 0;
}

/*
> isPlaying = RL.IsAudioStreamPlaying( AudioStream stream )

Check if audio stream is playing

- Success return bool
*/
int laudioIsAudioStreamPlaying( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	lua_pushboolean( L, IsAudioStreamPlaying( *stream ) );

	return 1;
}

/*
> RL.StopAudioStream( AudioStream stream )

Stop audio stream
*/
int laudioStopAudioStream( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );

	StopAudioStream( *stream );

	return 0;
}

/*
> RL.SetAudioStreamVolume( AudioStream stream, float volume )

Set volume for audio stream (1.0 is max level)
*/
int laudioSetAudioStreamVolume( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );
	float volume = luaL_checknumber( L, 2 );

	SetAudioStreamVolume( *stream, volume );

	return 0;
}

/*
> RL.SetAudioStreamPitch( AudioStream stream, float pitch )

Set pitch for audio stream (1.0 is base level)
*/
int laudioSetAudioStreamPitch( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );
	float pitch = luaL_checknumber( L, 2 );

	SetAudioStreamPitch( *stream, pitch );

	return 0;
}

/*
> RL.SetAudioStreamPan( AudioStream stream, float pan )

Set pan for audio stream (0.5 is centered)
*/
int laudioSetAudioStreamPan( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );
	float pan = luaL_checknumber( L, 2 );

	SetAudioStreamPan( *stream, pan );

	return 0;
}

/*
> RL.SetAudioStreamBufferSizeDefault( int size )

Default size for new audio streams
*/
int laudioSetAudioStreamBufferSizeDefault( lua_State* L ) {
	int size = luaL_checkinteger( L, 1 );

	SetAudioStreamBufferSizeDefault( size );

	return 0;
}

/*
> RL.SetAudioStreamCallback( AudioStream stream, AudioCallback callback )

Audio thread callback to request new data.
AudioCallback should be lightuserdata function pointer
*/
int laudioSetAudioStreamCallback( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );
	AudioCallback callback = lua_touserdata( L, 2 );

	SetAudioStreamCallback( *stream, callback );

	return 0;
}

/*
> RL.AttachAudioStreamProcessor( AudioStream stream, AudioCallback processor )

Attach audio stream processor to stream, receives the samples as 'float'.
AudioCallback should be lightuserdata function pointer
*/
int laudioAttachAudioStreamProcessor( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );
	AudioCallback processor = lua_touserdata( L, 2 );

	AttachAudioStreamProcessor( *stream, processor );

	return 0;
}

/*
> RL.DetachAudioStreamProcessor( AudioStream stream, AudioCallback processor )

Detach audio stream processor from stream.
AudioCallback should be lightuserdata function pointer
*/
int laudioDetachAudioStreamProcessor( lua_State* L ) {
	AudioStream* stream = uluaGetAudioStream( L, 1 );
	AudioCallback processor = lua_touserdata( L, 2 );

	DetachAudioStreamProcessor( *stream, processor );

	return 0;
}

/*
> RL.AttachAudioMixedProcessor( AudioCallback processor )

Attach audio stream processor to the entire audio pipeline, receives the samples as 'float'.
AudioCallback should be lightuserdata function pointer
*/
int laudioAttachAudioMixedProcessor( lua_State* L ) {
	AudioCallback processor = lua_touserdata( L, 1 );

	AttachAudioMixedProcessor( processor );

	return 0;
}

/*
> RL.DetachAudioMixedProcessor( AudioCallback processor )

Detach audio stream processor from the entire audio pipeline.
AudioCallback should be lightuserdata function pointer
*/
int laudioDetachAudioMixedProcessor( lua_State* L ) {
	AudioCallback processor = lua_touserdata( L, 1 );

	DetachAudioMixedProcessor( processor );

	return 0;
}