mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-11-01 22:58:50 -04:00
implement alsa capture with timers
Add timer based alsa capture support Improve format negotiation in alsa Better track buffer owner in the links
This commit is contained in:
Wim Taymans
parent
73ec9e2d24
commit
7b8bb8da6b
10 changed files with 190 additions and 337 deletions
|
|
@ -428,6 +428,8 @@ spa_alsa_sink_node_port_get_format (SpaNode *node,
|
|||
const SpaFormat **format)
|
||||
{
|
||||
SpaALSASink *this;
|
||||
SpaPODBuilder b = { NULL, };
|
||||
SpaPODFrame f[2];
|
||||
|
||||
if (node == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
|
@ -440,7 +442,14 @@ spa_alsa_sink_node_port_get_format (SpaNode *node,
|
|||
if (!this->have_format)
|
||||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
*format = NULL;
|
||||
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
|
||||
spa_pod_builder_format (&b, &f[0], this->type.format,
|
||||
this->type.media_type.audio, this->type.media_subtype.raw,
|
||||
PROP (&f[1], this->type.format_audio.format, SPA_POD_TYPE_ID, this->current_format.info.raw.format),
|
||||
PROP (&f[1], this->type.format_audio.rate, SPA_POD_TYPE_INT, this->current_format.info.raw.rate),
|
||||
PROP (&f[1], this->type.format_audio.channels, SPA_POD_TYPE_INT, this->current_format.info.raw.channels));
|
||||
|
||||
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -470,6 +470,8 @@ spa_alsa_source_node_port_get_format (SpaNode *node,
|
|||
const SpaFormat **format)
|
||||
{
|
||||
SpaALSASource *this;
|
||||
SpaPODBuilder b = { NULL, };
|
||||
SpaPODFrame f[2];
|
||||
|
||||
if (node == NULL || format == NULL)
|
||||
return SPA_RESULT_INVALID_ARGUMENTS;
|
||||
|
|
@ -482,7 +484,14 @@ spa_alsa_source_node_port_get_format (SpaNode *node,
|
|||
if (!this->have_format)
|
||||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
*format = NULL;
|
||||
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
|
||||
spa_pod_builder_format (&b, &f[0], this->type.format,
|
||||
this->type.media_type.audio, this->type.media_subtype.raw,
|
||||
PROP (&f[1], this->type.format_audio.format, SPA_POD_TYPE_ID, this->current_format.info.raw.format),
|
||||
PROP (&f[1], this->type.format_audio.rate, SPA_POD_TYPE_INT, this->current_format.info.raw.rate),
|
||||
PROP (&f[1], this->type.format_audio.channels, SPA_POD_TYPE_INT, this->current_format.info.raw.channels));
|
||||
|
||||
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
|
||||
|
||||
return SPA_RESULT_OK;
|
||||
}
|
||||
|
|
@ -549,6 +558,7 @@ spa_alsa_source_node_port_use_buffers (SpaNode *node,
|
|||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
if (this->n_buffers > 0) {
|
||||
spa_alsa_pause (this, false);
|
||||
if ((res = spa_alsa_clear_buffers (this)) < 0)
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,8 +14,6 @@
|
|||
|
||||
#define CHECK(s,msg) if ((err = (s)) < 0) { spa_log_error (state->log, msg ": %s", snd_strerror(err)); return err; }
|
||||
|
||||
static void alsa_on_fd_events (SpaSource *source);
|
||||
|
||||
static int
|
||||
spa_alsa_open (SpaALSAState *state)
|
||||
{
|
||||
|
|
@ -36,7 +34,6 @@ spa_alsa_open (SpaALSAState *state)
|
|||
SND_PCM_NO_AUTO_CHANNELS |
|
||||
SND_PCM_NO_AUTO_FORMAT), "open failed");
|
||||
|
||||
|
||||
state->timerfd = timerfd_create (CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
|
||||
state->opened = true;
|
||||
|
||||
|
|
@ -171,22 +168,6 @@ spa_alsa_set_format (SpaALSAState *state, SpaAudioInfo *fmt, SpaPortFormatFlags
|
|||
state->rate = info->rate;
|
||||
state->frame_size = info->channels * 2;
|
||||
|
||||
#if 0
|
||||
period_size = props->period_size;
|
||||
periods = props->periods;
|
||||
|
||||
spa_log_info (state->log, "trying period frames %zd and periods %u", period_size, periods);
|
||||
|
||||
dir = 0;
|
||||
CHECK (snd_pcm_hw_params_set_period_size_near (hndl, params, &period_size, &dir), "set_period_size_near");
|
||||
state->period_frames = period_size;
|
||||
|
||||
dir = 0;
|
||||
CHECK (snd_pcm_hw_params_set_periods_near (hndl, params, &periods, &dir), "set_periods_near");
|
||||
state->buffer_frames = periods * state->period_frames;
|
||||
|
||||
CHECK (snd_pcm_hw_params_set_buffer_size (hndl, params, state->buffer_frames), "set_buffer_size");
|
||||
#else
|
||||
CHECK (snd_pcm_hw_params_get_buffer_size_max (params, &state->buffer_frames), "get_buffer_size_max");
|
||||
|
||||
CHECK (snd_pcm_hw_params_set_buffer_size_near (hndl, params, &state->buffer_frames), "set_buffer_size_near");
|
||||
|
|
@ -196,7 +177,6 @@ spa_alsa_set_format (SpaALSAState *state, SpaAudioInfo *fmt, SpaPortFormatFlags
|
|||
CHECK (snd_pcm_hw_params_set_period_size_near (hndl, params, &period_size, &dir), "set_period_size_near");
|
||||
state->period_frames = period_size;
|
||||
periods = state->buffer_frames / state->period_frames;
|
||||
#endif
|
||||
|
||||
spa_log_info (state->log, "buffer frames %zd, period frames %zd, periods %u",
|
||||
state->buffer_frames, state->period_frames, periods);
|
||||
|
|
@ -226,67 +206,18 @@ set_swparams (SpaALSAState *state)
|
|||
|
||||
/* start the transfer */
|
||||
CHECK (snd_pcm_sw_params_set_start_threshold (hndl, params, LONG_MAX), "set_start_threshold");
|
||||
#if 1
|
||||
CHECK (snd_pcm_sw_params_get_boundary (params, &boundary), "get_boundary");
|
||||
|
||||
CHECK (snd_pcm_sw_params_set_stop_threshold (hndl, params, boundary), "set_stop_threshold");
|
||||
#else
|
||||
CHECK (snd_pcm_sw_params_set_stop_threshold (hndl, params, -1), "set_stop_threshold");
|
||||
#endif
|
||||
|
||||
// CHECK (snd_pcm_sw_params_set_silence_threshold (hndl, params, 0U), "set_silence_threshold");
|
||||
|
||||
/* enable period events when requested */
|
||||
// CHECK (snd_pcm_sw_params_set_period_event (hndl, params, props->period_event ? 1 : 0), "set_period_event");
|
||||
CHECK (snd_pcm_sw_params_set_period_event (hndl, params, 0), "set_period_event");
|
||||
|
||||
#if 1
|
||||
/* 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 (hndl, params, state->period_frames), "set_avail_min");
|
||||
#else
|
||||
CHECK (snd_pcm_sw_params_set_avail_min (hndl, params, 0), "set_avail_min");
|
||||
#endif
|
||||
|
||||
/* write the parameters to the playback device */
|
||||
CHECK (snd_pcm_sw_params (hndl, params), "sw_params");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Underrun and suspend recovery
|
||||
*/
|
||||
static int
|
||||
xrun_recovery (SpaALSAState *state, snd_pcm_t *hndl, int err)
|
||||
{
|
||||
snd_pcm_status_t *status;
|
||||
|
||||
snd_pcm_status_alloca (&status);
|
||||
|
||||
if ((err = snd_pcm_status (hndl, status)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_status error: %s", snd_strerror (err));
|
||||
}
|
||||
|
||||
if (snd_pcm_status_get_state (status) == SND_PCM_STATE_SUSPENDED) {
|
||||
spa_log_warn (state->log, "SUSPENDED, trying to resume");
|
||||
|
||||
if ((err = snd_pcm_prepare (hndl)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_prepare error: %s", snd_strerror (err));
|
||||
}
|
||||
}
|
||||
if (snd_pcm_status_get_state (status) == SND_PCM_STATE_XRUN) {
|
||||
spa_log_warn (state->log, "XRUN");
|
||||
}
|
||||
|
||||
if (spa_alsa_pause (state, true) != SPA_RESULT_OK)
|
||||
return -1;
|
||||
if (spa_alsa_start (state, true) != SPA_RESULT_OK)
|
||||
return -1;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static snd_pcm_uframes_t
|
||||
pull_frames_queue (SpaALSAState *state,
|
||||
const snd_pcm_channel_area_t *my_areas,
|
||||
|
|
@ -338,7 +269,6 @@ pull_frames_queue (SpaALSAState *state,
|
|||
spa_log_warn (state->log, "underrun, want %zd frames", total_frames);
|
||||
snd_pcm_areas_silence (my_areas, offset, state->channels, total_frames, state->format);
|
||||
}
|
||||
//spa_log_warn (state->log, "written %zd frames", total_frames);
|
||||
return total_frames;
|
||||
}
|
||||
|
||||
|
|
@ -361,7 +291,7 @@ pull_frames_ringbuffer (SpaALSAState *state,
|
|||
avail = spa_ringbuffer_get_read_areas (&b->rb->ringbuffer, areas);
|
||||
size = SPA_MIN (avail, frames * state->frame_size);
|
||||
|
||||
spa_log_debug (state->log, "%u %u %u %u %zd %zd",
|
||||
spa_log_trace (state->log, "%u %u %u %u %zd %zd",
|
||||
areas[0].offset, areas[0].len,
|
||||
areas[1].offset, areas[1].len, offset, size);
|
||||
|
||||
|
|
@ -387,140 +317,44 @@ pull_frames_ringbuffer (SpaALSAState *state,
|
|||
|
||||
return frames;
|
||||
}
|
||||
static int
|
||||
mmap_write (SpaALSAState *state)
|
||||
|
||||
static snd_pcm_uframes_t
|
||||
push_frames_queue (SpaALSAState *state,
|
||||
const snd_pcm_channel_area_t *my_areas,
|
||||
snd_pcm_uframes_t offset,
|
||||
snd_pcm_uframes_t frames)
|
||||
{
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
int err;
|
||||
snd_pcm_sframes_t avail;
|
||||
snd_pcm_uframes_t offset, frames, size;
|
||||
const snd_pcm_channel_area_t *my_areas;
|
||||
|
||||
#if 0
|
||||
snd_pcm_status_t *status;
|
||||
|
||||
snd_pcm_status_alloca (&status);
|
||||
|
||||
if ((err = snd_pcm_status (hndl, status)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_status error: %s", snd_strerror (err));
|
||||
return -1;
|
||||
}
|
||||
|
||||
avail = snd_pcm_status_get_avail (status);
|
||||
#else
|
||||
if ((avail = snd_pcm_avail_update (hndl)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_avail_update error: %s", snd_strerror (avail));
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
size = avail;
|
||||
while (size > 0) {
|
||||
frames = size;
|
||||
if ((err = snd_pcm_mmap_begin (hndl, &my_areas, &offset, &frames)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_mmap_begin error: %s", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
if (frames < state->period_frames)
|
||||
break;
|
||||
else
|
||||
frames = state->period_frames;
|
||||
|
||||
if (state->ringbuffer)
|
||||
frames = pull_frames_ringbuffer (state, my_areas, offset, frames);
|
||||
else
|
||||
frames = pull_frames_queue (state, my_areas, offset, frames);
|
||||
|
||||
if ((err = snd_pcm_mmap_commit (hndl, offset, frames)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_mmap_commit error: %s", snd_strerror(err));
|
||||
if (err != -EPIPE && err != -ESTRPIPE)
|
||||
return -1;
|
||||
}
|
||||
size -= frames;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
mmap_read (SpaALSAState *state)
|
||||
{
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
int err;
|
||||
snd_pcm_sframes_t avail;
|
||||
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 = NULL;
|
||||
size_t destsize;
|
||||
|
||||
snd_pcm_status_alloca(&status);
|
||||
|
||||
if ((err = snd_pcm_status (hndl, status)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_status error: %s", snd_strerror(err));
|
||||
return err;
|
||||
}
|
||||
|
||||
avail = snd_pcm_status_get_avail (status);
|
||||
snd_pcm_status_get_htstamp (status, &htstamp);
|
||||
now = (int64_t)htstamp.tv_sec * SPA_NSEC_PER_SEC + (int64_t)htstamp.tv_nsec;
|
||||
|
||||
state->last_ticks = state->sample_count * SPA_USEC_PER_SEC / state->rate;
|
||||
state->last_monotonic = now;
|
||||
snd_pcm_uframes_t total_frames = 0;
|
||||
|
||||
if (spa_list_is_empty (&state->free)) {
|
||||
b = NULL;
|
||||
spa_log_warn (state->log, "no more buffers");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
uint8_t *src;
|
||||
size_t n_bytes;
|
||||
SpaALSABuffer *b;
|
||||
SpaData *d;
|
||||
SpaPortOutput *output;
|
||||
|
||||
b = spa_list_first (&state->free, SpaALSABuffer, link);
|
||||
spa_list_remove (&b->link);
|
||||
|
||||
dest = b->outbuf->datas[0].data;
|
||||
destsize = b->outbuf->datas[0].maxsize;
|
||||
|
||||
if (b->h) {
|
||||
b->h->seq = state->sample_count;
|
||||
b->h->pts = state->last_monotonic;
|
||||
b->h->dts_offset = 0;
|
||||
}
|
||||
avail = SPA_MIN (avail, destsize / state->frame_size);
|
||||
}
|
||||
|
||||
state->sample_count += avail;
|
||||
|
||||
size = avail;
|
||||
while (size > 0) {
|
||||
frames = size;
|
||||
if ((err = snd_pcm_mmap_begin (hndl, &my_areas, &offset, &frames)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_mmap_begin error: %s", 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;
|
||||
}
|
||||
|
||||
if ((err = snd_pcm_mmap_commit (hndl, offset, frames)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_mmap_commit error: %s", snd_strerror(err));
|
||||
return -1;
|
||||
}
|
||||
size -= frames;
|
||||
}
|
||||
|
||||
if (b) {
|
||||
SpaData *d;
|
||||
SpaPortOutput *output;
|
||||
|
||||
d = b->outbuf->datas;
|
||||
|
||||
total_frames = SPA_MIN (frames, d[0].maxsize / state->frame_size);
|
||||
src = SPA_MEMBER (my_areas[0].addr, offset * state->frame_size, uint8_t);
|
||||
n_bytes = total_frames * state->frame_size;
|
||||
|
||||
memcpy (d[0].data, src, n_bytes);
|
||||
|
||||
d[0].chunk->offset = 0;
|
||||
d[0].chunk->size = avail * state->frame_size;
|
||||
d[0].chunk->size = n_bytes;
|
||||
d[0].chunk->stride = 0;
|
||||
|
||||
if ((output = state->io)) {
|
||||
|
|
@ -533,77 +367,16 @@ mmap_read (SpaALSAState *state)
|
|||
state->event_cb (&state->node, &event, state->user_data);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return total_frames;
|
||||
}
|
||||
|
||||
static inline short
|
||||
spa_io_to_poll (SpaIO mask)
|
||||
static snd_pcm_uframes_t
|
||||
push_frames_ringbuffer (SpaALSAState *state,
|
||||
const snd_pcm_channel_area_t *my_areas,
|
||||
snd_pcm_uframes_t offset,
|
||||
snd_pcm_uframes_t frames)
|
||||
{
|
||||
short events = 0;
|
||||
|
||||
if (mask & SPA_IO_IN)
|
||||
events |= POLLIN;
|
||||
if (mask & SPA_IO_OUT)
|
||||
events |= POLLOUT;
|
||||
if (mask & SPA_IO_ERR)
|
||||
events |= POLLERR;
|
||||
if (mask & SPA_IO_HUP)
|
||||
events |= POLLHUP;
|
||||
|
||||
return events;
|
||||
}
|
||||
|
||||
static inline SpaIO
|
||||
spa_poll_to_io (short events)
|
||||
{
|
||||
SpaIO mask = 0;
|
||||
|
||||
if (events & POLLIN)
|
||||
mask |= SPA_IO_IN;
|
||||
if (events & POLLOUT)
|
||||
mask |= SPA_IO_OUT;
|
||||
if (events & POLLERR)
|
||||
mask |= SPA_IO_ERR;
|
||||
if (events & POLLHUP)
|
||||
mask |= SPA_IO_HUP;
|
||||
|
||||
return mask;
|
||||
}
|
||||
|
||||
static void
|
||||
alsa_on_fd_events (SpaSource *source)
|
||||
{
|
||||
SpaALSAState *state = source->data;
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
int err, i;
|
||||
unsigned short revents = 0;
|
||||
|
||||
for (i = 0; i < state->n_fds; i++) {
|
||||
state->fds[i].revents = spa_io_to_poll (state->sources[i].rmask);
|
||||
state->sources[i].rmask = 0;
|
||||
}
|
||||
|
||||
snd_pcm_poll_descriptors_revents (hndl,
|
||||
state->fds,
|
||||
state->n_fds,
|
||||
&revents);
|
||||
if (revents & POLLERR) {
|
||||
if ((err = xrun_recovery (state, hndl, err)) < 0) {
|
||||
spa_log_error (state->log, "error: %s", snd_strerror (err));
|
||||
}
|
||||
}
|
||||
|
||||
if (state->stream == SND_PCM_STREAM_CAPTURE) {
|
||||
if (!(revents & POLLIN))
|
||||
return;
|
||||
|
||||
mmap_read (state);
|
||||
} else {
|
||||
if (!(revents & POLLOUT))
|
||||
return;
|
||||
|
||||
mmap_write (state);
|
||||
}
|
||||
return frames;
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -623,22 +396,21 @@ alsa_try_resume (SpaALSAState *state)
|
|||
}
|
||||
|
||||
static inline void
|
||||
calc_timeout (size_t frames,
|
||||
size_t cb_threshold,
|
||||
calc_timeout (size_t target,
|
||||
size_t current,
|
||||
size_t rate,
|
||||
snd_htimestamp_t *now,
|
||||
struct timespec *ts)
|
||||
{
|
||||
size_t to_play_usec;
|
||||
size_t to_sleep_usec;
|
||||
|
||||
ts->tv_sec = now->tv_sec;
|
||||
/* adjust sleep time to target our callback threshold */
|
||||
if (frames > cb_threshold)
|
||||
to_play_usec = (frames - cb_threshold) * 1000000 / rate;
|
||||
if (target > current)
|
||||
to_sleep_usec = (target - current) * 1000000 / rate;
|
||||
else
|
||||
to_play_usec = 0;
|
||||
to_sleep_usec = 0;
|
||||
|
||||
ts->tv_nsec = to_play_usec * 1000 + now->tv_nsec;
|
||||
ts->tv_nsec = to_sleep_usec * 1000 + now->tv_nsec;
|
||||
|
||||
while (ts->tv_nsec > 1000000000L) {
|
||||
ts->tv_sec++;
|
||||
|
|
@ -647,7 +419,7 @@ calc_timeout (size_t frames,
|
|||
}
|
||||
|
||||
static void
|
||||
alsa_on_timeout_event (SpaSource *source)
|
||||
alsa_on_playback_timeout_event (SpaSource *source)
|
||||
{
|
||||
uint64_t exp;
|
||||
int res;
|
||||
|
|
@ -680,7 +452,7 @@ alsa_on_timeout_event (SpaSource *source)
|
|||
avail = state->buffer_frames;
|
||||
|
||||
filled = state->buffer_frames - avail;
|
||||
if (filled > state->threshold + 10) {
|
||||
if (filled > state->threshold + 16) {
|
||||
if (snd_pcm_state (hndl) == SND_PCM_STATE_SUSPENDED) {
|
||||
spa_log_error (state->log, "suspended: try resume");
|
||||
if ((res = alsa_try_resume (state)) < 0)
|
||||
|
|
@ -734,14 +506,89 @@ alsa_on_timeout_event (SpaSource *source)
|
|||
timerfd_settime (state->timerfd, TFD_TIMER_ABSTIME, &ts, NULL);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
alsa_on_capture_timeout_event (SpaSource *source)
|
||||
{
|
||||
uint64_t exp;
|
||||
int res;
|
||||
SpaALSAState *state = source->data;
|
||||
snd_pcm_t *hndl = state->hndl;
|
||||
snd_pcm_sframes_t avail;
|
||||
snd_pcm_uframes_t total_read = 0;
|
||||
struct itimerspec ts;
|
||||
const snd_pcm_channel_area_t *my_areas;
|
||||
snd_pcm_status_t *status;
|
||||
snd_htimestamp_t htstamp;
|
||||
|
||||
read (state->timerfd, &exp, sizeof (uint64_t));
|
||||
|
||||
snd_pcm_status_alloca(&status);
|
||||
|
||||
if ((res = snd_pcm_status (hndl, status)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_status error: %s", snd_strerror (res));
|
||||
return;
|
||||
}
|
||||
|
||||
avail = snd_pcm_status_get_avail (status);
|
||||
snd_pcm_status_get_htstamp (status, &htstamp);
|
||||
|
||||
state->last_ticks = state->sample_count + avail;
|
||||
state->last_monotonic = (int64_t)htstamp.tv_sec * SPA_NSEC_PER_SEC + (int64_t)htstamp.tv_nsec;
|
||||
|
||||
if (avail < state->threshold) {
|
||||
if (snd_pcm_state (hndl) == SND_PCM_STATE_SUSPENDED) {
|
||||
spa_log_error (state->log, "suspended: try resume");
|
||||
if ((res = alsa_try_resume (state)) < 0)
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
snd_pcm_uframes_t to_read = avail;
|
||||
|
||||
while (total_read < to_read) {
|
||||
snd_pcm_uframes_t read, frames, offset;
|
||||
|
||||
frames = to_read - total_read;
|
||||
if ((res = snd_pcm_mmap_begin (hndl, &my_areas, &offset, &frames)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_mmap_begin error: %s", snd_strerror(res));
|
||||
return;
|
||||
}
|
||||
|
||||
if (state->ringbuffer)
|
||||
read = push_frames_ringbuffer (state, my_areas, offset, frames);
|
||||
else
|
||||
read = push_frames_queue (state, my_areas, offset, frames);
|
||||
|
||||
if (read < to_read)
|
||||
to_read = 0;
|
||||
|
||||
if ((res = snd_pcm_mmap_commit (hndl, offset, read)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_mmap_commit error: %s", snd_strerror(res));
|
||||
if (res != -EPIPE && res != -ESTRPIPE)
|
||||
return;
|
||||
}
|
||||
total_read += read;
|
||||
}
|
||||
state->sample_count += total_read;
|
||||
}
|
||||
calc_timeout (state->threshold, avail - total_read, state->rate, &htstamp, &ts.it_value);
|
||||
|
||||
// printf ("timeout %ld %ld %ld %ld\n", total_read, avail, ts.it_value.tv_sec, ts.it_value.tv_nsec);
|
||||
ts.it_interval.tv_sec = 0;
|
||||
ts.it_interval.tv_nsec = 0;
|
||||
timerfd_settime (state->timerfd, TFD_TIMER_ABSTIME, &ts, NULL);
|
||||
}
|
||||
|
||||
SpaResult
|
||||
spa_alsa_start (SpaALSAState *state, bool xrun_recover)
|
||||
{
|
||||
int err, i;
|
||||
int err;
|
||||
|
||||
if (state->started)
|
||||
return SPA_RESULT_OK;
|
||||
|
||||
spa_log_trace (state->log, "alsa %p: start", state);
|
||||
|
||||
CHECK (set_swparams (state), "swparams");
|
||||
if (!xrun_recover)
|
||||
snd_pcm_dump (state->hndl, state->output);
|
||||
|
|
@ -751,52 +598,29 @@ spa_alsa_start (SpaALSAState *state, bool xrun_recover)
|
|||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
|
||||
for (i = 0; i < state->n_fds; i++)
|
||||
spa_loop_remove_source (state->data_loop, &state->sources[i]);
|
||||
|
||||
#if 0
|
||||
if ((state->n_fds = snd_pcm_poll_descriptors_count (state->hndl)) <= 0) {
|
||||
spa_log_error (state->log, "Invalid poll descriptors count %d", state->n_fds);
|
||||
return SPA_RESULT_ERROR;
|
||||
if (state->stream == SND_PCM_STREAM_PLAYBACK) {
|
||||
state->source.func = alsa_on_playback_timeout_event;
|
||||
} else {
|
||||
state->source.func = alsa_on_capture_timeout_event;
|
||||
}
|
||||
state->source.data = state;
|
||||
state->source.fd = state->timerfd;
|
||||
state->source.mask = SPA_IO_IN;
|
||||
state->source.rmask = 0;
|
||||
spa_loop_add_source (state->data_loop, &state->source);
|
||||
|
||||
if ((err = snd_pcm_poll_descriptors (state->hndl, state->fds, state->n_fds)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_poll_descriptors: %s", snd_strerror(err));
|
||||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
|
||||
for (i = 0; i < state->n_fds; i++) {
|
||||
state->sources[i].func = alsa_on_fd_events;
|
||||
state->sources[i].data = state;
|
||||
state->sources[i].fd = state->fds[i].fd;
|
||||
state->sources[i].mask = spa_poll_to_io (state->fds[i].events);
|
||||
state->sources[i].rmask = 0;
|
||||
state->fds[i].revents = 0;
|
||||
spa_loop_add_source (state->data_loop, &state->sources[i]);
|
||||
}
|
||||
#else
|
||||
state->n_fds = 1;
|
||||
state->sources[0].func = alsa_on_timeout_event;
|
||||
state->sources[0].data = state;
|
||||
state->sources[0].fd = state->timerfd;
|
||||
state->sources[0].mask = SPA_IO_IN;
|
||||
state->sources[0].rmask = 0;
|
||||
spa_loop_add_source (state->data_loop, &state->sources[0]);
|
||||
#endif
|
||||
|
||||
state->threshold = 40;
|
||||
state->alsa_started = false;
|
||||
state->threshold = 1024;
|
||||
|
||||
if (state->stream == SND_PCM_STREAM_PLAYBACK) {
|
||||
alsa_on_timeout_event (&state->sources[0]);
|
||||
state->alsa_started = false;
|
||||
} else {
|
||||
if ((err = snd_pcm_start (state->hndl)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_start: %s", snd_strerror (err));
|
||||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
state->alsa_started = true;
|
||||
}
|
||||
|
||||
#if 0
|
||||
if ((err = snd_pcm_start (state->hndl)) < 0) {
|
||||
spa_log_error (state->log, "snd_pcm_start: %s", snd_strerror (err));
|
||||
return SPA_RESULT_ERROR;
|
||||
}
|
||||
#endif
|
||||
state->source.func (&state->source);
|
||||
|
||||
state->started = true;
|
||||
|
||||
|
|
@ -806,14 +630,14 @@ spa_alsa_start (SpaALSAState *state, bool xrun_recover)
|
|||
SpaResult
|
||||
spa_alsa_pause (SpaALSAState *state, bool xrun_recover)
|
||||
{
|
||||
int err, i;
|
||||
int err;
|
||||
|
||||
if (!state->started)
|
||||
return SPA_RESULT_OK;
|
||||
|
||||
for (i = 0; i < state->n_fds; i++)
|
||||
spa_loop_remove_source (state->data_loop, &state->sources[i]);
|
||||
state->n_fds = 0;
|
||||
spa_log_trace (state->log, "alsa %p: pause", state);
|
||||
|
||||
spa_loop_remove_source (state->data_loop, &state->source);
|
||||
|
||||
if ((err = snd_pcm_drop (state->hndl)) < 0)
|
||||
spa_log_error (state->log, "snd_pcm_drop %s", snd_strerror (err));
|
||||
|
|
|
|||
|
|
@ -158,9 +158,7 @@ struct _SpaALSAState {
|
|||
size_t ready_offset;
|
||||
|
||||
bool started;
|
||||
int n_fds;
|
||||
struct pollfd fds[16];
|
||||
SpaSource sources[16];
|
||||
SpaSource source;
|
||||
int timerfd;
|
||||
bool alsa_started;
|
||||
int threshold;
|
||||
|
|
|
|||
|
|
@ -709,6 +709,7 @@ spa_v4l2_source_node_port_use_buffers (SpaNode *node,
|
|||
return SPA_RESULT_NO_FORMAT;
|
||||
|
||||
if (state->n_buffers) {
|
||||
spa_v4l2_stream_off (this);
|
||||
if ((res = spa_v4l2_clear_buffers (this)) < 0)
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue