+/*
+ * This small demo sends a simple sinusoidal wave to your speakers.
+ */
+
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
+#include <sched.h>
+#include <errno.h>
+#include <getopt.h>
#include "../include/asoundlib.h"
+#include <sys/time.h>
+#include <math.h>
+
+static char *device = "plughw:0,0"; /* playback device */
+static snd_pcm_format_t format = SND_PCM_FORMAT_S16; /* sample format */
+static unsigned int rate = 44100; /* stream rate */
+static unsigned int channels = 1; /* count of channels */
+static unsigned int buffer_time = 500000; /* ring buffer length in us */
+static unsigned int period_time = 100000; /* period time in us */
+static double freq = 440; /* sinusoidal wave frequency in Hz */
+static int verbose = 0; /* verbose flag */
+static int resample = 1; /* enable alsa-lib resampling */
+static int period_event = 0; /* produce poll event after each period */
-#define BUFFER_SIZE 800000
+static snd_pcm_sframes_t buffer_size;
+static snd_pcm_sframes_t period_size;
+static snd_output_t *output = NULL;
-static char *xitoa(int aaa)
+static void generate_sine(const snd_pcm_channel_area_t *areas,
+ snd_pcm_uframes_t offset,
+ int count, double *_phase)
{
- static char str[12];
+ static double max_phase = 2. * M_PI;
+ double phase = *_phase;
+ double step = max_phase*freq/(double)rate;
+ unsigned char *samples[channels];
+ int steps[channels];
+ unsigned int chn;
+ int format_bits = snd_pcm_format_width(format);
+ unsigned int maxval = (1 << (format_bits - 1)) - 1;
+ int bps = format_bits / 8; /* bytes per sample */
+ int phys_bps = snd_pcm_format_physical_width(format) / 8;
+ int big_endian = snd_pcm_format_big_endian(format) == 1;
+ int to_unsigned = snd_pcm_format_unsigned(format) == 1;
+ int is_float = (format == SND_PCM_FORMAT_FLOAT_LE ||
+ format == SND_PCM_FORMAT_FLOAT_BE);
- sprintf(str, "%i", aaa);
- return str;
+ /* verify and prepare the contents of areas */
+ for (chn = 0; chn < channels; chn++) {
+ if ((areas[chn].first % 8) != 0) {
+ printf("areas[%u].first == %u, aborting...\n", chn, areas[chn].first);
+ exit(EXIT_FAILURE);
+ }
+ samples[chn] = /*(signed short *)*/(((unsigned char *)areas[chn].addr) + (areas[chn].first / 8));
+ if ((areas[chn].step % 16) != 0) {
+ printf("areas[%u].step == %u, aborting...\n", chn, areas[chn].step);
+ exit(EXIT_FAILURE);
+ }
+ steps[chn] = areas[chn].step / 8;
+ samples[chn] += offset * steps[chn];
+ }
+ /* fill the channel areas */
+ while (count-- > 0) {
+ union {
+ float f;
+ int i;
+ } fval;
+ int res, i;
+ if (is_float) {
+ fval.f = sin(phase);
+ res = fval.i;
+ } else
+ res = sin(phase) * maxval;
+ if (to_unsigned)
+ res ^= 1U << (format_bits - 1);
+ for (chn = 0; chn < channels; chn++) {
+ /* Generate data in native endian format */
+ if (big_endian) {
+ for (i = 0; i < bps; i++)
+ *(samples[chn] + phys_bps - 1 - i) = (res >> i * 8) & 0xff;
+ } else {
+ for (i = 0; i < bps; i++)
+ *(samples[chn] + i) = (res >> i * 8) & 0xff;
+ }
+ samples[chn] += steps[chn];
+ }
+ phase += step;
+ if (phase >= max_phase)
+ phase -= max_phase;
+ }
+ *_phase = phase;
}
-void setformat(void *phandle, void *rhandle)
+static int set_hwparams(snd_pcm_t *handle,
+ snd_pcm_hw_params_t *params,
+ snd_pcm_access_t access)
{
- int err;
- snd_pcm_format_t format;
+ unsigned int rrate;
+ snd_pcm_uframes_t size;
+ int err, dir;
- bzero(&format, sizeof(format));
- format.format = SND_PCM_SFMT_S16_LE;
- format.channels = 2;
- format.rate = 22050;
- if ((err = snd_pcm_playback_format(phandle, &format)) < 0) {
- printf("Playback format error: %s\n", snd_strerror(err));
+ /* choose all parameters */
+ err = snd_pcm_hw_params_any(handle, params);
+ if (err < 0) {
+ printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
+ return err;
+ }
+ /* set hardware resampling */
+ err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
+ if (err < 0) {
+ printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ /* set the interleaved read/write format */
+ err = snd_pcm_hw_params_set_access(handle, params, access);
+ if (err < 0) {
+ printf("Access type not available for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ /* set the sample format */
+ err = snd_pcm_hw_params_set_format(handle, params, format);
+ if (err < 0) {
+ printf("Sample format not available for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ /* set the count of channels */
+ err = snd_pcm_hw_params_set_channels(handle, params, channels);
+ if (err < 0) {
+ printf("Channels count (%u) not available for playbacks: %s\n", channels, snd_strerror(err));
+ return err;
+ }
+ /* set the stream rate */
+ rrate = rate;
+ err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
+ if (err < 0) {
+ printf("Rate %uHz not available for playback: %s\n", rate, snd_strerror(err));
+ return err;
+ }
+ if (rrate != rate) {
+ printf("Rate doesn't match (requested %uHz, get %iHz)\n", rate, err);
+ return -EINVAL;
+ }
+ /* set the buffer time */
+ err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, &dir);
+ if (err < 0) {
+ printf("Unable to set buffer time %u for playback: %s\n", buffer_time, snd_strerror(err));
+ return err;
+ }
+ err = snd_pcm_hw_params_get_buffer_size(params, &size);
+ if (err < 0) {
+ printf("Unable to get buffer size for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ buffer_size = size;
+ /* set the period time */
+ err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, &dir);
+ if (err < 0) {
+ printf("Unable to set period time %u for playback: %s\n", period_time, snd_strerror(err));
+ return err;
}
- if ((err = snd_pcm_record_format(rhandle, &format)) < 0) {
- printf("Record format error: %s\n", snd_strerror(err));
+ err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
+ if (err < 0) {
+ printf("Unable to get period size for playback: %s\n", snd_strerror(err));
+ return err;
}
+ period_size = size;
+ /* write the parameters to device */
+ err = snd_pcm_hw_params(handle, params);
+ if (err < 0) {
+ printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ return 0;
}
-void method1(void)
+static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
{
- snd_pcm_t *phandle, *rhandle;
- char buffer[BUFFER_SIZE];
int err;
- if ((err = snd_pcm_open(&phandle, 0, 0, SND_PCM_OPEN_PLAYBACK)) < 0) {
- printf("Playback open error: %s\n", snd_strerror(err));
- return;
- }
- if ((err = snd_pcm_open(&rhandle, 0, 0, SND_PCM_OPEN_RECORD)) < 0) {
- printf("Record open error: %s\n", snd_strerror(err));
- return;
- }
- setformat(phandle, rhandle);
- printf("Recording... ");
- fflush(stdout);
- if ((err = snd_pcm_read(rhandle, buffer, sizeof(buffer))) != sizeof(buffer)) {
- printf("Read error: %s\n", err < 0 ? snd_strerror(err) : xitoa(err));
- return;
- }
- printf("done...\n");
- printf("Playback... ");
- fflush(stdout);
- if ((err = snd_pcm_write(phandle, buffer, sizeof(buffer))) != sizeof(buffer)) {
- printf("Write error: %s\n", err < 0 ? snd_strerror(err) : xitoa(err));
- return;
- }
- printf("done...\n");
- snd_pcm_close(phandle);
- printf("Playback close...\n");
- snd_pcm_close(rhandle);
- printf("Record close...\n");
+ /* get the current swparams */
+ err = snd_pcm_sw_params_current(handle, swparams);
+ if (err < 0) {
+ printf("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ /* start the transfer when the buffer is almost full: */
+ /* (buffer_size / avail_min) * avail_min */
+ err = snd_pcm_sw_params_set_start_threshold(handle, swparams, (buffer_size / period_size) * period_size);
+ if (err < 0) {
+ printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ /* allow the transfer when at least period_size samples can be processed */
+ /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
+ err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_event ? buffer_size : period_size);
+ if (err < 0) {
+ printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ /* enable period events when requested */
+ if (period_event) {
+ err = snd_pcm_sw_params_set_period_event(handle, swparams, 1);
+ if (err < 0) {
+ printf("Unable to set period event: %s\n", snd_strerror(err));
+ return err;
+ }
+ }
+ /* write the parameters to the playback device */
+ err = snd_pcm_sw_params(handle, swparams);
+ if (err < 0) {
+ printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+ return 0;
}
-void method2(void)
+/*
+ * Underrun and suspend recovery
+ */
+
+static int xrun_recovery(snd_pcm_t *handle, int err)
{
- snd_pcm_t *phandle, *rhandle;
- char buffer[BUFFER_SIZE];
- int err;
+ if (verbose)
+ printf("stream recovery\n");
+ if (err == -EPIPE) { /* under-run */
+ err = snd_pcm_prepare(handle);
+ if (err < 0)
+ printf("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(err));
+ return 0;
+ } else if (err == -ESTRPIPE) {
+ while ((err = snd_pcm_resume(handle)) == -EAGAIN)
+ sleep(1); /* wait until the suspend flag is released */
+ if (err < 0) {
+ err = snd_pcm_prepare(handle);
+ if (err < 0)
+ printf("Can't recovery from suspend, prepare failed: %s\n", snd_strerror(err));
+ }
+ return 0;
+ }
+ return err;
+}
- if ((err = snd_pcm_open(&phandle, 0, 0, SND_PCM_OPEN_PLAYBACK)) < 0) {
- printf("Playback open error: %s\n", snd_strerror(err));
- return;
- }
- if ((err = snd_pcm_open(&rhandle, 0, 0, SND_PCM_OPEN_RECORD)) < 0) {
- printf("Record open error: %s\n", snd_strerror(err));
- return;
- }
- setformat(phandle, rhandle);
- printf("Recording... ");
- fflush(stdout);
- if ((err = snd_pcm_read(rhandle, buffer, sizeof(buffer))) != sizeof(buffer)) {
- printf("Read error: %s\n", err < 0 ? snd_strerror(err) : xitoa(err));
- return;
- }
- printf("done...\n");
- if ((err = snd_pcm_flush_record(rhandle)) < 0) {
- printf("Record flush error: %s\n", snd_strerror(err));
- return;
- }
- printf("Record flush done...\n");
- printf("Playback... ");
- fflush(stdout);
- if ((err = snd_pcm_write(phandle, buffer, sizeof(buffer))) != sizeof(buffer)) {
- printf("Write error: %s\n", err < 0 ? snd_strerror(err) : xitoa(err));
- return;
- }
- printf("done...\n");
- if ((err = snd_pcm_flush_playback(phandle)) < 0) {
- printf("Playback flush error: %s\n", snd_strerror(err));
- return;
- }
- printf("Playback flush done...\n");
- snd_pcm_close(phandle);
- printf("Playback close...\n");
- snd_pcm_close(rhandle);
- printf("Record close...\n");
+/*
+ * Transfer method - write only
+ */
+
+static int write_loop(snd_pcm_t *handle,
+ signed short *samples,
+ snd_pcm_channel_area_t *areas)
+{
+ double phase = 0;
+ signed short *ptr;
+ int err, cptr;
+
+ while (1) {
+ generate_sine(areas, 0, period_size, &phase);
+ ptr = samples;
+ cptr = period_size;
+ while (cptr > 0) {
+ err = snd_pcm_writei(handle, ptr, cptr);
+ if (err == -EAGAIN)
+ continue;
+ if (err < 0) {
+ if (xrun_recovery(handle, err) < 0) {
+ printf("Write error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ break; /* skip one period */
+ }
+ ptr += err * channels;
+ cptr -= err;
+ }
+ }
}
+
+/*
+ * Transfer method - write and wait for room in buffer using poll
+ */
-void method3(void)
+static int wait_for_poll(snd_pcm_t *handle, struct pollfd *ufds, unsigned int count)
{
- snd_pcm_t *handle;
- char buffer[BUFFER_SIZE];
+ unsigned short revents;
+
+ while (1) {
+ poll(ufds, count, -1);
+ snd_pcm_poll_descriptors_revents(handle, ufds, count, &revents);
+ if (revents & POLLERR)
+ return -EIO;
+ if (revents & POLLOUT)
+ return 0;
+ }
+}
+
+static int write_and_poll_loop(snd_pcm_t *handle,
+ signed short *samples,
+ snd_pcm_channel_area_t *areas)
+{
+ struct pollfd *ufds;
+ double phase = 0;
+ signed short *ptr;
+ int err, count, cptr, init;
+
+ count = snd_pcm_poll_descriptors_count (handle);
+ if (count <= 0) {
+ printf("Invalid poll descriptors count\n");
+ return count;
+ }
+
+ ufds = malloc(sizeof(struct pollfd) * count);
+ if (ufds == NULL) {
+ printf("No enough memory\n");
+ return -ENOMEM;
+ }
+ if ((err = snd_pcm_poll_descriptors(handle, ufds, count)) < 0) {
+ printf("Unable to obtain poll descriptors for playback: %s\n", snd_strerror(err));
+ return err;
+ }
+
+ init = 1;
+ while (1) {
+ if (!init) {
+ err = wait_for_poll(handle, ufds, count);
+ if (err < 0) {
+ if (snd_pcm_state(handle) == SND_PCM_STATE_XRUN ||
+ snd_pcm_state(handle) == SND_PCM_STATE_SUSPENDED) {
+ err = snd_pcm_state(handle) == SND_PCM_STATE_XRUN ? -EPIPE : -ESTRPIPE;
+ if (xrun_recovery(handle, err) < 0) {
+ printf("Write error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ init = 1;
+ } else {
+ printf("Wait for poll failed\n");
+ return err;
+ }
+ }
+ }
+
+ generate_sine(areas, 0, period_size, &phase);
+ ptr = samples;
+ cptr = period_size;
+ while (cptr > 0) {
+ err = snd_pcm_writei(handle, ptr, cptr);
+ if (err < 0) {
+ if (xrun_recovery(handle, err) < 0) {
+ printf("Write error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ init = 1;
+ break; /* skip one period */
+ }
+ if (snd_pcm_state(handle) == SND_PCM_STATE_RUNNING)
+ init = 0;
+ ptr += err * channels;
+ cptr -= err;
+ if (cptr == 0)
+ break;
+ /* it is possible, that the initial buffer cannot store */
+ /* all data from the last period, so wait awhile */
+ err = wait_for_poll(handle, ufds, count);
+ if (err < 0) {
+ if (snd_pcm_state(handle) == SND_PCM_STATE_XRUN ||
+ snd_pcm_state(handle) == SND_PCM_STATE_SUSPENDED) {
+ err = snd_pcm_state(handle) == SND_PCM_STATE_XRUN ? -EPIPE : -ESTRPIPE;
+ if (xrun_recovery(handle, err) < 0) {
+ printf("Write error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ init = 1;
+ } else {
+ printf("Wait for poll failed\n");
+ return err;
+ }
+ }
+ }
+ }
+}
+
+/*
+ * Transfer method - asynchronous notification
+ */
+
+struct async_private_data {
+ signed short *samples;
+ snd_pcm_channel_area_t *areas;
+ double phase;
+};
+
+static void async_callback(snd_async_handler_t *ahandler)
+{
+ snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler);
+ struct async_private_data *data = snd_async_handler_get_callback_private(ahandler);
+ signed short *samples = data->samples;
+ snd_pcm_channel_area_t *areas = data->areas;
+ snd_pcm_sframes_t avail;
int err;
+
+ avail = snd_pcm_avail_update(handle);
+ while (avail >= period_size) {
+ generate_sine(areas, 0, period_size, &data->phase);
+ err = snd_pcm_writei(handle, samples, period_size);
+ if (err < 0) {
+ printf("Write error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ if (err != period_size) {
+ printf("Write error: written %i expected %li\n", err, period_size);
+ exit(EXIT_FAILURE);
+ }
+ avail = snd_pcm_avail_update(handle);
+ }
+}
- if ((err = snd_pcm_open(&handle, 0, 0, SND_PCM_OPEN_DUPLEX)) < 0) {
- printf("Duplex open error: %s\n", snd_strerror(err));
- return;
- }
- setformat(handle, handle);
- printf("Recording... ");
- fflush(stdout);
- if ((err = snd_pcm_read(handle, buffer, sizeof(buffer))) != sizeof(buffer)) {
- printf("Read error: %s\n", err < 0 ? snd_strerror(err) : xitoa(err));
- return;
- }
- printf("done...\n");
- if ((err = snd_pcm_flush_record(handle)) < 0) {
- printf("Record flush error: %s\n", snd_strerror(err));
- return;
- }
- printf("Record flush done...\n");
- printf("Playback... ");
- fflush(stdout);
- if ((err = snd_pcm_write(handle, buffer, sizeof(buffer))) != sizeof(buffer)) {
- printf("Write error: %s\n", err < 0 ? snd_strerror(err) : xitoa(err));
- return;
- }
- printf("done...\n");
- if ((err = snd_pcm_flush_playback(handle)) < 0) {
- printf("Playback flush error: %s\n", snd_strerror(err));
- return;
- }
- printf("Playback flush done...\n");
- snd_pcm_close(handle);
- printf("Close...\n");
+static int async_loop(snd_pcm_t *handle,
+ signed short *samples,
+ snd_pcm_channel_area_t *areas)
+{
+ struct async_private_data data;
+ snd_async_handler_t *ahandler;
+ int err, count;
+
+ data.samples = samples;
+ data.areas = areas;
+ data.phase = 0;
+ err = snd_async_add_pcm_handler(&ahandler, handle, async_callback, &data);
+ if (err < 0) {
+ printf("Unable to register async handler\n");
+ exit(EXIT_FAILURE);
+ }
+ for (count = 0; count < 2; count++) {
+ generate_sine(areas, 0, period_size, &data.phase);
+ err = snd_pcm_writei(handle, samples, period_size);
+ if (err < 0) {
+ printf("Initial write error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ if (err != period_size) {
+ printf("Initial write error: written %i expected %li\n", err, period_size);
+ exit(EXIT_FAILURE);
+ }
+ }
+ if (snd_pcm_state(handle) == SND_PCM_STATE_PREPARED) {
+ err = snd_pcm_start(handle);
+ if (err < 0) {
+ printf("Start error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ /* because all other work is done in the signal handler,
+ suspend the process */
+ while (1) {
+ sleep(1);
+ }
+}
+
+/*
+ * Transfer method - asynchronous notification + direct write
+ */
+
+static void async_direct_callback(snd_async_handler_t *ahandler)
+{
+ snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler);
+ struct async_private_data *data = snd_async_handler_get_callback_private(ahandler);
+ const snd_pcm_channel_area_t *my_areas;
+ snd_pcm_uframes_t offset, frames, size;
+ snd_pcm_sframes_t avail, commitres;
+ snd_pcm_state_t state;
+ int first = 0, err;
+
+ while (1) {
+ state = snd_pcm_state(handle);
+ if (state == SND_PCM_STATE_XRUN) {
+ err = xrun_recovery(handle, -EPIPE);
+ if (err < 0) {
+ printf("XRUN recovery failed: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ first = 1;
+ } else if (state == SND_PCM_STATE_SUSPENDED) {
+ err = xrun_recovery(handle, -ESTRPIPE);
+ if (err < 0) {
+ printf("SUSPEND recovery failed: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ }
+ avail = snd_pcm_avail_update(handle);
+ if (avail < 0) {
+ err = xrun_recovery(handle, avail);
+ if (err < 0) {
+ printf("avail update failed: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ first = 1;
+ continue;
+ }
+ if (avail < period_size) {
+ if (first) {
+ first = 0;
+ err = snd_pcm_start(handle);
+ if (err < 0) {
+ printf("Start error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ break;
+ }
+ continue;
+ }
+ size = period_size;
+ while (size > 0) {
+ frames = size;
+ err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
+ if (err < 0) {
+ if ((err = xrun_recovery(handle, err)) < 0) {
+ printf("MMAP begin avail error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ first = 1;
+ }
+ generate_sine(my_areas, offset, frames, &data->phase);
+ commitres = snd_pcm_mmap_commit(handle, offset, frames);
+ if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
+ if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
+ printf("MMAP commit error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ first = 1;
+ }
+ size -= frames;
+ }
+ }
+}
+
+static int async_direct_loop(snd_pcm_t *handle,
+ signed short *samples ATTRIBUTE_UNUSED,
+ snd_pcm_channel_area_t *areas ATTRIBUTE_UNUSED)
+{
+ struct async_private_data data;
+ snd_async_handler_t *ahandler;
+ const snd_pcm_channel_area_t *my_areas;
+ snd_pcm_uframes_t offset, frames, size;
+ snd_pcm_sframes_t commitres;
+ int err, count;
+
+ data.samples = NULL; /* we do not require the global sample area for direct write */
+ data.areas = NULL; /* we do not require the global areas for direct write */
+ data.phase = 0;
+ err = snd_async_add_pcm_handler(&ahandler, handle, async_direct_callback, &data);
+ if (err < 0) {
+ printf("Unable to register async handler\n");
+ exit(EXIT_FAILURE);
+ }
+ for (count = 0; count < 2; count++) {
+ size = period_size;
+ while (size > 0) {
+ frames = size;
+ err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
+ if (err < 0) {
+ if ((err = xrun_recovery(handle, err)) < 0) {
+ printf("MMAP begin avail error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ }
+ generate_sine(my_areas, offset, frames, &data.phase);
+ commitres = snd_pcm_mmap_commit(handle, offset, frames);
+ if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
+ if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
+ printf("MMAP commit error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ }
+ size -= frames;
+ }
+ }
+ err = snd_pcm_start(handle);
+ if (err < 0) {
+ printf("Start error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+
+ /* because all other work is done in the signal handler,
+ suspend the process */
+ while (1) {
+ sleep(1);
+ }
+}
+
+/*
+ * Transfer method - direct write only
+ */
+
+static int direct_loop(snd_pcm_t *handle,
+ signed short *samples ATTRIBUTE_UNUSED,
+ snd_pcm_channel_area_t *areas ATTRIBUTE_UNUSED)
+{
+ double phase = 0;
+ const snd_pcm_channel_area_t *my_areas;
+ snd_pcm_uframes_t offset, frames, size;
+ snd_pcm_sframes_t avail, commitres;
+ snd_pcm_state_t state;
+ int err, first = 1;
+
+ while (1) {
+ state = snd_pcm_state(handle);
+ if (state == SND_PCM_STATE_XRUN) {
+ err = xrun_recovery(handle, -EPIPE);
+ if (err < 0) {
+ printf("XRUN recovery failed: %s\n", snd_strerror(err));
+ return err;
+ }
+ first = 1;
+ } else if (state == SND_PCM_STATE_SUSPENDED) {
+ err = xrun_recovery(handle, -ESTRPIPE);
+ if (err < 0) {
+ printf("SUSPEND recovery failed: %s\n", snd_strerror(err));
+ return err;
+ }
+ }
+ avail = snd_pcm_avail_update(handle);
+ if (avail < 0) {
+ err = xrun_recovery(handle, avail);
+ if (err < 0) {
+ printf("avail update failed: %s\n", snd_strerror(err));
+ return err;
+ }
+ first = 1;
+ continue;
+ }
+ if (avail < period_size) {
+ if (first) {
+ first = 0;
+ err = snd_pcm_start(handle);
+ if (err < 0) {
+ printf("Start error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ err = snd_pcm_wait(handle, -1);
+ if (err < 0) {
+ if ((err = xrun_recovery(handle, err)) < 0) {
+ printf("snd_pcm_wait error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ first = 1;
+ }
+ }
+ continue;
+ }
+ size = period_size;
+ while (size > 0) {
+ frames = size;
+ err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
+ if (err < 0) {
+ if ((err = xrun_recovery(handle, err)) < 0) {
+ printf("MMAP begin avail error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ first = 1;
+ }
+ generate_sine(my_areas, offset, frames, &phase);
+ commitres = snd_pcm_mmap_commit(handle, offset, frames);
+ if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
+ if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
+ printf("MMAP commit error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ first = 1;
+ }
+ size -= frames;
+ }
+ }
+}
+
+/*
+ * Transfer method - direct write only using mmap_write functions
+ */
+
+static int direct_write_loop(snd_pcm_t *handle,
+ signed short *samples,
+ snd_pcm_channel_area_t *areas)
+{
+ double phase = 0;
+ signed short *ptr;
+ int err, cptr;
+
+ while (1) {
+ generate_sine(areas, 0, period_size, &phase);
+ ptr = samples;
+ cptr = period_size;
+ while (cptr > 0) {
+ err = snd_pcm_mmap_writei(handle, ptr, cptr);
+ if (err == -EAGAIN)
+ continue;
+ if (err < 0) {
+ if (xrun_recovery(handle, err) < 0) {
+ printf("Write error: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ break; /* skip one period */
+ }
+ ptr += err * channels;
+ cptr -= err;
+ }
+ }
}
+
+/*
+ *
+ */
+
+struct transfer_method {
+ const char *name;
+ snd_pcm_access_t access;
+ int (*transfer_loop)(snd_pcm_t *handle,
+ signed short *samples,
+ snd_pcm_channel_area_t *areas);
+};
+static struct transfer_method transfer_methods[] = {
+ { "write", SND_PCM_ACCESS_RW_INTERLEAVED, write_loop },
+ { "write_and_poll", SND_PCM_ACCESS_RW_INTERLEAVED, write_and_poll_loop },
+ { "async", SND_PCM_ACCESS_RW_INTERLEAVED, async_loop },
+ { "async_direct", SND_PCM_ACCESS_MMAP_INTERLEAVED, async_direct_loop },
+ { "direct_interleaved", SND_PCM_ACCESS_MMAP_INTERLEAVED, direct_loop },
+ { "direct_noninterleaved", SND_PCM_ACCESS_MMAP_NONINTERLEAVED, direct_loop },
+ { "direct_write", SND_PCM_ACCESS_MMAP_INTERLEAVED, direct_write_loop },
+ { NULL, SND_PCM_ACCESS_RW_INTERLEAVED, NULL }
+};
-int main(void)
+static void help(void)
{
- printf(">>>>> METHOD 1\n");
- method1();
- printf(">>>>> METHOD 2\n");
- method2();
- printf(">>>>> METHOD 3\n");
- method3();
+ int k;
+ printf(
+"Usage: pcm [OPTION]... [FILE]...\n"
+"-h,--help help\n"
+"-D,--device playback device\n"
+"-r,--rate stream rate in Hz\n"
+"-c,--channels count of channels in stream\n"
+"-f,--frequency sine wave frequency in Hz\n"
+"-b,--buffer ring buffer size in us\n"
+"-p,--period period size in us\n"
+"-m,--method transfer method\n"
+"-o,--format sample format\n"
+"-v,--verbose show the PCM setup parameters\n"
+"-n,--noresample do not resample\n"
+"-e,--pevent enable poll event after each period\n"
+"\n");
+ printf("Recognized sample formats are:");
+ for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
+ const char *s = snd_pcm_format_name(k);
+ if (s)
+ printf(" %s", s);
+ }
+ printf("\n");
+ printf("Recognized transfer methods are:");
+ for (k = 0; transfer_methods[k].name; k++)
+ printf(" %s", transfer_methods[k].name);
+ printf("\n");
+}
+
+int main(int argc, char *argv[])
+{
+ struct option long_option[] =
+ {
+ {"help", 0, NULL, 'h'},
+ {"device", 1, NULL, 'D'},
+ {"rate", 1, NULL, 'r'},
+ {"channels", 1, NULL, 'c'},
+ {"frequency", 1, NULL, 'f'},
+ {"buffer", 1, NULL, 'b'},
+ {"period", 1, NULL, 'p'},
+ {"method", 1, NULL, 'm'},
+ {"format", 1, NULL, 'o'},
+ {"verbose", 1, NULL, 'v'},
+ {"noresample", 1, NULL, 'n'},
+ {"pevent", 1, NULL, 'e'},
+ {NULL, 0, NULL, 0},
+ };
+ snd_pcm_t *handle;
+ int err, morehelp;
+ snd_pcm_hw_params_t *hwparams;
+ snd_pcm_sw_params_t *swparams;
+ int method = 0;
+ signed short *samples;
+ unsigned int chn;
+ snd_pcm_channel_area_t *areas;
+
+ snd_pcm_hw_params_alloca(&hwparams);
+ snd_pcm_sw_params_alloca(&swparams);
+
+ morehelp = 0;
+ while (1) {
+ int c;
+ if ((c = getopt_long(argc, argv, "hD:r:c:f:b:p:m:o:vne", long_option, NULL)) < 0)
+ break;
+ switch (c) {
+ case 'h':
+ morehelp++;
+ break;
+ case 'D':
+ device = strdup(optarg);
+ break;
+ case 'r':
+ rate = atoi(optarg);
+ rate = rate < 4000 ? 4000 : rate;
+ rate = rate > 196000 ? 196000 : rate;
+ break;
+ case 'c':
+ channels = atoi(optarg);
+ channels = channels < 1 ? 1 : channels;
+ channels = channels > 1024 ? 1024 : channels;
+ break;
+ case 'f':
+ freq = atoi(optarg);
+ freq = freq < 50 ? 50 : freq;
+ freq = freq > 5000 ? 5000 : freq;
+ break;
+ case 'b':
+ buffer_time = atoi(optarg);
+ buffer_time = buffer_time < 1000 ? 1000 : buffer_time;
+ buffer_time = buffer_time > 1000000 ? 1000000 : buffer_time;
+ break;
+ case 'p':
+ period_time = atoi(optarg);
+ period_time = period_time < 1000 ? 1000 : period_time;
+ period_time = period_time > 1000000 ? 1000000 : period_time;
+ break;
+ case 'm':
+ for (method = 0; transfer_methods[method].name; method++)
+ if (!strcasecmp(transfer_methods[method].name, optarg))
+ break;
+ if (transfer_methods[method].name == NULL)
+ method = 0;
+ break;
+ case 'o':
+ for (format = 0; format < SND_PCM_FORMAT_LAST; format++) {
+ const char *format_name = snd_pcm_format_name(format);
+ if (format_name)
+ if (!strcasecmp(format_name, optarg))
+ break;
+ }
+ if (format == SND_PCM_FORMAT_LAST)
+ format = SND_PCM_FORMAT_S16;
+ if (!snd_pcm_format_linear(format) &&
+ !(format == SND_PCM_FORMAT_FLOAT_LE ||
+ format == SND_PCM_FORMAT_FLOAT_BE)) {
+ printf("Invalid (non-linear/float) format %s\n",
+ optarg);
+ return 1;
+ }
+ break;
+ case 'v':
+ verbose = 1;
+ break;
+ case 'n':
+ resample = 0;
+ break;
+ case 'e':
+ period_event = 1;
+ break;
+ }
+ }
+
+ if (morehelp) {
+ help();
+ return 0;
+ }
+
+ err = snd_output_stdio_attach(&output, stdout, 0);
+ if (err < 0) {
+ printf("Output failed: %s\n", snd_strerror(err));
+ return 0;
+ }
+
+ printf("Playback device is %s\n", device);
+ printf("Stream parameters are %uHz, %s, %u channels\n", rate, snd_pcm_format_name(format), channels);
+ printf("Sine wave rate is %.4fHz\n", freq);
+ printf("Using transfer method: %s\n", transfer_methods[method].name);
+
+ if ((err = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
+ printf("Playback open error: %s\n", snd_strerror(err));
+ return 0;
+ }
+
+ if ((err = set_hwparams(handle, hwparams, transfer_methods[method].access)) < 0) {
+ printf("Setting of hwparams failed: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+ if ((err = set_swparams(handle, swparams)) < 0) {
+ printf("Setting of swparams failed: %s\n", snd_strerror(err));
+ exit(EXIT_FAILURE);
+ }
+
+ if (verbose > 0)
+ snd_pcm_dump(handle, output);
+
+ samples = malloc((period_size * channels * snd_pcm_format_physical_width(format)) / 8);
+ if (samples == NULL) {
+ printf("No enough memory\n");
+ exit(EXIT_FAILURE);
+ }
+
+ areas = calloc(channels, sizeof(snd_pcm_channel_area_t));
+ if (areas == NULL) {
+ printf("No enough memory\n");
+ exit(EXIT_FAILURE);
+ }
+ for (chn = 0; chn < channels; chn++) {
+ areas[chn].addr = samples;
+ areas[chn].first = chn * snd_pcm_format_physical_width(format);
+ areas[chn].step = channels * snd_pcm_format_physical_width(format);
+ }
+
+ err = transfer_methods[method].transfer_loop(handle, samples, areas);
+ if (err < 0)
+ printf("Transfer failed: %s\n", snd_strerror(err));
+
+ free(areas);
+ free(samples);
+ snd_pcm_close(handle);
return 0;
}
+