static PyObject *simple_disconnect(simple *self) { if (self->s) pa_simple_free(self->s); self->s = NULL; return Py_BuildValue("i", 0); }
static void pulse_thread(void *context) { #ifdef __linux__ prctl(PR_SET_NAME, "deadbeef-pulse", 0, 0, 0, 0); #endif trace ("pulse thread started \n"); while (!pulse_terminate) { if (state != OUTPUT_STATE_PLAYING || !deadbeef->streamer_ok_to_read (-1)) { usleep(10000); continue; } int sample_size = plugin.fmt.channels * (plugin.fmt.bps / 8); char buf[buffer_size]; in_callback = 1; int bytesread = deadbeef->streamer_read(buf, buffer_size); in_callback = 0; if (pulse_terminate) { break; } if (bytesread < 0) { bytesread = 0; } int error; int res = 0; if (bytesread > 0) { deadbeef->mutex_lock (mutex); res = pa_simple_write(s, buf, bytesread, &error); deadbeef->mutex_unlock(mutex); } if (pulse_terminate) { break; } if (res < 0) { usleep(10000); } } deadbeef->mutex_lock (mutex); state = OUTPUT_STATE_STOPPED; if (s) { pa_simple_drain (s, NULL); pa_simple_free(s); s = NULL; } pulse_terminate = 0; pulse_tid = 0; deadbeef->mutex_unlock (mutex); trace ("pulse_thread finished\n"); }
int main(int argc, char*argv[]) { /* The sample type to use */ static const pa_sample_spec ss = { .format = PA_SAMPLE_S16LE, .rate = 44100, .channels = 2 }; pa_simple *s = NULL; int ret = 1; int error; /* Create the recording stream */ if (!(s = pa_simple_new(NULL, argv[0], PA_STREAM_RECORD, NULL, "record", &ss, NULL, NULL, &error))) { fprintf(stderr, __FILE__": pa_simple_new() failed: %s\n", pa_strerror(error)); goto finish; } for (;;) { uint8_t buf[BUFSIZE]; /* Record some data ... */ if (pa_simple_read(s, buf, sizeof(buf), &error) < 0) { fprintf(stderr, __FILE__": pa_simple_read() failed: %s\n", pa_strerror(error)); goto finish; } /* And write it to STDOUT */ if (loop_write(STDOUT_FILENO, buf, sizeof(buf)) != sizeof(buf)) { fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno)); goto finish; } } ret = 0; finish: if (s) pa_simple_free(s); return ret; }
static void pulseaudio_deallocate_recorder(ALLEGRO_AUDIO_RECORDER *r) { PULSEAUDIO_RECORDER *pa = (PULSEAUDIO_RECORDER *) r->extra; pa_simple_free(pa->s); al_free(r->extra); }
static void* pulse_thread(void* context) { sem_t* init = (sem_t*)context; pa_sample_spec ss; ss.format = PA_SAMPLE_S16LE; ss.channels = 2; ss.rate = g_sample_rate; int err; g_pulse = pa_simple_new(NULL, g_appname, PA_STREAM_PLAYBACK, NULL, g_appname, &ss, NULL, NULL, &err); if (!g_pulse) { snprintf(g_lasterror, c_nlasterror, "failed to connect to pulse server: %d", err); } sem_post(init); if (!g_pulse) return 0; pa_simple* s = g_pulse; short samples[c_nsamples*2]; g_running = true; while (g_running) { g_callback(samples, c_nsamples); if (0 > pa_simple_write(s, samples, sizeof(samples), NULL)) break; } pa_simple_flush(s, NULL); pa_simple_free(s); g_pulse = 0; return 0; }
void PulseThread::Close() { if(this->connection) { pa_simple_free(this->connection); this->connection = nullptr; } }
static void myshutdown() { xmp_smix_off(); if (s) pa_simple_free(s); }
void sound_close() { switch(sound_type) { case SOUND_NO: break; case SOUND_SDL: SDL_CloseAudio(); break; #ifdef D_SOUND_OSS case SOUND_OSS: close(audio_fd); break; #endif #ifdef D_SOUND_ALSA case SOUND_ALSA: snd_pcm_drain (_soundDevice); snd_pcm_close (_soundDevice); break; #endif #ifdef D_SOUND_PULSE case SOUND_PULSEAUDIO: pa_simple_free(pulse_s); break; #endif #ifdef GEKKO case SOUND_ASND: ASND_End(); break; #endif default: break; } }
RTC::ReturnCode_t PulseAudioOutput::onFinalize() { RTC_DEBUG(("onFinalize start")); is_active = false; m_mutex.lock(); RTC_DEBUG(("onFinalize:mutex lock")); try { if ( !m_data.empty() ) { RTC_DEBUG(("onFinalize:queue buffer clear start.")); m_data.clear(); //!< queue buffer clear RTC_DEBUG(("onFinalize:queue buffer clear finish.")); } if ( m_simple ) { RTC_DEBUG(("onFinalize:simple connection object free start.")); pa_simple_free( m_simple ); RTC_DEBUG(("onFinalize:simple connection object free finish.")); m_simple = NULL; } } catch (...) { RTC_WARN(("pa_simple_free() failed onDFinalize.")); } m_mutex.unlock(); RTC_DEBUG(("onFinalize:mutex unlock")); RTC_DEBUG(("onFinalize finish")); return RTC::RTC_OK; }
PulseAudioPCMOutputDriver::~PulseAudioPCMOutputDriver() { if(m_driver) { pa_simple_free(m_driver); } }
bool WaveOutPulseAudio::CloseWaveOutDevice() { bool tResult = false; int tRes; LOG(LOG_VERBOSE, "Going to close.."); if (mWaveOutOpened) { StopFilePlayback(); Stop(); if (mOutputStream != NULL) { LOG(LOG_VERBOSE, "..draining stream"); if (pa_simple_drain(mOutputStream, &tRes) < 0) { LOG(LOG_ERROR, "Couldn't drain the output stream because %s(%d)", pa_strerror(tRes), tRes); } LOG(LOG_VERBOSE, "..closing stream"); pa_simple_free(mOutputStream); } LOG(LOG_INFO, "...closed"); mWaveOutOpened = false; tResult = true; }else LOG(LOG_INFO, "...wasn't open"); ResetPacketStatistic(); return tResult; }
void pulseaudio_close_audio(void) { if (!pulseaudio_audiodev_is_open) return; if (pa_simple_drain(s, &error) < 0) { fprintf(stderr, __FILE__": pa_simple_drain() failed: %s\n", pa_strerror(error)); } pa_simple_free(s); pulseaudio_audiodev_is_open = FALSE; }
void _closeRecord() { if(!sr) return; pa_simple_free(sr); sr = NULL; }
void _closePlay() { if(!sp) return; pa_simple_free(sp); sp = NULL; }
bool WaveOutPulseAudio::OpenWaveOutDevice(int pSampleRate, int pOutputChannels) { pa_sample_spec tOutputFormat; int tRes; pa_usec_t tLatency; LOG(LOG_VERBOSE, "Trying to open the wave out device"); if (mWaveOutOpened) return false; mSampleRate = pSampleRate; mAudioChannels = pOutputChannels; LOG(LOG_VERBOSE, "Desired device is %s", mDesiredDevice.c_str()); if ((mDesiredDevice == "") || (mDesiredDevice == "auto") || (mDesiredDevice == "automatic")) { LOG(LOG_VERBOSE, "Using default audio device"); mDesiredDevice = ""; } tOutputFormat.format = PA_SAMPLE_S16LE; tOutputFormat.rate = mSampleRate; tOutputFormat.channels = mAudioChannels; // create a new playback stream if (!(mOutputStream = pa_simple_new(NULL, "Homer-Conferencing", PA_STREAM_PLAYBACK, (mDesiredDevice != "" ? mDesiredDevice.c_str() : NULL) /* dev Name */, GetStreamName().c_str(), &tOutputFormat, NULL, NULL, &tRes))) { LOG(LOG_ERROR, "Couldn't create PulseAudio stream because %s(%d)", pa_strerror(tRes), tRes); return false; } if ((tLatency = pa_simple_get_latency(mOutputStream, &tRes)) == (pa_usec_t) -1) { LOG(LOG_ERROR, "Couldn't determine the latency of the output stream because %s(%d)", pa_strerror(tRes), tRes); pa_simple_free(mOutputStream); mOutputStream = NULL; return false; } mCurrentDevice = mDesiredDevice; //###################################################### //### give some verbose output //###################################################### LOG(LOG_INFO, "PortAudio wave out opened..."); LOG(LOG_INFO," ..sample rate: %d", mSampleRate); LOG(LOG_INFO," ..channels: %d", pOutputChannels); LOG(LOG_INFO," ..desired device: %s", mDesiredDevice.c_str()); LOG(LOG_INFO," ..selected device: %s", mCurrentDevice.c_str()); LOG(LOG_INFO," ..latency: %"PRIu64" seconds", (uint64_t)tLatency * 1000 * 1000); LOG(LOG_INFO," ..sample format: %d", PA_SAMPLE_S16LE); mWaveOutOpened = true; return true; }
void mpgplayer::run() { if(mpg123_init() != MPG123_OK) qDebug("Error initilizing mpg123"); const char **test = mpg123_supported_decoders(); int error; mpg123_handle *mh = mpg123_new(test[0],&error); if(!mpg123_feature(MPG123_FEATURE_DECODE_LAYER3)) { qDebug("You do not seem to have mp3 decoding support"); return; } mpg123_format_none(mh); if(mpg123_format(mh,samplerate,MPG123_STEREO,MPG123_ENC_SIGNED_16)!=MPG123_OK) qDebug("Error in initilizing format decoder"); qDebug(test[0]); mpg123_open(mh,"/home/eli/Projects/groove-evan/Animal.mp3"); net = TData; pa_simple *s; pa_sample_spec ss; ss.format = PA_SAMPLE_S16NE; ss.rate = samplerate; ss.channels = 2; s =pa_simple_new(NULL,"Groove",PA_STREAM_PLAYBACK ,NULL,"Music",&ss,NULL,NULL,NULL); unsigned char bytes[1024]; size_t bsize = 1024; size_t done = 0; bool stop = false; playing=true; while(!stop) { switch(net) { case TWait: usleep(100); break; case TData: if(mpg123_read(mh,bytes,bsize,&done)==MPG123_DONE) { net=TFinish; } pa_simple_write(s,bytes,done,&error); break; case TAbort: stop = true; break; case TFinish: pa_simple_drain(s,&error); stop = true; break; default: break; } } qDebug("Finsihed playback"); pa_simple_free(s); mpg123_exit(); }
vis::PulseAudioSource::~PulseAudioSource() { #ifdef _ENABLE_PULSE if (m_pulseaudio_simple != nullptr) { pa_simple_free(m_pulseaudio_simple); } #endif }
boolean adin_close() { if(r) { pa_simple_free(r); r = NULL; } return TRUE; }
void OutputPulseAudio::uninitialize() { if (m_connection) { qDebug("OutputPulseAudio: closing connection"); pa_simple_free(m_connection); m_connection = 0; } }
static void pulsedrv_close(void) { int error = 0; if (pa_simple_flush(s, &error)) { log_error(LOG_DEFAULT, "pa_simple_flush(): %s", pa_strerror(error)); /* don't stop */ } pa_simple_free(s); s = NULL; }
uint8_t pulseSimpleAudioDevice::stop(void) { int er; ADM_assert(instance); pa_simple_flush(INSTANCE,&er); pa_simple_free(INSTANCE); instance=NULL; printf("[PulseAudio] Stopped\n"); return 1; }
void ManglerPulse::close(bool drain) {/*{{{*/ if (pulse_stream) { if (drain && pa_simple_drain(pulse_stream, &pulse_error) < 0) { fprintf(stderr, "pulse: pa_simple_drain() failed: %s\n", pa_strerror(pulse_error)); } pa_simple_free(pulse_stream); pulse_stream = NULL; } }/*}}}*/
int main(int argc, char*argv[]) { /* The sample type to use */ static const pa_sample_spec ss = { .format = PA_SAMPLE_S16LE, .rate = 44100, .channels = 2 }; pa_simple *inStream = NULL; pa_simple *outStream = NULL; int ret = 1; int error; /* Create the recording stream */ if (!(inStream = pa_simple_new(NULL, argv[0], PA_STREAM_RECORD, NULL, "record", &ss, NULL, NULL, &error))) { fprintf(stderr, __FILE__": pa_simple_new() failed: %s\n", pa_strerror(error)); goto finish; } /* Create the playback stream */ if (!(outStream = pa_simple_new(NULL, argv[0], PA_STREAM_PLAYBACK, NULL, "playback", &ss, NULL, NULL, &error))) { fprintf(stderr, __FILE__": pa_simple_new() failed: %s\n", pa_strerror(error)); goto finish; } for (;;) { uint8_t buf[BUFSIZE]; /* Record some data ... */ if (pa_simple_read(inStream, buf, sizeof(buf), &error) < 0) { fprintf(stderr, __FILE__": pa_simple_read() failed: %s\n", pa_strerror(error)); goto finish; } if (pa_simple_write(outStream, buf, sizeof(buf), &error) < 0) { fprintf(stderr, __FILE__": pa_simple_write() failed: %s\n", pa_strerror(error)); goto finish; } } ret = 0; finish: if (inStream) pa_simple_free(inStream); if (outStream) pa_simple_free(outStream); return ret; }
static int qpa_init_in (HWVoiceIn *hw, struct audsettings *as) { int error; static pa_sample_spec ss; struct audsettings obt_as = *as; PAVoiceIn *pa = (PAVoiceIn *) hw; ss.format = audfmt_to_pa (as->fmt, as->endianness); ss.channels = as->nchannels; ss.rate = as->freq; obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness); pa->s = pa_simple_new ( conf.server, "qemu", PA_STREAM_RECORD, conf.source, "pcm.capture", &ss, NULL, /* channel map */ NULL, /* buffering attributes */ &error ); if (!pa->s) { qpa_logerr (error, "pa_simple_new for capture failed\n"); goto fail1; } audio_pcm_init_info (&hw->info, &obt_as); hw->samples = conf.samples; pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); if (!pa->pcm_buf) { dolog ("Could not allocate buffer (%d bytes)\n", hw->samples << hw->info.shift); goto fail2; } if (audio_pt_init (&pa->pt, qpa_thread_in, hw, AUDIO_CAP, AUDIO_FUNC)) { goto fail3; } return 0; fail3: free (pa->pcm_buf); pa->pcm_buf = NULL; fail2: pa_simple_free (pa->s); pa->s = NULL; fail1: return -1; }
UINT8 Pulse_Start(void* drvObj, UINT32 deviceID, AUDIO_OPTS* options, void* audDrvParam) { DRV_PULSE* drv = (DRV_PULSE*)drvObj; UINT64 tempInt64; UINT8 retVal8; if (drv->devState != 0) return 0xD0; // already running drv->audDrvPtr = audDrvParam; if (options == NULL) options = &defOptions; drv->pulseFmt.channels = options->numChannels; drv->pulseFmt.rate = options->sampleRate; tempInt64 = (UINT64)options->sampleRate * options->usecPerBuf; drv->bufSmpls = (UINT32)((tempInt64 + 500000) / 1000000); drv->bufSize = (options->numBitsPerSmpl * drv->pulseFmt.channels / 8) * drv->bufSmpls; drv->bufCount = options->numBuffers ? options->numBuffers : 10; if (options->numBitsPerSmpl == 8) drv->pulseFmt.format = PA_SAMPLE_U8; else if (options->numBitsPerSmpl == 16) drv->pulseFmt.format = PA_SAMPLE_S16NE; else if (options->numBitsPerSmpl == 24) drv->pulseFmt.format = PA_SAMPLE_S24NE; else if (options->numBitsPerSmpl == 32) drv->pulseFmt.format = PA_SAMPLE_S32NE; else return 0xCF; drv->canPause = 1; drv->hPulse = pa_simple_new(NULL, "libvgm", PA_STREAM_PLAYBACK, NULL, drv->streamDesc, &drv->pulseFmt, NULL, NULL, NULL); if(!drv->hPulse) return 0xC0; OSSignal_Reset(drv->hSignal); retVal8 = OSThread_Init(&drv->hThread, &PulseThread, drv); if (retVal8) { pa_simple_free(drv->hPulse); return 0xC8; // CreateThread failed } drv->bufSpace = (UINT8*)malloc(drv->bufSize); drv->devState = 1; drv->pauseThread = 0x00; OSSignal_Signal(drv->hSignal); return AERR_OK; }
// Close an opened audio device, free any allocated buffers and // reset any variables that reflect the current state. void Audio_Pulse::close () { if (_audioHandle != NULL) { pa_simple_free(_audioHandle); _audioHandle = NULL; } if (_sampleBuffer != NULL) { delete [] _sampleBuffer; outOfOrder (); } }
static void pulse_close (sw_handle * handle) { struct pa_simple * pa ; pulse_drain(handle); if ((pa = (struct pa_simple *)handle->custom_data) == NULL) return; pa_simple_free(pa); handle->custom_data = NULL; }
void m1sdr_PlayStop(void) { #if 0 pa_operation *op; #endif #ifdef USE_SDL if (lnxdrv_apimode == 0) { SDL_PauseAudio(1); } #endif if (lnxdrv_apimode == 1) { // snd_pcm_pause(pHandle, 1); snd_pcm_drop(pHandle); } #if PULSE_USE_SIMPLE if ((lnxdrv_apimode == 3) && (my_simple)) { pa_simple_flush(my_simple, NULL); pa_simple_free(my_simple); my_simple = NULL; } #else #if 0 if (lnxdrv_apimode == 3) { op = pa_stream_drain(my_pa_stream, &pa_stream_drain_complete, NULL); if (op) { while (pa_operation_get_state(op) != PA_OPERATION_DONE) { if (pa_context_get_state(my_pa_context) != PA_CONTEXT_READY || pa_stream_get_state(my_pa_stream) != PA_STREAM_READY || pa_mainloop_iterate(my_pa_mainloop, 0, NULL) < 0) { pa_operation_cancel(op); break; } } } } #endif #endif waveLogStop(); oss_playing = 0; }
int audio_init(context_t *context) { int rc = 0; static const pa_sample_spec ss = { .format = PA_SAMPLE_S16LE, .rate = 44100, .channels = 1 }; int error; daemon_log(LOG_INFO, "Opening %s for input", context->input_device ?: "default source"); context->pa_input = pa_simple_new(NULL, "shusherd", PA_STREAM_RECORD, context->input_device, "record", &ss, NULL, NULL, &error); if (!context->pa_input) { daemon_log(LOG_ERR, "pa_simple_new failed: %s", pa_strerror(error)); assert(context->pa_input); } context->ebur128_state = ebur128_init(ss.channels, ss.rate, EBUR128_MODE_S); assert(context->ebur128_state); context->enable_processing = 1; rc = pthread_create(&context->audio_thread, NULL, audio_loop, (void *)context); if (rc) { daemon_log(LOG_ERR, "Unable to create audio thread: %d", rc); goto cleanup_ebur128_state; } return 0; cleanup_ebur128_state: ebur128_destroy(&context->ebur128_state); return rc; } void audio_destroy(context_t *context) { context->enable_processing = 0; pthread_join(context->audio_thread, NULL); ebur128_destroy(&context->ebur128_state); pa_simple_free(context->pa_input); }
int main(int argc, char *argv[]) { FILE *fp; int n; int16_t buf[BB], out[BB]; int error; static const pa_sample_spec ss = { .format = PA_SAMPLE_S16LE, .rate = 44100, .channels = 1}; pa_simple *s = NULL; if (!(s = pa_simple_new(NULL, argv[0], PA_STREAM_PLAYBACK, NULL, "playback", &ss, NULL, NULL, &error))) { fprintf(stderr, __FILE__ ": pa_simple_new() failed: %s\n", pa_strerror(error)); goto finish; } fp = fopen("out.wav", "rb"); if (!fp) exit(-1); fread(buf, 1, 44, fp); n = fread(buf, 2, BB, fp); while (!feof(fp)) { highpass(buf, out, BB, 1.0f, 10); memcpy(buf, out, BB * 2); lowpass(buf, out, BB, 1.0f / 44100.0f, 0.00002); if (pa_simple_write(s, out, (size_t)n * 2, &error) < 0) { fprintf(stderr, __FILE__ ": pa_simple_write() failed: %s\n", pa_strerror(error)); goto finish; } n = fread(buf, 2, BB, fp); } if (pa_simple_drain(s, &error) < 0) { fprintf(stderr, __FILE__ ": pa_simple_drain() failed: %s\n", pa_strerror(error)); goto finish; } finish: if (s) pa_simple_free(s); return 0; }