X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Falsa%2Falsa.c;h=527a7e5de49fa992521e61360e403475379f2b78;hb=c37d2b1ba12b62d63590509879bf58adf842896d;hp=4dd542d5a4689f18d5730a5f88a2f4cc6a1152da;hpb=8a2efef2d5900cb3dd935af92a0e22528660c4be;p=libsigrok.git

diff --git a/hardware/alsa/alsa.c b/hardware/alsa/alsa.c
index 4dd542d5..527a7e5d 100644
--- a/hardware/alsa/alsa.c
+++ b/hardware/alsa/alsa.c
@@ -18,12 +18,13 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
+#include "config.h" /* Must come before sigrok.h */
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
-#include <sigrok.h>
 #include <alsa/asoundlib.h>
-#include "config.h"
+#include "sigrok.h"
+#include "sigrok-internal.h"
 
 #define NUM_PROBES 2
 #define SAMPLE_WIDTH 16
@@ -35,6 +36,12 @@ static int capabilities[] = {
 	SR_HWCAP_CONTINUOUS,
 };
 
+static const char *probe_names[NUM_PROBES + 1] = {
+	"0",
+	"1",
+	NULL,
+};
+
 static GSList *device_instances = NULL;
 
 struct alsa {
@@ -45,7 +52,7 @@ struct alsa {
 	gpointer session_id;
 };
 
-static int hw_init(char *deviceinfo)
+static int hw_init(const char *deviceinfo)
 {
 	struct sr_device_instance *sdi;
 	struct alsa *alsa;
@@ -53,10 +60,10 @@ static int hw_init(char *deviceinfo)
 	/* Avoid compiler warnings. */
 	deviceinfo = deviceinfo;
 
-	alsa = malloc(sizeof(struct alsa));
-	if (!alsa)
+	if (!(alsa = g_try_malloc0(sizeof(struct alsa)))) {
+		sr_err("alsa: %s: alsa malloc failed", __func__);
 		return 0;
-	memset(alsa, 0, sizeof(struct alsa));
+	}
 
 	sdi = sr_device_instance_new(0, SR_ST_ACTIVE, "alsa", NULL, NULL);
 	if (!sdi)
@@ -68,7 +75,7 @@ static int hw_init(char *deviceinfo)
 
 	return 1;
 free_alsa:
-	free(alsa);
+	g_free(alsa);
 	return 0;
 }
 
@@ -85,21 +92,21 @@ static int hw_opendev(int device_index)
 	err = snd_pcm_open(&alsa->capture_handle, AUDIO_DEV,
 					SND_PCM_STREAM_CAPTURE, 0);
 	if (err < 0) {
-		g_warning("cannot open audio device %s (%s)", AUDIO_DEV,
-				snd_strerror(err));
+		sr_warn("cannot open audio device %s (%s)", AUDIO_DEV,
+			snd_strerror(err));
 		return SR_ERR;
 	}
 
 	err = snd_pcm_hw_params_malloc(&alsa->hw_params);
 	if (err < 0) {
-		g_warning("cannot allocate hardware parameter structure (%s)",
-				snd_strerror(err));
+		sr_warn("cannot allocate hardware parameter structure (%s)",
+			snd_strerror(err));
 		return SR_ERR;
 	}
 
 	err = snd_pcm_hw_params_any(alsa->capture_handle, alsa->hw_params);
 	if (err < 0) {
-		g_warning("cannot initialize hardware parameter structure (%s)",
+		sr_warn("cannot initialize hardware parameter structure (%s)",
 				snd_strerror(err));
 		return SR_ERR;
 	}
@@ -107,21 +114,28 @@ static int hw_opendev(int device_index)
 	return SR_OK;
 }
 
-static void hw_closedev(int device_index)
+static int hw_closedev(int device_index)
 {
 	struct sr_device_instance *sdi;
 	struct alsa *alsa;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
-		return;
-	alsa = sdi->priv;
-	if (!alsa)
-		return;
+	if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
+		sr_err("alsa: %s: sdi was NULL", __func__);
+		return SR_ERR; /* TODO: SR_ERR_ARG? */
+	}
+
+	if (!(alsa = sdi->priv)) {
+		sr_err("alsa: %s: sdi->priv was NULL", __func__);
+		return SR_ERR; /* TODO: SR_ERR_ARG? */
+	}
 
+	// TODO: Return values of snd_*?
 	if (alsa->hw_params)
 		snd_pcm_hw_params_free(alsa->hw_params);
 	if (alsa->capture_handle)
 		snd_pcm_close(alsa->capture_handle);
+
+	return SR_OK;
 }
 
 static void hw_cleanup(void)
@@ -152,6 +166,9 @@ static void *hw_get_device_info(int device_index, int device_info_id)
 	case SR_DI_NUM_PROBES:
 		info = GINT_TO_POINTER(NUM_PROBES);
 		break;
+	case SR_DI_PROBE_NAMES:
+		info = probe_names;
+		break;
 	case SR_DI_CUR_SAMPLERATE:
 		info = &alsa->cur_rate;
 		break;
@@ -204,9 +221,9 @@ static int receive_data(int fd, int revents, void *user_data)
 	struct sr_device_instance *sdi = user_data;
 	struct alsa *alsa = sdi->priv;
 	struct sr_datafeed_packet packet;
-	struct analog_sample *sample;
-	unsigned int sample_size = sizeof(struct analog_sample) +
-		(NUM_PROBES * sizeof(struct analog_probe));
+	struct sr_analog_sample *sample;
+	unsigned int sample_size = sizeof(struct sr_analog_sample) +
+		(NUM_PROBES * sizeof(struct sr_analog_probe));
 	char *outb;
 	char inb[4096];
 	int i, x, count;
@@ -219,16 +236,17 @@ static int receive_data(int fd, int revents, void *user_data)
 		count = snd_pcm_readi(alsa->capture_handle, inb,
 			MIN(4096/4, alsa->limit_samples));
 		if (count < 1) {
-			g_warning("Failed to read samples");
+			sr_warn("Failed to read samples");
 			return FALSE;
 		}
 
-		outb = malloc(sample_size * count);
-		if (!outb)
+		if (!(outb = g_try_malloc(sample_size * count))) {
+			sr_err("alsa: %s: outb malloc failed", __func__);
 			return FALSE;
+		}
 
 		for (i = 0; i < count; i++) {
-			sample = (struct analog_sample *)
+			sample = (struct sr_analog_sample *)
 						(outb + (i * sample_size));
 			sample->num_probes = NUM_PROBES;
 
@@ -245,7 +263,7 @@ static int receive_data(int fd, int revents, void *user_data)
 		packet.unitsize = sample_size;
 		packet.payload = outb;
 		sr_session_bus(user_data, &packet);
-		free(outb);
+		g_free(outb);
 		alsa->limit_samples -= count;
 
 	} while (alsa->limit_samples > 0);
@@ -273,7 +291,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	err = snd_pcm_hw_params_set_access(alsa->capture_handle,
 			alsa->hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
 	if (err < 0) {
-		g_warning("cannot set access type (%s)", snd_strerror(err));
+		sr_warn("cannot set access type (%s)", snd_strerror(err));
 		return SR_ERR;
 	}
 
@@ -281,57 +299,58 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	err = snd_pcm_hw_params_set_format(alsa->capture_handle,
 			alsa->hw_params, SND_PCM_FORMAT_S16_LE);
 	if (err < 0) {
-		g_warning("cannot set sample format (%s)", snd_strerror(err));
+		sr_warn("cannot set sample format (%s)", snd_strerror(err));
 		return SR_ERR;
 	}
 
 	err = snd_pcm_hw_params_set_rate_near(alsa->capture_handle,
 			alsa->hw_params, (unsigned int *) &alsa->cur_rate, 0);
 	if (err < 0) {
-		g_warning("cannot set sample rate (%s)", snd_strerror(err));
+		sr_warn("cannot set sample rate (%s)", snd_strerror(err));
 		return SR_ERR;
 	}
 
 	err = snd_pcm_hw_params_set_channels(alsa->capture_handle,
 			alsa->hw_params, NUM_PROBES);
 	if (err < 0) {
-		g_warning("cannot set channel count (%s)", snd_strerror(err));
+		sr_warn("cannot set channel count (%s)", snd_strerror(err));
 		return SR_ERR;
 	}
 
 	err = snd_pcm_hw_params(alsa->capture_handle, alsa->hw_params);
 	if (err < 0) {
-		g_warning("cannot set parameters (%s)", snd_strerror(err));
+		sr_warn("cannot set parameters (%s)", snd_strerror(err));
 		return SR_ERR;
 	}
 
 	err = snd_pcm_prepare(alsa->capture_handle);
 	if (err < 0) {
-		g_warning("cannot prepare audio interface for use (%s)",
+		sr_warn("cannot prepare audio interface for use (%s)",
 				snd_strerror(err));
 		return SR_ERR;
 	}
 
 	count = snd_pcm_poll_descriptors_count(alsa->capture_handle);
 	if (count < 1) {
-		g_warning("Unable to obtain poll descriptors count");
+		sr_warn("Unable to obtain poll descriptors count");
 		return SR_ERR;
 	}
 
-	ufds = malloc(count * sizeof(struct pollfd));
-	if (!ufds)
+	if (!(ufds = g_try_malloc(count * sizeof(struct pollfd)))) {
+		sr_warn("alsa: %s: ufds malloc failed", __func__);
 		return SR_ERR_MALLOC;
+	}
 
 	err = snd_pcm_poll_descriptors(alsa->capture_handle, ufds, count);
 	if (err < 0) {
-		g_warning("Unable to obtain poll descriptors (%s)",
+		sr_warn("Unable to obtain poll descriptors (%s)",
 				snd_strerror(err));
-		free(ufds);
+		g_free(ufds);
 		return SR_ERR;
 	}
 
 	alsa->session_id = session_device_id;
-	source_add(ufds[0].fd, ufds[0].events, 10, receive_data, sdi);
+	sr_source_add(ufds[0].fd, ufds[0].events, 10, receive_data, sdi);
 
 	packet.type = SR_DF_HEADER;
 	packet.length = sizeof(struct sr_datafeed_header);
@@ -343,7 +362,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	header.num_logic_probes = 0;
 	header.protocol_id = SR_PROTO_RAW;
 	sr_session_bus(session_device_id, &packet);
-	free(ufds);
+	g_free(ufds);
 
 	return SR_OK;
 }
@@ -356,17 +375,17 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 }
 
 struct sr_device_plugin alsa_plugin_info = {
-	"alsa",
-	"ALSA driver",
-	1,
-	hw_init,
-	hw_cleanup,
-	hw_opendev,
-	hw_closedev,
-	hw_get_device_info,
-	hw_get_status,
-	hw_get_capabilities,
-	hw_set_configuration,
-	hw_start_acquisition,
-	hw_stop_acquisition,
+	.name = "alsa",
+	.longname = "ALSA driver",
+	.api_version = 1,
+	.init = hw_init,
+	.cleanup = hw_cleanup,
+	.opendev = hw_opendev,
+	.closedev = hw_closedev,
+	.get_device_info = hw_get_device_info,
+	.get_status = hw_get_status,
+	.get_capabilities = hw_get_capabilities,
+	.set_configuration = hw_set_configuration,
+	.start_acquisition = hw_start_acquisition,
+	.stop_acquisition = hw_stop_acquisition,
 };