[alsa-devel] segfault when setting swparams! help
Guilherme
grlongo.ireland at gmail.com
Fri Jun 19 09:27:58 CEST 2009
Mates...
I am getting a segfault when running my app:
This is the part of the code where I am getting the error:
if ((err = set_swparams(handle, swparams)) < 0) {
printf("Setting of swparams failed: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
That is the gdb output: (*The full program code's been posted below the
debug output)
Starting program: /home/guilherme/Experimentos/PCM
[Thread debugging using libthread_db enabled]
[New Thread 0xb7c896c0 (LWP 3391)]
[Switching to Thread 0xb7c896c0 (LWP 3391)]
Breakpoint 1, main (argc=1, argv=0xbfa27da4) at pcm.c:777
777 };
(gdb) n
783 int method = 0;
(gdb) n
791 morehelp = 0;
(gdb) n
794 if ((c = getopt_long(argc, argv,
"hd:r:c:f:b:p:m:o:vne", long_option, NULL)) < 0)
(gdb) nn
Undefined command: "nn". Try "help".
(gdb) n
857 if(morehelp) {
(gdb) n
863 err = snd_output_stdio_attach(&output, &stdout, 0);
(gdb) n
864 if (err < 0) {
(gdb) n
869 printf("Playback device is %s\n", device);
(gdb) n
Playback device is default
870 printf("Stream parameters are %iHz, %s, %i
channels\n", rate, snd_pcm_format_name(format), channels);
(gdb) n
Stream parameters are 48000Hz, S16_LE, 1 channels
871 printf("sine wave rate is %i %.4fHz\n", freq);
(gdb) n
sine wave rate is 0 0.0000Hz
872 printf("Using transfer method: %s\n",
transfer_methods[method].name);
(gdb) n
Using transfer method: write
874 if ((err = snd_pcm_open(&handle, device,
SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
(gdb) n
879 if ((err = set_hwparams(handle, hwparams,
transfer_methods[method].access)) < 0) {
(gdb) n
Program received signal SIGSEGV, Segmentation fault.
0xb7d47e3f in memset () from /lib/libc.so.6
(gdb) Quit
(gdb) quit
The program is running. Exit anyway? (y or n)
That is the code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sched.h>
#include <errno.h>
#include <getopt.h>
#include <alsa/asoundlib.h>
#include <sys/time.h>
#include <math.h>
static char *device = "default"; //playback device
aplay -l
static snd_pcm_format_t format = SND_PCM_FORMAT_S16; //sample format
unsigned 16 bit endian
static unsigned int rate = 48000; //stream rate
static unsigned int channels = 1; //contagem dos
canais
static unsigned int buffer_time = 500; //ring buffer length
on us
static unsigned int period_time = 100; //period time in us
static double freq = 440; // frequencia da
senóide em Hz
static int verbose = 0; //verbose flag
static int resample = 1; //abilitar
alsa-lib resampling
static int period_event = 0; // produz um
event pool a cada periodo
static snd_pcm_sframes_t buffer_size; //quantidade de
buffers frames
static snd_pcm_sframes_t period_size; //quantidade de
periods frames
static snd_output_t *output = NULL; //ALSA usa esse
ponteiro para lidar com output objects
static void generate_sine(const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset,
int count, double *_phase)
{
static double max_phase = 2. * M_PI;
double phase = *_phase;
double step = max_phase*freq / (double)rate;
double res;
unsigned char *samples[channels], *tmp;
int steps[channels];
unsigned int chn, byte;
union {
int i;
unsigned char c[4];
} ires;
unsigned int maxval = (1 << (snd_pcm_format_width(format) - 1)) - 1;
int bps = snd_pcm_format_width(format) / 8; //bits per sample
/*verificar e preparar o conteúdo das areas*/
for (chn = 0; chn < channels; chn++) {
if ((areas[chn].first % 8) != 0) {
printf("areas[%i].first == %i, abortando...\n", chn,
areas[chn].first);
exit(EXIT_FAILURE);
}
//pega endereço e offset da area
samples[chn] = /*(signed short *)*/(((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];
}
//completa os channels da area
while(count-- > 0) {
res = sin(phase) * maxval;
ires.i = res;
tmp = ires.c;
for (chn = 0; chn < channels; chn++) {
for (byte = 0; byte < (unsigned int)bps; byte++)
*(samples[chn] + byte) = tmp[byte];
samples[chn] += steps[chn];
}
phase += step;
if (phase >= max_phase)
phase -= max_phase;
}
*_phase = phase;
}
static int set_hwparams(snd_pcm_t *handle,
snd_pcm_hw_params_t *params,
snd_pcm_access_t access)
{
unsigned int rrate;
snd_pcm_uframes_t size;
int err, dir;
/*escolha todos os parametros*/
err = snd_pcm_hw_params_any(handle, params);
if (err < 0) {
printf("Broken configuration for playback: no
configuration 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 SND_PCM_FORMAT_S16 */
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 1 */
err = snd_pcm_hw_params_set_channels(handle, params, channels);
if (err < 0) {
printf("Channels count (%i) 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 %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;
}
/* 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 %i 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 %i for playback: %s\n",
period_time, snd_strerror(err));
return 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;
}
static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) {
int err;
/*pegar os parametros atuais 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;
}
/*Começa a transferência quando o buffer está quase cheio*/
/*(buffer_size / avail_min) * avail_min */
err = snd_pcm_sw_params_set_avail_min(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;
}
/* Tenta recuperar estados de underrun e suspend */
static int xrun_recovery(snd_pcm_t *handle, 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); /*espera pela release flag*/
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;
}
/* Metodo de transferência *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);
}//if
ptr += err * channels;
cptr -= err;
}//if
}//if
}//while
}
/*
* Método de transferência - write and wait por espaço no buffer
*/
static int wait_for_poll(snd_pcm_t *handle, struct pollfd *ufds,
unsigned int count)
{
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;
}
}
}
}
}
/*
* Metodo de transferencia - Notificação assincrona
*/
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);
}
}
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 }
};
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) {
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; //ponteiro
para pcm handle
int err, morehelp;
snd_pcm_hw_params_t *hwparams;
//parametros de hardware
snd_pcm_sw_params_t *swparams;
//parametros de software
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 ? 19600 : 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;
break;
case 'v':
verbose = 1;
break;
case 'n':
resample = 0;
break;
case 'e':
period_event = 1;
break;
}//switch
}//while
if(morehelp) {
help();
return 0;
}
//cria um novo output objeto
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 %iHz, %s, %i channels\n",
rate, snd_pcm_format_name(format), channels);
printf("sine wave rate is %i %.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;
}
Any ideas of what might be happening?? I've been looking for a
reasonable explanation but i don't find any related error o online.
Tks in advanced!
Tks!
-------------------
Guilherme Longo
Dept. Eng. da Computação
Unaerp
Linux User - #484927
*Before Asking
http://www.istf.com.br/?page=perguntas
!- I'd rather die on my feet than live on my knees -!
Takashi Iwai wrote:
> At Fri, 19 Jun 2009 02:50:35 +0300,
> Maxim Levitsky wrote:
>
>> Hi,
>>
>> Due to lack of time, I didn't update kernel on my desktop system.
>> Now I notice that analog loopback go removed. Why?
>>
>
> Because it harms than helps more often. I've got tons of bug reports
> and been upset just because users blindly set "Analog Loopback" mixer
> switch and lost their sound output. This is no mixer element that
> behaves intuitively -- it shuts out PCM output instead of adding the
> analog loopback like other hardwares.
>
> The feature is still available, though. You just need to give the
> driver an instruction via sysfs. Namely, write to sysfs files
> corresponding to the IDT codec like
> # echo "loopback yes" > /sys/class/sound/hwC0D0/hints
> # echo 1 > /sys/class/sound/hwC0D0/reconfig
> Then the driver will reconfigure with the loopback mixer element.
>
> I have a patch series to add this with a "patch" firmware file to
> make it easier, which I'm going to send an RFC to this ML soon later.
> Take a look at topic/hda-patch branch on sound-unstable tree.
>
>
> thanks,
>
> Takashi
> _______________________________________________
> Alsa-devel mailing list
> Alsa-devel at alsa-project.org
> http://mailman.alsa-project.org/mailman/listinfo/alsa-devel
>
>
More information about the Alsa-devel
mailing list