/***************************************************************************

  c_al.c

  (c) 2000-2017 Benoît Minisini <g4mba5@gmail.com>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  MA 02110-1301, USA.

***************************************************************************/

#define __C_AL_C

#include "c_al.h"

/*
 * LISTENER
 * Listener represents the location and orientation of the
 * 'user' in 3D-space.
 *
 * Properties include: -
 *
 * Gain         AL_GAIN         ALfloat
 * Position     AL_POSITION     ALfloat[3]
 * Velocity     AL_VELOCITY     ALfloat[3]
 * Orientation  AL_ORIENTATION  ALfloat[6] (Forward then Up vectors)
*/

static int get_listener_float_param_size(int param)
{
	switch(param)
	{
		case AL_GAIN: return 1;
		case AL_POSITION: return 3;
		case AL_VELOCITY: return 3;
		case AL_ORIENTATION: return 6;
		default: return 0;
	}
}

static int get_listener_integer_param_size(int param)
{
	return 0;
}

/*
 * SOURCE
 * Sources represent individual sound objects in 3D-space.
 * Sources take the PCM data provided in the specified Buffer,
 * apply Source-specific modifications, and then
 * submit them to be mixed according to spatial arrangement etc.
 *
 * Properties include: -
 *
 * Gain                              AL_GAIN                 ALfloat
 * Min Gain                          AL_MIN_GAIN             ALfloat
 * Max Gain                          AL_MAX_GAIN             ALfloat
 * Position                          AL_POSITION             ALfloat[3]
 * Velocity                          AL_VELOCITY             ALfloat[3]
 * Direction                         AL_DIRECTION            ALfloat[3]
 * Head Relative Mode                AL_SOURCE_RELATIVE      ALint (AL_TRUE or AL_FALSE)
 * Reference Distance                AL_REFERENCE_DISTANCE   ALfloat
 * Max Distance                      AL_MAX_DISTANCE         ALfloat
 * RollOff Factor                    AL_ROLLOFF_FACTOR       ALfloat
 * Inner Angle                       AL_CONE_INNER_ANGLE     ALint or ALfloat
 * Outer Angle                       AL_CONE_OUTER_ANGLE     ALint or ALfloat
 * Cone Outer Gain                   AL_CONE_OUTER_GAIN      ALint or ALfloat
 * Pitch                             AL_PITCH                ALfloat
 * Looping                           AL_LOOPING              ALint (AL_TRUE or AL_FALSE)
 * MS Offset                         AL_MSEC_OFFSET          ALint or ALfloat
 * Byte Offset                       AL_BYTE_OFFSET          ALint or ALfloat
 * Sample Offset                     AL_SAMPLE_OFFSET        ALint or ALfloat
 * Attached Buffer                   AL_BUFFER               ALint
 * State (Query only)                AL_SOURCE_STATE         ALint
 * Buffers Queued (Query only)       AL_BUFFERS_QUEUED       ALint
 * Buffers Processed (Query only)    AL_BUFFERS_PROCESSED    ALint
 */

static int get_source_float_param_size(int param)
{
	switch(param)
	{
		case AL_GAIN: case AL_MIN_GAIN: case AL_MAX_GAIN: case AL_REFERENCE_DISTANCE: case AL_MAX_DISTANCE: case AL_ROLLOFF_FACTOR:
		case AL_CONE_INNER_ANGLE: case AL_CONE_OUTER_ANGLE: case AL_CONE_OUTER_GAIN: case AL_PITCH:  case AL_BYTE_OFFSET:
		case AL_SAMPLE_OFFSET:
		//case AL_MSEC_OFFSET:
			return 1;

		case AL_POSITION: case AL_VELOCITY: case AL_DIRECTION:
			return 3;

		default:
			return 0;
	}
}

static int get_source_integer_param_size(int param)
{
	switch(param)
	{
		case AL_SOURCE_RELATIVE: case AL_CONE_INNER_ANGLE: case AL_CONE_OUTER_ANGLE: case AL_CONE_OUTER_GAIN: case AL_LOOPING:
		//case AL_MSEC_OFFSET:
		case AL_BYTE_OFFSET: case AL_SAMPLE_OFFSET: case AL_BUFFER: case AL_SOURCE_STATE: case AL_BUFFERS_QUEUED: case AL_BUFFERS_PROCESSED:
			return 1;

		default:
			return 0;
	}
}

