#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";
static unsigned int rate = 44100;
static unsigned int channels = 1;
static unsigned int buffer_time = 500000;
static unsigned int period_time = 100000;
static double freq = 440;
static int verbose = 0;
static int resample = 1;
static int period_event = 0;
int count, double *_phase)
{
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;
unsigned int maxval = (1 << (format_bits - 1)) - 1;
int bps = format_bits / 8;
for (chn = 0; chn < channels; chn++) {
if ((areas[chn].first % 8) != 0) {
printf("areas[%i].first == %i, aborting...\n", chn, areas[chn].first);
exit(EXIT_FAILURE);
}
samples[chn] = (((
unsigned char *)areas[chn].addr) + (areas[chn].
first / 8));
if ((areas[chn].step % 16) != 0) {
printf("areas[%i].step == %i, aborting...\n", chn, areas[chn].step);
exit(EXIT_FAILURE);
}
steps[chn] = areas[chn].
step / 8;
samples[chn] += offset * steps[chn];
}
while (count-- > 0) {
union {
float f;
int i;
} fval;
int res, i;
if (is_float) {
fval.f = sin(phase) * maxval;
res = fval.i;
} else
res = sin(phase) * maxval;
if (to_unsigned)
res ^= 1U << (format_bits - 1);
for (chn = 0; chn < channels; chn++) {
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;
}
{
unsigned int rrate;
int err, dir;
if (err < 0) {
printf(
"Broken configuration for playback: no configurations available: %s\n",
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Resampling setup failed for playback: %s\n",
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Access type not available for playback: %s\n",
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Sample format not available for playback: %s\n",
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Channels count (%i) not available for playbacks: %s\n", channels,
snd_strerror(err));
return err;
}
rrate = rate;
if (err < 0) {
printf(
"Rate %iHz not available for playback: %s\n", rate,
snd_strerror(err));
return err;
}
if (rrate != rate) {
printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
return -EINVAL;
}
if (err < 0) {
printf(
"Unable to set buffer time %i for playback: %s\n", buffer_time,
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Unable to get buffer size for playback: %s\n",
snd_strerror(err));
return err;
}
buffer_size = size;
if (err < 0) {
printf(
"Unable to set period time %i for playback: %s\n", period_time,
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Unable to get period size for playback: %s\n",
snd_strerror(err));
return err;
}
period_size = size;
if (err < 0) {
printf(
"Unable to set hw params for playback: %s\n",
snd_strerror(err));
return err;
}
return 0;
}
{
int err;
if (err < 0) {
printf(
"Unable to determine current swparams for playback: %s\n",
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Unable to set start threshold mode for playback: %s\n",
snd_strerror(err));
return err;
}
if (err < 0) {
printf(
"Unable to set avail min for playback: %s\n",
snd_strerror(err));
return err;
}
if (period_event) {
if (err < 0) {
printf(
"Unable to set period event: %s\n",
snd_strerror(err));
return err;
}
}
if (err < 0) {
printf(
"Unable to set sw params for playback: %s\n",
snd_strerror(err));
return err;
}
return 0;
}
static int xrun_recovery(
snd_pcm_t *handle,
int err)
{
if (verbose)
printf("stream recovery\n");
if (err == -EPIPE) {
if (err < 0)
printf(
"Can't recovery from underrun, prepare failed: %s\n",
snd_strerror(err));
return 0;
} else if (err == -ESTRPIPE) {
sleep(1);
if (err < 0) {
if (err < 0)
printf(
"Can't recovery from suspend, prepare failed: %s\n",
snd_strerror(err));
}
return 0;
}
return err;
}
signed short *samples,
{
double phase = 0;
int err, cptr;
while (1) {
generate_sine(areas, 0, period_size, &phase);
ptr = samples;
cptr = period_size;
while (cptr > 0) {
if (err == -EAGAIN)
continue;
if (err < 0) {
if (xrun_recovery(handle, err) < 0) {
exit(EXIT_FAILURE);
}
break;
}
ptr += err * channels;
cptr -= err;
}
}
}
static int wait_for_poll(
snd_pcm_t *handle,
struct pollfd *ufds,
unsigned int count)
{
unsigned short revents;
while (1) {
poll(ufds, count, -1);
if (revents & POLLERR)
return -EIO;
if (revents & POLLOUT)
return 0;
}
}
static int write_and_poll_loop(
snd_pcm_t *handle,
signed short *samples,
{
struct pollfd *ufds;
double phase = 0;
int err, count, cptr, init;
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;
}
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 (xrun_recovery(handle, err) < 0) {
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) {
if (err < 0) {
if (xrun_recovery(handle, err) < 0) {
exit(EXIT_FAILURE);
}
init = 1;
break;
}
init = 0;
ptr += err * channels;
cptr -= err;
if (cptr == 0)
break;
err = wait_for_poll(handle, ufds, count);
if (err < 0) {
if (xrun_recovery(handle, err) < 0) {
exit(EXIT_FAILURE);
}
init = 1;
} else {
printf("Wait for poll failed\n");
return err;
}
}
}
}
}
struct async_private_data {
signed short *samples;
double phase;
};
{
signed short *samples = data->samples;
int err;
while (avail >= period_size) {
generate_sine(areas, 0, period_size, &data->phase);
if (err < 0) {
exit(EXIT_FAILURE);
}
if (err != period_size) {
printf("Write error: written %i expected %li\n", err, period_size);
exit(EXIT_FAILURE);
}
}
}
signed short *samples,
{
struct async_private_data data;
int err, count;
data.samples = samples;
data.areas = areas;
data.phase = 0;
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);
if (err < 0) {
exit(EXIT_FAILURE);
}
if (err != period_size) {
printf("Initial write error: written %i expected %li\n", err, period_size);
exit(EXIT_FAILURE);
}
}
if (err < 0) {
exit(EXIT_FAILURE);
}
}
while (1) {
sleep(1);
}
}
{
int first = 0, err;
while (1) {
err = xrun_recovery(handle, -EPIPE);
if (err < 0) {
exit(EXIT_FAILURE);
}
first = 1;
err = xrun_recovery(handle, -ESTRPIPE);
if (err < 0) {
exit(EXIT_FAILURE);
}
}
if (avail < 0) {
err = xrun_recovery(handle, avail);
if (err < 0) {
exit(EXIT_FAILURE);
}
first = 1;
continue;
}
if (avail < period_size) {
if (first) {
first = 0;
if (err < 0) {
exit(EXIT_FAILURE);
}
} else {
break;
}
continue;
}
size = period_size;
while (size > 0) {
frames = size;
if (err < 0) {
if ((err = xrun_recovery(handle, err)) < 0) {
exit(EXIT_FAILURE);
}
first = 1;
}
generate_sine(my_areas, offset, frames, &data->phase);
if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
exit(EXIT_FAILURE);
}
first = 1;
}
size -= frames;
}
}
}
static int async_direct_loop(
snd_pcm_t *handle,
signed short *samples ATTRIBUTE_UNUSED,
{
struct async_private_data data;
int err, count;
data.samples = NULL;
data.areas = NULL;
data.phase = 0;
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;
if (err < 0) {
if ((err = xrun_recovery(handle, err)) < 0) {
exit(EXIT_FAILURE);
}
}
generate_sine(my_areas, offset, frames, &data.phase);
if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
exit(EXIT_FAILURE);
}
}
size -= frames;
}
}
if (err < 0) {
exit(EXIT_FAILURE);
}
while (1) {
sleep(1);
}
}
signed short *samples ATTRIBUTE_UNUSED,
{
double phase = 0;
int err, first = 1;
while (1) {
err = xrun_recovery(handle, -EPIPE);
if (err < 0) {
return err;
}
first = 1;
err = xrun_recovery(handle, -ESTRPIPE);
if (err < 0) {
return err;
}
}
if (avail < 0) {
err = xrun_recovery(handle, avail);
if (err < 0) {
return err;
}
first = 1;
continue;
}
if (avail < period_size) {
if (first) {
first = 0;
if (err < 0) {
exit(EXIT_FAILURE);
}
} else {
if (err < 0) {
if ((err = xrun_recovery(handle, err)) < 0) {
exit(EXIT_FAILURE);
}
first = 1;
}
}
continue;
}
size = period_size;
while (size > 0) {
frames = size;
if (err < 0) {
if ((err = xrun_recovery(handle, err)) < 0) {
exit(EXIT_FAILURE);
}
first = 1;
}
generate_sine(my_areas, offset, frames, &phase);
if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
exit(EXIT_FAILURE);
}
first = 1;
}
size -= frames;
}
}
}
static int direct_write_loop(
snd_pcm_t *handle,
signed short *samples,
{
double phase = 0;
int err, cptr;
while (1) {
generate_sine(areas, 0, period_size, &phase);
ptr = samples;
cptr = period_size;
while (cptr > 0) {
if (err == -EAGAIN)
continue;
if (err < 0) {
if (xrun_recovery(handle, err) < 0) {
exit(EXIT_FAILURE);
}
break;
}
ptr += err * channels;
cptr -= err;
}
}
}
struct transfer_method {
const char *name;
signed short *samples,
};
static struct transfer_method transfer_methods[] = {
};
static void help(void)
{
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) {
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},
};
int err, morehelp;
int method = 0;
signed short *samples;
unsigned int chn;
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++) {
if (format_name)
if (!strcasecmp(format_name, optarg))
break;
}
if (format == SND_PCM_FORMAT_LAST)
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;
}
if (err < 0) {
return 0;
}
printf("Playback device is %s\n", device);
printf(
"Stream parameters are %iHz, %s, %i 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);
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)
if (samples == NULL) {
printf("No enough memory\n");
exit(EXIT_FAILURE);
}
if (areas == NULL) {
printf("No enough memory\n");
exit(EXIT_FAILURE);
}
for (chn = 0; chn < channels; chn++) {
areas[chn].
addr = samples;
}
err = transfer_methods[method].transfer_loop(handle, samples, areas);
if (err < 0)
free(areas);
free(samples);
return 0;
}