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