/*
 * BUFFER
 * Buffer objects are storage space for sample data.
 * Buffers are referred to by Sources. One Buffer can be used
 * by multiple Sources.
 *
 * Properties include: -
 *
 * Frequency (Query only)    AL_FREQUENCY      ALint
 * Size (Query only)         AL_SIZE           ALint
 * Bits (Query only)         AL_BITS           ALint
 * Channels (Query only)     AL_CHANNELS       ALint
 */

static int get_buffer_float_param_size(int param)
{
	return 0;
}

static int get_buffer_integer_param_size(int param)
{
	switch(param)
	{
		case AL_FREQUENCY: case AL_SIZE: case AL_BITS: case AL_CHANNELS:
			return 1;

		default:
			return 0;
	}
}


//---------------------------------------------------------------------------


BEGIN_METHOD_VOID(AL_GetError)

	GB.ReturnInteger(alGetError());

END_METHOD

BEGIN_METHOD(AL_Enable, GB_INTEGER cap)

	alEnable(VARG(cap));

END_METHOD

BEGIN_METHOD(AL_Disable, GB_INTEGER cap)

	alDisable(VARG(cap));

END_METHOD

BEGIN_METHOD(AL_IsEnabled, GB_INTEGER cap)

	GB.ReturnBoolean(alIsEnabled(VARG(cap)));

END_METHOD

BEGIN_METHOD(AL_GenBuffers, GB_INTEGER count)

	int count = VARG(count);
	GB_ARRAY array;

	if (count <= 0)
	{
		GB.ReturnNull();
		return;
	}

	GB.Array.New(&array, GB_T_INTEGER, count);
	alGenBuffers(VARG(count), (ALuint *)GB.Array.Get(array, 0));
	GB.ReturnObject(array);

END_METHOD

BEGIN_METHOD(AL_GenSources, GB_INTEGER count)

	int count = VARG(count);
	GB_ARRAY array;

	if (count <= 0)
	{
		GB.ReturnNull();
		return;
	}

	GB.Array.New(&array, GB_T_INTEGER, count);
	alGenSources(VARG(count), (ALuint *)GB.Array.Get(array, 0));
	GB.ReturnObject(array);

END_METHOD

BEGIN_METHOD(AL_DeleteBuffers, GB_OBJECT array)

	GB_ARRAY array = (GB_ARRAY)VARG(array);
	int count;
	
	if (GB.CheckObject(array))
		return;
	
	count = GB.Array.Count(array);
	if (count <= 0)
		return;
	
	alDeleteBuffers(count, GB.Array.Get(array, 0));

END_METHOD

BEGIN_METHOD(AL_DeleteSources, GB_OBJECT array)

	GB_ARRAY array = (GB_ARRAY)VARG(array);
	int count;
	
	if (GB.CheckObject(array))
		return;
	
	count = GB.Array.Count(array);
	if (count <= 0)
		return;
	
	alDeleteSources(count, GB.Array.Get(array, 0));

END_METHOD

BEGIN_METHOD(AL_IsBuffer, GB_INTEGER name)

	GB.ReturnBoolean(alIsBuffer(VARG(name)));

END_METHOD

BEGIN_METHOD(AL_IsSource, GB_INTEGER name)

	GB.ReturnBoolean(alIsSource(VARG(name)));

END_METHOD

BEGIN_METHOD(AL_GetBoolean, GB_INTEGER param)

	GB.ReturnBoolean(alGetBoolean(VARG(param)));

END_METHOD

BEGIN_METHOD(AL_GetInteger, GB_INTEGER param)

	GB.ReturnInteger(alGetInteger(VARG(param)));

END_METHOD

BEGIN_METHOD(AL_GetFloat, GB_INTEGER param)

	GB.ReturnSingle(alGetFloat(VARG(param)));

END_METHOD

