static void alsa_log(snd_pcm_hw_params_t* hw_params, snd_pcm_sw_params_t* sw_params)
{
unsigned period_time;
snd_pcm_uframes_t period_size;
unsigned period_count;
unsigned buffer_time;
snd_pcm_uframes_t buffer_size;
unsigned tick_time;
snd_pcm_uframes_t xfer_align;
snd_pcm_hw_params_get_period_time(hw_params, &period_time, 0);
snd_pcm_hw_params_get_period_size(hw_params, &period_size, 0);
snd_pcm_hw_params_get_periods(hw_params, &period_count, 0);
snd_pcm_hw_params_get_buffer_time(hw_params, &buffer_time, 0);
snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
snd_pcm_hw_params_get_tick_time(hw_params, &tick_time, 0);
log_std(("sound:alsa: hw period_time %g [us], period_size %d, periods %d, buffer_time %g [us], buffer_size %d, tick_time %g [us]\n",
(double)(period_time / 1000000.0), (unsigned)period_size, (unsigned)period_count, (double)(buffer_time / 1000000.0), (unsigned)buffer_size, (double)(tick_time / 1000000.0)
));
snd_pcm_sw_params_get_xfer_align(sw_params, &xfer_align);
log_std(("sound:alsa: sw xfer_align %d\n",
(unsigned)xfer_align
));
}
int main()
{
int rc;
snd_pcm_t* handle;
snd_pcm_hw_params_t* params;
unsigned int val;
unsigned int val2;
int dir;
snd_pcm_uframes_t frames;
if ( (rc = snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0)) < 0)
{
std::cerr << "unable to open pcm devices: " << snd_strerror(rc) << std::endl;
exit(1);
}
snd_pcm_hw_params_alloca(¶ms);
snd_pcm_hw_params_any(handle, params);
snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
snd_pcm_hw_params_set_channels(handle, params, 2);
val = 44100;
snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir);
if ( (rc = snd_pcm_hw_params(handle, params)) < 0)
{
std::cerr << "unable to set hw parameters: " << snd_strerror(rc) << std::endl;
exit(1);
}
std::cout << "PCM handle name = " << snd_pcm_name(handle) << std::endl;
std::cout << "PCM state = " << snd_pcm_state_name(snd_pcm_state(handle)) << std::endl;
snd_pcm_hw_params_get_access(params, (snd_pcm_access_t *)&val);
std::cout << "access type = " << snd_pcm_access_name((snd_pcm_access_t)val) << std::endl;
snd_pcm_hw_params_get_format(params, (snd_pcm_format_t*)(&val));
std::cout << "format = '" << snd_pcm_format_name((snd_pcm_format_t)val) << "' (" << snd_pcm_format_description((snd_pcm_format_t)val) << ")" << std::endl;
snd_pcm_hw_params_get_subformat(params, (snd_pcm_subformat_t *)&val);
std::cout << "subformat = '" <<
snd_pcm_subformat_name((snd_pcm_subformat_t)val) << "' (" << snd_pcm_subformat_description((snd_pcm_subformat_t)val) << ")" << std::endl;
snd_pcm_hw_params_get_channels(params, &val);
std::cout << "channels = " << val << std::endl;
snd_pcm_hw_params_get_rate(params, &val, &dir);
std::cout << "rate = " << val << " bps" << std::endl;
snd_pcm_hw_params_get_period_time(params, &val, &dir);
std::cout << "period time = " << val << " us" << std::endl;
snd_pcm_hw_params_get_period_size(params, &frames, &dir);
std::cout << "period size = " << static_cast<int>(frames) << " frames" << std::endl;
snd_pcm_hw_params_get_buffer_time(params, &val, &dir);
std::cout << "buffer time = " << val << " us" << std::endl;
snd_pcm_hw_params_get_buffer_size(params, (snd_pcm_uframes_t *) &val);
std::cout << "buffer size = " << val << " frames" << std::endl;
snd_pcm_hw_params_get_periods(params, &val, &dir);
std::cout << "periods per buffer = " << val << " frames" << std::endl;
snd_pcm_hw_params_get_rate_numden(params, &val, &val2);
std::cout << "exact rate = " << val/val2 << " bps" << std::endl;
val = snd_pcm_hw_params_get_sbits(params);
std::cout << "significant bits = " << val << std::endl;
snd_pcm_hw_params_get_tick_time(params, &val, &dir);
std::cout << "tick time = " << val << " us" << std::endl;
val = snd_pcm_hw_params_is_batch(params);
std::cout << "is batch = " << val << std::endl;
val = snd_pcm_hw_params_is_block_transfer(params);
std::cout << "is block transfer = " << val << std::endl;
val = snd_pcm_hw_params_is_double(params);
std::cout << "is double = " << val << std::endl;
val = snd_pcm_hw_params_is_half_duplex(params);
std::cout << "is half duplex = " << val << std::endl;
val = snd_pcm_hw_params_is_joint_duplex(params);
std::cout << "is joint duplex = " << val << std::endl;
val = snd_pcm_hw_params_can_overrange(params);
std::cout << "can overrange = " << val << std::endl;
val = snd_pcm_hw_params_can_mmap_sample_resolution(params);
std::cout << "can mmap = " << val << std::endl;
val = snd_pcm_hw_params_can_pause(params);
std::cout << "can pause = " << val << std::endl;
val = snd_pcm_hw_params_can_resume(params);
std::cout << "can resume = " << val << std::endl;
val = snd_pcm_hw_params_can_sync_start(params);
std::cout << "can sync start = " << val << std::endl;
snd_pcm_close(handle);
return 0;
}
int main() {
int rc;
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
unsigned int val, val2;
int dir;
snd_pcm_uframes_t frames;
/* Open PCM device for playback. */
rc = snd_pcm_open(&handle, "default",
SND_PCM_STREAM_PLAYBACK, 0);
if (rc < 0) {
fprintf(stderr,
"unable to open pcm device: %s\n",
snd_strerror(rc));
exit(1);
}
/* Allocate a hardware parameters object. */
snd_pcm_hw_params_alloca(¶ms);
/* Fill it in with default values. */
snd_pcm_hw_params_any(handle, params);
/* Set the desired hardware parameters. */
/* Interleaved mode */
snd_pcm_hw_params_set_access(handle, params,
SND_PCM_ACCESS_RW_INTERLEAVED);
/* Signed 16-bit little-endian format */
snd_pcm_hw_params_set_format(handle, params,
SND_PCM_FORMAT_S16_LE);
/* Two channels (stereo) */
snd_pcm_hw_params_set_channels(handle, params, 2);
/* 44100 bits/second sampling rate (CD quality) */
val = 44100;
snd_pcm_hw_params_set_rate_near(handle,
params, &val, &dir);
/* Write the parameters to the driver */
rc = snd_pcm_hw_params(handle, params);
if (rc < 0) {
fprintf(stderr,
"unable to set hw parameters: %s\n",
snd_strerror(rc));
exit(1);
}
/* Display information about the PCM interface */
printf("PCM handle name = '%s'\n",
snd_pcm_name(handle));
printf("PCM state = %s\n",
snd_pcm_state_name(snd_pcm_state(handle)));
snd_pcm_hw_params_get_access(params,
(snd_pcm_access_t *) &val);
printf("access type = %s\n",
snd_pcm_access_name((snd_pcm_access_t)val));
snd_pcm_hw_params_get_format(params, &val);
printf("format = '%s' (%s)\n",
snd_pcm_format_name((snd_pcm_format_t)val),
snd_pcm_format_description(
(snd_pcm_format_t)val));
snd_pcm_hw_params_get_subformat(params,
(snd_pcm_subformat_t *)&val);
printf("subformat = '%s' (%s)\n",
snd_pcm_subformat_name((snd_pcm_subformat_t)val),
snd_pcm_subformat_description(
(snd_pcm_subformat_t)val));
snd_pcm_hw_params_get_channels(params, &val);
printf("channels = %d\n", val);
snd_pcm_hw_params_get_rate(params, &val, &dir);
printf("rate = %d bps\n", val);
snd_pcm_hw_params_get_period_time(params,
&val, &dir);
printf("period time = %d us\n", val);
snd_pcm_hw_params_get_period_size(params,
&frames, &dir);
printf("period size = %d frames\n", (int)frames);
snd_pcm_hw_params_get_buffer_time(params,
&val, &dir);
printf("buffer time = %d us\n", val);
snd_pcm_hw_params_get_buffer_size(params,
(snd_pcm_uframes_t *) &val);
printf("buffer size = %d frames\n", val);
snd_pcm_hw_params_get_periods(params, &val, &dir);
printf("periods per buffer = %d frames\n", val);
snd_pcm_hw_params_get_rate_numden(params,
&val, &val2);
printf("exact rate = %d/%d bps\n", val, val2);
val = snd_pcm_hw_params_get_sbits(params);
printf("significant bits = %d\n", val);
snd_pcm_hw_params_get_tick_time(params,
&val, &dir);
printf("tick time = %d us\n", val);
val = snd_pcm_hw_params_is_batch(params);
printf("is batch = %d\n", val);
val = snd_pcm_hw_params_is_block_transfer(params);
printf("is block transfer = %d\n", val);
val = snd_pcm_hw_params_is_double(params);
printf("is double = %d\n", val);
val = snd_pcm_hw_params_is_half_duplex(params);
printf("is half duplex = %d\n", val);
val = snd_pcm_hw_params_is_joint_duplex(params);
printf("is joint duplex = %d\n", val);
val = snd_pcm_hw_params_can_overrange(params);
printf("can overrange = %d\n", val);
val = snd_pcm_hw_params_can_mmap_sample_resolution(params);
printf("can mmap = %d\n", val);
val = snd_pcm_hw_params_can_pause(params);
printf("can pause = %d\n", val);
val = snd_pcm_hw_params_can_resume(params);
printf("can resume = %d\n", val);
val = snd_pcm_hw_params_can_sync_start(params);
printf("can sync start = %d\n", val);
snd_pcm_close(handle);
return 0;
}
int setparams_set(snd_pcm_t *handle,
snd_pcm_hw_params_t *params,
snd_pcm_sw_params_t *swparams,
const char *id)
{
int err;
snd_pcm_uframes_t val;
unsigned int sleep_min = 0;
err = snd_pcm_hw_params(handle, params);
if (err < 0) {
printf("Unable to set hw params for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
printf("Unable to determine current swparams for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0x7fffffff);
if (err < 0) {
printf("Unable to set start threshold mode for %s: %s\n", id, snd_strerror(err));
return err;
}
tick_time_ok = 0;
if (tick_time > 0) {
int time, ttime;
snd_pcm_hw_params_get_period_time(params, &time, NULL);
snd_pcm_hw_params_get_tick_time(params, &ttime, NULL);
if (time < ttime) {
printf("Skipping to set minimal sleep: period time < tick time\n");
} else if (ttime <= 0) {
printf("Skipping to set minimal sleep: tick time <= 0 (%i)\n", ttime);
} else {
sleep_min = tick_time / ttime;
if (sleep_min <= 0)
sleep_min = 1;
err = snd_pcm_sw_params_set_sleep_min(handle, swparams, sleep_min);
if (err < 0) {
printf("Unable to set minimal sleep %i for %s: %s\n", sleep_min, id, snd_strerror(err));
return err;
}
tick_time_ok = sleep_min * ttime;
}
}
if (!block)
val = 4;
else
snd_pcm_hw_params_get_period_size(params, &val, NULL);
if (tick_time_ok > 0)
val = 16;
err = snd_pcm_sw_params_set_avail_min(handle, swparams, val);
if (err < 0) {
printf("Unable to set avail min for %s: %s\n", id, snd_strerror(err));
return err;
}
val = !block ? 4 : 1;
err = snd_pcm_sw_params_set_xfer_align(handle, swparams, val);
if (err < 0) {
printf("Unable to set transfer align for %s: %s\n", id, snd_strerror(err));
return err;
}
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
printf("Unable to set sw params for %s: %s\n", id, snd_strerror(err));
return err;
}
return 0;
}
bool QAudioInputPrivate::open( QObject *input )
{
// Open the Alsa capture device.
bool rc = true;
int err;
unsigned int freakuency = frequency;
if ((err = snd_pcm_open(&handle,
m_device.constData(), //"plughw:0,0"
SND_PCM_STREAM_CAPTURE,
0/*SND_PCM_ASYNC*/)) < 0) {
qWarning( "QAudioInput: snd_pcm_open: error %d", err);
rc = false;
}
else {
snd_pcm_hw_params_t *hwparams;
// We want non-blocking mode.
snd_pcm_nonblock(handle, 1);
// Set the desired parameters.
snd_pcm_hw_params_alloca(&hwparams);
err = snd_pcm_hw_params_any(handle, hwparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_any: err %d", err);
}
err = snd_pcm_hw_params_set_access(handle, hwparams,
access);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_access: err %d",err);
}
err = snd_pcm_hw_params_set_format(handle, hwparams,format);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_format: err %d",err);
}
err = snd_pcm_hw_params_set_channels(handle,hwparams,(unsigned int)channels);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_channels: err %d",err);
}
err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &freakuency, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_rate_near: err %d",err);
}
if(freakuency > 1.05 * frequency || freakuency < 0.95 * frequency) {
qWarning("QAudioInput: warning, sample rate %i not supported by the hardware, using %u", frequency, freakuency);
}
if ( samplesPerBlock != -1 ) {
// Set buffer and period sizes based on the supplied block size.
sample_size = (snd_pcm_uframes_t)( samplesPerBlock * channels / 8 );
err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &freakuency, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_rate_near: err %d",err);
}
if(freakuency > 1.05 * frequency || freakuency < 0.95 * frequency) {
qWarning( "QAudioInput: warning, sample rate %i not supported by the hardware, using %u", frequency, freakuency);
}
err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_buffer_time_near: err %d",err);
}
period_time = 1000000 * 256 / frequency;
err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_period_time_near: err %d",err);
}
} else {
// Use the largest buffer and period sizes we can.
err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_buffer_time_near: err %d",err);
}
period_time = 1000000 * 256 / frequency;
err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, 0);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params_set_period_time_near: err %d",err);
}
}
err = snd_pcm_hw_params(handle, hwparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_hw_params: err %d",err);
}
int dir;
unsigned int vval, vval2;
snd_pcm_access_t aval;
snd_pcm_format_t fval;
snd_pcm_subformat_t sval;
qLog(QAudioInput) << "PCM handle name = " << snd_pcm_name(handle);
qLog(QAudioInput) << "PCM state = " << snd_pcm_state_name(snd_pcm_state(handle));
snd_pcm_hw_params_get_access(hwparams,&aval);
vval = (unsigned int)aval;
if ( (int)vval != (int)access ) {
qLog(QAudioInput) << QString("access type not set, want %1 got %2")
.arg(snd_pcm_access_name((snd_pcm_access_t)access))
.arg(snd_pcm_access_name((snd_pcm_access_t)vval));
access = (snd_pcm_access_t)vval;
}
qLog(QAudioInput) << "access type = " << snd_pcm_access_name((snd_pcm_access_t)vval);
snd_pcm_hw_params_get_format(hwparams, &fval);
vval = (unsigned int)fval;
if ( (int)vval != (int)format ) {
qLog(QAudioInput) << QString("format type not set, want %1 got %2")
.arg(snd_pcm_format_name((snd_pcm_format_t)format))
.arg(snd_pcm_format_name((snd_pcm_format_t)vval));
format = (snd_pcm_format_t)vval;
}
qLog(QAudioInput) << QString("format = '%1' (%2)")
.arg(snd_pcm_format_name((snd_pcm_format_t)vval))
.arg(snd_pcm_format_description((snd_pcm_format_t)vval))
.toLatin1().constData();
snd_pcm_hw_params_get_subformat(hwparams,&sval);
vval = (unsigned int)sval;
qLog(QAudioInput) << QString("subformat = '%1' (%2)")
.arg(snd_pcm_subformat_name((snd_pcm_subformat_t)vval))
.arg(snd_pcm_subformat_description((snd_pcm_subformat_t)vval))
.toLatin1().constData();
snd_pcm_hw_params_get_channels(hwparams, &vval);
if ( (int)vval != (int)channels ) {
qLog(QAudioInput) << QString("channels type not set, want %1 got %2").arg(channels).arg(vval);
channels = vval;
}
qLog(QAudioInput) << "channels = " << vval;
snd_pcm_hw_params_get_rate(hwparams, &vval, &dir);
if ( (int)vval != (int)frequency ) {
qLog(QAudioInput) << QString("frequency type not set, want %1 got %2").arg(frequency).arg(vval);
frequency = vval;
}
qLog(QAudioInput) << "rate =" << vval << " bps";
snd_pcm_hw_params_get_period_time(hwparams,&period_time, &dir);
qLog(QAudioInput) << "period time =" << period_time << " us";
snd_pcm_hw_params_get_period_size(hwparams,&period_size, &dir);
qLog(QAudioInput) << "period size =" << (int)period_size;
snd_pcm_hw_params_get_buffer_time(hwparams,&buffer_time, &dir);
qLog(QAudioInput) << "buffer time =" << buffer_time;
snd_pcm_hw_params_get_buffer_size(hwparams,(snd_pcm_uframes_t *) &buffer_size);
qLog(QAudioInput) << "buffer size =" << (int)buffer_size;
snd_pcm_hw_params_get_periods(hwparams, &vval, &dir);
qLog(QAudioInput) << "periods per buffer =" << vval;
snd_pcm_hw_params_get_rate_numden(hwparams, &vval, &vval2);
qLog(QAudioInput) << QString("exact rate = %1/%2 bps").arg(vval).arg(vval2).toLatin1().constData();
vval = snd_pcm_hw_params_get_sbits(hwparams);
qLog(QAudioInput) << "significant bits =" << vval;
snd_pcm_hw_params_get_tick_time(hwparams,&vval, &dir);
qLog(QAudioInput) << "tick time =" << vval;
vval = snd_pcm_hw_params_is_batch(hwparams);
qLog(QAudioInput) << "is batch =" << vval;
vval = snd_pcm_hw_params_is_block_transfer(hwparams);
qLog(QAudioInput) << "is block transfer =" << vval;
vval = snd_pcm_hw_params_is_double(hwparams);
qLog(QAudioInput) << "is double =" << vval;
vval = snd_pcm_hw_params_is_half_duplex(hwparams);
qLog(QAudioInput) << "is half duplex =" << vval;
vval = snd_pcm_hw_params_is_joint_duplex(hwparams);
qLog(QAudioInput) << "is joint duplex =" << vval;
vval = snd_pcm_hw_params_can_overrange(hwparams);
qLog(QAudioInput) << "can overrange =" << vval;
vval = snd_pcm_hw_params_can_mmap_sample_resolution(hwparams);
qLog(QAudioInput) << "can mmap =" << vval;
vval = snd_pcm_hw_params_can_pause(hwparams);
qLog(QAudioInput) << "can pause =" << vval;
vval = snd_pcm_hw_params_can_resume(hwparams);
qLog(QAudioInput) << "can resume =" << vval;
vval = snd_pcm_hw_params_can_sync_start(hwparams);
qLog(QAudioInput) << "can sync start =" << vval;
snd_pcm_sw_params_t *swparams;
snd_pcm_sw_params_alloca(&swparams);
err = snd_pcm_sw_params_current(handle, swparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_current: err %d",err);
}
err = snd_pcm_sw_params_set_start_threshold(handle,swparams,period_size);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_set_start_threshold: err %d",err);
}
err = snd_pcm_sw_params_set_avail_min(handle, swparams,period_size);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_set_avail_min: err %d",err);
}
err = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params_set_xfer_align: err %d",err);
}
err = snd_pcm_sw_params(handle, swparams);
if ( err < 0 ) {
qWarning( "QAudioInput: snd_pcm_sw_params: err %d",err);
}
snd_pcm_prepare(handle);
snd_pcm_start(handle);
int count = snd_pcm_poll_descriptors_count(handle);
pollfd *pfds = new pollfd[count];
snd_pcm_poll_descriptors(handle, pfds, count);
for (int i = 0; i < count; ++i)
{
if ((pfds[i].events & POLLIN) != 0) {
notifier = new QSocketNotifier(pfds[i].fd, QSocketNotifier::Read);
QObject::connect(notifier,
SIGNAL(activated(int)),
input,
SIGNAL(readyRead()));
break;
}
}
if (notifier == NULL) {
rc = false;
}
delete pfds;
}
return rc;
}
int main() {
int result;
snd_pcm_t *handle = NULL;
snd_pcm_hw_params_t *params = NULL;
snd_pcm_uframes_t frames;
snd_pcm_access_t access;
snd_pcm_format_t format;
unsigned int rate = 44100;
unsigned int val, val2;
int dir = 0;
const char *device = getenv ("ALSA_DEFAULT");
if (device == NULL) {
device = "default";
}
result = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0);
if (result < 0)
showErrorAndExit(result, "Error: Unable to open PCM device: %s\n");
result = snd_pcm_hw_params_malloc(¶ms);
if (result < 0)
showErrorAndExit(result, "Error: No memory for hardware parameters: %s\n");
result = snd_pcm_hw_params_any(handle, params);
if (result < 0)
showErrorAndExit(result, "Error: Cannot read HW params: %s\n");
result = snd_pcm_hw_params_set_access(handle, params,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (result < 0)
showErrorAndExit(result, "Could not set access method: %s\n");
result = snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
if (result < 0)
showErrorAndExit(result, "Error: Could not set output format: %s\n");
result = snd_pcm_hw_params_set_channels(handle, params, 1);
if (result < 0)
showErrorAndExit(result, "Error: Cannot set to 1 channel: %s\n");
result = snd_pcm_hw_params_set_rate_near(handle, params, &rate, &dir);
if (result < 0)
showErrorAndExit(result, "Error: Could not set rate: %s\n");
result = snd_pcm_hw_params(handle, params);
if (result < 0)
showErrorAndExit(result, "Error: Could not write HW params: %s\n");
printf("Card Parameters\n");
printf("%30s: %s\n", "Alsa Library Version", snd_asoundlib_version());
result = snd_pcm_hw_params_get_access(params, &access);
if (result < 0) {
showErrorAndExit(result, "Error: Could not retrieve access mode: %s\n");
} else {
printf("%30s: %s\n", "Access Method", snd_pcm_access_name(access));
}
result = snd_pcm_hw_params_get_format(params, &format);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to retrieve format type: %d\n");
} else {
printf("%30s: %s\n", "Format", snd_pcm_format_name(format));
}
result = snd_pcm_hw_params_get_channels(params, &val);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to retrieve channel count: %s\n");
} else {
printf("%30s: %d\n", "Channels", val);
}
result = snd_pcm_hw_params_get_rate(params, &val, &dir);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to retrieve rate: %s\n");
} else {
printf("%30s: %d bps\n", "Rate", val);
}
result = snd_pcm_hw_params_get_period_time(params, &val, &dir);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to retrieve period time: %s\n");
} else {
printf("%30s: %d us\n", "Period Time", val);
}
result = snd_pcm_hw_params_get_period_size(params, &frames, &dir);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to retrieve period size: %s\n");
} else {
printf("%30s: %d frames\n", "Period Size", (int) frames);
}
result = snd_pcm_hw_params_get_buffer_time(params, &val, &dir);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to retrieve buffer time: %s\n");
} else {
printf("%30s: %d us\n", "Buffer Time", val);
}
result = snd_pcm_hw_params_get_buffer_size(params, &frames);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to retrieve buffer size: %s\n");
} else {
printf("%30s: %d frames\n", "Buffer Size", (int) frames);
}
result = snd_pcm_hw_params_get_periods(params, &val, &dir);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to get buffer periods: %s\n");
} else {
printf("%30s: %d frames\n", "Periods per Buffer", val);
}
result = snd_pcm_hw_params_get_rate_numden(params, &val, &val2);
if (result < 0) {
showErrorAndExit(result, "Error: Unable to get rate numerator/denominator: %s\n");
} else {
printf("%30s: %d/%d bps\n", "Exact Rate", val, val2);
}
val = snd_pcm_hw_params_get_sbits(params);
printf("%30s: %d\n", "Significant Bits", val);
result = snd_pcm_hw_params_get_tick_time(params, &val, &dir);
if (result < 0) {
showErrorAndExit(result, "Error: Could not retrieve tick time: %s\n");
} else {
printf("%30s: %d\n", "Tick Time", val);
}
printf("Card Capabilities\n");
val = snd_pcm_hw_params_is_batch(params);
printf("%30s: %s\n", "Batch Transfer", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_is_block_transfer(params);
printf("%30s: %s\n", "Block Transfer", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_is_double(params);
printf("%30s: %s\n", "Double Buffering", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_is_half_duplex(params);
printf("%30s: %s\n", "Half Duplex Only", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_is_joint_duplex(params);
printf("%30s: %s\n", "Joint Duplex Capable", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_can_overrange(params);
printf("%30s: %s\n", "Support Overrange Detection", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_can_mmap_sample_resolution(params);
printf("%30s: %s\n", "Support Sample-res Mmap", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_can_pause(params);
printf("%30s: %s\n", "Can Pause", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_can_resume(params);
printf("%30s: %s\n", "Can Resume", (val ? "Yes" : "No"));
val = snd_pcm_hw_params_can_sync_start(params);
printf("%30s: %s\n", "Support Sync Start", (val ? "Yes" : "No"));
result = snd_pcm_close(handle);
if (result < 0)
showErrorAndExit(result, "Error: Could not close PCM device: %s\n");
return 0;
}
