e16
/
e16
3
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
e16/src/sound_pulse.c

356 lines
8.6 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) 2008-2021 Kim Woelders
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of the Software, its documentation and marketing & publicity
* materials, and acknowledgment shall be given in the documentation, materials
* and software packages that this Software was used.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "config.h"
#include <fcntl.h>
#include <pulse/pulseaudio.h>
#include <sys/stat.h>
#include "sound.h"
#include "util.h"
#ifdef USE_MODULES
#define Estrdup strdup
#endif
#define DEBUG_PA 0
#if DEBUG_PA
#define D2printf(fmt...) if(EDebug(EDBUG_TYPE_SOUND)>1)Eprintf(fmt)
#define D3printf(fmt...) if(EDebug(EDBUG_TYPE_SOUND)>2)Eprintf(fmt)
#define D4printf(fmt...) if(EDebug(EDBUG_TYPE_SOUND)>3)Eprintf(fmt)
#else
#define D2printf(fmt...)
#define D3printf(fmt...)
#define D4printf(fmt...)
#endif
struct _sample {
SoundSampleData ssd;
char *name;
unsigned int written;
};
static pa_mainloop *pa_mloop = NULL;
static pa_mainloop_api *mainloop_api = NULL;
static pa_context *pa_ctx = NULL;
static int pa_block = 0;
static void _sound_pulse_Exit(void);
static int
dispatch(int block)
{
int err, rc;
D3printf("%s: beg\n", __func__);
rc = 1234;
pa_block = block;
for (;;)
{
err = pa_mainloop_iterate(pa_mloop, pa_block, &rc);
D4printf("%s: run err=%d rc=%d block=%d\n", __func__,
err, rc, pa_block);
if (err < 0 || (err == 0 && !pa_block))
break;
}
if (err < 0)
_sound_pulse_Exit();
D3printf("%s: end\n", __func__);
return err;
}
static void
context_op_callback(pa_context *pac __UNUSED__, int success __UNUSED__,
void *userdata __UNUSED__)
{
D2printf("%s: succ=%d %s\n", __func__, success,
(success) ? "" : pa_strerror(pa_context_errno(pac)));
pa_block = 0;
}
static void
context_drain_complete(pa_context *pac __UNUSED__, void *userdata __UNUSED__)
{
D2printf("%s\n", __func__);
}
static void
context_drain(pa_context *pac)
{
pa_operation *op;
D2printf("%s\n", __func__);
op = pa_context_drain(pac, context_drain_complete, NULL);
if (op)
pa_operation_unref(op);
pa_block = 0;
}
static void
stream_state_callback(pa_stream *pas, void *userdata __UNUSED__)
{
D2printf("%s: state=%d\n", __func__, pa_stream_get_state(pas));
switch (pa_stream_get_state(pas))
{
case PA_STREAM_CREATING: /* 1 */
case PA_STREAM_READY: /* 2 */
break;
case PA_STREAM_TERMINATED: /* 4 */
context_drain(pa_stream_get_context(pas));
break;
case PA_STREAM_FAILED: /* 3 */
default:
Eprintf("PA failure: %s\n",
pa_strerror(pa_context_errno(pa_stream_get_context(pas))));
pa_block = 0;
break;
}
}
static void
stream_write_callback(pa_stream *pas, size_t length, void *userdata)
{
D2printf("%s: state=%d length=%u\n", __func__, pa_stream_get_state(pas),
(unsigned int)length);
Sample *s = (Sample *) userdata;
unsigned int left;
left = s->ssd.size - s->written;
length = (left > length) ? length : left;
pa_stream_write(pas, s->ssd.data, length, NULL, 0, PA_SEEK_RELATIVE);
s->written += length;
D2printf("%s: size=%d written=%d\n", __func__, s->ssd.size, s->written);
if (s->written >= s->ssd.size)
{
pa_stream_set_write_callback(pas, NULL, NULL);
pa_stream_finish_upload(pas);
}
}
static void
context_state_callback(pa_context *pac, void *userdata __UNUSED__)
{
D2printf("%s: state=%d\n", __func__, pa_context_get_state(pac));
switch (pa_context_get_state(pac))
{
case PA_CONTEXT_CONNECTING: /* 1 */
case PA_CONTEXT_AUTHORIZING: /* 2 */
case PA_CONTEXT_SETTING_NAME: /* 3 */
break;
case PA_CONTEXT_READY: /* 4 */
pa_block = 0;
break;
case PA_CONTEXT_TERMINATED: /* 6 */
break;
case PA_CONTEXT_FAILED: /* 5 */
default:
Eprintf("PA failure: %s\n", pa_strerror(pa_context_errno(pac)));
pa_mainloop_quit(pa_mloop, 1);
break;
}
}
static void
_sound_pulse_Destroy(Sample *s)
{
pa_operation *op;
D2printf("%s beg: %s\n", __func__, s->name);
if (pa_ctx && s->name)
{
op = pa_context_remove_sample(pa_ctx, s->name,
context_op_callback, NULL);
if (op)
pa_operation_unref(op);
dispatch(-1);
}
D2printf("%s end\n", __func__);
Efree(s->name);
Efree(s->ssd.data);
Efree(s);
}
static Sample *
_sound_pulse_Load(const char *file)
{
Sample *s;
pa_sample_spec sample_spec;
pa_stream *sample_stream = NULL;
int err;
char *p;
if (!pa_ctx)
return NULL;
s = ECALLOC(Sample, 1);
if (!s)
return NULL;
err = SoundSampleGetData(file, &s->ssd);
if (err)
{
Efree(s);
return NULL;
}
s->name = Estrdup(file);
if (!s->name)
goto bail_out;
for (p = s->name; *p != '\0'; p++)
if (*p == '/')
*p = '_';
switch (s->ssd.bit_per_sample)
{
case 8:
sample_spec.format = PA_SAMPLE_U8;
break;
default:
sample_spec.format = PA_SAMPLE_S16NE;
break;
}
sample_spec.rate = s->ssd.rate;
sample_spec.channels = s->ssd.channels;
sample_stream = pa_stream_new(pa_ctx, s->name, &sample_spec, NULL);
if (!sample_stream)
goto bail_out;
pa_stream_set_state_callback(sample_stream, stream_state_callback, NULL);
pa_stream_set_write_callback(sample_stream, stream_write_callback, s);
pa_stream_connect_upload(sample_stream, s->ssd.size);
err = dispatch(-1);
if (err)
goto bail_out;
EFREE_NULL(s->ssd.data);
pa_stream_unref(sample_stream);
return s;
bail_out:
if (sample_stream)
pa_stream_unref(sample_stream);
_sound_pulse_Destroy(s);
return NULL;
}
static void
_sound_pulse_Play(Sample *s)
{
pa_operation *op;
D2printf("%s beg: %s\n", __func__, s->name);
if (!pa_ctx)
return;
op = pa_context_play_sample(pa_ctx, s->name, NULL, PA_VOLUME_NORM,
context_op_callback, NULL);
if (op)
pa_operation_unref(op);
dispatch(-1);
D2printf("%s end\n", __func__);
}
static void
_sound_pulse_Exit(void)
{
D2printf("%s\n", __func__);
#if 0
if (stream)
pa_stream_unref(stream);
#endif
if (pa_ctx)
{
pa_context_disconnect(pa_ctx);
pa_context_unref(pa_ctx);
pa_ctx = NULL;
}
if (pa_mloop)
{
pa_mainloop_quit(pa_mloop, 0);
pa_mainloop_free(pa_mloop);
pa_mloop = NULL;
}
}
static int
_sound_pulse_Init(void)
{
int err;
/* Set up a new main loop */
pa_mloop = pa_mainloop_new();
if (!pa_mloop)
{
Eprintf("pa_mainloop_new() failed.\n");
goto quit;
}
mainloop_api = pa_mainloop_get_api(pa_mloop);
/* Create a new connection context */
pa_ctx = pa_context_new(mainloop_api, "e16");
if (!pa_ctx)
{
Eprintf("pa_context_new() failed.\n");
goto quit;
}
pa_context_set_state_callback(pa_ctx, context_state_callback, NULL);
/* Connect the context */
err = pa_context_connect(pa_ctx, NULL, PA_CONTEXT_NOFLAGS, NULL);
if (err)
Eprintf("pa_context_connect(): %s\n", pa_strerror(err));
err = dispatch(-1);
if (err)
goto quit;
done:
return !pa_ctx;
quit:
_sound_pulse_Exit();
goto done;
}
__EXPORT__ extern const SoundOps SoundOps_pulse;
const SoundOps SoundOps_pulse = {
_sound_pulse_Init, _sound_pulse_Exit,
_sound_pulse_Load, _sound_pulse_Destroy, _sound_pulse_Play,
};
Reference in New Issue View Git Blame Copy Permalink