BEGIN_METHOD(AL_GetDouble, GB_INTEGER param)

	GB.ReturnFloat(alGetDouble(VARG(param)));

END_METHOD

BEGIN_METHOD(AL_GetString, GB_INTEGER param)

	GB.ReturnNewZeroString(alGetString(VARG(param)));

END_METHOD

BEGIN_METHOD(AL_IsExtensionPresent, GB_STRING name)

	GB.ReturnBoolean(alIsExtensionPresent(GB.ToZeroString(ARG(name))));

END_METHOD

BEGIN_METHOD(AL_GetEnumValue, GB_STRING name)

	GB.ReturnInteger(alGetEnumValue(GB.ToZeroString(ARG(name))));

END_METHOD

BEGIN_METHOD(AL_DistanceModel, GB_INTEGER model)

	alDistanceModel(VARG(model));

END_METHOD

BEGIN_METHOD(AL_DopplerFactor, GB_FLOAT factor)

	alDopplerFactor((float)VARG(factor));

END_METHOD

BEGIN_METHOD(AL_DopplerVelocity, GB_FLOAT velocity)

	alDopplerVelocity((float)VARG(velocity));

END_METHOD

BEGIN_METHOD(AL_SpeedOfSound, GB_FLOAT speed)

	alSpeedOfSound((float)VARG(speed));

END_METHOD

