static void audio_request_cb(pa_stream *s, size_t length, void *userdata) { int i; uint32_t buf[length/4]; if(pa_stream_is_corked(s)) return; for(i=0;i<length/4;i++) { if((offset+i-1)/ticksize != (offset+i)/ticksize) { int ntickno=(offset+i)/ticksize; if(ntickno!=tickno) { g_mutex_lock(tickmutex); tickno=ntickno; printf("signal %u %u (%u)\n",beatno(),tickinbeat(),offset+i); g_cond_signal(tickcond); g_mutex_unlock(tickmutex); } } int k; int32_t v=0; for(k=0;k<stack.len;k++) { v=stack.action[k].f(v,stack.action+k,offset+i); } buf[i]=v; } offset+=i; pa_stream_write(s,buf,length,0,0,PA_SEEK_RELATIVE); }
static PyObject* PulseAudio_resume(output_PulseAudio *self, PyObject *args) { /*ensure output stream is still running*/ /*FIXME*/ /*uncork output stream, if corked*/ pa_threaded_mainloop_lock(self->mainloop); if (pa_stream_is_corked(self->stream)) { pa_operation *op = pa_stream_cork( self->stream, 0, (pa_stream_success_cb_t)success_callback, self->mainloop); while (pa_operation_get_state(op) == PA_OPERATION_RUNNING) { pa_threaded_mainloop_wait(self->mainloop); } pa_operation_unref(op); } pa_threaded_mainloop_unlock(self->mainloop); Py_INCREF(Py_None); return Py_None; }
static void stream_latency_cb(pa_stream *s, void *userdata) { audio_output_t *aout = userdata; aout_sys_t *sys = aout->sys; /* This callback is _never_ called while paused. */ if (sys->first_pts == VLC_TS_INVALID) return; /* nothing to do if buffers are (still) empty */ if (pa_stream_is_corked(s) > 0) stream_start(s, aout); }
/** * Determines whether the stream is paused. On libpulse older than * 0.9.11, it uses a custom pause flag. */ static bool pulse_output_stream_is_paused(struct pulse_output *po) { assert(po->stream != NULL); #if !defined(PA_CHECK_VERSION) || !PA_CHECK_VERSION(0,9,11) return po->pause; #else return pa_stream_is_corked(po->stream); #endif }
int pa_simple_is_corked(pa_simple *p) { int is_cork; pa_assert(p); pa_threaded_mainloop_lock(p->mainloop); is_cork = pa_stream_is_corked(p->stream); pa_threaded_mainloop_unlock(p->mainloop); return is_cork; }
static int instream_pause_pa(SoundIoPrivate *si, SoundIoInStreamPrivate *is, bool pause) { SoundIoInStreamPulseAudio *ispa = &is->backend_data.pulseaudio; SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio; pa_threaded_mainloop_lock(sipa->main_loop); if (pause != pa_stream_is_corked(ispa->stream)) { pa_operation *op = pa_stream_cork(ispa->stream, pause, NULL, NULL); if (!op) return SoundIoErrorStreaming; pa_operation_unref(op); } pa_threaded_mainloop_unlock(sipa->main_loop); return 0; }
static int outstream_pause_pa(struct SoundIoPrivate *si, struct SoundIoOutStreamPrivate *os, bool pause) { struct SoundIoOutStreamPulseAudio *ospa = &os->backend_data.pulseaudio; struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio; if (!pa_threaded_mainloop_in_thread(sipa->main_loop)) { pa_threaded_mainloop_lock(sipa->main_loop); } if (pause != pa_stream_is_corked(ospa->stream)) { pa_operation *op = pa_stream_cork(ospa->stream, pause, NULL, NULL); if (!op) { pa_threaded_mainloop_unlock(sipa->main_loop); return SoundIoErrorStreaming; } pa_operation_unref(op); } if (!pa_threaded_mainloop_in_thread(sipa->main_loop)) { pa_threaded_mainloop_unlock(sipa->main_loop); } return 0; }
static ALuint PulseProc(ALvoid *param) { ALCdevice *Device = param; pulse_data *data = Device->ExtraData; ALuint buffer_size; ALint update_size; size_t frame_size; ssize_t len; SetRTPriority(); pa_threaded_mainloop_lock(data->loop); frame_size = pa_frame_size(&data->spec); update_size = Device->UpdateSize * frame_size; /* Sanitize buffer metrics, in case we actually have less than what we * asked for. */ buffer_size = minu(update_size*Device->NumUpdates, data->attr.tlength); update_size = minu(update_size, buffer_size/2); do { len = pa_stream_writable_size(data->stream) - data->attr.tlength + buffer_size; if(len < update_size) { if(pa_stream_is_corked(data->stream) == 1) { pa_operation *o; o = pa_stream_cork(data->stream, 0, NULL, NULL); if(o) pa_operation_unref(o); } pa_threaded_mainloop_unlock(data->loop); Sleep(1); pa_threaded_mainloop_lock(data->loop); continue; } len -= len%update_size; while(len > 0) { size_t newlen = len; void *buf; pa_free_cb_t free_func = NULL; #if PA_CHECK_VERSION(0,9,16) if(!pa_stream_begin_write || pa_stream_begin_write(data->stream, &buf, &newlen) < 0) #endif { buf = pa_xmalloc(newlen); free_func = pa_xfree; } pa_threaded_mainloop_unlock(data->loop); aluMixData(Device, buf, newlen/frame_size); pa_threaded_mainloop_lock(data->loop); pa_stream_write(data->stream, buf, newlen, free_func, 0, PA_SEEK_RELATIVE); len -= newlen; } } while(!data->killNow && Device->Connected); pa_threaded_mainloop_unlock(data->loop); return 0; }