void al_sourcestopv( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) {
if (NULL == alSourceStopv) mogl_glunsupported("alSourceStopv");
alSourceStopv((ALsizei)mxGetScalar(prhs[0]),
(const ALuint*)mxGetData(prhs[1]));
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer::stop(){
alSourceStopv(channels,&sources[sources.size()-channels]);
if(isStreaming){
setPosition(0);
stopThread();
}
}
/**
* @brief Cleans up after the sound subsytem.
*/
void sound_al_exit (void)
{
int i;
soundLock();
/* Free groups. */
for (i=0; i<al_ngroups; i++) {
if (al_groups[i].sources != NULL) {
free(al_groups[i].sources);
}
al_groups[i].sources = NULL;
al_groups[i].nsources = 0;
}
if (al_groups != NULL)
free(al_groups);
al_groups = NULL;
al_ngroups = 0;
/* Free stacks. */
if (source_all != NULL) {
alSourceStopv( source_nall, source_all );
alDeleteSources( source_nall, source_all );
free(source_all);
}
source_all = NULL;
source_nall = 0;
if (source_total)
free(source_total);
source_total = NULL;
source_ntotal = 0;
if (source_stack != NULL)
free(source_stack);
source_stack = NULL;
source_nstack = 0;
source_mstack = 0;
/* Clean up EFX stuff. */
if (al_info.efx == AL_TRUE) {
nalDeleteAuxiliaryEffectSlots( 1, &efx_directSlot );
if (al_info.efx_reverb == AL_TRUE)
nalDeleteEffects( 1, &efx_reverb );
if (al_info.efx_echo == AL_TRUE)
nalDeleteEffects( 1, &efx_echo );
}
/* Clean up global stuff. */
if (al_context) {
alcMakeContextCurrent(NULL);
alcDestroyContext( al_context );
}
if (al_device)
alcCloseDevice( al_device );
soundUnlock();
SDL_DestroyMutex( sound_lock );
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer::stop(){
if(sources.empty()) return;
std::unique_lock<std::mutex> lock(mutex);
alSourceStopv(channels,&sources[sources.size()-channels]);
if(isStreaming){
setPosition(0);
stopThread();
}
}
// 停止播放音频流
////////////////////////////////////////////////////////////////////////////////
void OALMusicBuffer::DoStop()
{
if (!stopped_)
{
stopped_ = true;
play_thread_();
}
alSourceStopv(1, &source_);
}
// 更新缓冲区
/////////////////////////////////////////////////////////////////////////////////
void OALMusicBuffer::LoopUpdateBuffer()
{
std::unique_lock<std::mutex> lock(play_mutex_);
while (!played_)
{
play_cond_.wait(lock);
}
played_ = false;
while (!stopped_)
{
ALint processed;
alGetSourcei(source_, AL_BUFFERS_PROCESSED, &processed);
if (processed > 0)
{
while (processed > 0)
{
-- processed;
ALuint buf;
alSourceUnqueueBuffers(source_, 1, &buf);
std::vector<uint8_t> data(READSIZE);
data.resize(dataSource_->Read(&data[0], data.size()));
if (data.empty())
{
if (loop_)
{
stopped_ = false;
alSourceStopv(1, &source_);
this->DoReset();
alSourcePlay(source_);
}
else
{
stopped_ = true;
}
}
else
{
alBufferData(buf, Convert(format_), &data[0],
static_cast<ALsizei>(data.size()), freq_);
alSourceQueueBuffers(source_, 1, &buf);
}
}
}
else
{
Sleep(1000 / PreSecond);
}
}
}
value lime_al_source_stopv (value n, value sources) {
int *data = val_array_int (sources);
if (data) {
alSourceStopv (val_int (n), (ALuint*)data);
}
return alloc_null ();
}
static void Mgr_Destroy(SMgrState& _State)
{
if (_State.cActive > 0) {
alSourceStopv(_State.cActive, _State.Active);
memcpy(_State.Avail + _State.cAvail, _State.Active, _State.cActive*sizeof(ALuint));
_State.cAvail += _State.cActive;
_State.cActive = 0;
}
for (int i=0; i < MGR_MAX_EMITTERS; i++) {
ALuint s = _State.Emitters[i].Source;
alSourceStop(s);
_State.Emitters[i].Source = 0;
_State.Avail[_State.cAvail] = s; _State.cAvail ++;
}
alDeleteSources(_State.cAvail, _State.Avail);
}
void lime_al_source_stopv (int n, value sources) {
if (val_is_null (sources) == false) {
int size = val_array_size (sources);
ALuint* data = new ALuint[size];
for (int i = 0; i < size; ++i) {
data[i] = (ALuint)val_int( val_array_i (sources, i) );
}
alSourceStopv (n, data);
delete[] data;
}
}
void OALSoundBuffer::Stop()
{
alSourceStopv(static_cast<ALsizei>(sources_.size()), sources_.data());
}
/**
* \brief stop playing and empty buffers (for seeking/pause)
*/
static void reset(struct ao *ao)
{
alSourceStopv(ao->channels.num, sources);
unqueue_buffers();
}
JNIEXPORT void JNICALL Java_org_lwjgl_openal_AL10_nalSourceStopv(JNIEnv *__env, jclass clazz, jint n, jlong sourcesAddress, jlong __functionAddress) {
const ALuint *sources = (const ALuint *)(intptr_t)sourcesAddress;
alSourceStopvPROC alSourceStopv = (alSourceStopvPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
alSourceStopv(n, sources);
}
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;
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer::stop(){
alSourceStopv(channels,&sources[sources.size()-channels]);
}
// ----------------------------------------------------------------------------
void ofOpenALSoundPlayer_TimelineAdditions::stop(){
alSourceStopv(channels,&sources[sources.size()-channels]);
}
ALvoid CDECL wine_alSourceStopv(ALsizei ns, const ALuint *sids)
{
alSourceStopv(ns, sids);
}
/**
* \brief stop playing and empty buffers (for seeking/pause)
*/
static void reset(void) {
alSourceStopv(ao_data.channels, sources);
unqueue_buffers();
}
//*****************************************************************************
// alSourceStopv
//*****************************************************************************
//
ALAPI ALvoid ALAPIENTRY alSourceStopv(ALsizei n, const ALuint* sourceNames)
{
AL_VOID_FXN(alSourceStopv(n, sourceNames));
}
static PyObject*
_sources_action (PyObject *self, PyObject *args, SourcesAction action)
{
unsigned int source;
if (!CONTEXT_IS_CURRENT (((PySources*)self)->context))
{
PyErr_SetString (PyExc_PyGameError, "source context is not current");
return NULL;
}
if (PySequence_Check (args))
{
ALuint *sources;
Py_ssize_t i;
Py_ssize_t len = PySequence_Size (args);
if (len > ((PySources*)self)->count)
{
PyErr_SetString (PyExc_ValueError,
"sequence size exceeds the available sources");
return NULL;
}
sources = PyMem_New (ALuint, (ALsizei) len);
if (!sources)
return NULL;
for (i = 0; i < len; i++)
{
if (!UintFromSeqIndex (args, i, &source))
{
PyMem_Free (sources);
return NULL;
}
sources[i] = source;
}
CLEAR_ALERROR_STATE ();
switch (action)
{
case PLAY:
alSourcePlayv ((ALsizei) len, sources);
break;
case PAUSE:
alSourcePausev ((ALsizei) len, sources);
break;
case STOP:
alSourceStopv ((ALsizei) len, sources);
break;
case REWIND:
alSourceRewindv ((ALsizei) len, sources);
break;
default:
break;
}
PyMem_Free (sources);
if (SetALErrorException (alGetError (), 0))
return NULL;
Py_RETURN_NONE;
}
else if (UintFromObj (args, &source))
{
CLEAR_ALERROR_STATE ();
switch (action)
{
case PLAY:
alSourcePlay ((ALuint)source);
break;
case PAUSE:
alSourcePause ((ALuint)source);
break;
case STOP:
alSourceStop ((ALuint)source);
break;
case REWIND:
alSourceRewind ((ALuint)source);
break;
}
if (SetALErrorException (alGetError (), 0))
return NULL;
Py_RETURN_NONE;
}
PyErr_SetString (PyExc_TypeError,
"argument must be a sequence or positive integer");
return NULL;
}
// ----------------------------------------------------------------------------
void ofSoundPlayerExtended::stop(){
alSourceStopv(channels,&sources[sources.size()-channels]);
}
void Audio::StopAll() noexcept {
alSourceStopv(NUM_SRC, source);
for (std::size_t i = 0; i < NUM_SRC; ++i) {
alSourcei(source[i], AL_BUFFER, AL_NONE);
}
}