#define IMPLEMENT_X(_name, _type) \
BEGIN_METHOD(AL_##_name, ID_PARAM GB_INTEGER param; _type value) \
  al##_name(ID_ARG VARG(param), VARG(value)); \
END_METHOD

#define IMPLEMENT_3X(_name, _type) \
BEGIN_METHOD(AL_##_name, ID_PARAM GB_INTEGER param; _type value1; _type value2; _type value3) \
  al##_name(ID_ARG VARG(param), VARG(value1), VARG(value2), VARG(value3)); \
END_METHOD

#define IMPLEMENT_XV(_name, _type) \
BEGIN_METHOD(AL_##_name, ID_PARAM GB_INTEGER param; GB_OBJECT array) \
	GB_ARRAY array = VARG(array); \
	if (GB.CheckObject(array)) \
		return; \
	al##_name(ID_ARG VARG(param), GB.Array.Get(array, 0)); \
END_METHOD

#define IMPLEMENT_GET_X(_name, _return, _ctype) \
BEGIN_METHOD(AL_##_name, ID_PARAM GB_INTEGER param) \
	_ctype val; \
	al##_name(ID_ARG VARG(param), &val); \
	GB.Return##_return(val); \
END_METHOD

#define IMPLEMENT_GET_XV(_name, _type, _get_size) \
BEGIN_METHOD(AL_##_name, ID_PARAM GB_INTEGER param) \
	GB_ARRAY array; \
	int size = _get_size(VARG(param)); \
	if (size == 0) \
		GB.ReturnNull(); \
	else \
	{ \
		GB.Array.New(&array, _type, size); \
		al##_name(ID_ARG VARG(param), GB.Array.Get(array, 0)); \
		GB.ReturnObject(array); \
	} \
END_METHOD

#define ID_PARAM
#define ID_ARG

IMPLEMENT_X(Listenerf, GB_SINGLE)
IMPLEMENT_3X(Listener3f, GB_SINGLE)
IMPLEMENT_XV(Listenerfv, GB_SINGLE)
IMPLEMENT_X(Listeneri, GB_INTEGER)
IMPLEMENT_3X(Listener3i, GB_INTEGER)
IMPLEMENT_XV(Listeneriv, GB_INTEGER)

IMPLEMENT_GET_X(GetListenerf, Single, ALfloat)
IMPLEMENT_GET_XV(GetListenerfv, GB_T_SINGLE, get_listener_float_param_size)
IMPLEMENT_GET_X(GetListeneri, Integer, ALint)
IMPLEMENT_GET_XV(GetListeneriv, GB_T_INTEGER, get_listener_integer_param_size)

#undef ID_PARAM
#define ID_PARAM GB_INTEGER id;
#undef ID_ARG
#define ID_ARG VARG(id),

IMPLEMENT_X(Sourcef, GB_SINGLE)
IMPLEMENT_3X(Source3f, GB_SINGLE)
IMPLEMENT_XV(Sourcefv, GB_SINGLE)
IMPLEMENT_X(Sourcei, GB_INTEGER)
IMPLEMENT_3X(Source3i, GB_INTEGER)
IMPLEMENT_XV(Sourceiv, GB_INTEGER)

IMPLEMENT_GET_X(GetSourcef, Single, ALfloat)
IMPLEMENT_GET_XV(GetSourcefv, GB_T_SINGLE, get_source_float_param_size)
IMPLEMENT_GET_X(GetSourcei, Integer, ALint)
IMPLEMENT_GET_XV(GetSourceiv, GB_T_INTEGER, get_source_integer_param_size)

#define IMPLEMENT_ACTION(_name) \
BEGIN_METHOD(AL_##_name, GB_INTEGER id) \
	al##_name(VARG(id)); \
END_METHOD

#define IMPLEMENT_ACTION_V(_name) \
BEGIN_METHOD(AL_##_name, GB_OBJECT ids) \
	GB_ARRAY array = VARG(ids); \
	if (GB.CheckObject(array)) \
		return; \
	al##_name(GB.Array.Count(array), GB.Array.Get(array, 0)); \
END_METHOD

IMPLEMENT_ACTION(SourcePlay)
IMPLEMENT_ACTION(SourceStop)
IMPLEMENT_ACTION(SourceRewind)
IMPLEMENT_ACTION(SourcePause)

IMPLEMENT_ACTION_V(SourcePlayv)
IMPLEMENT_ACTION_V(SourceStopv)
IMPLEMENT_ACTION_V(SourceRewindv)
IMPLEMENT_ACTION_V(SourcePausev)

#define IMPLEMENT_QUEUE_BUFFER(_name) \
BEGIN_METHOD(AL_##_name, GB_INTEGER source; GB_OBJECT buffers) \
	GB_ARRAY buffers = VARG(buffers); \
	if (GB.CheckObject(buffers)) \
		return; \
	al##_name(VARG(source), GB.Array.Count(buffers), GB.Array.Get(buffers, 0)); \
END_METHOD

IMPLEMENT_QUEUE_BUFFER(SourceQueueBuffers)
IMPLEMENT_QUEUE_BUFFER(SourceUnqueueBuffers)

BEGIN_METHOD(AL_BufferData, GB_INTEGER buffer; GB_INTEGER format; GB_VARIANT data; GB_INTEGER size; GB_INTEGER freq)

	void *data;
	int size = VARGOPT(size, -1);
	int max_size = -1;

	if (VARG(data).type == GB_T_STRING)
	{
		data = VARG(data).value._string;
		max_size = GB.StringLength(data);
	}
	else if (VARG(data).type == GB_T_POINTER)
	{
		data = (void *)VARG(data).value._pointer;
		max_size = size;
		if (max_size < 0)
			max_size = 0;
	}
	else if (VARG(data).type == GB_T_OBJECT)
	{
		void *object = VARG(data).value._object;

		if (GB.Is(object, GB.FindClass("Byte[]"))
			  || GB.Is(object, GB.FindClass("Short[]"))
			  || GB.Is(object, GB.FindClass("Integer[]")))
		{
			int count = GB.Array.Count((GB_ARRAY)object);

			if (count == 0)
			{
				data = NULL;
				max_size = 0;
			}
			else
			{
				data = GB.Array.Get((GB_ARRAY)object, 0);
				max_size = count * (GB.Array.Get((GB_ARRAY)object, 1) - data);
			}
		}
	}

	if (max_size < 0)
	{
		GB.Error("Unsupported data type. String, Pointer, Byte[], Short[] or Integer[] expected");
		return;
	}

	if (size < 0)
		size = max_size;
	else if (size > max_size)
		size = max_size;

	if (size <= 0)
		return;

	alBufferData(VARG(buffer), VARG(format), data, size, VARGOPT(freq, 44100));

END_METHOD

#undef ID_PARAM
#define ID_PARAM GB_INTEGER id;
#undef ID_ARG
#define ID_ARG VARG(id),

IMPLEMENT_X(Bufferf, GB_SINGLE)
IMPLEMENT_3X(Buffer3f, GB_SINGLE)
IMPLEMENT_XV(Bufferfv, GB_SINGLE)
IMPLEMENT_X(Bufferi, GB_INTEGER)
IMPLEMENT_3X(Buffer3i, GB_INTEGER)
IMPLEMENT_XV(Bufferiv, GB_INTEGER)

IMPLEMENT_GET_X(GetBufferf, Single, ALfloat)
IMPLEMENT_GET_XV(GetBufferfv, GB_T_SINGLE, get_buffer_float_param_size)
IMPLEMENT_GET_X(GetBufferi, Integer, ALint)
IMPLEMENT_GET_XV(GetBufferiv, GB_T_INTEGER, get_buffer_integer_param_size)


//---------------------------------------------------------------------------

GB_DESC AlDesc[] =
{
	GB_DECLARE_VIRTUAL("Al"),
	
	GB_STATIC_METHOD("GetError", "i", AL_GetError, NULL),
	
	GB_STATIC_METHOD("Enable", NULL, AL_Enable, "(Capability)i"),
	GB_STATIC_METHOD("Disable", NULL, AL_Disable, "(Capability)i"),
	GB_STATIC_METHOD("IsEnabled", "b", AL_IsEnabled, "(Capability)i"),
	
	GB_STATIC_METHOD("GetBoolean", "b", AL_GetBoolean, "(Param)i"),
	GB_STATIC_METHOD("GetInteger", "i", AL_GetInteger, "(Param)i"),
	GB_STATIC_METHOD("GetFloat", "g", AL_GetFloat, "(Param)i"),
	GB_STATIC_METHOD("GetDouble", "f", AL_GetDouble, "(Param)i"),

	//GB_STATIC_METHOD("GetBooleanv", "Boolean[]", AL_GetBooleanv, "(Param)i"),
	//GB_STATIC_METHOD("GetIntegerv", "Integer[]", AL_GetIntegerv, "(Param)i"),
	//GB_STATIC_METHOD("GetFloatv", "Single[]", AL_GetFloatv, "(Param)i"),
	//GB_STATIC_METHOD("GetDoublev", "Float[]", AL_GetDoublev, "(Param)i"),

	GB_STATIC_METHOD("GetString", "s", AL_GetString, "(Param)i"),

	GB_STATIC_METHOD("IsExtensionPresent", "b", AL_IsExtensionPresent, "(Name)s"),

	GB_STATIC_METHOD("GetEnumValue", "i", AL_GetEnumValue, "(Name)s"),

	GB_STATIC_METHOD("Listenerf", NULL, AL_Listenerf, "(Param)i(Value)g"),
	GB_STATIC_METHOD("Listener3f", NULL, AL_Listener3f, "(Param)i(Value1)g(Value2)g(Value3)g"),
	GB_STATIC_METHOD("Listenerfv", NULL, AL_Listenerfv, "(Param)i(Values)Single[];"),
	GB_STATIC_METHOD("Listeneri", NULL, AL_Listeneri, "(Param)i(Value)i"),
	GB_STATIC_METHOD("Listener3i", NULL, AL_Listener3i, "(Param)i(Value1)i(Value2)i(Value3)i"),
	GB_STATIC_METHOD("Listeneriv", NULL, AL_Listeneriv, "(Param)i(Values)Integer[];"),

	GB_STATIC_METHOD("GetListenerf", "g", AL_GetListenerf, "(Param)i"),
	GB_STATIC_METHOD("GetListener3f", "Single[]", AL_GetListenerfv, "(Param)i"),
	GB_STATIC_METHOD("GetListenerfv", "Single[]", AL_GetListenerfv, "(Param)i"),
	GB_STATIC_METHOD("GetListeneri", "i", AL_GetListenerf, "(Param)i"),
	GB_STATIC_METHOD("GetListener3i", "Integer[]", AL_GetListenerfv, "(Param)i"),
	GB_STATIC_METHOD("GetListeneriv", "Integer[]", AL_GetListenerfv, "(Param)i"),

	GB_STATIC_METHOD("GenSources", "Integer[]", AL_GenSources, "(Count)i"),
	GB_STATIC_METHOD("DeleteSources", NULL, AL_DeleteSources, "(Sources)Integer[];"),
	GB_STATIC_METHOD("IsSource", "b", AL_IsSource, "(Source)i"),

	GB_STATIC_METHOD("Sourcef", NULL, AL_Sourcef, "(Source)i(Param)i(Value)g"),
	GB_STATIC_METHOD("Source3f", NULL, AL_Source3f, "(Source)i(Param)i(Value1)g(Value2)g(Value3)g"),
	GB_STATIC_METHOD("Sourcefv", NULL, AL_Sourcefv, "(Source)i(Param)i(Values)Single[];"),
	GB_STATIC_METHOD("Sourcei", NULL, AL_Sourcei, "(Source)i(Param)i(Value)i"),
	GB_STATIC_METHOD("Source3i", NULL, AL_Source3i, "(Source)i(Param)i(Value1)i(Value2)i(Value3)i"),
	GB_STATIC_METHOD("Sourceiv", NULL, AL_Sourceiv, "(Source)i(Param)i(Values)Integer[];"),

	GB_STATIC_METHOD("GetSourcef", "g", AL_GetSourcef, "(Source)i(Param)i"),
	GB_STATIC_METHOD("GetSource3f", "Single[]", AL_GetSourcefv, "(Source)i(Param)i"),
	GB_STATIC_METHOD("GetSourcefv", "Single[]", AL_GetSourcefv, "(Source)i(Param)i"),
	GB_STATIC_METHOD("GetSourcei", "i", AL_GetSourcef, "(Source)i(Param)i"),
	GB_STATIC_METHOD("GetSource3i", "Integer[]", AL_GetSourcefv, "(Source)i(Param)i"),
	GB_STATIC_METHOD("GetSourceiv", "Integer[]", AL_GetSourcefv, "(Source)i(Param)i"),

	GB_STATIC_METHOD("SourcePlay", NULL, AL_SourcePlay, "(Source)i"),
	GB_STATIC_METHOD("SourceStop", NULL, AL_SourceStop, "(Source)i"),
	GB_STATIC_METHOD("SourceRewind", NULL, AL_SourceRewind, "(Source)i"),
	GB_STATIC_METHOD("SourcePause", NULL, AL_SourcePause, "(Source)i"),

	GB_STATIC_METHOD("SourcePlayv", NULL, AL_SourcePlayv, "(Sources)Integer[];"),
	GB_STATIC_METHOD("SourceStopv", NULL, AL_SourceStopv, "(Sources)Integer[];"),
	GB_STATIC_METHOD("SourceRewindv", NULL, AL_SourceRewindv, "(Sources)Integer[];"),
	GB_STATIC_METHOD("SourcePausev", NULL, AL_SourcePausev, "(Sources)Integer[];"),

	GB_STATIC_METHOD("SourceQueueBuffers", NULL, AL_SourceQueueBuffers, "(Source)i(Buffers)Integer[];"),
	GB_STATIC_METHOD("SourceUnqueueBuffers", NULL, AL_SourceUnqueueBuffers, "(Source)i(Buffers)Integer[];"),

	GB_STATIC_METHOD("GenBuffers", "Integer[]", AL_GenBuffers, "(Count)i"),
	GB_STATIC_METHOD("DeleteBuffers", NULL, AL_DeleteBuffers, "(Buffers)Integer[];"),
	GB_STATIC_METHOD("IsBuffer", "b", AL_IsBuffer, "(Buffer)i"),

	GB_STATIC_METHOD("BufferData", NULL, AL_BufferData, "(Buffer)i(Format)i(Data)v[(Size)i(Frequency)i]"),

	GB_STATIC_METHOD("Bufferf", NULL, AL_Bufferf, "(Buffer)i(Param)i(Value)g"),
	GB_STATIC_METHOD("Buffer3f", NULL, AL_Buffer3f, "(Buffer)i(Param)i(Value1)g(Value2)g(Value3)g"),
	GB_STATIC_METHOD("Bufferfv", NULL, AL_Bufferfv, "(Buffer)i(Param)i(Values)Single[];"),
	GB_STATIC_METHOD("Bufferi", NULL, AL_Bufferi, "(Buffer)i(Param)i(Value)i"),
	GB_STATIC_METHOD("Buffer3i", NULL, AL_Buffer3i, "(Buffer)i(Param)i(Value1)i(Value2)i(Value3)i"),
	GB_STATIC_METHOD("Bufferiv", NULL, AL_Bufferiv, "(Buffer)i(Param)i(Values)Integer[];"),

	GB_STATIC_METHOD("GetBufferf", "g", AL_GetBufferf, "(Buffer)i(Param)i"),
	GB_STATIC_METHOD("GetBuffer3f", "Single[]", AL_GetBufferfv, "(Buffer)i(Param)i"),
	GB_STATIC_METHOD("GetBufferfv", "Single[]", AL_GetBufferfv, "(Buffer)i(Param)i"),
	GB_STATIC_METHOD("GetBufferi", "i", AL_GetBufferf, "(Buffer)i(Param)i"),
	GB_STATIC_METHOD("GetBuffer3i", "Integer[]", AL_GetBufferfv, "(Buffer)i(Param)i"),
	GB_STATIC_METHOD("GetBufferiv", "Integer[]", AL_GetBufferfv, "(Buffer)i(Param)i"),

	GB_STATIC_METHOD("DopplerFactor", NULL, AL_DopplerFactor, "(DopplerFactor)f"),
	GB_STATIC_METHOD("DopplerVelocity", NULL, AL_DopplerVelocity, "(DopplerVelocity)f"),
	GB_STATIC_METHOD("SpeedOfSound", NULL, AL_SpeedOfSound, "(SpeedOfSound)f"),
	GB_STATIC_METHOD("DistanceModel", NULL, AL_DistanceModel, "(DistanceModel)i"),

	GB_CONSTANT("NONE", "i",                       AL_NONE),
	GB_CONSTANT("FALSE", "i",                      AL_FALSE),
	GB_CONSTANT("TRUE", "i",                       AL_TRUE),
	GB_CONSTANT("SOURCE_RELATIVE", "i",            AL_SOURCE_RELATIVE),
	GB_CONSTANT("CONE_INNER_ANGLE", "i",           AL_CONE_INNER_ANGLE),
	GB_CONSTANT("CONE_OUTER_ANGLE", "i",           AL_CONE_OUTER_ANGLE),
	GB_CONSTANT("PITCH", "i",                      AL_PITCH),
	GB_CONSTANT("POSITION", "i",                   AL_POSITION),
	GB_CONSTANT("DIRECTION", "i",                  AL_DIRECTION),
	GB_CONSTANT("VELOCITY", "i",                   AL_VELOCITY),
	GB_CONSTANT("LOOPING", "i",                    AL_LOOPING),
	GB_CONSTANT("BUFFER", "i",                     AL_BUFFER),
	GB_CONSTANT("GAIN", "i",                       AL_GAIN),
	GB_CONSTANT("MIN_GAIN", "i",                   AL_MIN_GAIN),
	GB_CONSTANT("MAX_GAIN", "i",                   AL_MAX_GAIN),
	GB_CONSTANT("ORIENTATION", "i",                AL_ORIENTATION),
	GB_CONSTANT("SOURCE_STATE", "i",               AL_SOURCE_STATE),
	GB_CONSTANT("INITIAL", "i",                    AL_INITIAL),
	GB_CONSTANT("PLAYING", "i",                    AL_PLAYING),
	GB_CONSTANT("PAUSED", "i",                     AL_PAUSED),
	GB_CONSTANT("STOPPED", "i",                    AL_STOPPED),
	GB_CONSTANT("BUFFERS_QUEUED", "i",             AL_BUFFERS_QUEUED),
	GB_CONSTANT("BUFFERS_PROCESSED", "i",          AL_BUFFERS_PROCESSED),
	GB_CONSTANT("SEC_OFFSET", "i",                 AL_SEC_OFFSET),
	GB_CONSTANT("SAMPLE_OFFSET", "i",              AL_SAMPLE_OFFSET),
	GB_CONSTANT("BYTE_OFFSET", "i",                AL_BYTE_OFFSET),
	GB_CONSTANT("SOURCE_TYPE", "i",                AL_SOURCE_TYPE),
	GB_CONSTANT("STATIC", "i",                     AL_STATIC),
	GB_CONSTANT("STREAMING", "i",                  AL_STREAMING),
	GB_CONSTANT("UNDETERMINED", "i",               AL_UNDETERMINED),
	GB_CONSTANT("FORMAT_MONO8", "i",               AL_FORMAT_MONO8),
	GB_CONSTANT("FORMAT_MONO16", "i",              AL_FORMAT_MONO16),
	GB_CONSTANT("FORMAT_STEREO8", "i",             AL_FORMAT_STEREO8),
	GB_CONSTANT("FORMAT_STEREO16", "i",            AL_FORMAT_STEREO16),
	GB_CONSTANT("REFERENCE_DISTANCE", "i",         AL_REFERENCE_DISTANCE),
	GB_CONSTANT("ROLLOFF_FACTOR", "i",             AL_ROLLOFF_FACTOR),
	GB_CONSTANT("CONE_OUTER_GAIN", "i",            AL_CONE_OUTER_GAIN),
	GB_CONSTANT("MAX_DISTANCE", "i",               AL_MAX_DISTANCE),
	GB_CONSTANT("FREQUENCY", "i",                  AL_FREQUENCY),
	GB_CONSTANT("BITS", "i",                       AL_BITS),
	GB_CONSTANT("CHANNELS", "i",                   AL_CHANNELS),
	GB_CONSTANT("SIZE", "i",                       AL_SIZE),
	GB_CONSTANT("UNUSED", "i",                     AL_UNUSED),
	GB_CONSTANT("PENDING", "i",                    AL_PENDING),
	GB_CONSTANT("PROCESSED", "i",                  AL_PROCESSED),
	GB_CONSTANT("NO_ERROR", "i",                   AL_NO_ERROR),
	GB_CONSTANT("INVALID_NAME", "i",               AL_INVALID_NAME),
	GB_CONSTANT("INVALID_ENUM", "i",               AL_INVALID_ENUM),
	GB_CONSTANT("INVALID_VALUE", "i",              AL_INVALID_VALUE),
	GB_CONSTANT("INVALID_OPERATION", "i",          AL_INVALID_OPERATION),
	GB_CONSTANT("OUT_OF_MEMORY", "i",              AL_OUT_OF_MEMORY),
	GB_CONSTANT("VENDOR", "i",                     AL_VENDOR),
	GB_CONSTANT("VERSION", "i",                    AL_VERSION),
	GB_CONSTANT("RENDERER", "i",                   AL_RENDERER),
	GB_CONSTANT("EXTENSIONS", "i",                 AL_EXTENSIONS),
	GB_CONSTANT("DOPPLER_FACTOR", "i",             AL_DOPPLER_FACTOR),
	GB_CONSTANT("DOPPLER_VELOCITY", "i",           AL_DOPPLER_VELOCITY),
	GB_CONSTANT("SPEED_OF_SOUND", "i",             AL_SPEED_OF_SOUND),
	GB_CONSTANT("DISTANCE_MODEL", "i",             AL_DISTANCE_MODEL),
	GB_CONSTANT("INVERSE_DISTANCE", "i",           AL_INVERSE_DISTANCE),
	GB_CONSTANT("INVERSE_DISTANCE_CLAMPED", "i",   AL_INVERSE_DISTANCE_CLAMPED),
	GB_CONSTANT("LINEAR_DISTANCE", "i",            AL_LINEAR_DISTANCE),
	GB_CONSTANT("LINEAR_DISTANCE_CLAMPED", "i",    AL_LINEAR_DISTANCE_CLAMPED),
	GB_CONSTANT("EXPONENT_DISTANCE", "i",          AL_EXPONENT_DISTANCE),
	GB_CONSTANT("EXPONENT_DISTANCE_CLAMPED", "i",  AL_EXPONENT_DISTANCE_CLAMPED),

	GB_END_DECLARE
};
