mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-11-01 22:58:50 -04:00
alsa: aad alsa source and monitor
This commit is contained in:
Wim Taymans
parent
2bf322ee71
commit
bd7009756c
12 changed files with 707 additions and 567 deletions
|
|
@ -24,25 +24,17 @@
|
|||
#include <spa/node.h>
|
||||
#include <spa/audio/format.h>
|
||||
|
||||
typedef struct _SpaALSASink SpaALSASink;
|
||||
#include "alsa-utils.h"
|
||||
|
||||
typedef struct _SpaALSAState SpaALSASink;
|
||||
|
||||
static const char default_device[] = "default";
|
||||
static const uint32_t default_buffer_time = 10000;
|
||||
static const uint32_t default_period_time = 5000;
|
||||
static const bool default_period_event = 0;
|
||||
|
||||
typedef struct {
|
||||
SpaProps props;
|
||||
char device[64];
|
||||
char device_name[128];
|
||||
char card_name[128];
|
||||
uint32_t buffer_time;
|
||||
uint32_t period_time;
|
||||
bool period_event;
|
||||
} SpaALSASinkProps;
|
||||
|
||||
static void
|
||||
reset_alsa_sink_props (SpaALSASinkProps *props)
|
||||
reset_alsa_sink_props (SpaALSAProps *props)
|
||||
{
|
||||
strncpy (props->device, default_device, 64);
|
||||
props->buffer_time = default_buffer_time;
|
||||
|
|
@ -50,58 +42,6 @@ reset_alsa_sink_props (SpaALSASinkProps *props)
|
|||
props->period_event = default_period_event;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
bool opened;
|
||||
bool have_buffers;
|
||||
snd_pcm_t *handle;
|
||||
snd_output_t *output;
|
||||
snd_pcm_sframes_t buffer_size;
|
||||
snd_pcm_sframes_t period_size;
|
||||
snd_pcm_channel_area_t areas[16];
|
||||
bool running;
|
||||
SpaPollFd fds[16];
|
||||
SpaPollItem poll;
|
||||
} SpaALSAState;
|
||||
|
||||
typedef struct _ALSABuffer ALSABuffer;
|
||||
|
||||
struct _ALSABuffer {
|
||||
SpaBuffer buffer;
|
||||
SpaMeta metas[2];
|
||||
SpaMetaHeader header;
|
||||
SpaMetaRingbuffer ringbuffer;
|
||||
SpaData datas[1];
|
||||
};
|
||||
|
||||
struct _SpaALSASink {
|
||||
SpaHandle handle;
|
||||
SpaNode node;
|
||||
|
||||
SpaALSASinkProps props[2];
|
||||
|
||||
SpaNodeEventCallback event_cb;
|
||||
void *user_data;
|
||||
|
||||
bool have_format;
|
||||
SpaFormatAudio query_format;
|
||||
SpaFormatAudio current_format;
|
||||
|
||||
SpaALSAState state;
|
||||
|
||||
SpaPortInfo info;
|
||||
SpaAllocParam *params[1];
|
||||
SpaAllocParamBuffers param_buffers;
|
||||
SpaPortStatus status;
|
||||
|
||||
SpaBuffer *buffers;
|
||||
unsigned int n_buffers;
|
||||
uint32_t input_buffer;
|
||||
|
||||
SpaMemory *alloc_bufmem;
|
||||
SpaMemory *alloc_mem;
|
||||
ALSABuffer *alloc_buffers;
|
||||
};
|
||||
|
||||
static void
|
||||
update_state (SpaALSASink *this, SpaNodeState state)
|
||||
{
|
||||
|
|
@ -120,8 +60,6 @@ update_state (SpaALSASink *this, SpaNodeState state)
|
|||
this->event_cb (&this->node, &event, this->user_data);
|
||||
}
|
||||
|
||||
#include "alsa-utils.c"
|
||||
|
||||
static const uint32_t min_uint32 = 1;
|
||||
static const uint32_t max_uint32 = UINT32_MAX;
|
||||
|
||||
|
|
@ -142,37 +80,37 @@ enum {
|
|||
|
||||
static const SpaPropInfo prop_info[] =
|
||||
{
|
||||
{ PROP_ID_DEVICE, offsetof (SpaALSASinkProps, device),
|
||||
{ PROP_ID_DEVICE, offsetof (SpaALSAProps, device),
|
||||
"device", "ALSA device, as defined in an asound configuration file",
|
||||
SPA_PROP_FLAG_READWRITE,
|
||||
SPA_PROP_TYPE_STRING, 63,
|
||||
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
|
||||
NULL },
|
||||
{ PROP_ID_DEVICE_NAME, offsetof (SpaALSASinkProps, device_name),
|
||||
{ PROP_ID_DEVICE_NAME, offsetof (SpaALSAProps, device_name),
|
||||
"device-name", "Human-readable name of the sound device",
|
||||
SPA_PROP_FLAG_READABLE,
|
||||
SPA_PROP_TYPE_STRING, 127,
|
||||
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
|
||||
NULL },
|
||||
{ PROP_ID_CARD_NAME, offsetof (SpaALSASinkProps, card_name),
|
||||
{ PROP_ID_CARD_NAME, offsetof (SpaALSAProps, card_name),
|
||||
"card-name", "Human-readable name of the sound card",
|
||||
SPA_PROP_FLAG_READABLE,
|
||||
SPA_PROP_TYPE_STRING, 127,
|
||||
SPA_PROP_RANGE_TYPE_NONE, 0, NULL,
|
||||
NULL },
|
||||
{ PROP_ID_BUFFER_TIME, offsetof (SpaALSASinkProps, buffer_time),
|
||||
{ PROP_ID_BUFFER_TIME, offsetof (SpaALSAProps, buffer_time),
|
||||
"buffer-time", "The total size of the buffer in time",
|
||||
SPA_PROP_FLAG_READWRITE,
|
||||
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
|
||||
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, uint32_range,
|
||||
NULL },
|
||||
{ PROP_ID_PERIOD_TIME, offsetof (SpaALSASinkProps, period_time),
|
||||
{ PROP_ID_PERIOD_TIME, offsetof (SpaALSAProps, period_time),
|
||||
"period-time", "The size of a period in time",
|
||||
SPA_PROP_FLAG_READWRITE,
|
||||
SPA_PROP_TYPE_UINT32, sizeof (uint32_t),
|
||||
SPA_PROP_RANGE_TYPE_MIN_MAX, 2, uint32_range,
|
||||
NULL },
|
||||
{ PROP_ID_PERIOD_EVENT, offsetof (SpaALSASinkProps, period_event),
|
||||
{ PROP_ID_PERIOD_EVENT, offsetof (SpaALSAProps, period_event),
|
||||
"period-event", "Generate an event each period",
|
||||
SPA_PROP_FLAG_READWRITE,
|
||||
SPA_PROP_TYPE_BOOL, sizeof (bool),
|
||||
|
|
@ -202,7 +140,7 @@ spa_alsa_sink_node_set_props (SpaNode *node,
|
|||
const SpaProps *props)
|
||||
{
|
||||
SpaALSASink *this;
|
||||
SpaALSASinkProps *p;
|
||||
SpaALSAProps *p;
|
||||
SpaResult res;
|
||||
|
||||
if (node == NULL || node->handle == NULL)
|
||||
|
|
@ -394,7 +332,7 @@ spa_alsa_sink_node_port_set_format (SpaNode *node,
|
|||
if ((res = spa_format_audio_parse (format, &this->current_format)) < 0)
|
||||
return res;
|
||||
|
||||
if (alsa_set_format (this, &this->current_format, false) < 0)
|
||||
if (spa_alsa_set_format (this, &this->current_format, false) < 0)
|
||||
return SPA_RESULT_ERROR;
|
||||
|
||||
this->info.flags = SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS;
|
||||
|
|
@ -495,9 +433,10 @@ spa_alsa_sink_node_port_alloc_buffers (SpaNode *node,
|
|||
uint32_t *n_buffers)
|
||||
{
|
||||
SpaALSASink *this;
|
||||
ALSABuffer *b;
|
||||
SpaALSAState *state;
|
||||
SpaALSABuffer *b;
|
||||
unsigned int i, n_bufs;
|
||||
size_t buffer_size;
|
||||
uint8_t *bufmem;
|
||||
|
||||
if (node == NULL || node->handle == NULL || buffers == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
|
@ -510,28 +449,30 @@ spa_alsa_sink_node_port_alloc_buffers (SpaNode *node,
|
|||
if (!this->have_format)
|
||||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
state = &this->state;
|
||||
|
||||
n_bufs = *n_buffers;
|
||||
|
||||
buffer_size = this->buffer_frames * this->frame_size;
|
||||
|
||||
if (!this->alloc_bufmem)
|
||||
this->alloc_bufmem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, NULL, state->buffer_size * n_bufs);
|
||||
this->alloc_bufmem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, NULL, buffer_size * n_bufs);
|
||||
bufmem = spa_memory_ensure_ptr (this->alloc_bufmem);
|
||||
|
||||
if (!this->alloc_mem)
|
||||
this->alloc_mem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, NULL, sizeof (ALSABuffer) * n_bufs);
|
||||
this->alloc_mem = spa_memory_alloc_with_fd (SPA_MEMORY_POOL_SHARED, NULL, sizeof (SpaALSABuffer) * n_bufs);
|
||||
this->alloc_buffers = spa_memory_ensure_ptr (this->alloc_mem);
|
||||
this->n_buffers = n_bufs;
|
||||
|
||||
for (i = 0; i < n_bufs; i++) {
|
||||
b = &this->alloc_buffers[i];
|
||||
b->buffer.id = i;
|
||||
b->buffer.mem.mem = this->alloc_mem->mem;
|
||||
b->buffer.mem.offset = sizeof (ALSABuffer) * i;
|
||||
b->buffer.mem.size = sizeof (ALSABuffer);
|
||||
b->buffer.mem.offset = sizeof (SpaALSABuffer) * i;
|
||||
b->buffer.mem.size = sizeof (SpaALSABuffer);
|
||||
|
||||
b->buffer.n_metas = 2;
|
||||
b->buffer.metas = offsetof (ALSABuffer, metas);
|
||||
b->buffer.metas = offsetof (SpaALSABuffer, metas);
|
||||
b->buffer.n_datas = 1;
|
||||
b->buffer.datas = offsetof (ALSABuffer, datas);
|
||||
b->buffer.datas = offsetof (SpaALSABuffer, datas);
|
||||
|
||||
b->header.flags = 0;
|
||||
b->header.seq = 0;
|
||||
|
|
@ -539,7 +480,7 @@ spa_alsa_sink_node_port_alloc_buffers (SpaNode *node,
|
|||
b->header.dts_offset = 0;
|
||||
|
||||
b->metas[0].type = SPA_META_TYPE_HEADER;
|
||||
b->metas[0].offset = offsetof (ALSABuffer, header);
|
||||
b->metas[0].offset = offsetof (SpaALSABuffer, header);
|
||||
b->metas[0].size = sizeof (b->header);
|
||||
|
||||
b->ringbuffer.readindex = 0;
|
||||
|
|
@ -548,13 +489,14 @@ spa_alsa_sink_node_port_alloc_buffers (SpaNode *node,
|
|||
b->ringbuffer.size_mask = 0;
|
||||
|
||||
b->metas[1].type = SPA_META_TYPE_RINGBUFFER;
|
||||
b->metas[1].offset = offsetof (ALSABuffer, ringbuffer);
|
||||
b->metas[1].offset = offsetof (SpaALSABuffer, ringbuffer);
|
||||
b->metas[1].size = sizeof (b->ringbuffer);
|
||||
|
||||
b->datas[0].mem.mem = this->alloc_bufmem->mem;
|
||||
b->datas[0].mem.offset = state->buffer_size * i;
|
||||
b->datas[0].mem.size = state->buffer_size;
|
||||
b->datas[0].mem.offset = buffer_size * i;
|
||||
b->datas[0].mem.size = buffer_size;
|
||||
b->datas[0].stride = 0;
|
||||
b->ptr = bufmem + buffer_size * i;
|
||||
|
||||
buffers[i] = &b->buffer;
|
||||
}
|
||||
|
|
@ -621,12 +563,13 @@ spa_alsa_sink_node_port_push_input (SpaNode *node,
|
|||
continue;
|
||||
}
|
||||
|
||||
if (this->input_buffer != -1) {
|
||||
if (this->ready_head != NULL) {
|
||||
info[i].status = SPA_RESULT_HAVE_ENOUGH_INPUT;
|
||||
have_enough = true;
|
||||
continue;
|
||||
}
|
||||
this->input_buffer = info[i].buffer_id;
|
||||
|
||||
this->ready_head = &this->alloc_buffers[info[i].buffer_id];
|
||||
}
|
||||
info[i].status = SPA_RESULT_OK;
|
||||
}
|
||||
|
|
@ -719,6 +662,7 @@ alsa_sink_init (const SpaHandleFactory *factory,
|
|||
this->node.handle = handle;
|
||||
this->props[1].props.n_prop_info = PROP_ID_LAST;
|
||||
this->props[1].props.prop_info = prop_info;
|
||||
this->stream = SND_PCM_STREAM_PLAYBACK;
|
||||
reset_alsa_sink_props (&this->props[1]);
|
||||
|
||||
this->status.flags = SPA_PORT_STATUS_FLAG_NEED_INPUT;
|
||||
|
|
|
|||
|
|
@ -7,26 +7,27 @@
|
|||
#include <sys/time.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "alsa-utils.h"
|
||||
|
||||
static int verbose = 0; /* verbose flag */
|
||||
|
||||
#define CHECK(s,msg) if ((err = (s)) < 0) { printf (msg ": %s\n", snd_strerror(err)); return err; }
|
||||
|
||||
static int
|
||||
spa_alsa_open (SpaALSASink *this)
|
||||
spa_alsa_open (SpaALSAState *state)
|
||||
{
|
||||
SpaALSAState *state = &this->state;
|
||||
int err;
|
||||
SpaALSASinkProps *props = &this->props[1];
|
||||
SpaALSAProps *props = &state->props[1];
|
||||
|
||||
if (state->opened)
|
||||
return 0;
|
||||
|
||||
CHECK (snd_output_stdio_attach (&state->output, stderr, 0), "attach failed");
|
||||
|
||||
printf ("Playback device open '%s'\n", props->device);
|
||||
CHECK (snd_pcm_open (&state->handle,
|
||||
printf ("ALSA device open '%s'\n", props->device);
|
||||
CHECK (snd_pcm_open (&state->hndl,
|
||||
props->device,
|
||||
SND_PCM_STREAM_PLAYBACK,
|
||||
state->stream,
|
||||
SND_PCM_NONBLOCK |
|
||||
SND_PCM_NO_AUTO_RESAMPLE |
|
||||
SND_PCM_NO_AUTO_CHANNELS |
|
||||
|
|
@ -38,16 +39,15 @@ spa_alsa_open (SpaALSASink *this)
|
|||
}
|
||||
|
||||
static int
|
||||
spa_alsa_close (SpaALSASink *this)
|
||||
spa_alsa_close (SpaALSAState *state)
|
||||
{
|
||||
SpaALSAState *state = &this->state;
|
||||
int err = 0;
|
||||
|
||||
if (!state->opened)
|
||||
return 0;
|
||||
|
||||
printf ("Playback device closing\n");
|
||||
CHECK (snd_pcm_close (state->handle), "close failed");
|
||||
CHECK (snd_pcm_close (state->hndl), "close failed");
|
||||
|
||||
state->opened = false;
|
||||
|
||||
|
|
@ -105,93 +105,94 @@ spa_alsa_format_to_alsa (SpaAudioFormat format)
|
|||
return SND_PCM_FORMAT_UNKNOWN;
|
||||
}
|
||||
|
||||
static int
|
||||
alsa_set_format (SpaALSASink *this, SpaFormatAudio *fmt, bool try_only)
|
||||
int
|
||||
spa_alsa_set_format (SpaALSAState *state, SpaFormatAudio *fmt, bool try_only)
|
||||
{
|
||||
unsigned int rrate;
|
||||
snd_pcm_uframes_t size;
|
||||
int err, dir;
|
||||
snd_pcm_hw_params_t *params;
|
||||
snd_pcm_format_t format;
|
||||
SpaALSAState *state = &this->state;
|
||||
SpaAudioInfoRaw *info = &fmt->info.raw;
|
||||
snd_pcm_t *handle;
|
||||
snd_pcm_t *hndl;
|
||||
unsigned int buffer_time;
|
||||
unsigned int period_time;
|
||||
SpaALSASinkProps *props = &this->props[1];
|
||||
SpaALSAProps *props = &state->props[1];
|
||||
|
||||
if ((err = spa_alsa_open (this)) < 0)
|
||||
if ((err = spa_alsa_open (state)) < 0)
|
||||
return err;
|
||||
|
||||
handle = state->handle;
|
||||
hndl = state->hndl;
|
||||
|
||||
snd_pcm_hw_params_alloca (¶ms);
|
||||
/* choose all parameters */
|
||||
CHECK (snd_pcm_hw_params_any (handle, params), "Broken configuration for playback: no configurations available");
|
||||
CHECK (snd_pcm_hw_params_any (hndl, params), "Broken configuration for playback: no configurations available");
|
||||
/* set hardware resampling */
|
||||
CHECK (snd_pcm_hw_params_set_rate_resample (handle, params, 0), "set_rate_resample");
|
||||
CHECK (snd_pcm_hw_params_set_rate_resample (hndl, params, 0), "set_rate_resample");
|
||||
/* set the interleaved read/write format */
|
||||
CHECK (snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set_access");
|
||||
CHECK (snd_pcm_hw_params_set_access(hndl, params, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set_access");
|
||||
|
||||
/* set the sample format */
|
||||
format = spa_alsa_format_to_alsa (info->format);
|
||||
printf ("Stream parameters are %iHz, %s, %i channels\n", info->rate, snd_pcm_format_name(format), info->channels);
|
||||
CHECK (snd_pcm_hw_params_set_format (handle, params, format), "set_format");
|
||||
CHECK (snd_pcm_hw_params_set_format (hndl, params, format), "set_format");
|
||||
/* set the count of channels */
|
||||
CHECK (snd_pcm_hw_params_set_channels (handle, params, info->channels), "set_channels");
|
||||
CHECK (snd_pcm_hw_params_set_channels (hndl, params, info->channels), "set_channels");
|
||||
/* set the stream rate */
|
||||
rrate = info->rate;
|
||||
CHECK (snd_pcm_hw_params_set_rate_near (handle, params, &rrate, 0), "set_rate_near");
|
||||
CHECK (snd_pcm_hw_params_set_rate_near (hndl, params, &rrate, 0), "set_rate_near");
|
||||
if (rrate != info->rate) {
|
||||
printf("Rate doesn't match (requested %iHz, get %iHz)\n", info->rate, rrate);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
state->frame_size = info->channels * 2;
|
||||
|
||||
/* set the buffer time */
|
||||
buffer_time = props->buffer_time;
|
||||
CHECK (snd_pcm_hw_params_set_buffer_time_near (handle, params, &buffer_time, &dir), "set_buffer_time_near");
|
||||
CHECK (snd_pcm_hw_params_set_buffer_time_near (hndl, params, &buffer_time, &dir), "set_buffer_time_near");
|
||||
CHECK (snd_pcm_hw_params_get_buffer_size (params, &size), "get_buffer_size");
|
||||
state->buffer_size = size;
|
||||
state->buffer_frames = size;
|
||||
|
||||
/* set the period time */
|
||||
period_time = props->period_time;
|
||||
CHECK (snd_pcm_hw_params_set_period_time_near (handle, params, &period_time, &dir), "set_period_time_near");
|
||||
CHECK (snd_pcm_hw_params_set_period_time_near (hndl, params, &period_time, &dir), "set_period_time_near");
|
||||
CHECK (snd_pcm_hw_params_get_period_size (params, &size, &dir), "get_period_size");
|
||||
state->period_size = size;
|
||||
state->period_frames = size;
|
||||
|
||||
/* write the parameters to device */
|
||||
CHECK (snd_pcm_hw_params (handle, params), "set_hw_params");
|
||||
CHECK (snd_pcm_hw_params (hndl, params), "set_hw_params");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
set_swparams (SpaALSASink *this)
|
||||
set_swparams (SpaALSAState *state)
|
||||
{
|
||||
SpaALSAState *state = &this->state;
|
||||
snd_pcm_t *handle = state->handle;
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
int err = 0;
|
||||
snd_pcm_sw_params_t *params;
|
||||
SpaALSASinkProps *props = &this->props[1];
|
||||
SpaALSAProps *props = &state->props[1];
|
||||
|
||||
snd_pcm_sw_params_alloca (¶ms);
|
||||
|
||||
/* get the current params */
|
||||
CHECK (snd_pcm_sw_params_current (handle, params), "sw_params_current");
|
||||
CHECK (snd_pcm_sw_params_current (hndl, params), "sw_params_current");
|
||||
/* start the transfer when the buffer is almost full: */
|
||||
/* (buffer_size / avail_min) * avail_min */
|
||||
CHECK (snd_pcm_sw_params_set_start_threshold (handle, params,
|
||||
(state->buffer_size / state->period_size) * state->period_size), "set_start_threshold");
|
||||
/* (buffer_frames / avail_min) * avail_min */
|
||||
CHECK (snd_pcm_sw_params_set_start_threshold (hndl, params,
|
||||
(state->buffer_frames / state->period_frames) * state->period_frames), "set_start_threshold");
|
||||
|
||||
/* allow the transfer when at least period_size samples can be processed */
|
||||
/* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
|
||||
CHECK (snd_pcm_sw_params_set_avail_min (handle, params,
|
||||
props->period_event ? state->buffer_size : state->period_size), "set_avail_min");
|
||||
CHECK (snd_pcm_sw_params_set_avail_min (hndl, params,
|
||||
props->period_event ? state->buffer_frames : state->period_frames), "set_avail_min");
|
||||
/* enable period events when requested */
|
||||
if (props->period_event) {
|
||||
CHECK (snd_pcm_sw_params_set_period_event (handle, params, 1), "set_period_event");
|
||||
CHECK (snd_pcm_sw_params_set_period_event (hndl, params, 1), "set_period_event");
|
||||
}
|
||||
/* write the parameters to the playback device */
|
||||
CHECK (snd_pcm_sw_params (handle, params), "sw_params");
|
||||
CHECK (snd_pcm_sw_params (hndl, params), "sw_params");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -200,20 +201,20 @@ set_swparams (SpaALSASink *this)
|
|||
* Underrun and suspend recovery
|
||||
*/
|
||||
static int
|
||||
xrun_recovery (snd_pcm_t *handle, int err)
|
||||
xrun_recovery (snd_pcm_t *hndl, int err)
|
||||
{
|
||||
if (verbose)
|
||||
printf("stream recovery\n");
|
||||
if (err == -EPIPE) { /* under-run */
|
||||
err = snd_pcm_prepare(handle);
|
||||
err = snd_pcm_prepare(hndl);
|
||||
if (err < 0)
|
||||
printf("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(err));
|
||||
return 0;
|
||||
} else if (err == -ESTRPIPE) {
|
||||
while ((err = snd_pcm_resume(handle)) == -EAGAIN)
|
||||
while ((err = snd_pcm_resume(hndl)) == -EAGAIN)
|
||||
sleep(1); /* wait until the suspend flag is released */
|
||||
if (err < 0) {
|
||||
err = snd_pcm_prepare(handle);
|
||||
err = snd_pcm_prepare(hndl);
|
||||
if (err < 0)
|
||||
printf("Can't recovery from suspend, prepare failed: %s\n", snd_strerror(err));
|
||||
}
|
||||
|
|
@ -223,7 +224,7 @@ xrun_recovery (snd_pcm_t *handle, int err)
|
|||
}
|
||||
|
||||
static void
|
||||
pull_input (SpaALSASink *this, void *data, snd_pcm_uframes_t frames)
|
||||
pull_input (SpaALSAState *state, void *data, snd_pcm_uframes_t frames)
|
||||
{
|
||||
SpaNodeEvent event;
|
||||
SpaNodeEventNeedInput ni;
|
||||
|
|
@ -232,21 +233,20 @@ pull_input (SpaALSASink *this, void *data, snd_pcm_uframes_t frames)
|
|||
event.size = sizeof (ni);
|
||||
event.data = ∋
|
||||
ni.port_id = 0;
|
||||
this->event_cb (&this->node, &event, this->user_data);
|
||||
state->event_cb (&state->node, &event, state->user_data);
|
||||
}
|
||||
|
||||
static int
|
||||
mmap_write (SpaALSASink *this)
|
||||
mmap_write (SpaALSAState *state)
|
||||
{
|
||||
SpaALSAState *state = &this->state;
|
||||
snd_pcm_t *handle = state->handle;
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
int err;
|
||||
snd_pcm_sframes_t avail, commitres;
|
||||
snd_pcm_uframes_t offset, frames, size;
|
||||
const snd_pcm_channel_area_t *my_areas;
|
||||
|
||||
if ((avail = snd_pcm_avail_update (handle)) < 0) {
|
||||
if ((err = xrun_recovery (handle, avail)) < 0) {
|
||||
if ((avail = snd_pcm_avail_update (hndl)) < 0) {
|
||||
if ((err = xrun_recovery (hndl, avail)) < 0) {
|
||||
printf ("Write error: %s\n", snd_strerror (err));
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -255,27 +255,20 @@ mmap_write (SpaALSASink *this)
|
|||
size = avail;
|
||||
while (size > 0) {
|
||||
frames = size;
|
||||
if ((err = snd_pcm_mmap_begin (handle, &my_areas, &offset, &frames)) < 0) {
|
||||
if ((err = xrun_recovery(handle, err)) < 0) {
|
||||
if ((err = snd_pcm_mmap_begin (hndl, &my_areas, &offset, &frames)) < 0) {
|
||||
if ((err = xrun_recovery(hndl, err)) < 0) {
|
||||
printf("MMAP begin avail error: %s\n", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
pull_input (this,
|
||||
pull_input (state,
|
||||
(uint8_t *)my_areas[0].addr + (offset * sizeof (uint16_t) * 2),
|
||||
frames);
|
||||
|
||||
if (this->input_buffer != SPA_ID_INVALID) {
|
||||
if (this->input_buffer != this->alloc_buffers[0].buffer.id) {
|
||||
/* FIXME, copy input */
|
||||
}
|
||||
this->input_buffer = SPA_ID_INVALID;
|
||||
}
|
||||
|
||||
commitres = snd_pcm_mmap_commit (handle, offset, frames);
|
||||
commitres = snd_pcm_mmap_commit (hndl, offset, frames);
|
||||
if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
|
||||
if ((err = xrun_recovery (handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
|
||||
if ((err = xrun_recovery (hndl, commitres >= 0 ? -EPIPE : commitres)) < 0) {
|
||||
printf("MMAP commit error: %s\n", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -285,25 +278,111 @@ mmap_write (SpaALSASink *this)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
mmap_read (SpaALSAState *state)
|
||||
{
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
int err;
|
||||
snd_pcm_sframes_t avail, commitres;
|
||||
snd_pcm_uframes_t offset, frames, size;
|
||||
snd_pcm_status_t *status;
|
||||
const snd_pcm_channel_area_t *my_areas;
|
||||
SpaALSABuffer *b;
|
||||
snd_htimestamp_t htstamp = { 0, 0 };
|
||||
int64_t now;
|
||||
uint8_t *dest;
|
||||
|
||||
snd_pcm_status_alloca(&status);
|
||||
|
||||
if ((err = snd_pcm_status (hndl, status)) < 0)
|
||||
return err;
|
||||
|
||||
avail = snd_pcm_status_get_avail (status);
|
||||
snd_pcm_status_get_htstamp (status, &htstamp);
|
||||
now = (int64_t)htstamp.tv_sec * 1000000000ll + (int64_t)htstamp.tv_nsec;
|
||||
|
||||
b = state->free_head;
|
||||
if (b == NULL)
|
||||
fprintf (stderr, "no more buffers\n");
|
||||
else {
|
||||
state->free_head = b->next;
|
||||
if (state->free_head == NULL)
|
||||
state->free_tail = NULL;
|
||||
b->next = NULL;
|
||||
dest = b->ptr;
|
||||
}
|
||||
|
||||
size = avail;
|
||||
while (size > 0) {
|
||||
frames = size;
|
||||
if ((err = snd_pcm_mmap_begin (hndl, &my_areas, &offset, &frames)) < 0) {
|
||||
if ((err = xrun_recovery(hndl, err)) < 0) {
|
||||
printf("MMAP begin avail error: %s\n", snd_strerror (err));
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (b) {
|
||||
size_t n_bytes = frames * state->frame_size;
|
||||
|
||||
memcpy (dest,
|
||||
(uint8_t *)my_areas[0].addr + (offset * state->frame_size),
|
||||
n_bytes);
|
||||
dest += n_bytes;
|
||||
}
|
||||
|
||||
commitres = snd_pcm_mmap_commit (hndl, offset, frames);
|
||||
if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
|
||||
if ((err = xrun_recovery (hndl, commitres >= 0 ? -EPIPE : commitres)) < 0) {
|
||||
printf("MMAP commit error: %s\n", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
size -= frames;
|
||||
}
|
||||
|
||||
if (b) {
|
||||
SpaNodeEvent event;
|
||||
SpaNodeEventHaveOutput ho;
|
||||
SpaData *d;
|
||||
|
||||
d = SPA_BUFFER_DATAS (b->outbuf);
|
||||
d[0].mem.size = avail * state->frame_size;
|
||||
|
||||
if (state->ready_tail)
|
||||
state->ready_tail->next = b;
|
||||
state->ready_tail = b;
|
||||
if (state->ready_head == NULL)
|
||||
state->ready_head = b;
|
||||
state->ready_count++;
|
||||
|
||||
event.type = SPA_NODE_EVENT_TYPE_HAVE_OUTPUT;
|
||||
event.size = sizeof (ho);
|
||||
event.data = &ho;
|
||||
ho.port_id = 0;
|
||||
state->event_cb (&state->node, &event, state->user_data);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
alsa_on_fd_events (SpaPollNotifyData *data)
|
||||
{
|
||||
SpaALSASink *this = data->user_data;
|
||||
SpaALSAState *state = &this->state;
|
||||
snd_pcm_t *handle = state->handle;
|
||||
SpaALSAState *state = data->user_data;
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
int err;
|
||||
unsigned short revents;
|
||||
|
||||
snd_pcm_poll_descriptors_revents (handle,
|
||||
snd_pcm_poll_descriptors_revents (hndl,
|
||||
(struct pollfd *)data->fds,
|
||||
data->n_fds,
|
||||
&revents);
|
||||
if (revents & POLLERR) {
|
||||
if (snd_pcm_state (handle) == SND_PCM_STATE_XRUN ||
|
||||
snd_pcm_state (handle) == SND_PCM_STATE_SUSPENDED) {
|
||||
err = snd_pcm_state (handle) == SND_PCM_STATE_XRUN ? -EPIPE : -ESTRPIPE;
|
||||
if ((err = xrun_recovery (handle, err)) < 0) {
|
||||
printf ("Write error: %s\n", snd_strerror(err));
|
||||
if (snd_pcm_state (hndl) == SND_PCM_STATE_XRUN ||
|
||||
snd_pcm_state (hndl) == SND_PCM_STATE_SUSPENDED) {
|
||||
err = snd_pcm_state (hndl) == SND_PCM_STATE_XRUN ? -EPIPE : -ESTRPIPE;
|
||||
if ((err = xrun_recovery (hndl, err)) < 0) {
|
||||
printf ("error: %s\n", snd_strerror (err));
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -311,36 +390,43 @@ alsa_on_fd_events (SpaPollNotifyData *data)
|
|||
return -1;
|
||||
}
|
||||
}
|
||||
if (!(revents & POLLOUT))
|
||||
return -1;
|
||||
|
||||
mmap_write (this);
|
||||
if (state->stream == SND_PCM_STREAM_CAPTURE) {
|
||||
if (!(revents & POLLIN))
|
||||
return -1;
|
||||
|
||||
mmap_read (state);
|
||||
} else {
|
||||
if (!(revents & POLLOUT))
|
||||
return -1;
|
||||
|
||||
mmap_write (state);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
spa_alsa_start (SpaALSASink *this)
|
||||
int
|
||||
spa_alsa_start (SpaALSAState *state)
|
||||
{
|
||||
SpaALSAState *state = &this->state;
|
||||
int err;
|
||||
SpaNodeEvent event;
|
||||
|
||||
if (spa_alsa_open (this) < 0)
|
||||
if (spa_alsa_open (state) < 0)
|
||||
return -1;
|
||||
|
||||
if (!state->have_buffers)
|
||||
return -1;
|
||||
|
||||
CHECK (set_swparams (this), "swparams");
|
||||
CHECK (set_swparams (state), "swparams");
|
||||
|
||||
snd_pcm_dump (state->handle, state->output);
|
||||
snd_pcm_dump (state->hndl, state->output);
|
||||
|
||||
if ((state->poll.n_fds = snd_pcm_poll_descriptors_count (state->handle)) <= 0) {
|
||||
if ((state->poll.n_fds = snd_pcm_poll_descriptors_count (state->hndl)) <= 0) {
|
||||
printf ("Invalid poll descriptors count\n");
|
||||
return state->poll.n_fds;
|
||||
}
|
||||
if ((err = snd_pcm_poll_descriptors (state->handle, (struct pollfd *)state->fds, state->poll.n_fds)) < 0) {
|
||||
if ((err = snd_pcm_poll_descriptors (state->hndl, (struct pollfd *)state->fds, state->poll.n_fds)) < 0) {
|
||||
printf ("Unable to obtain poll descriptors for playback: %s\n", snd_strerror(err));
|
||||
return err;
|
||||
}
|
||||
|
|
@ -355,32 +441,31 @@ spa_alsa_start (SpaALSASink *this)
|
|||
state->poll.idle_cb = NULL;
|
||||
state->poll.before_cb = NULL;
|
||||
state->poll.after_cb = alsa_on_fd_events;
|
||||
state->poll.user_data = this;
|
||||
this->event_cb (&this->node, &event, this->user_data);
|
||||
state->poll.user_data = state;
|
||||
state->event_cb (&state->node, &event, state->user_data);
|
||||
|
||||
mmap_write (this);
|
||||
err = snd_pcm_start (state->handle);
|
||||
mmap_write (state);
|
||||
err = snd_pcm_start (state->hndl);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
spa_alsa_stop (SpaALSASink *this)
|
||||
int
|
||||
spa_alsa_stop (SpaALSAState *state)
|
||||
{
|
||||
SpaALSAState *state = &this->state;
|
||||
SpaNodeEvent event;
|
||||
|
||||
if (!state->opened)
|
||||
return 0;
|
||||
|
||||
snd_pcm_drop (state->handle);
|
||||
snd_pcm_drop (state->hndl);
|
||||
|
||||
event.type = SPA_NODE_EVENT_TYPE_REMOVE_POLL;
|
||||
event.data = &state->poll;
|
||||
event.size = sizeof (state->poll);
|
||||
this->event_cb (&this->node, &event, this->user_data);
|
||||
state->event_cb (&state->node, &event, state->user_data);
|
||||
|
||||
spa_alsa_close (this);
|
||||
spa_alsa_close (state);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,9 @@
|
|||
#include <spa/plugin.h>
|
||||
#include <spa/node.h>
|
||||
|
||||
extern const SpaHandleFactory spa_alsa_source_factory;
|
||||
extern const SpaHandleFactory spa_alsa_sink_factory;
|
||||
extern const SpaHandleFactory spa_alsa_monitor_factory;
|
||||
|
||||
SpaResult
|
||||
spa_enum_handle_factory (const SpaHandleFactory **factory,
|
||||
|
|
@ -35,8 +37,14 @@ spa_enum_handle_factory (const SpaHandleFactory **factory,
|
|||
|
||||
switch (index) {
|
||||
case 0:
|
||||
*factory = &spa_alsa_source_factory;
|
||||
break;
|
||||
case 1:
|
||||
*factory = &spa_alsa_sink_factory;
|
||||
break;
|
||||
case 2:
|
||||
*factory = &spa_alsa_monitor_factory;
|
||||
break;
|
||||
default:
|
||||
return SPA_RESULT_ENUM_END;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,12 @@
|
|||
alsa_sources = ['alsa.c',
|
||||
'alsa-sink.c']
|
||||
'alsa-monitor.c',
|
||||
'alsa-sink.c',
|
||||
'alsa-source.c',
|
||||
'alsa-utils.c']
|
||||
|
||||
alsalib = shared_library('spa-alsa',
|
||||
alsa_sources,
|
||||
include_directories : inc,
|
||||
dependencies : alsa_dep,
|
||||
dependencies : [ alsa_dep, libudev_dep ],
|
||||
link_with : spalib,
|
||||
install : true)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue