aplay: Refactor code related to ALSA PCM

Author: borine

test/test-utils-aplay.c

@@ -291,14 +291,14 @@ CK_START_TEST(test_play_dbus_signals) {
 				"Used configuration for 12:34:56:78:9A:BC"), NULL);
 	/* check proper sample rate for CVSD codec */
 	ck_assert_ptr_ne(strstr(output,
-				"Sample rate: 8000 Hz"), NULL);
+				"ALSA PCM sample rate: 8000 Hz"), NULL);
 
 #if ENABLE_MSBC
 	ck_assert_ptr_ne(strstr(output,
 				"Used configuration for 12:34:56:78:9A:BC"), NULL);
 	/* check proper sample rate for mSBC codec */
 	ck_assert_ptr_ne(strstr(output,
-				"Sample rate: 16000 Hz"), NULL);
+				"ALSA PCM sample rate: 16000 Hz"), NULL);
 #endif
 
 	spawn_close(&sp_ba_aplay, NULL);

utils/aplay/alsa-pcm.c

@@ -1,6 +1,6 @@
 /*
  * BlueALSA - alsa-pcm.c
- * Copyright (c) 2016-2023 Arkadiusz Bokowy
+ * Copyright (c) 2016-2025 Arkadiusz Bokowy
  *
  * This file is a part of bluez-alsa.
  *
@@ -14,55 +14,64 @@
 #include <stdlib.h>
 #include <string.h>
 
-static int alsa_pcm_set_hw_params(snd_pcm_t *pcm, snd_pcm_format_t format, int channels,
-		int rate, unsigned int *buffer_time, unsigned int *period_time, char **msg) {
+#include "shared/log.h"
+
+static int alsa_pcm_set_hw_params(
+		struct alsa_pcm *pcm,
+		snd_pcm_format_t format,
+		unsigned int channels,
+		unsigned int rate,
+		unsigned int *buffer_time,
+		unsigned int *period_time,
+		char **msg) {
 
 	const snd_pcm_access_t access = SND_PCM_ACCESS_RW_INTERLEAVED;
+	snd_pcm_t *snd_pcm = pcm->pcm;
 	snd_pcm_hw_params_t *params;
 	char buf[256];
 	int dir;
 	int err;
 
 	snd_pcm_hw_params_alloca(&params);
 
-	if ((err = snd_pcm_hw_params_any(pcm, params)) < 0) {
+	if ((err = snd_pcm_hw_params_any(snd_pcm, params)) < 0) {
 		snprintf(buf, sizeof(buf), "Set all possible ranges: %s", snd_strerror(err));
 		goto fail;
 	}
 
-	if ((err = snd_pcm_hw_params_set_access(pcm, params, access)) != 0) {
+	if ((err = snd_pcm_hw_params_set_access(snd_pcm, params, access)) != 0) {
 		snprintf(buf, sizeof(buf), "Set assess type: %s: %s", snd_strerror(err), snd_pcm_access_name(access));
 		goto fail;
 	}
 
-	if ((err = snd_pcm_hw_params_set_format(pcm, params, format)) != 0) {
+	if ((err = snd_pcm_hw_params_set_format(snd_pcm, params, format)) != 0) {
 		snprintf(buf, sizeof(buf), "Set format: %s: %s", snd_strerror(err), snd_pcm_format_name(format));
 		goto fail;
 	}
 
-	if ((err = snd_pcm_hw_params_set_channels(pcm, params, channels)) != 0) {
+	if ((err = snd_pcm_hw_params_set_channels(snd_pcm, params, channels)) != 0) {
 		snprintf(buf, sizeof(buf), "Set channels: %s: %d", snd_strerror(err), channels);
 		goto fail;
 	}
 
-	if ((err = snd_pcm_hw_params_set_rate(pcm, params, rate, 0)) != 0) {
+	if ((err = snd_pcm_hw_params_set_rate(snd_pcm, params, rate, 0)) != 0) {
 		snprintf(buf, sizeof(buf), "Set sample rate: %s: %d", snd_strerror(err), rate);
 		goto fail;
 	}
 
 	dir = 0;
-	if ((err = snd_pcm_hw_params_set_period_time_near(pcm, params, period_time, &dir)) != 0) {
+	if ((err = snd_pcm_hw_params_set_period_time_near(snd_pcm, params, period_time, &dir)) != 0) {
 		snprintf(buf, sizeof(buf), "Set period time: %s: %u", snd_strerror(err), *period_time);
 		goto fail;
 	}
 
 	dir = 0;
-	if ((err = snd_pcm_hw_params_set_buffer_time_near(pcm, params, buffer_time, &dir)) != 0) {
+	if ((err = snd_pcm_hw_params_set_buffer_time_near(snd_pcm, params, buffer_time, &dir)) != 0) {
 		snprintf(buf, sizeof(buf), "Set buffer time: %s: %u", snd_strerror(err), *buffer_time);
 		goto fail;
 	}
 
-	if ((err = snd_pcm_hw_params(pcm, params)) != 0) {
+	if ((err = snd_pcm_hw_params(snd_pcm, params)) != 0) {
 		snprintf(buf, sizeof(buf), "%s", snd_strerror(err));
 		goto fail;
 	}
@@ -75,36 +84,40 @@ static int alsa_pcm_set_hw_params(snd_pcm_t *pcm, snd_pcm_format_t format, int c
 	return err;
 }
 
-static int alsa_pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t buffer_size,
-		snd_pcm_uframes_t period_size, char **msg) {
+static int alsa_pcm_set_sw_params(
+		struct alsa_pcm *pcm,
+		snd_pcm_uframes_t buffer_size,
+		snd_pcm_uframes_t period_size,
+		char **msg) {
 
+	snd_pcm_t *snd_pcm = pcm->pcm;
 	snd_pcm_sw_params_t *params;
 	char buf[256];
 	int err;
 
 	snd_pcm_sw_params_alloca(&params);
 
-	if ((err = snd_pcm_sw_params_current(pcm, params)) != 0) {
+	if ((err = snd_pcm_sw_params_current(snd_pcm, params)) != 0) {
 		snprintf(buf, sizeof(buf), "Get current params: %s", snd_strerror(err));
 		goto fail;
 	}
 
 	/* Start the transfer when the buffer is half full - this allows
 	 * spare capacity to accommodate bursts and short breaks in the
 	 * Bluetooth stream. */
-	snd_pcm_uframes_t threshold = buffer_size / 2;
-	if ((err = snd_pcm_sw_params_set_start_threshold(pcm, params, threshold)) != 0) {
+	snd_pcm_uframes_t threshold = pcm->start_threshold = buffer_size / 2;
+	if ((err = snd_pcm_sw_params_set_start_threshold(snd_pcm, params, threshold)) != 0) {
 		snprintf(buf, sizeof(buf), "Set start threshold: %s: %lu", snd_strerror(err), threshold);
 		goto fail;
 	}
 
 	/* Allow the transfer when at least period_size samples can be processed. */
-	if ((err = snd_pcm_sw_params_set_avail_min(pcm, params, period_size)) != 0) {
+	if ((err = snd_pcm_sw_params_set_avail_min(snd_pcm, params, period_size)) != 0) {
 		snprintf(buf, sizeof(buf), "Set avail min: %s: %lu", snd_strerror(err), period_size);
 		goto fail;
 	}
 
-	if ((err = snd_pcm_sw_params(pcm, params)) != 0) {
+	if ((err = snd_pcm_sw_params(snd_pcm, params)) != 0) {
 		snprintf(buf, sizeof(buf), "%s", snd_strerror(err));
 		goto fail;
 	}
@@ -117,58 +130,112 @@ static int alsa_pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t buffer_size,
 	return err;
 }
 
-int alsa_pcm_open(snd_pcm_t **pcm, const char *name,
-		snd_pcm_format_t format, int channels, int rate,
-		unsigned int *buffer_time, unsigned int *period_time,
+void alsa_pcm_init(struct alsa_pcm *pcm) {
+	pcm->pcm = NULL;
+}
+
+int alsa_pcm_open(
+		struct alsa_pcm *pcm,
+		const char *name,
+		snd_pcm_format_t format,
+		unsigned int channels,
+		unsigned int rate,
+		unsigned int buffer_time,
+		unsigned int period_time,
+		int flags,
 		char **msg) {
 
-	snd_pcm_t *_pcm = NULL;
 	char *tmp = NULL;
 	char buf[256];
 	int err;
 
-	if ((err = snd_pcm_open(&_pcm, name, SND_PCM_STREAM_PLAYBACK, 0)) != 0) {
+	if ((err = snd_pcm_open(&pcm->pcm, name, SND_PCM_STREAM_PLAYBACK, flags)) != 0) {
 		snprintf(buf, sizeof(buf), "Open PCM: %s", snd_strerror(err));
 		goto fail;
 	}
 
-	if ((err = alsa_pcm_set_hw_params(_pcm, format, channels, rate, buffer_time, period_time, &tmp)) != 0) {
+	unsigned int actual_buffer_time = buffer_time;
+	unsigned int actual_period_time = period_time;
+	if ((err = alsa_pcm_set_hw_params(pcm, format, channels, rate,
+				&actual_buffer_time, &actual_period_time, &tmp)) != 0) {
 		snprintf(buf, sizeof(buf), "Set HW params: %s", tmp);
 		goto fail;
 	}
 
 	snd_pcm_uframes_t buffer_size, period_size;
-	if ((err = snd_pcm_get_params(_pcm, &buffer_size, &period_size)) != 0) {
+	if ((err = snd_pcm_get_params(pcm->pcm, &buffer_size, &period_size)) != 0) {
 		snprintf(buf, sizeof(buf), "Get params: %s", snd_strerror(err));
 		goto fail;
 	}
 
-	if ((err = alsa_pcm_set_sw_params(_pcm, buffer_size, period_size, &tmp)) != 0) {
+	if ((err = alsa_pcm_set_sw_params(pcm, buffer_size, period_size, &tmp)) != 0) {
 		snprintf(buf, sizeof(buf), "Set SW params: %s", tmp);
 		goto fail;
 	}
 
-	if ((err = snd_pcm_prepare(_pcm)) != 0) {
+	if ((err = snd_pcm_prepare(pcm->pcm)) != 0) {
 		snprintf(buf, sizeof(buf), "Prepare: %s", snd_strerror(err));
 		goto fail;
 	}
 
-	*pcm = _pcm;
+	pcm->format = format;
+	pcm->channels = channels;
+	pcm->sample_size = snd_pcm_format_size(format, 1);
+	pcm->frame_size = snd_pcm_format_size(format, channels);
+	pcm->rate = rate;
+	pcm->buffer_time = actual_buffer_time;
+	pcm->period_time = actual_period_time;
+	pcm->buffer_frames = buffer_size;
+	pcm->period_frames = period_size;
+
 	return 0;
 
 fail:
-	if (_pcm != NULL)
-		snd_pcm_close(_pcm);
+	alsa_pcm_close(pcm);
 	if (msg != NULL)
 		*msg = strdup(buf);
 	if (tmp != NULL)
 		free(tmp);
 	return err;
+
+}
+
+void alsa_pcm_close(struct alsa_pcm *pcm) {
+	if (pcm->pcm != NULL)
+		snd_pcm_close(pcm->pcm);
+	pcm->pcm = NULL;
+}
+
+int alsa_pcm_write(struct alsa_pcm *pcm, ffb_t *buffer) {
+
+	size_t samples = ffb_len_out(buffer);
+	snd_pcm_sframes_t frames;
+
+	for (;;) {
+		frames = samples / pcm->channels;
+		if ((frames = snd_pcm_writei(pcm->pcm, buffer->data, frames)) > 0)
+			break;
+		switch (-frames) {
+		case EINTR:
+			continue;
+		case EPIPE:
+			debug("ALSA playback PCM underrun");
+			snd_pcm_prepare(pcm->pcm);
+			continue;
+		default:
+			error("ALSA playback PCM write error: %s", snd_strerror(frames));
+			return -1;
+		}
+	}
+
+	/* Move leftovers to the beginning of buffer and reposition tail. */
+	ffb_shift(buffer, frames * pcm->channels);
+	return 0;
 }
 
-void alsa_pcm_dump(snd_pcm_t *pcm, FILE *fp) {
+void alsa_pcm_dump(const struct alsa_pcm *pcm, FILE *fp) {
 	snd_output_t *out;
 	snd_output_stdio_attach(&out, fp, 0);
-	snd_pcm_dump(pcm, out);
+	snd_pcm_dump(pcm->pcm, out);
 	snd_output_close(out);
 }

utils/aplay/alsa-pcm.h

@@ -1,6 +1,6 @@
 /*
  * BlueALSA - alsa-pcm.h
- * Copyright (c) 2016-2023 Arkadiusz Bokowy
+ * Copyright (c) 2016-2025 Arkadiusz Bokowy
  *
  * This file is a part of bluez-alsa.
  *
@@ -12,15 +12,83 @@
 #ifndef BLUEALSA_APLAY_ALSAPCM_H_
 #define BLUEALSA_APLAY_ALSAPCM_H_
 
+#include <stdbool.h>
 #include <stdio.h>
 
 #include <alsa/asoundlib.h>
 
-int alsa_pcm_open(snd_pcm_t **pcm, const char *name,
-		snd_pcm_format_t format, int channels, int rate,
-		unsigned int *buffer_time, unsigned int *period_time,
+#include "shared/ffb.h"
+
+struct alsa_pcm {
+
+	/* The ALSA device handle. */
+	snd_pcm_t *pcm;
+
+	snd_pcm_format_t format;
+	/* The hardware parameters actually set within the ALSA device. Note that
+	 * these may differ from the values requested by the application. */
+	unsigned int channels;
+	unsigned int rate;
+	unsigned int buffer_time;
+	unsigned int period_time;
+	snd_pcm_uframes_t buffer_frames;
+	snd_pcm_uframes_t period_frames;
+
+	/* The number of frames that must be written to trigger
+	 * automatic start of the ALSA device. */
+	snd_pcm_uframes_t start_threshold;
+
+	/* The number of bytes in 1 sample. */
+	size_t sample_size;
+	/* The number of bytes in 1 frame. */
+	size_t frame_size;
+
+	/* The internal delay of the ALSA device immediately
+	 * after the last write. */
+	size_t delay;
+
+};
+
+void alsa_pcm_init(
+		struct alsa_pcm *pcm);
+
+int alsa_pcm_open(
+		struct alsa_pcm *pcm,
+		const char *name,
+		snd_pcm_format_t format,
+		unsigned int channels,
+		unsigned int rate,
+		unsigned int buffer_time,
+		unsigned int period_time,
+		int flags,
 		char **msg);
 
-void alsa_pcm_dump(snd_pcm_t *pcm, FILE *fp);
+void alsa_pcm_close(
+		struct alsa_pcm *pcm);
+
+inline static bool alsa_pcm_is_open(
+		const struct alsa_pcm *pcm) {
+	return pcm->pcm != NULL;
+}
+
+inline static int alsa_pcm_delay(
+		const struct alsa_pcm *pcm,
+		snd_pcm_sframes_t *delay) {
+	return snd_pcm_delay(pcm->pcm, delay);
+}
+
+inline static ssize_t alsa_pcm_frames_to_bytes(
+		const struct alsa_pcm *pcm,
+		snd_pcm_sframes_t frames) {
+	return snd_pcm_frames_to_bytes(pcm->pcm, frames);
+}
+
+int alsa_pcm_write(
+		struct alsa_pcm *pcm,
+		ffb_t *buffer);
+
+void alsa_pcm_dump(
+		const struct alsa_pcm *pcm,
+		FILE *fp);
 
 #endif