void set_buffer_loader(std::shared_ptr<buffer_loader> const &l) {
SET_CONTEXT(ctx_);
alSourceStop(src_);
alSourcei(src_, AL_BUFFER, AL_NONE);
if (!l) {
loader_.reset();
return;
}
ALint unqueuing_count;
alGetSourceiv(src_, AL_BUFFERS_QUEUED, &unqueuing_count);
std::vector<ALuint> unqueued(unqueuing_count);
alSourceUnqueueBuffers(src_, unqueuing_count, &unqueued.front());
loader_ = l;
int queuing_count = 0;
assert(!l->is_end());
ticks_[0] = 0;
for (; queuing_count < BUFFER_NUMBER; ++queuing_count) {
buf_sizes_[queuing_count] = loader_->load_buffer(buffers_[queuing_count]);
ticks_[queuing_count + 1] = loader_->midi_ticks();
if (loader_->is_end()) {
queuing_count++;
break;
}
}
alSourceQueueBuffers(src_, queuing_count, buffers_.data());
alSourcePlay(src_);
}
void update() {
ALint processed;
alGetSourceiv(src_, AL_BUFFERS_PROCESSED, &processed);
std::vector<ALuint> unqueued(processed);
alSourceUnqueueBuffers(src_, processed, &unqueued.front());
int queuing_count = 0;
for (; queuing_count < processed; ++queuing_count) {
if (not loop_play_ and loader_->is_end()) {
loader_.reset();
++queuing_count;
break;
}
if (loader_->is_end()) {
ticks_.push_back(0);
}
buf_sizes_.push_back(loader_->load_buffer(unqueued[queuing_count]));
ticks_.push_back(loader_->midi_ticks());
}
alSourceQueueBuffers(src_, queuing_count, &unqueued.front());
if (fade_milli_ != 0) {
SET_CONTEXT(ctx_);
loop_count_++;
if (fade_ended()) {
alSourceStop(src_);
} else {
alSourcef(src_, AL_GAIN, current_volume());
}
}
}
static void iterate( void ) {
static ALfloat position[] = { 10.0, 0.0, 4.0 };
static ALfloat movefactor = 4.5;
static time_t then = 0;
time_t now;
ALint byteloki;
ALint size;
now = time( NULL );
/* Switch between left and right stereo sample every two seconds. */
if( now - then > 2 ) {
then = now;
movefactor *= -1.0;
}
position[0] += movefactor;
alSourcefv( moving_source, AL_POSITION, position );
micro_sleep(500000);
alGetSourceiv( moving_source, AL_BYTE_LOKI, &byteloki);
alGetBufferi( stereo, AL_SIZE, &size);
fprintf(stderr, "byteloki = %d size = %d\n", byteloki, size);
return;
}
AL_API int OPENAL_PlaySoundEx(int channel, OPENAL_SAMPLE *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused)
{
if (!initialized) return -1;
if (sptr == NULL) return -1;
if (dsp != NULL) return -1;
if (channel == OPENAL_FREE)
{
for (int i = 0; i < num_channels; i++)
{
ALint state = 0;
alGetSourceiv(channels[i].sid, AL_SOURCE_STATE, &state);
if ((state != AL_PLAYING) && (state != AL_PAUSED))
{
channel = i;
break;
}
}
}
if ((channel < 0) || (channel >= num_channels)) return -1;
alSourceStop(channels[channel].sid);
channels[channel].sample = sptr;
alSourcei(channels[channel].sid, AL_BUFFER, sptr->bid);
alSourcei(channels[channel].sid, AL_LOOPING, (sptr->mode == OPENAL_LOOP_OFF) ? AL_FALSE : AL_TRUE);
set_channel_position(channel, 0.0f, 0.0f, 0.0f);
channels[channel].startpaused = ((startpaused) ? true : false);
if (!startpaused)
alSourcePlay(channels[channel].sid);
return channel;
}
AL_API signed char OPENAL_SetPaused(int channel, signed char paused)
{
if (!initialized) return false;
if (channel == OPENAL_ALL)
{
for (int i = 0; i < num_channels; i++)
OPENAL_SetPaused(i, paused);
return true;
}
if ((channel < 0) || (channel >= num_channels)) return false;
ALint state = 0;
if (channels[channel].startpaused)
state = AL_PAUSED;
else
alGetSourceiv(channels[channel].sid, AL_SOURCE_STATE, &state);
if ((paused) && (state == AL_PLAYING))
alSourcePause(channels[channel].sid);
else if ((!paused) && (state == AL_PAUSED))
{
alSourcePlay(channels[channel].sid);
channels[channel].startpaused = false;
}
return true;
}
bool CSoundBase::IsPlaying()
{
int proc_state;
alGetSourceiv(m_ALSource, AL_SOURCE_STATE, &proc_state);
return (proc_state == AL_PLAYING);
}
void set_buffer_loader(EASYRPG_SHARED_PTR<buffer_loader> const &l) {
SET_CONTEXT(ctx_);
alSourceStop(src_);
alSourcei(src_, AL_BUFFER, AL_NONE);
if (not l) {
loader_.reset();
return;
}
ALint unqueuing_count;
alGetSourceiv(src_, AL_BUFFERS_QUEUED, &unqueuing_count);
std::vector<ALuint> unqueued(unqueuing_count);
alSourceUnqueueBuffers(src_, unqueuing_count, &unqueued.front());
loader_ = l;
int queuing_count = 0;
BOOST_ASSERT(not l->is_end());
ticks_.push_back(0);
for (; queuing_count < BUFFER_NUMBER; ++queuing_count) {
buf_sizes_.push_back(loader_->load_buffer(buffers_[queuing_count]));
ticks_.push_back(loader_->midi_ticks());
if (loader_->is_end()) {
queuing_count++;
break;
}
}
alSourceQueueBuffers(src_, queuing_count, buffers_.data());
alSourcePlay(src_);
}
void al_getsourceiv( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) {
if (NULL == alGetSourceiv) mogl_glunsupported("alGetSourceiv");
alGetSourceiv((ALuint)mxGetScalar(prhs[0]),
(ALenum)mxGetScalar(prhs[1]),
(ALint*)mxGetData(prhs[2]));
}
AL_API signed char OPENAL_IsPlaying(int channel)
{
if (!initialized) return false;
if ((channel < 0) || (channel >= num_channels)) return false;
ALint state = 0;
alGetSourceiv(channels[channel].sid, AL_SOURCE_STATE, &state);
return((state == AL_PLAYING) ? true : false);
}
AL_API unsigned int OPENAL_GetLoopMode(int channel)
{
if (!initialized) return 0;
if ((channel < 0) || (channel >= num_channels)) return 0;
ALint loop = 0;
alGetSourceiv(channels[channel].sid, AL_LOOPING, &loop);
if (loop)
return(OPENAL_LOOP_NORMAL);
return OPENAL_LOOP_OFF;
}
bool CALL HGE_Impl::Channel_IsPlaying(HCHANNEL chn)
{
if(hOpenAL)
{
ALint state = AL_STOPPED;
alGetSourceiv((ALuint) chn, AL_SOURCE_STATE, &state);
return state == AL_PLAYING;
}
else return false;
}
unsigned midi_ticks() const {
if (not loader_) {
return 0;
}
ALint offset;
alGetSourceiv(src_, AL_SAMPLE_OFFSET, &offset);
return ticks_[0] + (ticks_[1] - ticks_[0]) * offset / buf_sizes_[0];
}
AL_API signed char OPENAL_GetPaused(int channel)
{
if (!initialized) return false;
if ((channel < 0) || (channel >= num_channels)) return false;
if (channels[channel].startpaused)
return(true);
ALint state = 0;
alGetSourceiv(channels[channel].sid, AL_SOURCE_STATE, &state);
return((state == AL_PAUSED) ? true : false);
}
bl KLAL_IsPlaying(KLAL* p)
{
ALint v;
if( !p )
p = &klal;
alGetSourceiv( p->src, AL_SOURCE_STATE, &v );
return v==AL_PLAYING;
}
bl KLAL_IsStopped(KLAL* p)
{
ALint v;
if( !p )
p = &klal;
alGetSourceiv( p->src, AL_SOURCE_STATE, &v );
return v==AL_STOPPED;
}
void CSoundBase::FadeToIn(ALfloat newVolume, double fadeDuration)
{
int proc_state;
alGetSourceiv(m_ALSource, AL_SOURCE_STATE, &proc_state);
if (proc_state == AL_PLAYING)
{
m_StartFadeTime = timer_Time();
m_EndFadeTime = m_StartFadeTime + fadeDuration;
alGetSourcef(m_ALSource, AL_GAIN, &m_StartVolume);
m_EndVolume = newVolume;
}
}
void CSoundBase::Stop()
{
m_ShouldBePlaying = false;
if (m_ALSource != 0)
{
int proc_state;
alSourcei(m_ALSource, AL_LOOPING, AL_FALSE);
alGetSourceiv(m_ALSource, AL_SOURCE_STATE, &proc_state);
if (proc_state == AL_PLAYING)
alSourceStop(m_ALSource);
}
}
void hdW32SoundVoiceDevice::UpdateVoice()
{
if ( voice_ )
{
ALint processed;
ALint queued;
alGetSourceiv( voice_, AL_BUFFERS_PROCESSED, &processed );
HEART_CHECK_OPENAL_ERRORS();
alGetSourceiv( voice_, AL_BUFFERS_QUEUED, &queued );
HEART_CHECK_OPENAL_ERRORS();
if ( processed > 0 )
{
ALuint proBufs[BUFFER_COUNT];
alSourceUnqueueBuffers( voice_, processed, proBufs );
HEART_CHECK_OPENAL_ERRORS();
}
ALint playing;
alGetSourcei( voice_, AL_SOURCE_STATE, &playing );
HEART_CHECK_OPENAL_ERRORS();
if ( queued && playing != AL_PLAYING && playing != AL_PAUSED )
{
alSourcePlay( voice_ );
}
if ( queued == 0 && sourceComplete_ == hTrue )
{
info_.callback_( this, VOICE_STOPPED );
}
if ( queued < BUFFER_COUNT && sourceComplete_ != hTrue )
{
info_.callback_( this, NEED_MORE_PCM_DATA );
}
}
}
value lime_al_get_sourceiv (int source, int param, int count) {
ALint* values = new ALint[count];
alGetSourceiv (source, param, values);
value result = alloc_array (count);
for (int i = 0; i < count; i++) {
val_array_set_i (result, i, alloc_int (values[i]));
}
delete [] values;
return result;
}
value lime_al_get_sourceiv (value source, value param, value count) {
int length = val_int (count);
ALint* values = new ALint[length];
alGetSourceiv (val_int (source), val_int (param), values);
value result = alloc_array (length);
for (int i = 0; i < length; ++i) {
val_array_set_i (result, i, alloc_int (values[i]));
}
return result;
}
static ALuint get_source()
{
for (int i = 0; i < sidcount; i++)
{
ALint state = AL_PLAYING;
alGetSourceiv(sids[i], AL_SOURCE_STATE, &state);
if ((state != AL_PLAYING) && (state != AL_PAUSED))
return sids[i];
}
if (sidcount >= MAX_SIDS)
return 0;
ALuint sid = 0;
alGenSources(1, &sid);
if (sid == 0)
return 0;
sids[sidcount++] = sid;
return sid;
}
ALboolean SourceIsPlaying(ALuint sid) {
ALint state;
if(alIsSource(sid) == AL_FALSE) {
return AL_FALSE;
}
state = AL_INITIAL;
alGetSourceiv(sid, AL_SOURCE_STATE, &state);
switch(state) {
case AL_PLAYING:
case AL_PAUSED:
return AL_TRUE;
default:
break;
}
return AL_FALSE;
}
bool CStreamItem::IdleTask()
{
AL_CHECK
HandleFade();
AL_CHECK
int proc_state;
alGetSourceiv(m_ALSource, AL_SOURCE_STATE, &proc_state);
AL_CHECK
if (proc_state == AL_STOPPED)
{
if (m_LastPlay)
return (proc_state != AL_STOPPED);
}
else
{
COggData* tmp = (COggData*)m_SoundData;
if (! tmp->IsFileFinished())
{
int num_processed;
alGetSourcei(m_ALSource, AL_BUFFERS_PROCESSED, &num_processed);
AL_CHECK
if (num_processed > 0)
{
ALuint* al_buf = new ALuint[num_processed];
alSourceUnqueueBuffers(m_ALSource, num_processed, al_buf);
AL_CHECK
int didWrite = tmp->FetchDataIntoBuffer(num_processed, al_buf);
alSourceQueueBuffers(m_ALSource, didWrite, al_buf);
AL_CHECK
delete[] al_buf;
}
}
else if (GetLooping())
//*****************************************************************************
// alGetSourceiv
//*****************************************************************************
//
ALAPI ALvoid ALAPIENTRY alGetSourceiv(ALuint sourceName, ALenum param, ALint* values)
{
AL_VOID_FXN(alGetSourceiv(sourceName, param, values));
}
int main( int argc, char* argv[] ) {
ALCdevice *dev;
int attrlist[] = { ALC_FREQUENCY, 22050, 0 };
time_t shouldend, start;
ALint test = AL_FALSE;
dev = alcOpenDevice( NULL );
if( dev == NULL ) {
return 1;
}
/* Initialize ALUT. */
context_id = alcCreateContext( dev, attrlist);
if(context_id == NULL) {
alcCloseDevice( dev );
exit(1);
}
alcMakeContextCurrent( context_id );
fixup_function_pointers();
talBombOnError();
if(argc == 1) {
init(WAVEFILE);
} else {
init(argv[1]);
}
fprintf( stderr, "Loop for 4 seconds\n");
alSourcePlay( moving_source );
shouldend = start = time( NULL );
while( shouldend - start <= 4 ) {
shouldend = time(NULL);
micro_sleep( 1000000 );
}
alSourceStop( moving_source );
test = -1;
alGetSourceiv( moving_source, AL_LOOPING, &test );
fprintf(stderr, "is looping? getsi says %s\n",
(test == AL_TRUE)?"AL_TRUE":"AL_FALSE");
/* part the second */
fprintf( stderr, "Play once\n");
micro_sleep( 1000000 );
alSourcei( moving_source, AL_LOOPING, AL_FALSE );
alSourcePlay( moving_source );
do {
micro_sleep( 1000000 );
} while( SourceIsPlaying( moving_source ) );
alcDestroyContext(context_id);
alcCloseDevice( dev );
cleanup();
return 0;
}
static int lua_alGetSource(lua_State* lua_state)
{
ALuint source_id;
ALenum enum_parameter;
int openal_primitive_type;
source_id = lua_tointeger(lua_state, 1);
enum_parameter = lua_tointeger(lua_state, 2);
openal_primitive_type = lua_getTypeForEnum(enum_parameter);
switch(openal_primitive_type)
{
case LUAOPENAL_BOOL_TYPE:
{
ALint ret_val;
alGetSourcei(source_id, enum_parameter, &ret_val);
lua_pushboolean(lua_state, ret_val);
return 1;
break;
}
case LUAOPENAL_INT_TYPE:
{
ALint ret_val;
alGetSourcei(source_id, enum_parameter, &ret_val);
lua_pushinteger(lua_state, ret_val);
return 1;
break;
}
case LUAOPENAL_FLOAT_TYPE:
{
ALfloat ret_val;
alGetSourcef(source_id, enum_parameter, &ret_val);
lua_pushnumber(lua_state, ret_val);
return 1;
break;
}
case LUAOPENAL_INT_3_TYPE:
{
ALint ret_val[3];
alGetSourceiv(source_id, enum_parameter, ret_val);
lua_pushinteger(lua_state, ret_val[0]);
lua_pushinteger(lua_state, ret_val[1]);
lua_pushinteger(lua_state, ret_val[2]);
return 3;
break;
}
case LUAOPENAL_FLOAT_3_TYPE:
{
ALfloat ret_val[3];
alGetSourcefv(source_id, enum_parameter, ret_val);
lua_pushnumber(lua_state, ret_val[0]);
lua_pushnumber(lua_state, ret_val[1]);
lua_pushnumber(lua_state, ret_val[2]);
return 3;
break;
}
default:
{
/* TODO: Figure out how to handle OpenAL extensions. */
luaL_error(lua_state, "Unhandled parameter type for alGetSource*");
}
}
return 0;
}
void ActualizarMusica ( ){
ALint error;
int cont = 0;
int contador = 0;
int i;
int posicion = 0;
ALuint streambuffers[NUM_BUFFER_MUSICA]; /* Utilizado en la carga de archivos OGG */
ALshort waveout [BUFFER_MUSICA]; /* Donde almacenamos los OGG Vorbis decodificados */
ALuint streamsource[1]; /* Utilizado en la carga de archivos OGG */
/* Generamos buffers para hacer el streaming */
alGenBuffers ( NUM_BUFFER_MUSICA, streambuffers);
if ( (error = alGetError()) != AL_NO_ERROR){
fprintf ( logs,"Fallo al crear los buffers para la musica:%s\n", alGetString(error));
exit (2);
}
/* Rellenamos los buffers creados con la musica decodificada */
for ( i=0; i < NUM_BUFFER_MUSICA ; i++){
cont = ov_read ( &buff, (char *)&waveout[posicion], BUFFER_MUSICA , 0, 2, 1, ¤t_section ) / 2;
contador += cont;
fprintf ( logs, "contador = \n");
alBufferData ( streambuffers[i], formato, waveout , BUFFER_MUSICA , informacion->rate );
if ( (error =alGetError ()) != AL_NO_ERROR ){
fprintf ( logs, "Error al anyadir datos al buffer %i:%s\n",i,alGetString(error));
}
}
/* Creamos la fuente y definimos sus propiedades */
alGenSources( 1, streamsource );
if ( (error = alGetError()) != AL_NO_ERROR ){
fprintf ( logs, "Error al generar la fuente de sonido: %s\n", alGetString (error));
}
/* Defino propiedades para la fuente */
/*alSourcei ( streamsource[0], AL_SOURCE_RELATIVE, AL_TRUE ); /* Para que se mueva con el listener */
/*alSourcei ( streamsource[0], AL_LOOPING, AL_FALSE ); /* No se repite por ella sola */
/*alSourcef ( streamsource[0], AL_GAIN, 0.9f ); /* Para que suene menos que los sonidos */
/* Asignamos los buffers creados a la fuente */
alSourceQueueBuffers ( streamsource[0], NUM_BUFFER_MUSICA, streambuffers );
/* Se empieza a reproducir la musica */
alSourcePlay ( streamsource[0] );
if ( (error = alGetError ()) != AL_NO_ERROR ){
fprintf ( logs, "Error al reproducir musica:%s\n",alGetString (error));
}
/* A partir de aqui es donde realmente empieza el Streaming*/
while ( contador < tamanyo_cancion ){
/* Comprobamos estado de los buffers */
alGetSourceiv ( streamsource[0], AL_BUFFERS_PROCESSED, &buffers_vacios);
/* Si algun buffer esta vacio, lo rellenamos */
if ( buffers_vacios > 0 ){
while ( buffers_vacios ){
/* Desasignamos buffers para rellenarlos */
alSourceUnqueueBuffers ( streamsource[0], 1, &streambuffers );
if ( (alGetError( )) != AL_NO_ERROR ){
fprintf ( logs,"No va el streaming\n");
}
/* Descomprimimos datos en el buffer intermedio */
cont = ov_read ( &buff, (char *)&waveout, BUFFER_MUSICA, 0, 2, 1, ¤t_section);
contador += cont;
/* Los anyadimos en el buffer */
alBufferData ( streambuffers, formato, waveout, BUFFER_MUSICA, frecuencia );
if ((alGetError()) != AL_NO_ERROR ){
fprintf ( logs, "No se puede añadir datos al buffer\n");
}
/* Asignamos de nuevo los buffers al streamsource */
alSourceQueueBuffers ( streamsource[0], 1, &streambuffers );
buffers_vacios --;
/* Compruebo si se ha acabado la cancion */
if ( contador < tamanyo_cancion){
break;
}
}
}
}
/* Cuando se acaba la cancion, paramos todo y borramos buffers y fuentes */
alSourceStopv(1, streamsource);
if (alGetError() != AL_NO_ERROR){
fprintf ( logs,"No se pueden parar el streamsource\n");
}
alDeleteSources(1, streamsource);
if (alGetError() != AL_NO_ERROR){
fprintf ( logs,"No se puede borrar el stremsource\n");
}
alDeleteBuffers(NUM_BUFFER_MUSICA, streambuffers);
if (alGetError() != AL_NO_ERROR){
fprintf ( logs,"No se pueden borrar los buffers\n");
}
musica_on = 0;
}
ALvoid CDECL wine_alGetSourceiv(ALuint sid, ALenum param, ALint* values)
{
alGetSourceiv(sid, param, values);
}
int main( int argc, char *argv[] )
{
ALCdevice *device;
int attributeList[] = { ALC_FREQUENCY, 22050, 0 };
time_t shouldend, start;
ALint test = AL_FALSE;
device = alcOpenDevice( NULL );
if( device == NULL ) {
return EXIT_FAILURE;
}
/* Initialize ALUT. */
context = alcCreateContext( device, attributeList );
if( context == NULL ) {
alcCloseDevice( device );
exit( EXIT_FAILURE );
}
alcMakeContextCurrent( context );
testInitWithoutContext( &argc, argv );
getExtensionEntries( );
palBombOnError( );
init( ( const ALbyte * ) ( ( argc == 1 ) ? WAVEFILE : argv[1] ) );
fprintf( stderr, "Loop for 4 seconds\n" );
alSourcePlay( movingSource );
shouldend = start = time( NULL );
while( shouldend - start <= 4 ) {
shouldend = time( NULL );
microSleep( 1000000 );
}
alSourceStop( movingSource );
test = -1;
alGetSourceiv( movingSource, AL_LOOPING, &test );
fprintf( stderr, "is looping? getsi says %s\n",
( test == AL_TRUE ) ? "AL_TRUE" : "AL_FALSE" );
/* part the second */
fprintf( stderr, "Play once\n" );
microSleep( 1000000 );
alSourcei( movingSource, AL_LOOPING, AL_FALSE );
alSourcePlay( movingSource );
do {
microSleep( 1000000 );
}
while( sourceIsPlaying( movingSource ) );
testExit();
alcDestroyContext( context );
alcCloseDevice( device );
return EXIT_SUCCESS;
}
static PyObject*
_sources_getprop (PyObject *self, PyObject *args)
{
long bufnum;
ALenum param;
char *type;
int size = 0, cnt;
PropType ptype = INVALID;
if (!CONTEXT_IS_CURRENT (((PySources*)self)->context))
{
PyErr_SetString (PyExc_PyGameError, "source context is not current");
return NULL;
}
if (!PyArg_ParseTuple (args, "lls:get_prop", &bufnum, ¶m, &type))
{
PyErr_Clear ();
if (!PyArg_ParseTuple (args, "lls|i:get_prop", &bufnum, ¶m, &type,
&size))
return NULL;
if (size <= 0)
{
PyErr_SetString (PyExc_ValueError, "size must not smaller than 0");
return NULL;
}
}
ptype = GetPropTypeFromStr (type);
CLEAR_ALERROR_STATE ();
switch (ptype)
{
case INT:
{
ALint val;
alGetSourcei ((ALuint)bufnum, param, &val);
if (SetALErrorException (alGetError (), 0))
return NULL;
return PyLong_FromLong ((long)val);
}
case FLOAT:
{
ALfloat val;
alGetSourcef ((ALuint)bufnum, param, &val);
if (SetALErrorException (alGetError (), 0))
return NULL;
return PyFloat_FromDouble ((double)val);
}
case INT3:
{
ALint val[3];
alGetSource3i ((ALuint)bufnum, param, &val[0], &val[1], &val[2]);
if (SetALErrorException (alGetError (), 0))
return NULL;
return Py_BuildValue ("(lll)", (long)val[0], (long)val[1],
(long)val[2]);
}
case FLOAT3:
{
ALfloat val[3];
alGetSource3f ((ALuint)bufnum, param, &val[0], &val[1], &val[2]);
if (SetALErrorException (alGetError (), 0))
return NULL;
return Py_BuildValue ("(ddd)", (double)val[0], (double)val[1],
(double)val[2]);
}
case INTARRAY:
{
PyObject *tuple, *item;
ALint* val = PyMem_New (ALint, size);
if (!val)
return NULL;
alGetSourceiv ((ALuint)bufnum, param, val);
if (SetALErrorException (alGetError (), 0))
{
PyMem_Free (val);
return NULL;
}
tuple = PyTuple_New ((Py_ssize_t) size);
if (!tuple)
return NULL;
for (cnt = 0; cnt < size; cnt++)
{
item = PyLong_FromLong ((long)val[cnt]);
if (!item)
{
PyMem_Free (val);
Py_DECREF (tuple);
return NULL;
}
PyTuple_SET_ITEM (tuple, (Py_ssize_t) cnt, item);
}
return tuple;
}
case FLOATARRAY:
{
PyObject *tuple, *item;
ALfloat* val = PyMem_New (ALfloat, size);
if (!val)
return NULL;
alGetSourcefv ((ALuint)bufnum, param, val);
if (SetALErrorException (alGetError (), 0))
{
PyMem_Free (val);
return NULL;
}
tuple = PyTuple_New ((Py_ssize_t) size);
if (!tuple)
return NULL;
for (cnt = 0; cnt < size; cnt++)
{
item = PyFloat_FromDouble ((double)val[cnt]);
if (!item || PyTuple_SET_ITEM (tuple, (Py_ssize_t) cnt, item) != 0)
{
PyMem_Free (val);
Py_XDECREF (item);
Py_DECREF (tuple);
return NULL;
}
}
return tuple;
}
default:
PyErr_SetString (PyExc_ValueError, "invalid type specifier");
return NULL;
}
}
