i have a test app that works successfully with hw:0,1 on gnto if i link it dynamically:
dmx-gnto jutz # ./atestminhw1
Playback device is hw:0,1
Stream parameters are 48000Hz, S16_LE, 6 channels
Rate set to 48000Hz (requested 48000Hz)
Buffer size range from 6 to 5461
Period size range from 3 to 2730
Using max buffer size 5460
Periods = 4
was set period_size = 1365
was set buffer_size = 5460
Channel: 0 Freq: 220.000000
but it fails to find hw:0,1 if i link it statically, is that expected behavior?
dmx-gnto jutz # ./atestminhw1
Playback device is hw:0,1
Stream parameters are 48000Hz, S16_LE, 6 channels
ALSA lib pcm.c:2109:(snd_pcm_open_conf) symbol _snd_pcm_hw_open is not defined inside (null)
Failed: No such device or address
this line succeeds with a dynamic linking and fails with
if(0 > (iErr = snd_pcm_open(&pPcm, gs_pcNameDev, SND_PCM_STREAM_PLAYBACK, 0))) goto fin;
here is my static link arguments:
gcc -g -static -o atestminhw1 atestmin.c -lasound -lm -lpthread -ldl
here is my dynamic link arguments:
gcc -g -o atestminhw1 atestmin.c -lasound
and, for completeness, here is my lame test app, derived from other test apps that come with the source:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sched.h>
#include <errno.h>
#include <getopt.h>
#include <inttypes.h>
#include <ctype.h>
#include <byteswap.h>
#define ALSA_PCM_NEW_HW_PARAMS_API
#define ALSA_PCM_NEW_SW_PARAMS_API
#include <alsa/asoundlib.h>
#include <sys/time.h>
#include <math.h>
#define MAX_CHANNELS 16
static char *gs_pcNameDev = "hw:0,1"; /* playback device */
//static char *gs_pcNameDev = "plughw"; /* playback device */
//static char *gs_pcNameDev = "default"; /* playback device */
static snd_pcm_format_t gs_SndPcmFmt = SND_PCM_FORMAT_S16; /* sample format */
static unsigned int gs_uRate = 48000; /* stream rate */
static unsigned int gs_uCntChan = 6; /* count of channels */
static unsigned int gs_uTimBuf = 0; /* ring buffer length in us */
static unsigned int gs_uTimPer = 0; /* period time in us */
static unsigned int gs_uCntPer = 4; /* number of periods */
static double gs_dFreq = 440; /* sinusoidal wave frequency in Hz */
static snd_pcm_uframes_t gs_uSizBuf;
static snd_pcm_uframes_t gs_uSizPer;
static int set_hwparams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, snd_pcm_access_t access)
{
unsigned int uRate;
int iErr;
snd_pcm_uframes_t period_size_min;
snd_pcm_uframes_t period_size_max;
snd_pcm_uframes_t buffer_size_min;
snd_pcm_uframes_t buffer_size_max;
/* choose all parameters */
if (0 > (iErr = snd_pcm_hw_params_any(handle, params)))
{
printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(iErr));
return iErr;
}
/* set the interleaved read/write format */
if (0 > (iErr = snd_pcm_hw_params_set_access(handle, params, access)))
{
printf("Access type not available for playback: %s\n", snd_strerror(iErr));
return iErr;
}
/* set the sample format */
if (0 > (iErr = snd_pcm_hw_params_set_format(handle, params, gs_SndPcmFmt)))
{
printf("Sample format not available for playback: %s\n", snd_strerror(iErr));
return iErr;
}
/* set the count of channels */
if (0 > (iErr = snd_pcm_hw_params_set_channels(handle, params, gs_uCntChan)))
{
printf("Channels count (%i) not available for playbacks: %s\n", gs_uCntChan, snd_strerror(iErr));
return iErr;
}
/* set the stream rate */
uRate = gs_uRate;
if (0 > (iErr = snd_pcm_hw_params_set_rate(handle, params, gs_uRate, 0)))
{
printf("Rate %iHz not available for playback: %s\n", gs_uRate, snd_strerror(iErr));
return iErr;
}
if (uRate != gs_uRate)
{
printf("Rate doesn't match (requested %iHz, get %iHz, err %d)\n", gs_uRate, uRate, iErr);
return -EINVAL;
}
printf("Rate set to %iHz (requested %iHz)\n", uRate, gs_uRate);
/* set the buffer time */
iErr = snd_pcm_hw_params_get_buffer_size_min(params, &buffer_size_min);
iErr = snd_pcm_hw_params_get_buffer_size_max(params, &buffer_size_max);
iErr = snd_pcm_hw_params_get_period_size_min(params, &period_size_min, NULL);
iErr = snd_pcm_hw_params_get_period_size_max(params, &period_size_max, NULL);
printf("Buffer size range from %lu to %lu\n",buffer_size_min, buffer_size_max);
printf("Period size range from %lu to %lu\n",period_size_min, period_size_max);
if (gs_uTimPer > 0)
{
printf("Requested period time %u us\n", gs_uTimPer);
if (0 > (iErr = snd_pcm_hw_params_set_period_time_near(handle, params, &gs_uTimPer, NULL)))
{
printf("Unable to set period time %u us for playback: %s\n",
gs_uTimPer, snd_strerror(iErr));
return iErr;
}
}
if (gs_uTimBuf > 0)
{
printf("Requested buffer time %u us\n", gs_uTimBuf);
if (0 > (iErr = snd_pcm_hw_params_set_buffer_time_near(handle, params, &gs_uTimBuf, NULL)))
{
printf("Unable to set buffer time %u us for playback: %s\n",
gs_uTimBuf, snd_strerror(iErr));
return iErr;
}
}
if (! gs_uTimBuf && ! gs_uTimPer)
{
gs_uSizBuf = buffer_size_max;
if (! gs_uTimPer) gs_uSizBuf = (gs_uSizBuf / gs_uCntPer) * gs_uCntPer;
printf("Using max buffer size %lu\n", gs_uSizBuf);
if (0 > (iErr = snd_pcm_hw_params_set_buffer_size_near(handle, params, &gs_uSizBuf)))
{
printf("Unable to set buffer size %lu for playback: %s\n",
gs_uSizBuf, snd_strerror(iErr));
return iErr;
}
}
if (! gs_uTimBuf || ! gs_uTimPer)
{
printf("Periods = %u\n", gs_uCntPer);
if (0 > (iErr = snd_pcm_hw_params_set_periods_near(handle, params, &gs_uCntPer, NULL)))
{
printf("Unable to set nperiods %u for playback: %s\n",
gs_uCntPer, snd_strerror(iErr));
return iErr;
}
}
snd_pcm_hw_params_get_buffer_size(params, &gs_uSizBuf);
snd_pcm_hw_params_get_period_size(params, &gs_uSizPer, NULL);
printf("was set period_size = %lu\n",gs_uSizPer);
printf("was set buffer_size = %lu\n",gs_uSizBuf);
if (2*gs_uSizPer > gs_uSizBuf) {
printf("buffer to small, could not use\n");
return iErr;
}
/* write the parameters to device */
iErr = snd_pcm_hw_params(handle, params);
if (iErr < 0) {
printf("Unable to set hw params for playback: %s\n", snd_strerror(iErr));
return iErr;
}
return 0;
}
static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
{
int iErr;
/* get the current swparams */
if (0 > (iErr = snd_pcm_sw_params_current(handle, swparams)))
{
printf("Unable to determine current swparams for playback: %s\n", snd_strerror(iErr));
return iErr;
}
/* start the transfer when a buffer is full */
if (0 > (iErr = snd_pcm_sw_params_set_start_threshold(handle, swparams, gs_uSizBuf)))
{
printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(iErr));
return iErr;
}
/* allow the transfer when at least period_size frames can be processed */
if (0 > (iErr = snd_pcm_sw_params_set_avail_min(handle, swparams, gs_uSizPer)))
{
printf("Unable to set avail min for playback: %s\n", snd_strerror(iErr));
return iErr;
}
/* align all transfers to 1 sample */
if (0 > (iErr = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1)))
{
printf("Unable to set transfer align for playback: %s\n", snd_strerror(iErr));
return iErr;
}
/* write the parameters to the playback device */
if (0 > (iErr = snd_pcm_sw_params(handle, swparams)))
{
printf("Unable to set sw params for playback: %s\n", snd_strerror(iErr));
return iErr;
}
return 0;
}
static void generate_sine(uint8_t *pu8Frames, int iChannel, int iCntFrames, double *pdPhase, float fFreq)
{
double dPhase = *pdPhase;
double dPhaseMax = 1.0 / fFreq;
double dSizStep = 1.0 / (double)gs_uRate;
double dRes;
int iIdxChan;
int32_t i32Res;
int16_t *pi16Samp = (int16_t*) pu8Frames;
while (iCntFrames-- > 0)
{
for(iIdxChan=0;iIdxChan<gs_uCntChan;iIdxChan++)
if (iIdxChan==iChannel)
{
dRes = (sin((dPhase * 2 * M_PI) / dPhaseMax - M_PI)) * 0x03fffffff; /* Don't use MAX volume */
i32Res = dRes;
*pi16Samp++ = i32Res >>16;
}
else *pi16Samp++ = 0;
dPhase += dSizStep;
if (dPhase >= dPhaseMax)
dPhase -= dPhaseMax;
}
*pdPhase = dPhase;
}
/*
* Underrun and suspend recovery
*/
static int xrun_recovery(snd_pcm_t *pPcm, int iErr)
{
if (iErr == -EPIPE) { /* under-run */
iErr = snd_pcm_prepare(pPcm);
if (iErr < 0)
printf("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(iErr));
return 0;
}
else if (iErr == -ESTRPIPE) {
while ((iErr = snd_pcm_resume(pPcm)) == -EAGAIN)
sleep(1); /* wait until the suspend flag is released */
if (iErr < 0) {
iErr = snd_pcm_prepare(pPcm);
if (iErr < 0)
printf("Can't recovery from suspend, prepare failed: %s\n", snd_strerror(iErr));
}
return 0;
}
return iErr;
}
static int write_loop(snd_pcm_t *pPcm, int iChan, int iNumPer, uint8_t *pu8Frames)
{
double phase = 0;
int iErr, iIdxPer, iCntFrames;
uint8_t *pu8FramesLocal;
float fFreq = gs_dFreq*(iChan+1)/2; // provide an audible chan change cue
printf("Channel: %d Freq: %f\n", iChan, fFreq);
for(iIdxPer = 0; iIdxPer < iNumPer; iIdxPer++)
{
iCntFrames = gs_uSizPer;
pu8FramesLocal = pu8Frames;
generate_sine(pu8FramesLocal, iChan, gs_uSizPer, &phase, fFreq);
while (0 < iCntFrames)
{
if (-EAGAIN == (iErr = snd_pcm_writei(pPcm, pu8FramesLocal, iCntFrames)))
continue;
if (0 > iErr)
{
printf("Write error: %d,%s\n", iErr, snd_strerror(iErr));
if (0 > xrun_recovery(pPcm, iErr))
{
printf("xrun_recovery failed: %d,%s\n", iErr, snd_strerror(iErr));
return -1;
}
break; // skip one period
}
pu8FramesLocal += snd_pcm_frames_to_bytes(pPcm, iErr);
iCntFrames -= iErr;
}
}
if (gs_uSizBuf > iIdxPer * gs_uSizPer)
{
snd_pcm_drain(pPcm);
snd_pcm_prepare(pPcm );
}
return 0;
}
int main(int argc, char *argv[])
{
int iErr;
int iIdxChan;
uint8_t *pu8Frames = NULL;
snd_pcm_t *pPcm = NULL;
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
snd_pcm_hw_params_alloca(&hwparams);
snd_pcm_sw_params_alloca(&swparams);
printf("Playback device is %s\n", gs_pcNameDev);
printf("Stream parameters are %iHz, %s, %i channels\n", gs_uRate, snd_pcm_format_name(gs_SndPcmFmt), gs_uCntChan);
if(0 > (iErr = snd_pcm_open(&pPcm, gs_pcNameDev, SND_PCM_STREAM_PLAYBACK, 0))) goto fin;
if(0 > (iErr = set_hwparams(pPcm, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED))) goto fin;
if(0 > (iErr = set_swparams(pPcm, swparams))) goto fin;
if(!(pu8Frames = malloc(snd_pcm_frames_to_bytes(pPcm, gs_uSizPer)))) goto fin;
while(1)
for(iIdxChan = 0; iIdxChan < gs_uCntChan; iIdxChan++)
if (0> (iErr = write_loop(pPcm, iIdxChan, (gs_uRate*3)/gs_uSizPer, pu8Frames)))
goto fin;
iErr = EXIT_SUCCESS;
fin:
if(iErr) printf("Failed: %s\n",snd_strerror(iErr));
if(pu8Frames) free(pu8Frames);
if(pPcm) snd_pcm_close(pPcm);
exit(iErr);
}
