void setup_input_stream( void)
{
int err;
snd_pcm_hw_params_t *hw_params;
if( (err = snd_pcm_open( &capture_handle, CF_device,
SND_PCM_STREAM_CAPTURE, 0)) < 0)
bailout( "cannot open audio device %s (%s)\n",
CF_device, snd_strerror( err));
if( (err = snd_pcm_hw_params_malloc( &hw_params)) < 0 ||
(err = snd_pcm_hw_params_any( capture_handle, hw_params)) < 0)
bailout( "cannot init hardware params struct (%s)\n", snd_strerror( err));
unsigned int rate_min, rate_max;
snd_pcm_hw_params_get_rate_min( hw_params, &rate_min, 0);
snd_pcm_hw_params_get_rate_max( hw_params, &rate_max, 0);
report( 1, "rate min %d max %d", rate_min, rate_max);
if( (err = snd_pcm_hw_params_set_access( capture_handle,
hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
bailout("cannot set access type (%s)\n", snd_strerror (err));
if ((err = snd_pcm_hw_params_set_format(
capture_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0)
bailout( "cannot set sample format (%s)\n", snd_strerror (err));
if ((err = snd_pcm_hw_params_set_rate_near(
capture_handle, hw_params, &CF_sample_rate, 0)) < 0)
bailout( "cannot set sample rate (%s)\n", snd_strerror (err));
report( 0, "sample rate set: %d", CF_sample_rate);
if( (err = snd_pcm_hw_params_set_channels(
capture_handle, hw_params, CF_chans)) < 0)
bailout( "cannot set channel count (%s)\n", snd_strerror (err));
if( (err = snd_pcm_hw_params( capture_handle, hw_params)) < 0)
bailout( "cannot set parameters (%s)\n", snd_strerror (err));
snd_pcm_hw_params_free( hw_params);
if ((err = snd_pcm_prepare( capture_handle)) < 0)
bailout( "cannot prepare soundcard (%s)", snd_strerror (err));
}
optional<int> AudioOutputDeviceAlsa::ParameterSampleRate::RangeMaxAsInt(std::map<String,String> Parameters) {
if (!Parameters.count("CARD")) return optional<int>::nothing;
// obtain information from given sound card
String pcm_name = "hw:" + Parameters["CARD"];
snd_pcm_t* pcm_handle = NULL;
if (snd_pcm_open(&pcm_handle, pcm_name.c_str(), SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) < 0) return optional<int>::nothing;
snd_pcm_hw_params_t* hwparams;
snd_pcm_hw_params_alloca(&hwparams);
if (snd_pcm_hw_params_any(pcm_handle, hwparams) < 0) {
snd_pcm_close(pcm_handle);
return optional<int>::nothing;
}
uint rate;
if (snd_pcm_hw_params_get_rate_max(hwparams, &rate, NULL) < 0) {
snd_pcm_close(pcm_handle);
return optional<int>::nothing;
}
snd_pcm_close(pcm_handle);
return rate;
}
static gint
set_rates (alsa_driver *d, guint channels, guint format)
{
guint ratemin, ratemax;
snd_pcm_uframes_t bufsizemin, bufsizemax;
gint err;
if((err = snd_pcm_hw_params_set_channels(d->soundfd, d->hwparams, channels)) < 0) {
alsa_error(N_("Unable to set channles number"), err);
return -1;
}
if((err = snd_pcm_hw_params_get_rate_min(d->hwparams, &ratemin, 0)) < 0) {
alsa_error(N_("Unable to get minimal sample rate"), err);
return -1;
}
d->devcap[format].minfreq = MAX(ratemin, 8000);
if((err = snd_pcm_hw_params_get_rate_max(d->hwparams, &ratemax, 0)) < 0) {
alsa_error(N_("Unable to get maximal sample rate"), err);
return -1;
}
d->devcap[format].maxfreq = MIN(ratemax, 96000);
if((err = snd_pcm_hw_params_get_buffer_size_min(d->hwparams, &bufsizemin)) < 0) {
alsa_error(N_("Unable to get minimal buffer size"), err);
return -1;
}
d->devcap[format].minbufsize = MAX(bufsizemin, 256);
if((err = snd_pcm_hw_params_get_buffer_size_max(d->hwparams, &bufsizemax)) < 0) {
alsa_error(N_("Unable to get maximal buffer size"), err);
return -1;
}
d->devcap[format].maxbufsize = bufsizemax;
return 0;
}
size_t stack_alsa_audio_device_list_outputs(StackAudioDeviceDesc **outputs)
{
static const int common_sample_rates[] = {8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200, 96000, 176400, 192000};
static const size_t num_common_sample_rates = 11;
// Initialise pulse audio
if (!stack_init_alsa_audio())
{
// Failed to initialise, return NULL
*outputs = NULL;
return 0;
}
// Get some hints
void **hints = NULL;
int result = snd_device_name_hint(-1, "pcm", &hints);
if (result != 0)
{
*outputs = NULL;
return 0;
}
size_t alsa_device_count = 0, stack_device_count = 0;
// Count how many devices we find
for (size_t i = 0; hints[i] != NULL; i++)
{
alsa_device_count = i + 1;
}
// If there are no devices, return immediately
if (alsa_device_count == 0)
{
snd_device_name_free_hint(hints);
*outputs = NULL;
return 0;
}
StackAudioDeviceDesc* devices = new StackAudioDeviceDesc[alsa_device_count];
// Iterate over the devices and build information
for (size_t alsa_device_idx = 0, stack_device_idx = 0; alsa_device_idx < alsa_device_count; alsa_device_idx++)
{
char *name = snd_device_name_get_hint(hints[alsa_device_idx], "NAME");
char *desc = snd_device_name_get_hint(hints[alsa_device_idx], "DESC");
// Open the device
snd_pcm_t* pcm = NULL;
if (snd_pcm_open(&pcm, name, SND_PCM_STREAM_PLAYBACK, 0) != 0)
{
free(name);
free(desc);
continue;
}
// Get parameters
snd_pcm_hw_params_t* hw_params = NULL;
snd_pcm_hw_params_malloc(&hw_params);
snd_pcm_hw_params_any(pcm, hw_params);
// Get minimum and maximum number of channels
unsigned int min, max;
snd_pcm_hw_params_get_channels_min(hw_params, &min);
snd_pcm_hw_params_get_channels_max(hw_params, &max);
// Limit the maximum to 32 channels, as some devices return "-1" channels
if (max > 32)
{
max = 32;
}
// Store channel counts
devices[stack_device_idx].min_channels = min;
devices[stack_device_idx].max_channels = max;
// Get minimum and maximum sample rates
int dir;
snd_pcm_hw_params_get_rate_min(hw_params, &min, &dir);
snd_pcm_hw_params_get_rate_max(hw_params, &max, &dir);
// Iterate over our common sample rates and see which ones are valid
size_t sample_rate_count = 0;
for (size_t common_rate_idx = 0; common_rate_idx < num_common_sample_rates; common_rate_idx++)
{
if (common_sample_rates[common_rate_idx] >= min && common_sample_rates[common_rate_idx] <= max)
{
if (snd_pcm_hw_params_test_rate(pcm, hw_params, common_sample_rates[common_rate_idx], 0) == 0)
{
sample_rate_count++;
}
}
}
// Store the sample rates
devices[stack_device_idx].num_rates = sample_rate_count;
if (sample_rate_count > 0)
{
devices[stack_device_idx].rates = new uint32_t[sample_rate_count];
for (size_t rate_idx = 0, common_rate_idx = 0; common_rate_idx < num_common_sample_rates; common_rate_idx++)
{
if (common_sample_rates[common_rate_idx] >= min && common_sample_rates[common_rate_idx] <= max)
{
devices[stack_device_idx].rates[rate_idx] = common_sample_rates[common_rate_idx];
rate_idx++;
}
}
}
else
{
devices[stack_device_idx].rates = NULL;
}
// Store the name and description
devices[stack_device_idx].name = strdup(name);
devices[stack_device_idx].desc = strdup(desc);
// Tidy up
free(name);
free(desc);
snd_pcm_hw_params_free(hw_params);
snd_pcm_close(pcm);
stack_device_count++;
stack_device_idx++;
}
// Tidy up
snd_device_name_free_hint(hints);
// We can technically return an array that contains more elements than
// we say (if a device fails to open, for example), but this is not a
// problem, as we only allocate and indeed free the internals of the
// number we say, but we tidy up the whole array
*outputs = devices;
return stack_device_count;
}
/**
* ags_devout_pcm_info:
* @soundcard: the #AgsSoundcard
* @card_id: alsa identifier
* @channels_min: minimum channels supported
* @channels_max: maximum channels supported
* @rate_min: minimum samplerate supported
* @rate_max: maximum samplerate supported
* @buffer_size_min: minimum buffer size supported
* @buffer_size_max maximum buffer size supported
* @error: on success %NULL
*
* List soundcard settings.
*
* Since: 0.4
*/
void
ags_devout_pcm_info(AgsSoundcard *soundcard,
char *card_id,
guint *channels_min, guint *channels_max,
guint *rate_min, guint *rate_max,
guint *buffer_size_min, guint *buffer_size_max,
GError **error)
{
int rc;
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
unsigned int val;
int dir;
snd_pcm_uframes_t frames;
int err;
/* Open PCM device for playback. */
handle = NULL;
rc = snd_pcm_open(&handle, card_id, SND_PCM_STREAM_PLAYBACK, 0);
if(rc < 0) {
g_message("unable to open pcm device: %s\n\0", snd_strerror(rc));
g_set_error(error,
AGS_DEVOUT_ERROR,
AGS_DEVOUT_ERROR_LOCKED_SOUNDCARD,
"unable to open pcm device: %s\n\0",
snd_strerror(rc));
return;
}
/* Allocate a hardware parameters object. */
snd_pcm_hw_params_alloca(¶ms);
/* Fill it in with default values. */
snd_pcm_hw_params_any(handle, params);
/* channels */
snd_pcm_hw_params_get_channels_min(params, &val);
*channels_min = val;
snd_pcm_hw_params_get_channels_max(params, &val);
*channels_max = val;
/* samplerate */
dir = 0;
snd_pcm_hw_params_get_rate_min(params, &val, &dir);
*rate_min = val;
dir = 0;
snd_pcm_hw_params_get_rate_max(params, &val, &dir);
*rate_max = val;
/* buffer size */
dir = 0;
snd_pcm_hw_params_get_buffer_size_min(params, &frames);
*buffer_size_min = frames;
dir = 0;
snd_pcm_hw_params_get_buffer_size_max(params, &frames);
*buffer_size_max = frames;
snd_pcm_close(handle);
}
static void *_msynth_thread_main(void *arg)
{
int i;
int err;
int sample;
int processed;
struct sampleclock sc = {0, 0, 0.0f, 0.0f};
msynth_frame fb = NULL;
puts("synthread: started");
/* Begin initialization of ALSA */
/* snd_pcm_open(pcm_handle, device_name, stream_type, open_mode) */
err = snd_pcm_open(&pcm, config.device_name, SND_PCM_STREAM_PLAYBACK, 0);
ALSERT("opening audio device");
/* First ALSA hardware settings */
/* Allocate HW params */
err = snd_pcm_hw_params_malloc(&hw_p);
ALSERT("allocating hw params");
/* Get default HW parameters */
err = snd_pcm_hw_params_any(pcm, hw_p);
ALSERT("requesting hw default params");
/* Disable software resampling */
err = snd_pcm_hw_params_set_rate_resample(pcm, hw_p, config.resample);
ALSERT("disabling software resampling");
/* Configure sample rate */
if (config.srate != -1)
srate = config.srate;
else {
/* Get maximum hardware samplerate */
err = snd_pcm_hw_params_get_rate_max(hw_p, &srate, &dir);
ALSERT("requesting maximum hardware samplerate");
}
/* Set sample rate
* snd_pcm_hw_params_set_rate_near(pcn, hw_p, *rate,
* 0 (== set exact rate))
*/
err = snd_pcm_hw_params_set_rate_near(pcm, hw_p, &srate, 0);
ALSERT("setting samplerate");
printf("synthread: Detected samplerate of %u\n", srate);
/* RW interleaved access (means we will use the snd_pcm_writei function) */
err = snd_pcm_hw_params_set_access(pcm, hw_p,
SND_PCM_ACCESS_RW_INTERLEAVED);
ALSERT("setting access mode");
/* native-endian 16-bit signed sample format */
err = snd_pcm_hw_params_set_format(pcm, hw_p, SND_PCM_FORMAT_S16);
ALSERT("setting sample format");
/* Switch to 2.0ch audio */
err = snd_pcm_hw_params_set_channels(pcm, hw_p, 2);
ALSERT("switching to 2.0ch audio");
if (config.buffer_time != -1) {
/* Set configured buffer time */
err = snd_pcm_hw_params_set_buffer_time_near(pcm, hw_p,
&config.buffer_time, &dir);
ALSERT("setting buffer time");
/* Fetch resulting size */
err = snd_pcm_hw_params_get_buffer_size(hw_p, &buffer_size);
ALSERT("getting buffer size");
} else {
/* Since we want the interactive synthesizer to be very responsive
* select a minimum buffer size.
*/
err = snd_pcm_hw_params_set_buffer_size_first(pcm, hw_p, &buffer_size);
ALSERT("setting buffer size");
}
printf("synthread: Selected buffersize of %lu\n", buffer_size);
printf("synthread: Response delay is approximately %.2f ms\n",
(double)buffer_size / (double)srate * 1000.0);
if (config.period_time != -1) {
err = snd_pcm_hw_params_set_period_time_near(pcm, hw_p,
&config.period_time, &dir);
ALSERT("setting period time");
err = snd_pcm_hw_params_get_period_size(hw_p, &period_size, &dir);
ALSERT("getting period size");
} else {
/* Select a period time of half the buffer time
* since this improves processing performance
*/
err = snd_pcm_hw_params_set_period_size_last(pcm, hw_p, &period_size, &dir);
ALSERT("setting period size");
}
if (dir)
printf("synthread: Selected period size near %lu\n", period_size);
else
printf("synthread: Selected period size of %lu\n", period_size);
/* write hw parameters to device */
err = snd_pcm_hw_params(pcm, hw_p);
ALSERT("writing hw params");
/* Begin ALSA software side setup */
/* Allocate SW params */
err = snd_pcm_sw_params_malloc(&sw_p);
ALSERT("allocating sw params");
/* Request software current settings */
err = snd_pcm_sw_params_current(pcm, sw_p);
ALSERT("requesting current sw params");
/* Automatically start playing after the first period is written */
err = snd_pcm_sw_params_set_start_threshold(pcm, sw_p, period_size);
ALSERT("settings start threshold");
/* XRUN when buffer is empty */
err = snd_pcm_sw_params_set_stop_threshold(pcm, sw_p, buffer_size * 2);
ALSERT("setting stop threshold");
/* Block synthesizer when there is not at least period frames available */
err = snd_pcm_sw_params_set_avail_min(pcm, sw_p, period_size);
ALSERT("setting minimum free frames");
/* Write software parameters */
err = snd_pcm_sw_params(pcm, sw_p);
ALSERT("writing sw params");
printf("synthread: Audio system configured.\n");
/* Prepare device for playback */
err = snd_pcm_prepare(pcm);
ALSERT("preparing device");
/* Allocate a period sized framebuffer
* (yup an audio buffer is in ALSA speak indeed called a framebuffer)
*/
fb = malloc(sizeof(struct _msynth_frame) * period_size);
if (!fb) {
perror("malloc framebuffer failed");
exit(1);
}
/* Set sampleclock to 0 */
sc.samples = 0;
sc.samplerate = srate;
sc.cycle = 0.0f;
sc.seconds = 0.0f;
/* Initially the <root> variable describing the flow of sound within
* the synthesizer is configured to be a NULL signal. (silence)
*/
/* Signal successful completion of initialization */
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
/* -------------- Main loop --------------- */
while (!shutdown) {
/* Only during generation we need the synth tree to be static */
synth_lock_graphs();
for (i = 0; i < period_size; i++) {
/* Evaluate variables */
ssv_eval(sc);
sample = (int)(32767.5 * ssv_get_var_eval("left") * volume);
/* Clip samples */
if (sample > 32767) sample = 32767;
if (sample < -32768) sample = -32768;
fb[i].left = (short)sample;
sample = (int)(32767.5 * ssv_get_var_eval("right") * volume);
/* Clip samples */
if (sample > 32767) sample = 32767;
if (sample < -32768) sample = -32768;
fb[i].right = (short)sample;
sc = sc_from_samples(sc.samplerate, sc.samples + 1);
}
synth_unlock_graphs();
/* Send audio to sound card */
processed = 0;
while (processed != period_size) {
err = snd_pcm_writei(pcm, fb + processed, period_size - processed);
/* Retry on interruption by signal */
if (err == -EAGAIN)
continue;
/* Recover from XRUN/suspend */
if (err < 0) {
err = synth_recover(err);
ALSERT("sending audio");
continue;
}
/* Update processed samples */
processed += err;
}
}
puts("synthread: shutting down");
/* Dump any statistics recorded */
if (recover_resumes)
printf("synthread: Device was resumed %i times\n", recover_resumes);
if (recover_xruns)
printf("synthread: %i xrun recoveries were needed\n", recover_xruns);
printf("synthread: processed %i samples\n", sc.samples);
/* Wait for playback to complete */
err = snd_pcm_drain(pcm);
ALSERT("draining device");
/* Shutdown PCM device */
err = snd_pcm_close(pcm);
ALSERT("closing audio device");
/* Clean up parameters */
snd_pcm_hw_params_free(hw_p);
snd_pcm_sw_params_free(sw_p);
return NULL;
}
int main(int argc, char *argv[])
{
const char *device_name = "hw";
snd_pcm_t *pcm;
snd_pcm_hw_params_t *hw_params;
unsigned int i;
unsigned int min, max;
int any_rate;
int err;
if (argc > 1)
device_name = argv[1];
err = snd_pcm_open(&pcm, device_name, SND_PCM_STREAM_CAPTURE,
SND_PCM_NONBLOCK);
if (err < 0) {
fprintf(stderr, "cannot open device '%s': %s\n", device_name,
snd_strerror(err));
return 1;
}
snd_pcm_hw_params_alloca(&hw_params);
err = snd_pcm_hw_params_any(pcm, hw_params);
if (err < 0) {
fprintf(stderr, "cannot get hardware parameters: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
printf("Device: %s (type: %s)\n", device_name,
snd_pcm_type_name(snd_pcm_type(pcm)));
printf("Access types:");
for (i = 0; i < ARRAY_SIZE(accesses); ++i) {
if (!snd_pcm_hw_params_test_access(pcm, hw_params, accesses[i]))
printf(" %s", snd_pcm_access_name(accesses[i]));
}
putchar('\n');
printf("Formats:");
for (i = 0; i < ARRAY_SIZE(formats); ++i) {
if (!snd_pcm_hw_params_test_format(pcm, hw_params, formats[i]))
printf(" %s", snd_pcm_format_name(formats[i]));
}
putchar('\n');
err = snd_pcm_hw_params_get_channels_min(hw_params, &min);
if (err < 0) {
fprintf(stderr, "cannot get minimum channels count: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
err = snd_pcm_hw_params_get_channels_max(hw_params, &max);
if (err < 0) {
fprintf(stderr, "cannot get maximum channels count: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
printf("Channels:");
for (i = min; i <= max; ++i) {
if (!snd_pcm_hw_params_test_channels(pcm, hw_params, i))
printf(" %u", i);
}
putchar('\n');
err = snd_pcm_hw_params_get_rate_min(hw_params, &min, NULL);
if (err < 0) {
fprintf(stderr, "cannot get minimum rate: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
err = snd_pcm_hw_params_get_rate_max(hw_params, &max, NULL);
if (err < 0) {
fprintf(stderr, "cannot get maximum rate: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
printf("Sample rates:");
if (min == max)
printf(" %u", min);
else if (!snd_pcm_hw_params_test_rate(pcm, hw_params, min + 1, 0))
printf(" %u-%u", min, max);
else {
any_rate = 0;
for (i = 0; i < ARRAY_SIZE(rates); ++i) {
if (!snd_pcm_hw_params_test_rate(pcm, hw_params,
rates[i], 0)) {
any_rate = 1;
printf(" %u", rates[i]);
}
}
if (!any_rate)
printf(" %u-%u", min, max);
}
putchar('\n');
err = snd_pcm_hw_params_get_period_time_min(hw_params, &min, NULL);
if (err < 0) {
fprintf(stderr, "cannot get minimum period time: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
err = snd_pcm_hw_params_get_period_time_max(hw_params, &max, NULL);
if (err < 0) {
fprintf(stderr, "cannot get maximum period time: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
printf("Interrupt interval: %u-%u us\n", min, max);
err = snd_pcm_hw_params_get_buffer_time_min(hw_params, &min, NULL);
if (err < 0) {
fprintf(stderr, "cannot get minimum buffer time: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
err = snd_pcm_hw_params_get_buffer_time_max(hw_params, &max, NULL);
if (err < 0) {
fprintf(stderr, "cannot get maximum buffer time: %s\n",
snd_strerror(err));
snd_pcm_close(pcm);
return 1;
}
printf("Buffer size: %u-%u us\n", min, max);
snd_pcm_close(pcm);
return 0;
}
int setup_pcmdev(char *pcm_name)
{
snd_pcm_hw_params_t *params;
snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
int rate = 44100, dir;
snd_pcm_uframes_t persize, persize2;
int maxrate, minrate;
unsigned int pertime, perTmin, perTmax;
snd_pcm_uframes_t bufsize, perSmin, perSmax, bufSmin, bufSmax;
/* Allocate the snd_pcm_hw_params_t structure on the stack. */
snd_pcm_hw_params_alloca(¶ms);
/* Open PCM device for playback. */
if (snd_pcm_open(&handle, pcm_name, stream, 0) < 0) {
fprintf(stderr, "Error opening PCM device %s\n", pcm_name);
return(-1);
}
/* Init params with full configuration space */
if (snd_pcm_hw_params_any(handle, params) < 0) {
fprintf(stderr, "Can not configure this PCM device.\n");
return(-1);
}
/* set interleaved mode */
if (snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
fprintf(stderr, "Error setting access.\n");
return(-1);
}
/* Set sample format */
if (snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE) < 0) {
fprintf(stderr, "Error setting format.\n");
return(-1);
}
/* Set sample rate.*/
if (snd_pcm_hw_params_set_rate_near(handle, params, &rate, 0) < 0) {
fprintf(stderr, "Error setting rate.\n");
return(-1);
}
/* Set number of channels */
if (snd_pcm_hw_params_set_channels(handle, params, nchan) < 0) {
fprintf(stderr, "Error setting channels.\n");
return(-1);
}
/* Set period size to n frames (samples). */
persize = 1024; dir=0;
if (snd_pcm_hw_params_set_period_size_near(handle,params, &persize, &dir)< 0) {
fprintf(stderr, "Error setting period size to %d.\n", (int) persize);
return(-1);
}
/* Apply HW parameter settings to PCM device */
if (snd_pcm_hw_params(handle, params) < 0) {
fprintf(stderr, "Error setting HW params.\n");
return(-1);
}
/*get some inof about the hardware*/
// printf("\n ---------- hardware parameters ------------ \n");
snd_pcm_hw_params_get_rate_min (params, &minrate, &dir);
//printf("min rate: %d samples per sec\n",minrate);
snd_pcm_hw_params_get_rate_max (params, &maxrate, &dir);
//printf("max rate: %d samples per sec\n",maxrate);
snd_pcm_hw_params_get_period_time (params, &pertime, &dir);
//printf("period: %d microseconds\n",pertime);
snd_pcm_hw_params_get_period_time_min (params, &perTmin, &dir);
snd_pcm_hw_params_get_period_time_min (params, &perTmax, &dir);
//printf("min period time: %d microseconds\n",perTmin);
//printf("max period time: %d microseconds\n",perTmax);
snd_pcm_hw_params_get_period_size (params, &persize2, &dir);
//printf("period: %d frames\n",(int) persize2);
snd_pcm_hw_params_get_period_size_min (params, &perSmin, &dir);
snd_pcm_hw_params_get_period_size_min (params, &perSmax, &dir);
//printf("min period size: %d frames\n",(int) perSmin);
//printf("max period size: %d frames\n",(int) perSmax);
snd_pcm_hw_params_get_buffer_size (params, &bufsize);
//printf("buffer size: %d frames\n",(int) bufsize);
snd_pcm_hw_params_get_buffer_size_min (params, &bufSmin);
snd_pcm_hw_params_get_buffer_size_min (params, &bufSmax);
//printf("min buffer size: %d frames\n",(int) bufSmin);
//printf("max buffer size: %d frames\n",(int) bufSmax);
return (double) persize2;
}
bool AlsaRenderer::SetupHwParams()
{
snd_pcm_hw_params_t* params;
/* allocate a hardware parameters object */
snd_pcm_hw_params_malloc(¶ms);
/* choose all parameters */
snd_pcm_hw_params_any(m_PcmHandle, params);
/* enable hardware resampling */
snd_pcm_hw_params_set_rate_resample(m_PcmHandle, params, m_Resample);
/* set the interleaved read/write format */
snd_pcm_hw_params_set_access(m_PcmHandle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
/* signed 16-bit little-endian format */
snd_pcm_hw_params_set_format(m_PcmHandle, params, SND_PCM_FORMAT_S16_LE);
/* set the count of channels */
snd_pcm_hw_params_get_channels_max(params, &m_Channels.max);
snd_pcm_hw_params_get_channels_min(params, &m_Channels.min);
if (m_Channels.val < m_Channels.min || m_Channels.val > m_Channels.max)
m_Channels.val = m_Channels.min;
snd_pcm_hw_params_set_channels(m_PcmHandle, params, m_Channels.val);
/* set the stream rate */
snd_pcm_hw_params_get_rate_max(params, &m_SampleRate.max, &m_Dir);
snd_pcm_hw_params_get_rate_min(params, &m_SampleRate.min, &m_Dir);
if (m_SampleRate.val < m_SampleRate.min || m_SampleRate.val > m_SampleRate.max)
m_SampleRate.val = m_SampleRate.min;
printf("sample rate max:%d, min:%d, val:%d\n",
m_SampleRate.max, m_SampleRate.min, m_SampleRate.val);
snd_pcm_hw_params_set_rate(m_PcmHandle, params, m_SampleRate.val, m_Dir);
/* we can set period and buffer by size or time */
/* by default we use "size" (count of frames) */
/* set how many frames in a buffer (a buffer cantains several periods) */
snd_pcm_hw_params_get_buffer_size_max(params, &m_BufferSize.max);
snd_pcm_hw_params_get_buffer_size_min(params, &m_BufferSize.min);
/* detect period time and buffer time range */
snd_pcm_hw_params_get_buffer_time_max(params, &m_BufferTime.max, &m_Dir);
snd_pcm_hw_params_get_buffer_time_min(params, &m_BufferTime.min, &m_Dir);
m_BufferTime.val = std::max(m_BufferTime.max / 2, m_BufferTime.min);
//m_BufferTime.val = m_BufferTime.min + (m_BufferTime.max - m_BufferTime.min) /2;
printf("buffer time max:%d, min:%d, val:%d\n",
m_BufferTime.max, m_BufferTime.min, m_BufferTime.val);
//(m_BufferTime.max > 120000) ? 120000 : m_BufferTime.max;//120000
snd_pcm_hw_params_set_buffer_time_near(m_PcmHandle, params, &m_BufferTime.val, &m_Dir);
snd_pcm_hw_params_get_period_time_max(params, &m_PeriodTime.max, &m_Dir);
snd_pcm_hw_params_get_period_time_min(params, &m_PeriodTime.min, &m_Dir);
m_PeriodTime.val = m_BufferTime.val / 4;
//m_PeriodTime.val = m_PeriodTime.min + (m_PeriodTime.max - m_PeriodTime.min) / 2;
printf("period time max:%d, min:%d, val:%d\n",
m_PeriodTime.max, m_PeriodTime.min, m_PeriodTime.val);
snd_pcm_hw_params_set_period_time_near(m_PcmHandle, params, &m_PeriodTime.val, &m_Dir);
int ret = snd_pcm_hw_params(m_PcmHandle, params);
if (ret != 0) {
snd_pcm_hw_params_free(params);
return false;
}
// get period size again
snd_pcm_hw_params_get_period_size(params, &m_PeriodSize.val, &m_Dir);
snd_pcm_hw_params_get_buffer_size(params, &m_BufferSize.val);
m_BitsPerSample = snd_pcm_format_physical_width(SND_PCM_FORMAT_S16_LE);
m_FrameLength = (m_BitsPerSample/8 * m_Channels.val);
//mPeriodBufferLength = m_PeriodSize.val * m_FrameLength ;
snd_pcm_hw_params_free(params);
return true;
}
void info(char *dev_name, snd_pcm_stream_t stream) {
snd_pcm_hw_params_t *hw_params;
int err;
snd_pcm_t *handle;
unsigned int max;
unsigned int min;
unsigned int val;
unsigned int dir;
snd_pcm_uframes_t frames;
if ((err = snd_pcm_open (&handle, dev_name, stream, 0)) < 0) {
fprintf (stderr, "cannot open audio device %s (%s)\n",
dev_name,
snd_strerror (err));
return;
}
if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params_any (handle, hw_params)) < 0) {
fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
snd_strerror (err));
exit (1);
}
if ((err = snd_pcm_hw_params_get_channels_max(hw_params, &max)) < 0) {
fprintf (stderr, "cannot (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max channels %d\n", max);
if ((err = snd_pcm_hw_params_get_channels_min(hw_params, &min)) < 0) {
fprintf (stderr, "cannot get channel info (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min channels %d\n", min);
/*
if ((err = snd_pcm_hw_params_get_sbits(hw_params)) < 0) {
fprintf (stderr, "cannot get bits info (%s)\n",
snd_strerror (err));
exit (1);
}
printf("bits %d\n", err);
*/
if ((err = snd_pcm_hw_params_get_rate_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min rate (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min rate %d hz\n", val);
if ((err = snd_pcm_hw_params_get_rate_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get max rate (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max rate %d hz\n", val);
if ((err = snd_pcm_hw_params_get_period_time_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min period time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min period time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_period_time_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get max period time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max period time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_period_size_min(hw_params, &frames, &dir)) < 0) {
fprintf (stderr, "cannot get min period size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min period size in frames %d\n", frames);
if ((err = snd_pcm_hw_params_get_period_size_max(hw_params, &frames, &dir)) < 0) {
fprintf (stderr, "cannot get max period size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max period size in frames %d\n", frames);
if ((err = snd_pcm_hw_params_get_periods_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min periods (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min periods per buffer %d\n", val);
if ((err = snd_pcm_hw_params_get_periods_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min periods (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max periods per buffer %d\n", val);
if ((err = snd_pcm_hw_params_get_buffer_time_min(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get min buffer time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min buffer time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_buffer_time_max(hw_params, &val, &dir)) < 0) {
fprintf (stderr, "cannot get max buffer time (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max buffer time %d usecs\n", val);
if ((err = snd_pcm_hw_params_get_buffer_size_min(hw_params, &frames)) < 0) {
fprintf (stderr, "cannot get min buffer size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("min buffer size in frames %d\n", frames);
if ((err = snd_pcm_hw_params_get_buffer_size_max(hw_params, &frames)) < 0) {
fprintf (stderr, "cannot get max buffer size (%s)\n",
snd_strerror (err));
exit (1);
}
printf("max buffer size in frames %d\n", frames);
}
static GstCaps *
gst_alsa_detect_rates (GstObject * obj, snd_pcm_hw_params_t * hw_params,
GstCaps * in_caps)
{
GstCaps *caps;
guint min, max;
gint err, dir, min_rate, max_rate, i;
GST_LOG_OBJECT (obj, "probing sample rates ...");
if ((err = snd_pcm_hw_params_get_rate_min (hw_params, &min, &dir)) < 0)
goto min_rate_err;
if ((err = snd_pcm_hw_params_get_rate_max (hw_params, &max, &dir)) < 0)
goto max_rate_err;
min_rate = min;
max_rate = max;
if (min_rate < 4000)
min_rate = 4000; /* random 'sensible minimum' */
if (max_rate <= 0)
max_rate = G_MAXINT; /* or maybe just use 192400 or so? */
else if (max_rate > 0 && max_rate < 4000)
max_rate = MAX (4000, min_rate);
GST_DEBUG_OBJECT (obj, "Min. rate = %u (%d)", min_rate, min);
GST_DEBUG_OBJECT (obj, "Max. rate = %u (%d)", max_rate, max);
caps = gst_caps_make_writable (in_caps);
for (i = 0; i < gst_caps_get_size (caps); ++i) {
GstStructure *s;
s = gst_caps_get_structure (caps, i);
if (min_rate == max_rate) {
gst_structure_set (s, "rate", G_TYPE_INT, min_rate, NULL);
} else {
gst_structure_set (s, "rate", GST_TYPE_INT_RANGE,
min_rate, max_rate, NULL);
}
}
return caps;
/* ERRORS */
min_rate_err:
{
GST_ERROR_OBJECT (obj, "failed to query minimum sample rate: %s",
snd_strerror (err));
gst_caps_unref (in_caps);
return NULL;
}
max_rate_err:
{
GST_ERROR_OBJECT (obj, "failed to query maximum sample rate: %s",
snd_strerror (err));
gst_caps_unref (in_caps);
return NULL;
}
}
static int setparams(snd_pcm_t *phandle, snd_pcm_t *chandle,
snd_pcm_format_t format,
int latency, int allow_resample,
struct final_params *negotiated)
{
int i;
unsigned ratep, ratec = 0;
unsigned ratemin = 32000, ratemax = 96000, val;
int err, channels = 2;
snd_pcm_hw_params_t *p_hwparams, *c_hwparams;
snd_pcm_sw_params_t *p_swparams, *c_swparams;
snd_pcm_uframes_t c_size, p_psize, c_psize;
/* Our latency is 2 periods (in usecs) */
unsigned int c_periods = 2, p_periods;
unsigned int c_periodtime, p_periodtime;
const unsigned int prefered_rates[] = { 44100, 48000, 32000 };
snd_pcm_hw_params_alloca(&p_hwparams);
snd_pcm_hw_params_alloca(&c_hwparams);
snd_pcm_sw_params_alloca(&p_swparams);
snd_pcm_sw_params_alloca(&c_swparams);
if (setparams_stream(chandle, c_hwparams, format, &channels, "capture"))
return 1;
if (setparams_stream(phandle, p_hwparams, format, &channels, "playback"))
return 1;
if (allow_resample) {
err = snd_pcm_hw_params_set_rate_resample(chandle, c_hwparams, 1);
if (err < 0) {
fprintf(error_fp, "alsa: Resample setup failed: %s\n", snd_strerror(err));
return 1;
} else if (verbose)
fprintf(error_fp, "alsa: Resample enabled.\n");
}
err = snd_pcm_hw_params_get_rate_min(c_hwparams, &ratemin, 0);
if (err >= 0 && verbose)
fprintf(error_fp, "alsa: Capture min rate is %d\n", ratemin);
err = snd_pcm_hw_params_get_rate_max(c_hwparams, &ratemax, 0);
if (err >= 0 && verbose)
fprintf(error_fp, "alsa: Capture max rate is %u\n", ratemax);
err = snd_pcm_hw_params_get_rate_min(p_hwparams, &val, 0);
if (err >= 0) {
if (verbose)
fprintf(error_fp, "alsa: Playback min rate is %u\n", val);
if (val > ratemin)
ratemin = val;
}
err = snd_pcm_hw_params_get_rate_max(p_hwparams, &val, 0);
if (err >= 0) {
if (verbose)
fprintf(error_fp, "alsa: Playback max rate is %u\n", val);
if (val < ratemax)
ratemax = val;
}
if (verbose)
fprintf(error_fp,
"alsa: Will search a common rate between %u and %u\n",
ratemin, ratemax);
/* First try a set of common rates */
err = -1;
for (i = 0; i < ARRAY_SIZE(prefered_rates); i++) {
if (prefered_rates[i] < ratemin || prefered_rates[i] > ratemax)
continue;
ratep = ratec = prefered_rates[i];
err = alsa_try_rate(phandle, chandle, p_hwparams, c_hwparams,
allow_resample, &ratep, &ratec);
if (err == 0)
break;
}
if (err != 0) {
if (ratemin >= 44100) {
for (i = ratemin; i <= ratemax; i += 100) {
ratep = ratec = i;
err = alsa_try_rate(phandle, chandle, p_hwparams, c_hwparams,
allow_resample, &ratep, &ratec);
if (err == 0)
break;
}
} else {
for (i = ratemax; i >= ratemin; i -= 100) {
ratep = ratec = i;
err = alsa_try_rate(phandle, chandle, p_hwparams, c_hwparams,
allow_resample, &ratep, &ratec);
if (err == 0)
break;
}
}
}
if (err < 0) {
fprintf(error_fp, "alsa: Failed to set a supported rate: %s\n",
snd_strerror(err));
return 1;
}
if (ratep != ratec) {
if (verbose || allow_resample)
fprintf(error_fp,
"alsa: Couldn't find a rate that it is supported by both playback and capture\n");
return 2;
}
if (verbose)
fprintf(error_fp, "alsa: Using Rate %d\n", ratec);
/* Negotiate period parameters */
c_periodtime = latency * 1000 / c_periods;
getparams_periods(chandle, c_hwparams, &c_periodtime, &c_periods, "capture");
p_periods = c_periods * 2;
p_periodtime = c_periodtime;
getparams_periods(phandle, p_hwparams, &p_periodtime, &p_periods, "playback");
c_periods = p_periods / 2;
/*
* Some playback devices support a very limited periodtime range. If the user needs to
* use a higher latency to avoid overrun/underrun, use an alternate algorithm of incresing
* the number of periods, to archive the needed latency
*/
if (p_periodtime < c_periodtime) {
c_periodtime = p_periodtime;
c_periods = round (latency * 1000.0 / c_periodtime + 0.5);
getparams_periods(chandle, c_hwparams, &c_periodtime, &c_periods, "capture");
p_periods = c_periods * 2;
p_periodtime = c_periodtime;
getparams_periods(phandle, p_hwparams, &p_periodtime, &p_periods, "playback");
c_periods = p_periods / 2;
}
if (setparams_periods(chandle, c_hwparams, &c_periodtime, &c_periods, "capture"))
return 1;
/* Note we use twice as much periods for the playback buffer, since we
will get a period size near the requested time and we don't want it to
end up smaller then the capture buffer as then we could end up blocking
on writing to it. Note we will configure the playback dev to start
playing as soon as it has 2 capture periods worth of data, so this
won't influence latency */
if (setparams_periods(phandle, p_hwparams, &p_periodtime, &p_periods, "playback"))
return 1;
snd_pcm_hw_params_get_period_size(p_hwparams, &p_psize, NULL);
snd_pcm_hw_params_get_period_size(c_hwparams, &c_psize, NULL);
snd_pcm_hw_params_get_buffer_size(c_hwparams, &c_size);
latency = c_periods * c_psize;
if (setparams_set(phandle, p_hwparams, p_swparams, latency, "playback"))
return 1;
if (setparams_set(chandle, c_hwparams, c_swparams, c_psize, "capture"))
return 1;
if ((err = snd_pcm_prepare(phandle)) < 0) {
fprintf(error_fp, "alsa: Prepare error: %s\n", snd_strerror(err));
return 1;
}
if (verbose) {
fprintf(error_fp, "alsa: Negociated configuration:\n");
snd_pcm_dump_setup(phandle, output);
snd_pcm_dump_setup(chandle, output);
fprintf(error_fp, "alsa: Parameters are %iHz, %s, %i channels\n",
ratep, snd_pcm_format_name(format), channels);
fprintf(error_fp, "alsa: Set bitrate to %u%s, buffer size is %u\n", ratec,
allow_resample ? " with resample enabled at playback": "",
(unsigned int)c_size);
}
negotiated->bufsize = c_size;
negotiated->rate = ratep;
negotiated->channels = channels;
negotiated->latency = latency;
return 0;
}
/*----------------------------------------------------------------------------
** ALSA_ComputeCaps
**
** Given an ALSA PCM, figure out our HW CAPS structure info.
** ctl can be null, pcm is required, as is all output parms.
**
*/
static int ALSA_ComputeCaps(snd_ctl_t *ctl, snd_pcm_t *pcm,
WORD *channels, DWORD *flags, DWORD *formats, DWORD *supports)
{
snd_pcm_hw_params_t *hw_params;
snd_pcm_format_mask_t *fmask;
snd_pcm_access_mask_t *acmask;
unsigned int ratemin = 0;
unsigned int ratemax = 0;
unsigned int chmin = 0;
unsigned int chmax = 0;
int rc, dir = 0;
hw_params = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_hw_params_sizeof() );
fmask = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_format_mask_sizeof() );
acmask = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_access_mask_sizeof() );
if ((rc = snd_pcm_hw_params_any(pcm, hw_params)) < 0) goto done;
snd_pcm_hw_params_get_format_mask(hw_params, fmask);
if ((rc = snd_pcm_hw_params_get_access_mask(hw_params, acmask)) < 0) goto done;
if ((rc = snd_pcm_hw_params_get_rate_min(hw_params, &ratemin, &dir)) < 0) goto done;
if ((rc = snd_pcm_hw_params_get_rate_max(hw_params, &ratemax, &dir)) < 0) goto done;
if ((rc = snd_pcm_hw_params_get_channels_min(hw_params, &chmin)) < 0) goto done;
if ((rc = snd_pcm_hw_params_get_channels_max(hw_params, &chmax)) < 0) goto done;
#define X(r,v) \
if ( (r) >= ratemin && ( (r) <= ratemax || ratemax == -1) ) \
{ \
if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_U8)) \
{ \
if (chmin <= 1 && 1 <= chmax) \
*formats |= WAVE_FORMAT_##v##M08; \
if (chmin <= 2 && 2 <= chmax) \
*formats |= WAVE_FORMAT_##v##S08; \
} \
if (snd_pcm_format_mask_test( fmask, SND_PCM_FORMAT_S16_LE)) \
{ \
if (chmin <= 1 && 1 <= chmax) \
*formats |= WAVE_FORMAT_##v##M16; \
if (chmin <= 2 && 2 <= chmax) \
*formats |= WAVE_FORMAT_##v##S16; \
} \
}
X(11025,1);
X(22050,2);
X(44100,4);
X(48000,48);
X(96000,96);
#undef X
if (chmin > 1)
FIXME("Device has a minimum of %d channels\n", chmin);
*channels = chmax;
/* FIXME: is sample accurate always true ?
** Can we do WAVECAPS_PITCH, WAVECAPS_SYNC, or WAVECAPS_PLAYBACKRATE? */
*supports |= WAVECAPS_SAMPLEACCURATE;
*supports |= WAVECAPS_DIRECTSOUND;
/* check for volume control support */
if (ctl) {
if (snd_ctl_name(ctl))
{
snd_hctl_t *hctl;
if (snd_hctl_open(&hctl, snd_ctl_name(ctl), 0) >= 0)
{
snd_hctl_load(hctl);
if (!ALSA_CheckSetVolume( hctl, NULL, NULL, NULL, NULL, NULL, NULL, NULL ))
{
*supports |= WAVECAPS_VOLUME;
if (chmin <= 2 && 2 <= chmax)
*supports |= WAVECAPS_LRVOLUME;
}
snd_hctl_free(hctl);
snd_hctl_close(hctl);
}
}
}
*flags = DSCAPS_CERTIFIED | DSCAPS_CONTINUOUSRATE;
*flags |= DSCAPS_SECONDARYMONO | DSCAPS_SECONDARYSTEREO;
*flags |= DSCAPS_SECONDARY8BIT | DSCAPS_SECONDARY16BIT;
if (*formats & (WAVE_FORMAT_1M08 | WAVE_FORMAT_2M08 |
WAVE_FORMAT_4M08 | WAVE_FORMAT_48M08 |
WAVE_FORMAT_96M08 | WAVE_FORMAT_1M16 |
WAVE_FORMAT_2M16 | WAVE_FORMAT_4M16 |
WAVE_FORMAT_48M16 | WAVE_FORMAT_96M16) )
*flags |= DSCAPS_PRIMARYMONO;
if (*formats & (WAVE_FORMAT_1S08 | WAVE_FORMAT_2S08 |
WAVE_FORMAT_4S08 | WAVE_FORMAT_48S08 |
WAVE_FORMAT_96S08 | WAVE_FORMAT_1S16 |
WAVE_FORMAT_2S16 | WAVE_FORMAT_4S16 |
WAVE_FORMAT_48S16 | WAVE_FORMAT_96S16) )
*flags |= DSCAPS_PRIMARYSTEREO;
if (*formats & (WAVE_FORMAT_1M08 | WAVE_FORMAT_2M08 |
WAVE_FORMAT_4M08 | WAVE_FORMAT_48M08 |
WAVE_FORMAT_96M08 | WAVE_FORMAT_1S08 |
WAVE_FORMAT_2S08 | WAVE_FORMAT_4S08 |
WAVE_FORMAT_48S08 | WAVE_FORMAT_96S08) )
*flags |= DSCAPS_PRIMARY8BIT;
if (*formats & (WAVE_FORMAT_1M16 | WAVE_FORMAT_2M16 |
WAVE_FORMAT_4M16 | WAVE_FORMAT_48M16 |
WAVE_FORMAT_96M16 | WAVE_FORMAT_1S16 |
WAVE_FORMAT_2S16 | WAVE_FORMAT_4S16 |
WAVE_FORMAT_48S16 | WAVE_FORMAT_96S16) )
*flags |= DSCAPS_PRIMARY16BIT;
rc = 0;
done:
if (rc < 0) ERR("failed: %s(%d)\n", snd_strerror(rc), rc);
HeapFree( GetProcessHeap(), 0, hw_params );
HeapFree( GetProcessHeap(), 0, fmask );
HeapFree( GetProcessHeap(), 0, acmask );
return rc;
}
bool S9xAlsaSoundDriver::open_device()
{
int err;
unsigned int periods = 8;
unsigned int buffer_size = gui_config->sound_buffer_size * 1000;
snd_pcm_sw_params_t *sw_params;
snd_pcm_hw_params_t *hw_params;
snd_pcm_uframes_t alsa_buffer_size, alsa_period_size;
unsigned int min = 0;
unsigned int max = 0;
printf("ALSA sound driver initializing...\n");
printf(" --> (Device: default)...\n");
err = snd_pcm_open(&pcm,
"default",
SND_PCM_STREAM_PLAYBACK,
SND_PCM_NONBLOCK);
if (err < 0)
{
goto fail;
}
printf(" --> (16-bit Stereo, %dhz, %d ms)...\n",
Settings.SoundPlaybackRate,
gui_config->sound_buffer_size);
snd_pcm_hw_params_alloca(&hw_params);
snd_pcm_hw_params_any(pcm, hw_params);
snd_pcm_hw_params_set_format(pcm, hw_params, SND_PCM_FORMAT_S16);
snd_pcm_hw_params_set_access(pcm, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_pcm_hw_params_set_rate_resample(pcm, hw_params, 0);
snd_pcm_hw_params_set_channels(pcm, hw_params, 2);
snd_pcm_hw_params_get_rate_min(hw_params, &min, NULL);
snd_pcm_hw_params_get_rate_max(hw_params, &max, NULL);
printf(" --> Available rates: %d to %d\n", min, max);
if (Settings.SoundPlaybackRate > max && Settings.SoundPlaybackRate < min)
{
printf(" Rate %d not available. Using %d instead.\n", Settings.SoundPlaybackRate, max);
Settings.SoundPlaybackRate = max;
}
snd_pcm_hw_params_set_rate_near(pcm, hw_params, &Settings.SoundPlaybackRate, NULL);
snd_pcm_hw_params_get_buffer_time_min(hw_params, &min, NULL);
snd_pcm_hw_params_get_buffer_time_max(hw_params, &max, NULL);
printf(" --> Available buffer sizes: %dms to %dms\n", min / 1000, max / 1000);
if (buffer_size < min && buffer_size > max)
{
printf(" Buffer size %dms not available. Using %d instead.\n", buffer_size / 1000, (min + max) / 2000);
buffer_size = (min + max) / 2;
}
snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, &buffer_size, NULL);
snd_pcm_hw_params_get_periods_min(hw_params, &min, NULL);
snd_pcm_hw_params_get_periods_max(hw_params, &max, NULL);
printf(" --> Period ranges: %d to %d blocks\n", min, max);
if (periods > max)
{
periods = max;
}
snd_pcm_hw_params_set_periods_near(pcm, hw_params, &periods, NULL);
if ((err = snd_pcm_hw_params(pcm, hw_params)) < 0)
{
printf(" Hardware parameter set failed.\n");
goto close_fail;
}
snd_pcm_sw_params_alloca(&sw_params);
snd_pcm_sw_params_current(pcm, sw_params);
snd_pcm_get_params(pcm, &alsa_buffer_size, &alsa_period_size);
/* Don't start until we're [nearly] full */
snd_pcm_sw_params_set_start_threshold(pcm, sw_params, (alsa_buffer_size / 2));
err = snd_pcm_sw_params(pcm, sw_params);
output_buffer_size = snd_pcm_frames_to_bytes(pcm, alsa_buffer_size);
if (err < 0)
{
printf(" Software parameter set failed.\n");
goto close_fail;
}
printf("OK\n");
S9xSetSamplesAvailableCallback(alsa_samples_available, this);
return true;
close_fail:
snd_pcm_drain(pcm);
snd_pcm_close(pcm);
pcm = NULL;
fail:
printf("Failed: %s\n", snd_strerror(err));
return false;
}
