diff options
Diffstat (limited to 'spa/plugins/alsa/alsa-pcm.c')
| -rw-r--r-- | spa/plugins/alsa/alsa-pcm.c | 2696 |
1 files changed, 2696 insertions, 0 deletions
diff --git a/spa/plugins/alsa/alsa-pcm.c b/spa/plugins/alsa/alsa-pcm.c new file mode 100644 index 0000000..012b460 --- /dev/null +++ b/spa/plugins/alsa/alsa-pcm.c @@ -0,0 +1,2696 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sched.h> +#include <errno.h> +#include <getopt.h> +#include <sys/time.h> +#include <math.h> +#include <limits.h> + +#include <spa/pod/filter.h> +#include <spa/utils/string.h> +#include <spa/utils/result.h> +#include <spa/support/system.h> +#include <spa/utils/keys.h> + +#include "alsa-pcm.h" + +static struct spa_list cards = SPA_LIST_INIT(&cards); + +static struct card *find_card(uint32_t index) +{ + struct card *c; + spa_list_for_each(c, &cards, link) { + if (c->index == index) { + c->ref++; + return c; + } + } + return NULL; +} + +static struct card *ensure_card(uint32_t index, bool ucm) +{ + struct card *c; + char card_name[64]; + const char *alibpref = NULL; + int err; + + if ((c = find_card(index)) != NULL) + return c; + + c = calloc(1, sizeof(*c)); + c->ref = 1; + c->index = index; + + if (ucm) { + snprintf(card_name, sizeof(card_name), "hw:%i", index); + err = snd_use_case_mgr_open(&c->ucm, card_name); + if (err < 0) { + char *name; + err = snd_card_get_name(index, &name); + if (err < 0) + goto error; + + snprintf(card_name, sizeof(card_name), "%s", name); + free(name); + + err = snd_use_case_mgr_open(&c->ucm, card_name); + if (err < 0) + goto error; + } + if ((snd_use_case_get(c->ucm, "_alibpref", &alibpref) != 0)) + alibpref = NULL; + c->ucm_prefix = (char*)alibpref; + } + spa_list_append(&cards, &c->link); + + return c; +error: + free(c); + errno = -err; + return NULL; +} + +static void release_card(struct card *c) +{ + spa_assert(c->ref > 0); + + if (--c->ref > 0) + return; + + spa_list_remove(&c->link); + if (c->ucm) { + free(c->ucm_prefix); + snd_use_case_mgr_close(c->ucm); + } + free(c); +} + +static int alsa_set_param(struct state *state, const char *k, const char *s) +{ + int fmt_change = 0; + if (spa_streq(k, SPA_KEY_AUDIO_CHANNELS)) { + state->default_channels = atoi(s); + fmt_change++; + } else if (spa_streq(k, SPA_KEY_AUDIO_RATE)) { + state->default_rate = atoi(s); + fmt_change++; + } else if (spa_streq(k, SPA_KEY_AUDIO_FORMAT)) { + state->default_format = spa_alsa_format_from_name(s, strlen(s)); + fmt_change++; + } else if (spa_streq(k, SPA_KEY_AUDIO_POSITION)) { + spa_alsa_parse_position(&state->default_pos, s, strlen(s)); + fmt_change++; + } else if (spa_streq(k, SPA_KEY_AUDIO_ALLOWED_RATES)) { + state->n_allowed_rates = spa_alsa_parse_rates(state->allowed_rates, + MAX_RATES, s, strlen(s)); + fmt_change++; + } else if (spa_streq(k, "iec958.codecs")) { + spa_alsa_parse_iec958_codecs(&state->iec958_codecs, s, strlen(s)); + fmt_change++; + } else if (spa_streq(k, "api.alsa.period-size")) { + state->default_period_size = atoi(s); + } else if (spa_streq(k, "api.alsa.period-num")) { + state->default_period_num = atoi(s); + } else if (spa_streq(k, "api.alsa.headroom")) { + state->default_headroom = atoi(s); + } else if (spa_streq(k, "api.alsa.start-delay")) { + state->default_start_delay = atoi(s); + } else if (spa_streq(k, "api.alsa.disable-mmap")) { + state->disable_mmap = spa_atob(s); + } else if (spa_streq(k, "api.alsa.disable-batch")) { + state->disable_batch = spa_atob(s); + } else if (spa_streq(k, "api.alsa.use-chmap")) { + state->props.use_chmap = spa_atob(s); + } else if (spa_streq(k, "api.alsa.multi-rate")) { + state->multi_rate = spa_atob(s); + } else if (spa_streq(k, "latency.internal.rate")) { + state->process_latency.rate = atoi(s); + } else if (spa_streq(k, "latency.internal.ns")) { + state->process_latency.ns = atoi(s); + } else if (spa_streq(k, "clock.name")) { + spa_scnprintf(state->clock_name, + sizeof(state->clock_name), "%s", s); + } else + return 0; + + if (fmt_change > 0) { + state->port_info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS; + state->port_params[PORT_EnumFormat].user++; + } + return 1; +} + +static int position_to_string(struct channel_map *map, char *val, size_t len) +{ + uint32_t i, o = 0; + int r; + o += snprintf(val, len, "[ "); + for (i = 0; i < map->channels; i++) { + r = snprintf(val+o, len-o, "%s%s", i == 0 ? "" : ", ", + spa_debug_type_find_short_name(spa_type_audio_channel, + map->pos[i])); + if (r < 0 || o + r >= len) + return -ENOSPC; + o += r; + } + if (len > o) + o += snprintf(val+o, len-o, " ]"); + return 0; +} + +static int uint32_array_to_string(uint32_t *vals, uint32_t n_vals, char *val, size_t len) +{ + uint32_t i, o = 0; + int r; + o += snprintf(val, len, "[ "); + for (i = 0; i < n_vals; i++) { + r = snprintf(val+o, len-o, "%s%d", i == 0 ? "" : ", ", vals[i]); + if (r < 0 || o + r >= len) + return -ENOSPC; + o += r; + } + if (len > o) + o += snprintf(val+o, len-o, " ]"); + return 0; +} + +struct spa_pod *spa_alsa_enum_propinfo(struct state *state, + uint32_t idx, struct spa_pod_builder *b) +{ + struct spa_pod *param; + + switch (idx) { + case 0: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String(SPA_KEY_AUDIO_CHANNELS), + SPA_PROP_INFO_description, SPA_POD_String("Audio Channels"), + SPA_PROP_INFO_type, SPA_POD_Int(state->default_channels), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 1: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String(SPA_KEY_AUDIO_RATE), + SPA_PROP_INFO_description, SPA_POD_String("Audio Rate"), + SPA_PROP_INFO_type, SPA_POD_Int(state->default_rate), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 2: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String(SPA_KEY_AUDIO_FORMAT), + SPA_PROP_INFO_description, SPA_POD_String("Audio Format"), + SPA_PROP_INFO_type, SPA_POD_String( + spa_debug_type_find_short_name(spa_type_audio_format, + state->default_format)), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 3: + { + char buf[1024]; + position_to_string(&state->default_pos, buf, sizeof(buf)); + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String(SPA_KEY_AUDIO_POSITION), + SPA_PROP_INFO_description, SPA_POD_String("Audio Position"), + SPA_PROP_INFO_type, SPA_POD_String(buf), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + } + case 4: + { + char buf[1024]; + uint32_array_to_string(state->allowed_rates, state->n_allowed_rates, buf, sizeof(buf)); + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String(SPA_KEY_AUDIO_ALLOWED_RATES), + SPA_PROP_INFO_description, SPA_POD_String("Audio Allowed Rates"), + SPA_PROP_INFO_type, SPA_POD_String(buf), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + } + case 5: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.period-size"), + SPA_PROP_INFO_description, SPA_POD_String("Period Size"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(state->default_period_size, 0, 8192), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 6: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.period-num"), + SPA_PROP_INFO_description, SPA_POD_String("Number of Periods"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(state->default_period_num, 0, 1024), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 7: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.headroom"), + SPA_PROP_INFO_description, SPA_POD_String("Headroom"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(state->default_headroom, 0, 8192), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 8: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.start-delay"), + SPA_PROP_INFO_description, SPA_POD_String("Start Delay"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(state->default_start_delay, 0, 8192), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 9: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.disable-mmap"), + SPA_PROP_INFO_description, SPA_POD_String("Disable MMAP"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool(state->disable_mmap), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 10: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.disable-batch"), + SPA_PROP_INFO_description, SPA_POD_String("Disable Batch"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool(state->disable_batch), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 11: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.use-chmap"), + SPA_PROP_INFO_description, SPA_POD_String("Use the driver channelmap"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool(state->props.use_chmap), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 12: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("api.alsa.multi-rate"), + SPA_PROP_INFO_description, SPA_POD_String("Support multiple rates"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool(state->multi_rate), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 13: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("latency.internal.rate"), + SPA_PROP_INFO_description, SPA_POD_String("Internal latency in samples"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(state->process_latency.rate, + 0, 65536), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 14: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("latency.internal.ns"), + SPA_PROP_INFO_description, SPA_POD_String("Internal latency in nanoseconds"), + SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Long(state->process_latency.ns, + 0LL, 2 * SPA_NSEC_PER_SEC), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + case 15: + param = spa_pod_builder_add_object(b, + SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo, + SPA_PROP_INFO_name, SPA_POD_String("clock.name"), + SPA_PROP_INFO_description, SPA_POD_String("The name of the clock"), + SPA_PROP_INFO_type, SPA_POD_String(state->clock_name), + SPA_PROP_INFO_params, SPA_POD_Bool(true)); + break; + default: + return NULL; + } + return param; +} + +int spa_alsa_add_prop_params(struct state *state, struct spa_pod_builder *b) +{ + struct spa_pod_frame f[1]; + char buf[1024]; + + spa_pod_builder_prop(b, SPA_PROP_params, 0); + spa_pod_builder_push_struct(b, &f[0]); + + spa_pod_builder_string(b, SPA_KEY_AUDIO_CHANNELS); + spa_pod_builder_int(b, state->default_channels); + + spa_pod_builder_string(b, SPA_KEY_AUDIO_RATE); + spa_pod_builder_int(b, state->default_rate); + + spa_pod_builder_string(b, SPA_KEY_AUDIO_FORMAT); + spa_pod_builder_string(b, + spa_debug_type_find_short_name(spa_type_audio_format, + state->default_format)); + + position_to_string(&state->default_pos, buf, sizeof(buf)); + spa_pod_builder_string(b, SPA_KEY_AUDIO_POSITION); + spa_pod_builder_string(b, buf); + + uint32_array_to_string(state->allowed_rates, state->n_allowed_rates, + buf, sizeof(buf)); + spa_pod_builder_string(b, SPA_KEY_AUDIO_ALLOWED_RATES); + spa_pod_builder_string(b, buf); + + spa_pod_builder_string(b, "api.alsa.period-size"); + spa_pod_builder_int(b, state->default_period_size); + + spa_pod_builder_string(b, "api.alsa.period-num"); + spa_pod_builder_int(b, state->default_period_num); + + spa_pod_builder_string(b, "api.alsa.headroom"); + spa_pod_builder_int(b, state->default_headroom); + + spa_pod_builder_string(b, "api.alsa.start-delay"); + spa_pod_builder_int(b, state->default_start_delay); + + spa_pod_builder_string(b, "api.alsa.disable-mmap"); + spa_pod_builder_bool(b, state->disable_mmap); + + spa_pod_builder_string(b, "api.alsa.disable-batch"); + spa_pod_builder_bool(b, state->disable_batch); + + spa_pod_builder_string(b, "api.alsa.use-chmap"); + spa_pod_builder_bool(b, state->props.use_chmap); + + spa_pod_builder_string(b, "api.alsa.multi-rate"); + spa_pod_builder_bool(b, state->multi_rate); + + spa_pod_builder_string(b, "latency.internal.rate"); + spa_pod_builder_int(b, state->process_latency.rate); + + spa_pod_builder_string(b, "latency.internal.ns"); + spa_pod_builder_long(b, state->process_latency.ns); + + spa_pod_builder_string(b, "clock.name"); + spa_pod_builder_string(b, state->clock_name); + + spa_pod_builder_pop(b, &f[0]); + return 0; +} + +int spa_alsa_parse_prop_params(struct state *state, struct spa_pod *params) +{ + struct spa_pod_parser prs; + struct spa_pod_frame f; + int changed = 0; + + if (params == NULL) + return 0; + + spa_pod_parser_pod(&prs, params); + if (spa_pod_parser_push_struct(&prs, &f) < 0) + return 0; + + while (true) { + const char *name; + struct spa_pod *pod; + char value[512]; + + if (spa_pod_parser_get_string(&prs, &name) < 0) + break; + + if (spa_pod_parser_get_pod(&prs, &pod) < 0) + break; + if (spa_pod_is_string(pod)) { + spa_pod_copy_string(pod, sizeof(value), value); + } else if (spa_pod_is_int(pod)) { + snprintf(value, sizeof(value), "%d", + SPA_POD_VALUE(struct spa_pod_int, pod)); + } else if (spa_pod_is_long(pod)) { + snprintf(value, sizeof(value), "%"PRIi64, + SPA_POD_VALUE(struct spa_pod_long, pod)); + } else if (spa_pod_is_bool(pod)) { + snprintf(value, sizeof(value), "%s", + SPA_POD_VALUE(struct spa_pod_bool, pod) ? + "true" : "false"); + } else + continue; + + spa_log_info(state->log, "key:'%s' val:'%s'", name, value); + alsa_set_param(state, name, value); + changed++; + } + if (changed > 0) { + state->info.change_mask |= SPA_NODE_CHANGE_MASK_PARAMS; + state->params[NODE_Props].user++; + } + return changed; +} + +#define CHECK(s,msg,...) if ((err = (s)) < 0) { spa_log_error(state->log, msg ": %s", ##__VA_ARGS__, snd_strerror(err)); return err; } + +static ssize_t log_write(void *cookie, const char *buf, size_t size) +{ + struct state *state = cookie; + int len; + + while (size > 0) { + len = strcspn(buf, "\n"); + if (len > 0) + spa_log_debug(state->log, "%.*s", (int)len, buf); + buf += len + 1; + size -= len + 1; + } + return size; +} + +static cookie_io_functions_t io_funcs = { + .write = log_write, +}; + +int spa_alsa_init(struct state *state, const struct spa_dict *info) +{ + uint32_t i; + int err; + + snd_config_update_free_global(); + + state->multi_rate = true; + for (i = 0; info && i < info->n_items; i++) { + const char *k = info->items[i].key; + const char *s = info->items[i].value; + if (spa_streq(k, SPA_KEY_API_ALSA_PATH)) { + snprintf(state->props.device, 63, "%s", s); + } else if (spa_streq(k, SPA_KEY_API_ALSA_PCM_CARD)) { + state->card_index = atoi(s); + } else if (spa_streq(k, SPA_KEY_API_ALSA_OPEN_UCM)) { + state->open_ucm = spa_atob(s); + } else if (spa_streq(k, "clock.quantum-limit")) { + spa_atou32(s, &state->quantum_limit, 0); + } else { + alsa_set_param(state, k, s); + } + } + if (state->clock_name[0] == '\0') + snprintf(state->clock_name, sizeof(state->clock_name), + "api.alsa.%s-%u", + state->stream == SND_PCM_STREAM_PLAYBACK ? "p" : "c", + state->card_index); + + if (state->stream == SND_PCM_STREAM_PLAYBACK) { + state->is_iec958 = spa_strstartswith(state->props.device, "iec958"); + state->is_hdmi = spa_strstartswith(state->props.device, "hdmi"); + state->iec958_codecs |= 1ULL << SPA_AUDIO_IEC958_CODEC_PCM; + } + + state->card = ensure_card(state->card_index, state->open_ucm); + if (state->card == NULL) { + spa_log_error(state->log, "can't create card %u", state->card_index); + return -errno; + } + state->log_file = fopencookie(state, "w", io_funcs); + if (state->log_file == NULL) { + spa_log_error(state->log, "can't create log file"); + return -errno; + } + CHECK(snd_output_stdio_attach(&state->output, state->log_file, 0), "attach failed"); + + state->rate_limit.interval = 2 * SPA_NSEC_PER_SEC; + state->rate_limit.burst = 1; + + return 0; +} + +int spa_alsa_clear(struct state *state) +{ + int err; + + release_card(state->card); + + state->card = NULL; + state->card_index = SPA_ID_INVALID; + + if ((err = snd_output_close(state->output)) < 0) + spa_log_warn(state->log, "output close failed: %s", snd_strerror(err)); + fclose(state->log_file); + + return err; +} + +int spa_alsa_open(struct state *state, const char *params) +{ + int err; + struct props *props = &state->props; + char device_name[256]; + + if (state->opened) + return 0; + + spa_scnprintf(device_name, sizeof(device_name), "%s%s%s", + state->card->ucm_prefix ? state->card->ucm_prefix : "", + props->device, params ? params : ""); + + spa_log_info(state->log, "%p: ALSA device open '%s' %s", state, device_name, + state->stream == SND_PCM_STREAM_CAPTURE ? "capture" : "playback"); + CHECK(snd_pcm_open(&state->hndl, + device_name, + state->stream, + SND_PCM_NONBLOCK | + SND_PCM_NO_AUTO_RESAMPLE | + SND_PCM_NO_AUTO_CHANNELS | SND_PCM_NO_AUTO_FORMAT), "'%s': %s open failed", + device_name, + state->stream == SND_PCM_STREAM_CAPTURE ? "capture" : "playback"); + + if ((err = spa_system_timerfd_create(state->data_system, + CLOCK_MONOTONIC, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK)) < 0) + goto error_exit_close; + + state->timerfd = err; + + if (state->clock) + spa_scnprintf(state->clock->name, sizeof(state->clock->name), + "%s", state->clock_name); + state->opened = true; + state->sample_count = 0; + state->sample_time = 0; + + return 0; + +error_exit_close: + spa_log_info(state->log, "%p: Device '%s' closing: %s", state, state->props.device, + spa_strerror(err)); + snd_pcm_close(state->hndl); + return err; +} + +int spa_alsa_close(struct state *state) +{ + int err = 0; + + if (!state->opened) + return 0; + + spa_alsa_pause(state); + + spa_log_info(state->log, "%p: Device '%s' closing", state, state->props.device); + if ((err = snd_pcm_close(state->hndl)) < 0) + spa_log_warn(state->log, "%s: close failed: %s", state->props.device, + snd_strerror(err)); + + spa_system_close(state->data_system, state->timerfd); + + if (state->have_format) + state->card->format_ref--; + + state->have_format = false; + state->opened = false; + + return err; +} + +struct format_info { + uint32_t spa_format; + uint32_t spa_pformat; + snd_pcm_format_t format; +}; + +static const struct format_info format_info[] = { + { SPA_AUDIO_FORMAT_UNKNOWN, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_UNKNOWN}, + { SPA_AUDIO_FORMAT_F32_LE, SPA_AUDIO_FORMAT_F32P, SND_PCM_FORMAT_FLOAT_LE}, + { SPA_AUDIO_FORMAT_F32_BE, SPA_AUDIO_FORMAT_F32P, SND_PCM_FORMAT_FLOAT_BE}, + { SPA_AUDIO_FORMAT_S32_LE, SPA_AUDIO_FORMAT_S32P, SND_PCM_FORMAT_S32_LE}, + { SPA_AUDIO_FORMAT_S32_BE, SPA_AUDIO_FORMAT_S32P, SND_PCM_FORMAT_S32_BE}, + { SPA_AUDIO_FORMAT_S24_32_LE, SPA_AUDIO_FORMAT_S24_32P, SND_PCM_FORMAT_S24_LE}, + { SPA_AUDIO_FORMAT_S24_32_BE, SPA_AUDIO_FORMAT_S24_32P, SND_PCM_FORMAT_S24_BE}, + { SPA_AUDIO_FORMAT_S24_LE, SPA_AUDIO_FORMAT_S24P, SND_PCM_FORMAT_S24_3LE}, + { SPA_AUDIO_FORMAT_S24_BE, SPA_AUDIO_FORMAT_S24P, SND_PCM_FORMAT_S24_3BE}, + { SPA_AUDIO_FORMAT_S16_LE, SPA_AUDIO_FORMAT_S16P, SND_PCM_FORMAT_S16_LE}, + { SPA_AUDIO_FORMAT_S16_BE, SPA_AUDIO_FORMAT_S16P, SND_PCM_FORMAT_S16_BE}, + { SPA_AUDIO_FORMAT_S8, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_S8}, + { SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8P, SND_PCM_FORMAT_U8}, + { SPA_AUDIO_FORMAT_U16_LE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U16_LE}, + { SPA_AUDIO_FORMAT_U16_BE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U16_BE}, + { SPA_AUDIO_FORMAT_U24_32_LE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U24_LE}, + { SPA_AUDIO_FORMAT_U24_32_BE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U24_BE}, + { SPA_AUDIO_FORMAT_U24_LE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U24_3LE}, + { SPA_AUDIO_FORMAT_U24_BE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U24_3BE}, + { SPA_AUDIO_FORMAT_U32_LE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U32_LE}, + { SPA_AUDIO_FORMAT_U32_BE, SPA_AUDIO_FORMAT_UNKNOWN, SND_PCM_FORMAT_U32_BE}, + { SPA_AUDIO_FORMAT_F64_LE, SPA_AUDIO_FORMAT_F64P, SND_PCM_FORMAT_FLOAT64_LE}, + { SPA_AUDIO_FORMAT_F64_BE, SPA_AUDIO_FORMAT_F64P, SND_PCM_FORMAT_FLOAT64_BE}, +}; + +static snd_pcm_format_t spa_format_to_alsa(uint32_t format, bool *planar) +{ + SPA_FOR_EACH_ELEMENT_VAR(format_info, i) { + *planar = i->spa_pformat == format; + if (i->spa_format == format || *planar) + return i->format; + } + return SND_PCM_FORMAT_UNKNOWN; +} + +struct chmap_info { + enum snd_pcm_chmap_position pos; + enum spa_audio_channel channel; +}; + +static const struct chmap_info chmap_info[] = { + [SND_CHMAP_UNKNOWN] = { SND_CHMAP_UNKNOWN, SPA_AUDIO_CHANNEL_UNKNOWN }, + [SND_CHMAP_NA] = { SND_CHMAP_NA, SPA_AUDIO_CHANNEL_NA }, + [SND_CHMAP_MONO] = { SND_CHMAP_MONO, SPA_AUDIO_CHANNEL_MONO }, + [SND_CHMAP_FL] = { SND_CHMAP_FL, SPA_AUDIO_CHANNEL_FL }, + [SND_CHMAP_FR] = { SND_CHMAP_FR, SPA_AUDIO_CHANNEL_FR }, + [SND_CHMAP_RL] = { SND_CHMAP_RL, SPA_AUDIO_CHANNEL_RL }, + [SND_CHMAP_RR] = { SND_CHMAP_RR, SPA_AUDIO_CHANNEL_RR }, + [SND_CHMAP_FC] = { SND_CHMAP_FC, SPA_AUDIO_CHANNEL_FC }, + [SND_CHMAP_LFE] = { SND_CHMAP_LFE, SPA_AUDIO_CHANNEL_LFE }, + [SND_CHMAP_SL] = { SND_CHMAP_SL, SPA_AUDIO_CHANNEL_SL }, + [SND_CHMAP_SR] = { SND_CHMAP_SR, SPA_AUDIO_CHANNEL_SR }, + [SND_CHMAP_RC] = { SND_CHMAP_RC, SPA_AUDIO_CHANNEL_RC }, + [SND_CHMAP_FLC] = { SND_CHMAP_FLC, SPA_AUDIO_CHANNEL_FLC }, + [SND_CHMAP_FRC] = { SND_CHMAP_FRC, SPA_AUDIO_CHANNEL_FRC }, + [SND_CHMAP_RLC] = { SND_CHMAP_RLC, SPA_AUDIO_CHANNEL_RLC }, + [SND_CHMAP_RRC] = { SND_CHMAP_RRC, SPA_AUDIO_CHANNEL_RRC }, + [SND_CHMAP_FLW] = { SND_CHMAP_FLW, SPA_AUDIO_CHANNEL_FLW }, + [SND_CHMAP_FRW] = { SND_CHMAP_FRW, SPA_AUDIO_CHANNEL_FRW }, + [SND_CHMAP_FLH] = { SND_CHMAP_FLH, SPA_AUDIO_CHANNEL_FLH }, + [SND_CHMAP_FCH] = { SND_CHMAP_FCH, SPA_AUDIO_CHANNEL_FCH }, + [SND_CHMAP_FRH] = { SND_CHMAP_FRH, SPA_AUDIO_CHANNEL_FRH }, + [SND_CHMAP_TC] = { SND_CHMAP_TC, SPA_AUDIO_CHANNEL_TC }, + [SND_CHMAP_TFL] = { SND_CHMAP_TFL, SPA_AUDIO_CHANNEL_TFL }, + [SND_CHMAP_TFR] = { SND_CHMAP_TFR, SPA_AUDIO_CHANNEL_TFR }, + [SND_CHMAP_TFC] = { SND_CHMAP_TFC, SPA_AUDIO_CHANNEL_TFC }, + [SND_CHMAP_TRL] = { SND_CHMAP_TRL, SPA_AUDIO_CHANNEL_TRL }, + [SND_CHMAP_TRR] = { SND_CHMAP_TRR, SPA_AUDIO_CHANNEL_TRR }, + [SND_CHMAP_TRC] = { SND_CHMAP_TRC, SPA_AUDIO_CHANNEL_TRC }, + [SND_CHMAP_TFLC] = { SND_CHMAP_TFLC, SPA_AUDIO_CHANNEL_TFLC }, + [SND_CHMAP_TFRC] = { SND_CHMAP_TFRC, SPA_AUDIO_CHANNEL_TFRC }, + [SND_CHMAP_TSL] = { SND_CHMAP_TSL, SPA_AUDIO_CHANNEL_TSL }, + [SND_CHMAP_TSR] = { SND_CHMAP_TSR, SPA_AUDIO_CHANNEL_TSR }, + [SND_CHMAP_LLFE] = { SND_CHMAP_LLFE, SPA_AUDIO_CHANNEL_LLFE }, + [SND_CHMAP_RLFE] = { SND_CHMAP_RLFE, SPA_AUDIO_CHANNEL_RLFE }, + [SND_CHMAP_BC] = { SND_CHMAP_BC, SPA_AUDIO_CHANNEL_BC }, + [SND_CHMAP_BLC] = { SND_CHMAP_BLC, SPA_AUDIO_CHANNEL_BLC }, + [SND_CHMAP_BRC] = { SND_CHMAP_BRC, SPA_AUDIO_CHANNEL_BRC }, +}; + +#define _M(ch) (1LL << SND_CHMAP_ ##ch) + +struct def_mask { + int channels; + uint64_t mask; +}; + +static const struct def_mask default_layouts[] = { + { 0, 0 }, + { 1, _M(MONO) }, + { 2, _M(FL) | _M(FR) }, + { 3, _M(FL) | _M(FR) | _M(LFE) }, + { 4, _M(FL) | _M(FR) | _M(RL) |_M(RR) }, + { 5, _M(FL) | _M(FR) | _M(RL) |_M(RR) | _M(FC) }, + { 6, _M(FL) | _M(FR) | _M(RL) |_M(RR) | _M(FC) | _M(LFE) }, + { 7, _M(FL) | _M(FR) | _M(RL) |_M(RR) | _M(SL) | _M(SR) | _M(FC) }, + { 8, _M(FL) | _M(FR) | _M(RL) |_M(RR) | _M(SL) | _M(SR) | _M(FC) | _M(LFE) }, +}; + +#define _C(ch) (SPA_AUDIO_CHANNEL_ ##ch) + +static const struct channel_map default_map[] = { + { 0, { 0, } } , + { 1, { _C(MONO), } }, + { 2, { _C(FL), _C(FR), } }, + { 3, { _C(FL), _C(FR), _C(LFE) } }, + { 4, { _C(FL), _C(FR), _C(RL), _C(RR), } }, + { 5, { _C(FL), _C(FR), _C(RL), _C(RR), _C(FC) } }, + { 6, { _C(FL), _C(FR), _C(RL), _C(RR), _C(FC), _C(LFE), } }, + { 7, { _C(FL), _C(FR), _C(RL), _C(RR), _C(FC), _C(SL), _C(SR), } }, + { 8, { _C(FL), _C(FR), _C(RL), _C(RR), _C(FC), _C(LFE), _C(SL), _C(SR), } }, +}; + +static enum spa_audio_channel chmap_position_to_channel(enum snd_pcm_chmap_position pos) +{ + return chmap_info[pos].channel; +} + +static void sanitize_map(snd_pcm_chmap_t* map) +{ + uint64_t mask = 0, p, dup = 0; + const struct def_mask *def; + uint32_t i, j, pos; + + for (i = 0; i < map->channels; i++) { + if (map->pos[i] > SND_CHMAP_LAST) + map->pos[i] = SND_CHMAP_UNKNOWN; + + p = 1LL << map->pos[i]; + if (mask & p) { + /* duplicate channel */ + for (j = 0; j <= i; j++) + if (map->pos[j] == map->pos[i]) + map->pos[j] = SND_CHMAP_UNKNOWN; + dup |= p; + p = 1LL << SND_CHMAP_UNKNOWN; + } + mask |= p; + } + if ((mask & (1LL << SND_CHMAP_UNKNOWN)) == 0) + return; + + def = &default_layouts[map->channels]; + + /* remove duplicates */ + mask &= ~dup; + /* keep unassigned channels */ + mask = def->mask & ~mask; + + pos = 0; + for (i = 0; i < map->channels; i++) { + if (map->pos[i] == SND_CHMAP_UNKNOWN) { + do { + mask >>= 1; + pos++; + } + while (mask != 0 && (mask & 1) == 0); + map->pos[i] = mask ? pos : 0; + } + + } +} + +static bool uint32_array_contains(uint32_t *vals, uint32_t n_vals, uint32_t val) +{ + uint32_t i; + for (i = 0; i < n_vals; i++) + if (vals[i] == val) + return true; + return false; +} + +static int add_rate(struct state *state, uint32_t scale, uint32_t interleave, bool all, uint32_t index, uint32_t *next, + uint32_t min_allowed_rate, snd_pcm_hw_params_t *params, struct spa_pod_builder *b) +{ + struct spa_pod_frame f[1]; + int err, dir; + unsigned int min, max; + struct spa_pod_choice *choice; + uint32_t rate; + + CHECK(snd_pcm_hw_params_get_rate_min(params, &min, &dir), "get_rate_min"); + CHECK(snd_pcm_hw_params_get_rate_max(params, &max, &dir), "get_rate_max"); + + spa_log_debug(state->log, "min:%u max:%u min-allowed:%u scale:%u interleave:%u all:%d", + min, max, min_allowed_rate, scale, interleave, all); + + min = SPA_MAX(min_allowed_rate * scale / interleave, min) * interleave / scale; + max = max * interleave / scale; + if (max < min) + return 0; + + if (!state->multi_rate && state->card->format_ref > 0) + rate = state->card->rate; + else + rate = state->default_rate; + + if (rate < min || rate > max) + rate = 0; + + if (rate != 0 && !all) + min = max = rate; + + if (rate == 0) + rate = state->position ? state->position->clock.rate.denom : DEFAULT_RATE; + + rate = SPA_CLAMP(rate, min, max); + + spa_log_debug(state->log, "rate:%u multi:%d card:%d def:%d", + rate, state->multi_rate, state->card->rate, state->default_rate); + + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_rate, 0); + + spa_pod_builder_push_choice(b, &f[0], SPA_CHOICE_None, 0); + choice = (struct spa_pod_choice*)spa_pod_builder_frame(b, &f[0]); + + if (state->n_allowed_rates > 0) { + uint32_t i, v, last = 0, count = 0; + + if (uint32_array_contains(state->allowed_rates, state->n_allowed_rates, rate)) { + spa_pod_builder_int(b, rate * scale); + count++; + } + for (i = 0; i < state->n_allowed_rates; i++) { + v = SPA_CLAMP(state->allowed_rates[i], min, max); + if (v != last && + uint32_array_contains(state->allowed_rates, state->n_allowed_rates, v)) { + spa_pod_builder_int(b, v * scale); + if (count == 0) + spa_pod_builder_int(b, v * scale); + count++; + } + last = v; + } + if (count > 1) + choice->body.type = SPA_CHOICE_Enum; + } else { + spa_pod_builder_int(b, rate * scale); + + if (min != max) { + spa_pod_builder_int(b, min * scale); + spa_pod_builder_int(b, max * scale); + choice->body.type = SPA_CHOICE_Range; + } + } + spa_pod_builder_pop(b, &f[0]); + + return 1; +} + +static int add_channels(struct state *state, bool all, uint32_t index, uint32_t *next, + snd_pcm_hw_params_t *params, struct spa_pod_builder *b) +{ + struct spa_pod_frame f[1]; + size_t i; + int err; + snd_pcm_t *hndl = state->hndl; + snd_pcm_chmap_query_t **maps; + unsigned int min, max; + + CHECK(snd_pcm_hw_params_get_channels_min(params, &min), "get_channels_min"); + CHECK(snd_pcm_hw_params_get_channels_max(params, &max), "get_channels_max"); + spa_log_debug(state->log, "channels (%d %d) default:%d all:%d", + min, max, state->default_channels, all); + + if (state->default_channels != 0 && !all) { + if (min < state->default_channels) + min = state->default_channels; + if (max > state->default_channels) + max = state->default_channels; + } + min = SPA_MIN(min, SPA_AUDIO_MAX_CHANNELS); + max = SPA_MIN(max, SPA_AUDIO_MAX_CHANNELS); + + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_channels, 0); + + if (state->props.use_chmap && (maps = snd_pcm_query_chmaps(hndl)) != NULL) { + uint32_t channel; + snd_pcm_chmap_t* map; + +skip_channels: + if (maps[index] == NULL) { + snd_pcm_free_chmaps(maps); + return 0; + } + map = &maps[index]->map; + + spa_log_debug(state->log, "map %d channels (%d %d)", map->channels, min, max); + + if (map->channels < min || map->channels > max) { + index = (*next)++; + goto skip_channels; + } + + sanitize_map(map); + spa_pod_builder_int(b, map->channels); + + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_position, 0); + spa_pod_builder_push_array(b, &f[0]); + for (i = 0; i < map->channels; i++) { + spa_log_debug(state->log, "%p: position %zd %d", state, i, map->pos[i]); + channel = chmap_position_to_channel(map->pos[i]); + spa_pod_builder_id(b, channel); + } + spa_pod_builder_pop(b, &f[0]); + + snd_pcm_free_chmaps(maps); + } + else { + const struct channel_map *map = NULL; + struct spa_pod_choice *choice; + + if (index > 0) + return 0; + + spa_pod_builder_push_choice(b, &f[0], SPA_CHOICE_None, 0); + choice = (struct spa_pod_choice*)spa_pod_builder_frame(b, &f[0]); + spa_pod_builder_int(b, max); + if (min != max) { + spa_pod_builder_int(b, min); + spa_pod_builder_int(b, max); + choice->body.type = SPA_CHOICE_Range; + } + spa_pod_builder_pop(b, &f[0]); + + if (min == max) { + if (state->default_pos.channels == min) + map = &state->default_pos; + else if (min == max && min <= 8) + map = &default_map[min]; + } + if (map) { + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_position, 0); + spa_pod_builder_push_array(b, &f[0]); + for (i = 0; i < map->channels; i++) { + spa_log_debug(state->log, "%p: position %zd %d", state, i, map->pos[i]); + spa_pod_builder_id(b, map->pos[i]); + } + spa_pod_builder_pop(b, &f[0]); + } + } + return 1; +} + +static void debug_hw_params(struct state *state, const char *prefix, snd_pcm_hw_params_t *params) +{ + if (SPA_UNLIKELY(spa_log_level_topic_enabled(state->log, SPA_LOG_TOPIC_DEFAULT, SPA_LOG_LEVEL_DEBUG))) { + spa_log_debug(state->log, "%s:", prefix); + snd_pcm_hw_params_dump(params, state->output); + fflush(state->log_file); + } +} +static int enum_pcm_formats(struct state *state, uint32_t index, uint32_t *next, + struct spa_pod **result, struct spa_pod_builder *b) +{ + int res, err; + size_t j; + snd_pcm_t *hndl; + snd_pcm_hw_params_t *params; + struct spa_pod_frame f[2]; + snd_pcm_format_mask_t *fmask; + snd_pcm_access_mask_t *amask; + unsigned int rrate, rchannels; + struct spa_pod_choice *choice; + + hndl = state->hndl; + snd_pcm_hw_params_alloca(¶ms); + CHECK(snd_pcm_hw_params_any(hndl, params), "Broken configuration: no configurations available"); + + debug_hw_params(state, __func__, params); + + CHECK(snd_pcm_hw_params_set_rate_resample(hndl, params, 0), "set_rate_resample"); + + if (state->default_channels != 0) { + rchannels = state->default_channels; + CHECK(snd_pcm_hw_params_set_channels_near(hndl, params, &rchannels), "set_channels"); + if (state->default_channels != rchannels) { + spa_log_warn(state->log, "%s: Channels doesn't match (requested %u, got %u)", + state->props.device, state->default_channels, rchannels); + } + } + if (state->default_rate != 0) { + rrate = state->default_rate; + CHECK(snd_pcm_hw_params_set_rate_near(hndl, params, &rrate, 0), "set_rate_near"); + if (state->default_rate != rrate) { + spa_log_warn(state->log, "%s: Rate doesn't match (requested %u, got %u)", + state->props.device, state->default_rate, rrate); + } + } + + spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat); + spa_pod_builder_add(b, + SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio), + SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw), + 0); + + snd_pcm_format_mask_alloca(&fmask); + snd_pcm_hw_params_get_format_mask(params, fmask); + + snd_pcm_access_mask_alloca(&amask); + snd_pcm_hw_params_get_access_mask(params, amask); + + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_format, 0); + + spa_pod_builder_push_choice(b, &f[1], SPA_CHOICE_None, 0); + choice = (struct spa_pod_choice*)spa_pod_builder_frame(b, &f[1]); + + j = 0; + SPA_FOR_EACH_ELEMENT_VAR(format_info, fi) { + if (fi->format == SND_PCM_FORMAT_UNKNOWN) + continue; + + if (snd_pcm_format_mask_test(fmask, fi->format)) { + if ((snd_pcm_access_mask_test(amask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED) || + snd_pcm_access_mask_test(amask, SND_PCM_ACCESS_RW_NONINTERLEAVED)) && + fi->spa_pformat != SPA_AUDIO_FORMAT_UNKNOWN && + (state->default_format == 0 || state->default_format == fi->spa_pformat)) { + if (j++ == 0) + spa_pod_builder_id(b, fi->spa_pformat); + spa_pod_builder_id(b, fi->spa_pformat); + } + if ((snd_pcm_access_mask_test(amask, SND_PCM_ACCESS_MMAP_INTERLEAVED) || + snd_pcm_access_mask_test(amask, SND_PCM_ACCESS_RW_INTERLEAVED)) && + (state->default_format == 0 || state->default_format == fi->spa_format)) { + if (j++ == 0) + spa_pod_builder_id(b, fi->spa_format); + spa_pod_builder_id(b, fi->spa_format); + } + } + } + if (j == 0) { + char buf[1024]; + int i, r, offs; + + for (i = 0, offs = 0; i <= SND_PCM_FORMAT_LAST; i++) { + if (snd_pcm_format_mask_test(fmask, (snd_pcm_format_t)i)) { + r = snprintf(&buf[offs], sizeof(buf) - offs, + "%s ", snd_pcm_format_name((snd_pcm_format_t)i)); + if (r < 0 || r + offs >= (int)sizeof(buf)) + return -ENOSPC; + offs += r; + } + } + spa_log_warn(state->log, "%s: no format found (def:%d) formats:%s", + state->props.device, state->default_format, buf); + + for (i = 0, offs = 0; i <= SND_PCM_ACCESS_LAST; i++) { + if (snd_pcm_access_mask_test(amask, (snd_pcm_access_t)i)) { + r = snprintf(&buf[offs], sizeof(buf) - offs, + "%s ", snd_pcm_access_name((snd_pcm_access_t)i)); + if (r < 0 || r + offs >= (int)sizeof(buf)) + return -ENOSPC; + offs += r; + } + } + spa_log_warn(state->log, "%s: access:%s", state->props.device, buf); + return -ENOTSUP; + } + if (j > 1) + choice->body.type = SPA_CHOICE_Enum; + spa_pod_builder_pop(b, &f[1]); + + if ((res = add_rate(state, 1, 1, false, index & 0xffff, next, 0, params, b)) != 1) + return res; + + if ((res = add_channels(state, false, index & 0xffff, next, params, b)) != 1) + return res; + + *result = spa_pod_builder_pop(b, &f[0]); + return 1; +} + +static bool codec_supported(uint32_t codec, unsigned int chmax, unsigned int rmax) +{ + switch (codec) { + case SPA_AUDIO_IEC958_CODEC_PCM: + case SPA_AUDIO_IEC958_CODEC_DTS: + case SPA_AUDIO_IEC958_CODEC_AC3: + case SPA_AUDIO_IEC958_CODEC_MPEG: + case SPA_AUDIO_IEC958_CODEC_MPEG2_AAC: + if (chmax >= 2) + return true; + break; + case SPA_AUDIO_IEC958_CODEC_EAC3: + if (rmax >= 48000 * 4 && chmax >= 2) + return true; + break; + case SPA_AUDIO_IEC958_CODEC_TRUEHD: + case SPA_AUDIO_IEC958_CODEC_DTSHD: + if (chmax >= 8) + return true; + break; + } + return false; +} + +static int enum_iec958_formats(struct state *state, uint32_t index, uint32_t *next, + struct spa_pod **result, struct spa_pod_builder *b) +{ + int res, err, dir; + snd_pcm_t *hndl; + snd_pcm_hw_params_t *params; + struct spa_pod_frame f[2]; + unsigned int rmin, rmax; + unsigned int chmin, chmax; + uint32_t i, c, codecs[16], n_codecs; + + if ((index & 0xffff) > 0) + return 0; + + if (!(state->is_iec958 || state->is_hdmi)) + return 0; + if (state->iec958_codecs == 0) + return 0; + + hndl = state->hndl; + snd_pcm_hw_params_alloca(¶ms); + CHECK(snd_pcm_hw_params_any(hndl, params), "Broken configuration: no configurations available"); + + debug_hw_params(state, __func__, params); + + CHECK(snd_pcm_hw_params_set_rate_resample(hndl, params, 0), "set_rate_resample"); + + spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat); + spa_pod_builder_add(b, + SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio), + SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_iec958), + 0); + + CHECK(snd_pcm_hw_params_get_channels_min(params, &chmin), "get_channels_min"); + CHECK(snd_pcm_hw_params_get_channels_max(params, &chmax), "get_channels_max"); + spa_log_debug(state->log, "channels (%d %d)", chmin, chmax); + + CHECK(snd_pcm_hw_params_get_rate_min(params, &rmin, &dir), "get_rate_min"); + CHECK(snd_pcm_hw_params_get_rate_max(params, &rmax, &dir), "get_rate_max"); + spa_log_debug(state->log, "rate (%d %d)", rmin, rmax); + + if (state->default_rate != 0) { + if (rmin < state->default_rate) + rmin = state->default_rate; + if (rmax > state->default_rate) + rmax = state->default_rate; + } + + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_iec958Codec, 0); + spa_pod_builder_push_choice(b, &f[1], SPA_CHOICE_Enum, 0); + + n_codecs = spa_alsa_get_iec958_codecs(state, codecs, SPA_N_ELEMENTS(codecs)); + for (i = 0, c = 0; i < n_codecs; i++) { + if (!codec_supported(codecs[i], chmax, rmax)) + continue; + if (c++ == 0) + spa_pod_builder_id(b, codecs[i]); + spa_pod_builder_id(b, codecs[i]); + } + spa_pod_builder_pop(b, &f[1]); + + if ((res = add_rate(state, 1, 1, true, index & 0xffff, next, 0, params, b)) != 1) + return res; + + (*next)++; + *result = spa_pod_builder_pop(b, &f[0]); + return 1; +} + +static int enum_dsd_formats(struct state *state, uint32_t index, uint32_t *next, + struct spa_pod **result, struct spa_pod_builder *b) +{ + int res, err; + snd_pcm_t *hndl; + snd_pcm_hw_params_t *params; + snd_pcm_format_mask_t *fmask; + struct spa_pod_frame f[2]; + int32_t interleave; + + if ((index & 0xffff) > 0) + return 0; + + hndl = state->hndl; + snd_pcm_hw_params_alloca(¶ms); + CHECK(snd_pcm_hw_params_any(hndl, params), "Broken configuration: no configurations available"); + + debug_hw_params(state, __func__, params); + + snd_pcm_format_mask_alloca(&fmask); + snd_pcm_hw_params_get_format_mask(params, fmask); + + if (snd_pcm_format_mask_test(fmask, SND_PCM_FORMAT_DSD_U32_BE)) + interleave = 4; + else if (snd_pcm_format_mask_test(fmask, SND_PCM_FORMAT_DSD_U32_LE)) + interleave = -4; + else if (snd_pcm_format_mask_test(fmask, SND_PCM_FORMAT_DSD_U16_BE)) + interleave = 2; + else if (snd_pcm_format_mask_test(fmask, SND_PCM_FORMAT_DSD_U16_LE)) + interleave = -2; + else if (snd_pcm_format_mask_test(fmask, SND_PCM_FORMAT_DSD_U8)) + interleave = 1; + else + return 0; + + CHECK(snd_pcm_hw_params_set_rate_resample(hndl, params, 0), "set_rate_resample"); + + spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat); + spa_pod_builder_add(b, + SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio), + SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_dsd), + 0); + + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_bitorder, 0); + spa_pod_builder_id(b, SPA_PARAM_BITORDER_msb); + + spa_pod_builder_prop(b, SPA_FORMAT_AUDIO_interleave, 0); + spa_pod_builder_int(b, interleave); + + /* Use a lower rate limit of 352800 (= 44100 * 64 / 8). This is because in + * PipeWire, DSD rates are given in bytes, not bits, so 352800 corresponds + * to the bit rate of DSD64. (The "64" in DSD64 means "64 times the rate + * of 44.1 kHz".) Some hardware may report rates lower than that, for example + * 176400. This would correspond to "DSD32" (which does not exist). Trying + * to use such a rate with DSD hardware does not work and may cause undefined + * behavior in said hardware. */ + if ((res = add_rate(state, 8, SPA_ABS(interleave), true, index & 0xffff, + next, 44100, params, b)) != 1) + return res; + + if ((res = add_channels(state, true, index & 0xffff, next, params, b)) != 1) + return res; + + *result = spa_pod_builder_pop(b, &f[0]); + return 1; +} + +int +spa_alsa_enum_format(struct state *state, int seq, uint32_t start, uint32_t num, + const struct spa_pod *filter) +{ + uint8_t buffer[4096]; + struct spa_pod_builder b = { 0 }; + struct spa_pod *fmt; + int err, res; + bool opened; + struct spa_result_node_params result; + uint32_t count = 0; + + spa_log_debug(state->log, "opened:%d format:%d started:%d", state->opened, + state->have_format, state->started); + + opened = state->opened; + if (!state->started && state->have_format) + spa_alsa_close(state); + if ((err = spa_alsa_open(state, NULL)) < 0) + return err; + + result.id = SPA_PARAM_EnumFormat; + result.next = start; + + next: + result.index = result.next++; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + + if (result.index < 0x10000) { + if ((res = enum_pcm_formats(state, result.index, &result.next, &fmt, &b)) != 1) { + result.next = 0x10000; + goto next; + } + } + else if (result.index < 0x20000) { + if ((res = enum_iec958_formats(state, result.index, &result.next, &fmt, &b)) != 1) { + result.next = 0x20000; + goto next; + } + } + else if (result.index < 0x30000) { + if ((res = enum_dsd_formats(state, result.index, &result.next, &fmt, &b)) != 1) { + result.next = 0x30000; + goto next; + } + } + else + goto enum_end; + + if (spa_pod_filter(&b, &result.param, fmt, filter) < 0) + goto next; + + spa_node_emit_result(&state->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result); + + if (++count != num) + goto next; + + enum_end: + res = 0; + if (!opened) + spa_alsa_close(state); + return res; +} + +int spa_alsa_set_format(struct state *state, struct spa_audio_info *fmt, uint32_t flags) +{ + unsigned int rrate, rchannels, val, rscale = 1; + snd_pcm_uframes_t period_size; + int err, dir; + snd_pcm_hw_params_t *params; + snd_pcm_format_t rformat; + snd_pcm_access_mask_t *amask; + snd_pcm_t *hndl; + unsigned int periods; + bool match = true, planar = false, is_batch; + char spdif_params[128] = ""; + + spa_log_debug(state->log, "opened:%d format:%d started:%d", state->opened, + state->have_format, state->started); + + state->use_mmap = !state->disable_mmap; + + switch (fmt->media_subtype) { + case SPA_MEDIA_SUBTYPE_raw: + { + struct spa_audio_info_raw *f = &fmt->info.raw; + rrate = f->rate; + rchannels = f->channels; + rformat = spa_format_to_alsa(f->format, &planar); + break; + } + case SPA_MEDIA_SUBTYPE_iec958: + { + struct spa_audio_info_iec958 *f = &fmt->info.iec958; + unsigned aes3; + + spa_log_info(state->log, "using IEC958 Codec:%s rate:%d", + spa_debug_type_find_short_name(spa_type_audio_iec958_codec, f->codec), + f->rate); + + rformat = SND_PCM_FORMAT_S16_LE; + rchannels = 2; + rrate = f->rate; + + switch (f->codec) { + case SPA_AUDIO_IEC958_CODEC_PCM: + case SPA_AUDIO_IEC958_CODEC_DTS: + case SPA_AUDIO_IEC958_CODEC_AC3: + case SPA_AUDIO_IEC958_CODEC_MPEG: + case SPA_AUDIO_IEC958_CODEC_MPEG2_AAC: + break; + case SPA_AUDIO_IEC958_CODEC_EAC3: + /* EAC3 has 3 rates, 32, 44.1 and 48KHz. We need to + * open the device in 4x that rate. Some clients + * already multiply (mpv,..) others don't (vlc). */ + if (rrate <= 48000) + rrate *= 4; + break; + case SPA_AUDIO_IEC958_CODEC_TRUEHD: + case SPA_AUDIO_IEC958_CODEC_DTSHD: + rchannels = 8; + break; + default: + return -ENOTSUP; + } + switch (rrate) { + case 22050: aes3 = IEC958_AES3_CON_FS_22050; break; + case 24000: aes3 = IEC958_AES3_CON_FS_24000; break; + case 32000: aes3 = IEC958_AES3_CON_FS_32000; break; + case 44100: aes3 = IEC958_AES3_CON_FS_44100; break; + case 48000: aes3 = IEC958_AES3_CON_FS_48000; break; + case 88200: aes3 = IEC958_AES3_CON_FS_88200; break; + case 96000: aes3 = IEC958_AES3_CON_FS_96000; break; + case 176400: aes3 = IEC958_AES3_CON_FS_176400; break; + case 192000: aes3 = IEC958_AES3_CON_FS_192000; break; + case 768000: aes3 = IEC958_AES3_CON_FS_768000; break; + default: aes3 = IEC958_AES3_CON_FS_NOTID; break; + } + spa_scnprintf(spdif_params, sizeof(spdif_params), + ",AES0=0x%x,AES1=0x%x,AES2=0x%x,AES3=0x%x", + IEC958_AES0_CON_EMPHASIS_NONE | IEC958_AES0_NONAUDIO, + IEC958_AES1_CON_ORIGINAL | IEC958_AES1_CON_PCM_CODER, + 0, aes3); + break; + } + case SPA_MEDIA_SUBTYPE_dsd: + { + struct spa_audio_info_dsd *f = &fmt->info.dsd; + + rrate = f->rate; + rchannels = f->channels; + + switch (f->interleave) { + case 4: + rformat = SND_PCM_FORMAT_DSD_U32_BE; + rrate /= 4; + rscale = 4; + break; + case -4: + rformat = SND_PCM_FORMAT_DSD_U32_LE; + rrate /= 4; + rscale = 4; + break; + case 2: + rformat = SND_PCM_FORMAT_DSD_U16_BE; + rrate /= 2; + rscale = 2; + break; + case -2: + rformat = SND_PCM_FORMAT_DSD_U16_LE; + rrate /= 2; + rscale = 2; + break; + case 1: + rformat = SND_PCM_FORMAT_DSD_U8; + rscale = 1; + break; + default: + return -ENOTSUP; + } + break; + } + default: + return -ENOTSUP; + } + + if (rformat == SND_PCM_FORMAT_UNKNOWN) { + spa_log_warn(state->log, "%s: unknown format", + state->props.device); + return -EINVAL; + } + + if (!state->started && state->have_format) + spa_alsa_close(state); + if ((err = spa_alsa_open(state, spdif_params)) < 0) + return err; + + hndl = state->hndl; + + snd_pcm_hw_params_alloca(¶ms); + /* choose all parameters */ + CHECK(snd_pcm_hw_params_any(hndl, params), "Broken configuration for playback: no configurations available"); + + debug_hw_params(state, __func__, params); + + /* set hardware resampling, no resample */ + CHECK(snd_pcm_hw_params_set_rate_resample(hndl, params, 0), "set_rate_resample"); + + /* set the interleaved/planar read/write format */ + snd_pcm_access_mask_alloca(&amask); + snd_pcm_hw_params_get_access_mask(params, amask); + + if (state->use_mmap) { + if ((err = snd_pcm_hw_params_set_access(hndl, params, + planar ? SND_PCM_ACCESS_MMAP_NONINTERLEAVED + : SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0) { + spa_log_debug(state->log, "%p: MMAP not possible: %s", state, + snd_strerror(err)); + state->use_mmap = false; + } + } + if (!state->use_mmap) { + if ((err = snd_pcm_hw_params_set_access(hndl, params, + planar ? SND_PCM_ACCESS_RW_NONINTERLEAVED + : SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) { + spa_log_error(state->log, "%s: RW not possible: %s", + state->props.device, snd_strerror(err)); + return err; + } + } + + /* set the sample format */ + spa_log_debug(state->log, "%p: Stream parameters are %iHz fmt:%s access:%s-%s channels:%i", + state, rrate, snd_pcm_format_name(rformat), + state->use_mmap ? "mmap" : "rw", + planar ? "planar" : "interleaved", rchannels); + CHECK(snd_pcm_hw_params_set_format(hndl, params, rformat), "set_format"); + + /* set the count of channels */ + val = rchannels; + CHECK(snd_pcm_hw_params_set_channels_near(hndl, params, &val), "set_channels"); + if (rchannels != val) { + spa_log_warn(state->log, "%s: Channels doesn't match (requested %u, got %u)", + state->props.device, rchannels, val); + if (!SPA_FLAG_IS_SET(flags, SPA_NODE_PARAM_FLAG_NEAREST)) + return -EINVAL; + if (fmt->media_subtype != SPA_MEDIA_SUBTYPE_raw) + return -EINVAL; + rchannels = val; + fmt->info.raw.channels = rchannels; + match = false; + } + + if (!state->multi_rate && + state->card->format_ref > 0 && + state->card->rate != rrate) { + spa_log_error(state->log, "%p: card already opened at rate:%i", + state, state->card->rate); + return -EINVAL; + } + + /* set the stream rate */ + val = rrate; + CHECK(snd_pcm_hw_params_set_rate_near(hndl, params, &val, 0), "set_rate_near"); + if (rrate != val) { + spa_log_warn(state->log, "%s: Rate doesn't match (requested %iHz, got %iHz)", + state->props.device, rrate, val); + if (!SPA_FLAG_IS_SET(flags, SPA_NODE_PARAM_FLAG_NEAREST)) + return -EINVAL; + if (fmt->media_subtype != SPA_MEDIA_SUBTYPE_raw) + return -EINVAL; + rrate = val; + fmt->info.raw.rate = rrate; + match = false; + } + if (rchannels == 0 || rrate == 0) { + spa_log_error(state->log, "%s: invalid channels:%d or rate:%d", + state->props.device, rchannels, rrate); + return -EIO; + } + + state->format = rformat; + state->channels = rchannels; + state->rate = rrate; + state->frame_size = snd_pcm_format_physical_width(rformat) / 8; + state->frame_scale = rscale; + state->planar = planar; + state->blocks = 1; + if (planar) + state->blocks *= rchannels; + else + state->frame_size *= rchannels; + + state->have_format = true; + if (state->card->format_ref++ == 0) + state->card->rate = rrate; + + dir = 0; + period_size = state->default_period_size; + is_batch = snd_pcm_hw_params_is_batch(params) && + !state->disable_batch; + + if (is_batch) { + if (period_size == 0) + period_size = state->position ? state->position->clock.duration : DEFAULT_PERIOD; + if (period_size == 0) + period_size = DEFAULT_PERIOD; + /* batch devices get their hw pointers updated every period. Make + * the period smaller and add one period of headroom. Limit the + * period size to our default so that we don't create too much + * headroom. */ + period_size = SPA_MIN(period_size, DEFAULT_PERIOD) / 2; + spa_log_info(state->log, "%s: batch mode, period_size:%ld", + state->props.device, period_size); + } else { + if (period_size == 0) + period_size = DEFAULT_PERIOD; + /* disable ALSA wakeups, we use a timer */ + if (snd_pcm_hw_params_can_disable_period_wakeup(params)) + CHECK(snd_pcm_hw_params_set_period_wakeup(hndl, params, 0), "set_period_wakeup"); + } + + CHECK(snd_pcm_hw_params_set_period_size_near(hndl, params, &period_size, &dir), "set_period_size_near"); + + if (period_size == 0) { + spa_log_error(state->log, "%s: invalid period_size 0 (driver error?)", state->props.device); + return -EIO; + } + + state->period_frames = period_size; + + if (state->default_period_num != 0) { + periods = state->default_period_num; + CHECK(snd_pcm_hw_params_set_periods_near(hndl, params, &periods, &dir), "set_periods"); + state->buffer_frames = period_size * periods; + } else { + CHECK(snd_pcm_hw_params_get_buffer_size_max(params, &state->buffer_frames), "get_buffer_size_max"); + + state->buffer_frames = SPA_MIN(state->buffer_frames, state->quantum_limit * 4)* state->frame_scale; + + CHECK(snd_pcm_hw_params_set_buffer_size_min(hndl, params, &state->buffer_frames), "set_buffer_size_min"); + CHECK(snd_pcm_hw_params_set_buffer_size_near(hndl, params, &state->buffer_frames), "set_buffer_size_near"); + periods = state->buffer_frames / period_size; + } + if (state->buffer_frames == 0) { + spa_log_error(state->log, "%s: invalid buffer_frames 0 (driver error?)", state->props.device); + return -EIO; + } + + state->headroom = state->default_headroom; + if (is_batch) + state->headroom += period_size; + + if (spa_strstartswith(state->props.device, "a52") || + spa_strstartswith(state->props.device, "dca")) + state->min_delay = SPA_MIN(2048u, state->buffer_frames); + else + state->min_delay = 0; + + state->headroom = SPA_MIN(state->headroom, state->buffer_frames); + state->start_delay = state->default_start_delay; + + state->latency[state->port_direction].min_rate = + state->latency[state->port_direction].max_rate = + SPA_MAX(state->min_delay, state->headroom); + + spa_log_info(state->log, "%s (%s): format:%s access:%s-%s rate:%d channels:%d " + "buffer frames %lu, period frames %lu, periods %u, frame_size %zd " + "headroom %u start-delay:%u", + state->props.device, + state->stream == SND_PCM_STREAM_CAPTURE ? "capture" : "playback", + snd_pcm_format_name(state->format), + state->use_mmap ? "mmap" : "rw", + planar ? "planar" : "interleaved", + state->rate, state->channels, state->buffer_frames, state->period_frames, + periods, state->frame_size, state->headroom, state->start_delay); + + /* write the parameters to device */ + CHECK(snd_pcm_hw_params(hndl, params), "set_hw_params"); + + return match ? 0 : 1; +} + +static int set_swparams(struct state *state) +{ + snd_pcm_t *hndl = state->hndl; + int err = 0; + snd_pcm_sw_params_t *params; + + snd_pcm_sw_params_alloca(¶ms); + + /* get the current params */ + CHECK(snd_pcm_sw_params_current(hndl, params), "sw_params_current"); + + CHECK(snd_pcm_sw_params_set_tstamp_mode(hndl, params, SND_PCM_TSTAMP_ENABLE), + "sw_params_set_tstamp_mode"); + CHECK(snd_pcm_sw_params_set_tstamp_type(hndl, params, SND_PCM_TSTAMP_TYPE_MONOTONIC), + "sw_params_set_tstamp_type"); +#if 0 + snd_pcm_uframes_t boundary; + 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"); +#endif + + /* start the transfer */ + CHECK(snd_pcm_sw_params_set_start_threshold(hndl, params, LONG_MAX), "set_start_threshold"); + + CHECK(snd_pcm_sw_params_set_period_event(hndl, params, 0), "set_period_event"); + + /* write the parameters to the playback device */ + CHECK(snd_pcm_sw_params(hndl, params), "sw_params"); + + if (SPA_UNLIKELY(spa_log_level_topic_enabled(state->log, SPA_LOG_TOPIC_DEFAULT, SPA_LOG_LEVEL_DEBUG))) { + spa_log_debug(state->log, "state after sw_params:"); + snd_pcm_dump(hndl, state->output); + fflush(state->log_file); + } + + return 0; +} + +static int set_timeout(struct state *state, uint64_t time) +{ + struct itimerspec ts; + + ts.it_value.tv_sec = time / SPA_NSEC_PER_SEC; + ts.it_value.tv_nsec = time % SPA_NSEC_PER_SEC; + ts.it_interval.tv_sec = 0; + ts.it_interval.tv_nsec = 0; + spa_system_timerfd_settime(state->data_system, + state->timerfd, SPA_FD_TIMER_ABSTIME, &ts, NULL); + return 0; +} + +int spa_alsa_silence(struct state *state, snd_pcm_uframes_t silence) +{ + snd_pcm_t *hndl = state->hndl; + const snd_pcm_channel_area_t *my_areas; + snd_pcm_uframes_t frames, offset; + int i, res; + + if (state->use_mmap) { + frames = state->buffer_frames; + + if (SPA_UNLIKELY((res = snd_pcm_mmap_begin(hndl, &my_areas, &offset, &frames)) < 0)) { + spa_log_error(state->log, "%s: snd_pcm_mmap_begin error: %s", + state->props.device, snd_strerror(res)); + return res; + } + silence = SPA_MIN(silence, frames); + + spa_log_trace_fp(state->log, "%p: frames:%ld offset:%ld silence %ld", + state, frames, offset, silence); + snd_pcm_areas_silence(my_areas, offset, state->channels, silence, state->format); + + if (SPA_UNLIKELY((res = snd_pcm_mmap_commit(hndl, offset, silence)) < 0)) { + spa_log_error(state->log, "%s: snd_pcm_mmap_commit error: %s", + state->props.device, snd_strerror(res)); + return res; + } + } else { + uint8_t buffer[silence * state->frame_size]; + memset(buffer, 0, silence * state->frame_size); + + if (state->planar) { + void *bufs[state->channels]; + for (i = 0; i < state->channels; i++) + bufs[i] = buffer; + snd_pcm_writen(hndl, bufs, silence); + } else { + snd_pcm_writei(hndl, buffer, silence); + } + } + return 0; +} + +static inline int do_start(struct state *state) +{ + int res; + if (SPA_UNLIKELY(!state->alsa_started)) { + spa_log_trace(state->log, "%p: snd_pcm_start", state); + if ((res = snd_pcm_start(state->hndl)) < 0) { + spa_log_error(state->log, "%s: snd_pcm_start: %s", + state->props.device, snd_strerror(res)); + return res; + } + state->alsa_started = true; + } + return 0; +} + +static int alsa_recover(struct state *state, int err) +{ + int res, st; + snd_pcm_status_t *status; + + snd_pcm_status_alloca(&status); + if (SPA_UNLIKELY((res = snd_pcm_status(state->hndl, status)) < 0)) { + spa_log_error(state->log, "%s: snd_pcm_status error: %s", + state->props.device, snd_strerror(res)); + goto recover; + } + + st = snd_pcm_status_get_state(status); + switch (st) { + case SND_PCM_STATE_XRUN: + { + struct timeval now, trigger, diff; + uint64_t delay, missing; + + snd_pcm_status_get_tstamp (status, &now); + snd_pcm_status_get_trigger_tstamp (status, &trigger); + timersub(&now, &trigger, &diff); + + delay = SPA_TIMEVAL_TO_USEC(&diff); + missing = delay * state->rate / SPA_USEC_PER_SEC; + + spa_log_trace(state->log, "%p: xrun of %"PRIu64" usec %"PRIu64, + state, delay, missing); + + spa_node_call_xrun(&state->callbacks, + SPA_TIMEVAL_TO_USEC(&trigger), delay, NULL); + + state->sample_count += missing ? missing : state->threshold; + break; + } + case SND_PCM_STATE_SUSPENDED: + spa_log_info(state->log, "%s: recover from state %s", + state->props.device, snd_pcm_state_name(st)); + res = snd_pcm_resume(state->hndl); + if (res >= 0) + return res; + err = -ESTRPIPE; + break; + default: + spa_log_error(state->log, "%s: recover from error state %s", + state->props.device, snd_pcm_state_name(st)); + break; + } + +recover: + if (SPA_UNLIKELY((res = snd_pcm_recover(state->hndl, err, true)) < 0)) { + spa_log_error(state->log, "%s: snd_pcm_recover error: %s", + state->props.device, snd_strerror(res)); + return res; + } + spa_dll_init(&state->dll); + state->alsa_recovering = true; + state->alsa_started = false; + + if (state->stream == SND_PCM_STREAM_PLAYBACK) + spa_alsa_silence(state, state->start_delay + state->threshold + state->headroom); + + return do_start(state); +} + +static int get_avail(struct state *state, uint64_t current_time) +{ + int res, missed; + snd_pcm_sframes_t avail; + + if (SPA_UNLIKELY((avail = snd_pcm_avail(state->hndl)) < 0)) { + if ((res = alsa_recover(state, avail)) < 0) + return res; + if ((avail = snd_pcm_avail(state->hndl)) < 0) { + if ((missed = ratelimit_test(&state->rate_limit, current_time)) >= 0) { + spa_log_warn(state->log, "%s: (%d missed) snd_pcm_avail after recover: %s", + state->props.device, missed, snd_strerror(avail)); + } + avail = state->threshold * 2; + } + } else { + state->alsa_recovering = false; + } + return avail; +} + +#if 0 +static int get_avail_htimestamp(struct state *state, uint64_t current_time) +{ + int res, missed; + snd_pcm_uframes_t avail; + snd_htimestamp_t tstamp; + uint64_t then; + + if ((res = snd_pcm_htimestamp(state->hndl, &avail, &tstamp)) < 0) { + if ((res = alsa_recover(state, avail)) < 0) + return res; + if ((res = snd_pcm_htimestamp(state->hndl, &avail, &tstamp)) < 0) { + if ((missed = ratelimit_test(&state->rate_limit, current_time)) >= 0) { + spa_log_warn(state->log, "%s: (%d missed) snd_pcm_htimestamp error: %s", + state->props.device, missed, snd_strerror(res)); + } + avail = state->threshold * 2; + } + } else { + state->alsa_recovering = false; + } + + if ((then = SPA_TIMESPEC_TO_NSEC(&tstamp)) != 0) { + if (then < current_time) + avail += (current_time - then) * state->rate / SPA_NSEC_PER_SEC; + else + avail -= (then - current_time) * state->rate / SPA_NSEC_PER_SEC; + } + return SPA_MIN(avail, state->buffer_frames); +} +#endif + +static int get_status(struct state *state, uint64_t current_time, + snd_pcm_uframes_t *delay, snd_pcm_uframes_t *target) +{ + int avail; + + if ((avail = get_avail(state, current_time)) < 0) + return avail; + + avail = SPA_MIN(avail, (int)state->buffer_frames); + + *target = state->threshold + state->headroom; + + if (state->resample && state->rate_match) { + state->delay = state->rate_match->delay; + state->read_size = state->rate_match->size; + } else { + state->delay = 0; + state->read_size = state->threshold; + } + + if (state->stream == SND_PCM_STREAM_PLAYBACK) { + *delay = state->buffer_frames - avail; + } else { + *delay = avail; + *target = SPA_MAX(*target, state->read_size); + } + *target = SPA_CLAMP(*target, state->min_delay, state->buffer_frames); + return 0; +} + +static int update_time(struct state *state, uint64_t current_time, snd_pcm_sframes_t delay, + snd_pcm_sframes_t target, bool follower) +{ + double err, corr; + int32_t diff; + + if (state->stream == SND_PCM_STREAM_PLAYBACK) + err = delay - target; + else + err = target - delay; + + if (SPA_UNLIKELY(state->dll.bw == 0.0)) { + spa_dll_set_bw(&state->dll, SPA_DLL_BW_MAX, state->threshold, state->rate); + state->next_time = current_time; + state->base_time = current_time; + } + diff = (int32_t) (state->last_threshold - state->threshold); + + if (SPA_UNLIKELY(diff != 0)) { + err -= diff; + spa_log_trace(state->log, "%p: follower:%d quantum change %d -> %d (%d) %f", + state, follower, state->last_threshold, state->threshold, diff, err); + state->last_threshold = state->threshold; + state->alsa_sync = true; + state->alsa_sync_warning = false; + } + if (err > state->max_error) { + err = state->max_error; + state->alsa_sync = true; + } else if (err < -state->max_error) { + err = -state->max_error; + state->alsa_sync = true; + } + + if (!follower || state->matching) + corr = spa_dll_update(&state->dll, err); + else + corr = 1.0; + + if (diff < 0) + state->next_time += diff / corr * 1e9 / state->rate; + + if (SPA_UNLIKELY((state->next_time - state->base_time) > BW_PERIOD)) { + state->base_time = state->next_time; + + spa_log_debug(state->log, "%s: follower:%d match:%d rate:%f " + "bw:%f thr:%u del:%ld target:%ld err:%f max:%f", + state->props.device, follower, state->matching, + corr, state->dll.bw, state->threshold, delay, target, + err, state->max_error); + } + + if (state->rate_match) { + if (state->stream == SND_PCM_STREAM_PLAYBACK) + state->rate_match->rate = corr; + else + state->rate_match->rate = 1.0/corr; + + SPA_FLAG_UPDATE(state->rate_match->flags, SPA_IO_RATE_MATCH_FLAG_ACTIVE, state->matching); + } + + state->next_time += state->threshold / corr * 1e9 / state->rate; + + if (SPA_LIKELY(!follower && state->clock)) { + state->clock->nsec = current_time; + state->clock->position += state->duration; + state->clock->duration = state->duration; + state->clock->delay = delay + state->delay; + state->clock->rate_diff = corr; + state->clock->next_nsec = state->next_time; + } + + spa_log_trace_fp(state->log, "%p: follower:%d %"PRIu64" %f %ld %f %f %u", + state, follower, current_time, corr, delay, err, state->threshold * corr, + state->threshold); + + return 0; +} + +static inline bool is_following(struct state *state) +{ + return state->position && state->clock && state->position->clock.id != state->clock->id; +} + +static int setup_matching(struct state *state) +{ + state->matching = state->following; + + if (state->position == NULL) + return -ENOTSUP; + + spa_log_debug(state->log, "driver clock:'%s' our clock:'%s'", + state->position->clock.name, state->clock_name); + + if (spa_streq(state->position->clock.name, state->clock_name)) + state->matching = false; + + state->resample = ((uint32_t)state->rate != state->rate_denom) || state->matching; + + spa_log_info(state->log, "driver clock:'%s'@%d our clock:'%s'@%d matching:%d resample:%d", + state->position->clock.name, state->rate_denom, + state->clock_name, state->rate, + state->matching, state->resample); + return 0; +} + +static inline void check_position_config(struct state *state) +{ + if (SPA_UNLIKELY(state->position == NULL)) + return; + + if (SPA_UNLIKELY((state->duration != state->position->clock.duration) || + (state->rate_denom != state->position->clock.rate.denom))) { + state->duration = state->position->clock.duration; + state->rate_denom = state->position->clock.rate.denom; + state->threshold = SPA_SCALE32_UP(state->duration, state->rate, state->rate_denom); + state->max_error = SPA_MAX(256.0f, state->threshold / 2.0f); + state->resample = ((uint32_t)state->rate != state->rate_denom) || state->matching; + state->alsa_sync = true; + } +} + +int spa_alsa_write(struct state *state) +{ + snd_pcm_t *hndl = state->hndl; + const snd_pcm_channel_area_t *my_areas; + snd_pcm_uframes_t written, frames, offset, off, to_write, total_written, max_write; + snd_pcm_sframes_t commitres; + int res = 0, missed; + size_t frame_size = state->frame_size; + + check_position_config(state); + + max_write = state->buffer_frames; + + if (state->following && state->alsa_started) { + uint64_t current_time; + snd_pcm_uframes_t delay, target; + + current_time = state->position->clock.nsec; + + if (SPA_UNLIKELY((res = get_status(state, current_time, &delay, &target)) < 0)) + return res; + + if (SPA_UNLIKELY((res = update_time(state, current_time, delay, target, true)) < 0)) + return res; + + if (SPA_UNLIKELY(state->alsa_sync)) { + enum spa_log_level lev; + + if (SPA_UNLIKELY(state->alsa_sync_warning)) + lev = SPA_LOG_LEVEL_WARN; + else + lev = SPA_LOG_LEVEL_INFO; + + if ((missed = ratelimit_test(&state->rate_limit, current_time)) >= 0) { + spa_log_lev(state->log, lev, "%s: follower delay:%ld target:%ld thr:%u, " + "resync (%d missed)", state->props.device, delay, + target, state->threshold, missed); + } + + if (delay > target) + snd_pcm_rewind(state->hndl, delay - target); + else if (delay < target) + spa_alsa_silence(state, target - delay); + delay = target; + state->alsa_sync = false; + } else + state->alsa_sync_warning = true; + } + + total_written = 0; +again: + + frames = max_write; + if (state->use_mmap && frames > 0) { + if (SPA_UNLIKELY((res = snd_pcm_mmap_begin(hndl, &my_areas, &offset, &frames)) < 0)) { + spa_log_error(state->log, "%s: snd_pcm_mmap_begin error: %s", + state->props.device, snd_strerror(res)); + return res; + } + spa_log_trace_fp(state->log, "%p: begin %ld %ld %d", + state, offset, frames, state->threshold); + off = offset; + } else { + off = 0; + } + + to_write = frames; + written = 0; + + while (!spa_list_is_empty(&state->ready) && to_write > 0) { + size_t n_bytes, n_frames; + struct buffer *b; + struct spa_data *d; + uint32_t i, offs, size, last_offset; + + b = spa_list_first(&state->ready, struct buffer, link); + d = b->buf->datas; + + offs = d[0].chunk->offset + state->ready_offset; + last_offset = d[0].chunk->size; + size = last_offset - state->ready_offset; + + offs = SPA_MIN(offs, d[0].maxsize); + size = SPA_MIN(d[0].maxsize - offs, size); + + n_frames = SPA_MIN(size / frame_size, to_write); + n_bytes = n_frames * frame_size; + + if (SPA_LIKELY(state->use_mmap)) { + for (i = 0; i < b->buf->n_datas; i++) { + spa_memcpy(SPA_PTROFF(my_areas[i].addr, off * frame_size, void), + SPA_PTROFF(d[i].data, offs, void), n_bytes); + } + } else { + void *bufs[b->buf->n_datas]; + for (i = 0; i < b->buf->n_datas; i++) + bufs[i] = SPA_PTROFF(d[i].data, offs, void); + + if (state->planar) + snd_pcm_writen(hndl, bufs, n_frames); + else + snd_pcm_writei(hndl, bufs[0], n_frames); + } + + state->ready_offset += n_bytes; + + if (state->ready_offset >= last_offset) { + spa_list_remove(&b->link); + SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT); + state->io->buffer_id = b->id; + spa_log_trace_fp(state->log, "%p: reuse buffer %u", state, b->id); + + spa_node_call_reuse_buffer(&state->callbacks, 0, b->id); + + state->ready_offset = 0; + } + written += n_frames; + off += n_frames; + to_write -= n_frames; + } + + spa_log_trace_fp(state->log, "%p: commit %ld %ld %"PRIi64, + state, offset, written, state->sample_count); + total_written += written; + + if (state->use_mmap && written > 0) { + if (SPA_UNLIKELY((commitres = snd_pcm_mmap_commit(hndl, offset, written)) < 0)) { + spa_log_error(state->log, "%s: snd_pcm_mmap_commit error: %s", + state->props.device, snd_strerror(commitres)); + if (commitres != -EPIPE && commitres != -ESTRPIPE) + return res; + } + if (commitres > 0 && written != (snd_pcm_uframes_t) commitres) { + spa_log_warn(state->log, "%s: mmap_commit wrote %ld instead of %ld", + state->props.device, commitres, written); + } + } + + if (!spa_list_is_empty(&state->ready) && written > 0) + goto again; + + state->sample_count += total_written; + + if (SPA_UNLIKELY(!state->alsa_started && (total_written > 0 || frames == 0))) + do_start(state); + + return 0; +} + +void spa_alsa_recycle_buffer(struct state *this, uint32_t buffer_id) +{ + struct buffer *b = &this->buffers[buffer_id]; + + if (SPA_FLAG_IS_SET(b->flags, BUFFER_FLAG_OUT)) { + spa_log_trace_fp(this->log, "%p: recycle buffer %u", this, buffer_id); + spa_list_append(&this->free, &b->link); + SPA_FLAG_CLEAR(b->flags, BUFFER_FLAG_OUT); + } +} + +static snd_pcm_uframes_t +push_frames(struct state *state, + const snd_pcm_channel_area_t *my_areas, + snd_pcm_uframes_t offset, + snd_pcm_uframes_t frames) +{ + snd_pcm_uframes_t total_frames = 0; + + if (spa_list_is_empty(&state->free)) { + spa_log_warn(state->log, "%s: no more buffers", state->props.device); + total_frames = frames; + } else { + size_t n_bytes, left, frame_size = state->frame_size; + struct buffer *b; + struct spa_data *d; + uint32_t i, avail, l0, l1; + + b = spa_list_first(&state->free, struct buffer, link); + spa_list_remove(&b->link); + + if (b->h) { + b->h->seq = state->sample_count; + b->h->pts = state->next_time; + b->h->dts_offset = 0; + } + + d = b->buf->datas; + + avail = d[0].maxsize / frame_size; + total_frames = SPA_MIN(avail, frames); + n_bytes = total_frames * frame_size; + + if (my_areas) { + left = state->buffer_frames - offset; + l0 = SPA_MIN(n_bytes, left * frame_size); + l1 = n_bytes - l0; + + for (i = 0; i < b->buf->n_datas; i++) { + spa_memcpy(d[i].data, + SPA_PTROFF(my_areas[i].addr, offset * frame_size, void), + l0); + if (SPA_UNLIKELY(l1 > 0)) + spa_memcpy(SPA_PTROFF(d[i].data, l0, void), + my_areas[i].addr, + l1); + d[i].chunk->offset = 0; + d[i].chunk->size = n_bytes; + d[i].chunk->stride = frame_size; + } + } else { + void *bufs[b->buf->n_datas]; + for (i = 0; i < b->buf->n_datas; i++) { + bufs[i] = d[i].data; + d[i].chunk->offset = 0; + d[i].chunk->size = n_bytes; + d[i].chunk->stride = frame_size; + } + if (state->planar) { + snd_pcm_readn(state->hndl, bufs, total_frames); + } else { + snd_pcm_readi(state->hndl, bufs[0], total_frames); + } + } + spa_log_trace_fp(state->log, "%p: wrote %ld frames into buffer %d", + state, total_frames, b->id); + + spa_list_append(&state->ready, &b->link); + } + return total_frames; +} + + +int spa_alsa_read(struct state *state) +{ + snd_pcm_t *hndl = state->hndl; + snd_pcm_uframes_t total_read = 0, to_read, max_read; + const snd_pcm_channel_area_t *my_areas; + snd_pcm_uframes_t read, frames, offset; + snd_pcm_sframes_t commitres; + int res = 0, missed; + + check_position_config(state); + + max_read = state->buffer_frames; + + if (state->following && state->alsa_started) { + uint64_t current_time; + snd_pcm_uframes_t avail, delay, target; + + current_time = state->position->clock.nsec; + + if ((res = get_status(state, current_time, &delay, &target)) < 0) + return res; + + avail = delay; + + if (SPA_UNLIKELY((res = update_time(state, current_time, delay, target, true)) < 0)) + return res; + + if (state->alsa_sync) { + enum spa_log_level lev; + + if (SPA_UNLIKELY(state->alsa_sync_warning)) + lev = SPA_LOG_LEVEL_WARN; + else + lev = SPA_LOG_LEVEL_INFO; + + if ((missed = ratelimit_test(&state->rate_limit, current_time)) >= 0) { + spa_log_lev(state->log, lev, "%s: follower delay:%ld target:%ld thr:%u, " + "resync (%d missed)", state->props.device, delay, + target, state->threshold, missed); + } + + if (delay < target) + max_read = target - delay; + else if (delay > target) + snd_pcm_forward(state->hndl, delay - target); + delay = target; + state->alsa_sync = false; + } else + state->alsa_sync_warning = true; + + if (avail < state->read_size) + max_read = 0; + } + + frames = SPA_MIN(max_read, state->read_size); + + if (state->use_mmap) { + to_read = state->buffer_frames; + if ((res = snd_pcm_mmap_begin(hndl, &my_areas, &offset, &to_read)) < 0) { + spa_log_error(state->log, "%s: snd_pcm_mmap_begin error: %s", + state->props.device, snd_strerror(res)); + return res; + } + spa_log_trace_fp(state->log, "%p: begin offs:%ld frames:%ld to_read:%ld thres:%d", state, + offset, frames, to_read, state->threshold); + } else { + my_areas = NULL; + offset = 0; + } + + if (frames > 0) { + read = push_frames(state, my_areas, offset, frames); + total_read += read; + } else { + spa_alsa_skip(state); + total_read += state->read_size; + read = 0; + } + + if (state->use_mmap && read > 0) { + spa_log_trace_fp(state->log, "%p: commit offs:%ld read:%ld count:%"PRIi64, state, + offset, read, state->sample_count); + if ((commitres = snd_pcm_mmap_commit(hndl, offset, read)) < 0) { + spa_log_error(state->log, "%s: snd_pcm_mmap_commit error %lu %lu: %s", + state->props.device, frames, read, snd_strerror(commitres)); + if (commitres != -EPIPE && commitres != -ESTRPIPE) + return res; + } + if (commitres > 0 && read != (snd_pcm_uframes_t) commitres) { + spa_log_warn(state->log, "%s: mmap_commit read %ld instead of %ld", + state->props.device, commitres, read); + } + } + + state->sample_count += total_read; + + return 0; +} + +int spa_alsa_skip(struct state *state) +{ + struct buffer *b; + struct spa_data *d; + uint32_t i, avail, total_frames, n_bytes, frames; + + if (spa_list_is_empty(&state->free)) { + spa_log_warn(state->log, "%s: no more buffers", state->props.device); + return -EPIPE; + } + + frames = state->read_size; + + b = spa_list_first(&state->free, struct buffer, link); + spa_list_remove(&b->link); + + d = b->buf->datas; + + avail = d[0].maxsize / state->frame_size; + total_frames = SPA_MIN(avail, frames); + n_bytes = total_frames * state->frame_size; + + for (i = 0; i < b->buf->n_datas; i++) { + memset(d[i].data, 0, n_bytes); + d[i].chunk->offset = 0; + d[i].chunk->size = n_bytes; + d[i].chunk->stride = state->frame_size; + } + spa_list_append(&state->ready, &b->link); + + return 0; +} + + +static int handle_play(struct state *state, uint64_t current_time, + snd_pcm_uframes_t delay, snd_pcm_uframes_t target) +{ + int res; + + if (state->alsa_started && SPA_UNLIKELY(delay > target + state->max_error)) { + spa_log_trace(state->log, "%p: early wakeup %lu %lu", state, delay, target); + if (delay > target * 3) + delay = target * 3; + state->next_time = current_time + (delay - target) * SPA_NSEC_PER_SEC / state->rate; + return -EAGAIN; + } + + if (SPA_UNLIKELY((res = update_time(state, current_time, delay, target, false)) < 0)) + return res; + + if (spa_list_is_empty(&state->ready)) { + struct spa_io_buffers *io = state->io; + + spa_log_trace_fp(state->log, "%p: %d", state, io->status); + + io->status = SPA_STATUS_NEED_DATA; + + res = spa_node_call_ready(&state->callbacks, SPA_STATUS_NEED_DATA); + } + else { + res = spa_alsa_write(state); + } + return res; +} + +static int handle_capture(struct state *state, uint64_t current_time, + snd_pcm_uframes_t delay, snd_pcm_uframes_t target) +{ + int res; + struct spa_io_buffers *io; + + if (SPA_UNLIKELY(delay < target)) { + spa_log_trace(state->log, "%p: early wakeup %ld %ld", state, delay, target); + state->next_time = current_time + (target - delay) * SPA_NSEC_PER_SEC / + state->rate; + return -EAGAIN; + } + + if (SPA_UNLIKELY(res = update_time(state, current_time, delay, target, false)) < 0) + return res; + + if ((res = spa_alsa_read(state)) < 0) + return res; + + if (spa_list_is_empty(&state->ready)) + return 0; + + io = state->io; + if (io != NULL && + (io->status != SPA_STATUS_HAVE_DATA || state->rate_match != NULL)) { + struct buffer *b; + + if (io->buffer_id < state->n_buffers) + spa_alsa_recycle_buffer(state, io->buffer_id); + + b = spa_list_first(&state->ready, struct buffer, link); + spa_list_remove(&b->link); + SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT); + + io->buffer_id = b->id; + io->status = SPA_STATUS_HAVE_DATA; + spa_log_trace_fp(state->log, "%p: output buffer:%d", state, b->id); + } + spa_node_call_ready(&state->callbacks, SPA_STATUS_HAVE_DATA); + return 0; +} + +static void alsa_on_timeout_event(struct spa_source *source) +{ + struct state *state = source->data; + snd_pcm_uframes_t delay, target; + uint64_t expire, current_time; + int res; + + if (SPA_LIKELY(state->started)) { + if (SPA_UNLIKELY((res = spa_system_timerfd_read(state->data_system, + state->timerfd, &expire)) < 0)) { + /* we can get here when the timer is changed since the last + * timerfd wakeup, for example by do_reassign_follower() executed + * in the same epoll wakeup cycle */ + if (res != -EAGAIN) + spa_log_warn(state->log, "%p: error reading timerfd: %s", + state, spa_strerror(res)); + return; + } + } + + check_position_config(state); + + current_time = state->next_time; + + if (SPA_UNLIKELY(get_status(state, current_time, &delay, &target) < 0)) { + spa_log_error(state->log, "get_status error"); + state->next_time += state->threshold * 1e9 / state->rate; + goto done; + } + +#ifndef FASTPATH + if (SPA_UNLIKELY(spa_log_level_topic_enabled(state->log, SPA_LOG_TOPIC_DEFAULT, SPA_LOG_LEVEL_TRACE))) { + struct timespec now; + uint64_t nsec; + if (spa_system_clock_gettime(state->data_system, CLOCK_MONOTONIC, &now) < 0) + return; + nsec = SPA_TIMESPEC_TO_NSEC(&now); + spa_log_trace_fp(state->log, "%p: timeout %lu %lu %"PRIu64" %"PRIu64" %"PRIi64 + " %d %"PRIi64, state, delay, target, nsec, nsec, + nsec - current_time, state->threshold, state->sample_count); + } +#endif + + if (state->stream == SND_PCM_STREAM_PLAYBACK) + handle_play(state, current_time, delay, target); + else + handle_capture(state, current_time, delay, target); + +done: + if (state->next_time > current_time + SPA_NSEC_PER_SEC || + current_time > state->next_time + SPA_NSEC_PER_SEC) { + spa_log_error(state->log, "%s: impossible timeout %lu %lu %"PRIu64" %"PRIu64" %"PRIi64 + " %d %"PRIi64, state->props.device, delay, target, current_time, state->next_time, + state->next_time - current_time, state->threshold, state->sample_count); + state->next_time = current_time + state->threshold * 1e9 / state->rate; + } + set_timeout(state, state->next_time); +} + +static void reset_buffers(struct state *this) +{ + uint32_t i; + + spa_list_init(&this->free); + spa_list_init(&this->ready); + + for (i = 0; i < this->n_buffers; i++) { + struct buffer *b = &this->buffers[i]; + if (this->stream == SND_PCM_STREAM_PLAYBACK) { + SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT); + spa_node_call_reuse_buffer(&this->callbacks, 0, b->id); + } else { + spa_list_append(&this->free, &b->link); + SPA_FLAG_CLEAR(b->flags, BUFFER_FLAG_OUT); + } + } +} + +static int set_timers(struct state *state) +{ + struct timespec now; + int res; + + if ((res = spa_system_clock_gettime(state->data_system, CLOCK_MONOTONIC, &now)) < 0) + return res; + state->next_time = SPA_TIMESPEC_TO_NSEC(&now); + + if (state->following) { + set_timeout(state, 0); + } else { + set_timeout(state, state->next_time); + } + return 0; +} + +int spa_alsa_start(struct state *state) +{ + int err; + + if (state->started) + return 0; + + if (state->position) { + state->duration = state->position->clock.duration; + state->rate_denom = state->position->clock.rate.denom; + } + else { + spa_log_warn(state->log, "%s: no position set, using defaults", + state->props.device); + state->duration = 1024; + state->rate_denom = state->rate; + } + if (state->rate_denom == 0) { + spa_log_error(state->log, "%s: unset rate_denom", state->props.device); + return -EIO; + } + if (state->duration == 0) { + spa_log_error(state->log, "%s: unset duration", state->props.device); + return -EIO; + } + + state->following = is_following(state); + setup_matching(state); + + spa_dll_init(&state->dll); + state->threshold = SPA_SCALE32_UP(state->duration, state->rate, state->rate_denom); + state->last_threshold = state->threshold; + state->max_error = SPA_MAX(256.0f, state->threshold / 2.0f); + + spa_log_debug(state->log, "%p: start %d duration:%d rate:%d follower:%d match:%d resample:%d", + state, state->threshold, state->duration, state->rate_denom, + state->following, state->matching, state->resample); + + CHECK(set_swparams(state), "swparams"); + + if ((err = snd_pcm_prepare(state->hndl)) < 0 && err != -EBUSY) { + spa_log_error(state->log, "%s: snd_pcm_prepare error: %s", + state->props.device, snd_strerror(err)); + return err; + } + + state->source.func = alsa_on_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); + + reset_buffers(state); + state->alsa_sync = true; + state->alsa_sync_warning = false; + state->alsa_recovering = false; + state->alsa_started = false; + + /* start capture now, playback will start after first write */ + if (state->stream == SND_PCM_STREAM_PLAYBACK) + spa_alsa_silence(state, state->start_delay + state->threshold + state->headroom); + else if ((err = do_start(state)) < 0) + return err; + + set_timers(state); + + state->started = true; + + return 0; +} + +static int do_reassign_follower(struct spa_loop *loop, + bool async, + uint32_t seq, + const void *data, + size_t size, + void *user_data) +{ + struct state *state = user_data; + set_timers(state); + spa_dll_init(&state->dll); + return 0; +} + +int spa_alsa_reassign_follower(struct state *state) +{ + bool following, freewheel; + + if (!state->started) + return 0; + + following = is_following(state); + if (following != state->following) { + spa_log_debug(state->log, "%p: reassign follower %d->%d", state, state->following, following); + state->following = following; + spa_loop_invoke(state->data_loop, do_reassign_follower, 0, NULL, 0, true, state); + } + setup_matching(state); + + freewheel = state->position && + SPA_FLAG_IS_SET(state->position->clock.flags, SPA_IO_CLOCK_FLAG_FREEWHEEL); + + if (state->freewheel != freewheel) { + spa_log_debug(state->log, "%p: freewheel %d->%d", state, state->freewheel, freewheel); + state->freewheel = freewheel; + if (freewheel) + snd_pcm_pause(state->hndl, 1); + else + snd_pcm_pause(state->hndl, 0); + } + + state->alsa_sync_warning = false; + return 0; +} + +static int do_remove_source(struct spa_loop *loop, + bool async, + uint32_t seq, + const void *data, + size_t size, + void *user_data) +{ + struct state *state = user_data; + struct itimerspec ts; + + spa_loop_remove_source(state->data_loop, &state->source); + ts.it_value.tv_sec = 0; + ts.it_value.tv_nsec = 0; + ts.it_interval.tv_sec = 0; + ts.it_interval.tv_nsec = 0; + spa_system_timerfd_settime(state->data_system, state->timerfd, 0, &ts, NULL); + + return 0; +} + +int spa_alsa_pause(struct state *state) +{ + int err; + + if (!state->started) + return 0; + + spa_log_debug(state->log, "%p: pause", state); + + spa_loop_invoke(state->data_loop, do_remove_source, 0, NULL, 0, true, state); + + if ((err = snd_pcm_drop(state->hndl)) < 0) + spa_log_error(state->log, "%s: snd_pcm_drop %s", state->props.device, + snd_strerror(err)); + + state->started = false; + + return 0; +} |