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; } }