bool CAESinkALSA::InitializeSW(AEAudioFormat &format)
{
snd_pcm_sw_params_t *sw_params;
snd_pcm_uframes_t boundary;
snd_pcm_sw_params_alloca(&sw_params);
memset(sw_params, 0, snd_pcm_sw_params_sizeof());
snd_pcm_sw_params_current (m_pcm, sw_params);
snd_pcm_sw_params_set_start_threshold (m_pcm, sw_params, INT_MAX);
snd_pcm_sw_params_set_silence_threshold(m_pcm, sw_params, 0);
snd_pcm_sw_params_get_boundary (sw_params, &boundary);
snd_pcm_sw_params_set_silence_size (m_pcm, sw_params, boundary);
snd_pcm_sw_params_set_avail_min (m_pcm, sw_params, format.m_frames);
if (snd_pcm_sw_params(m_pcm, sw_params) < 0)
{
CLog::Log(LOGERROR, "CAESinkALSA::InitializeSW - Failed to set the parameters");
return false;
}
return true;
}
static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams, int playback)
{
#ifndef ALSAAPI9
int err;
snd_pcm_uframes_t ps,ops;
snd_pcm_uframes_t bs,obs;
/* get the current swparams */
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
check_error(err,"Unable to determine current swparams for playback");
return err;
}
/* AUTOSTART: start the transfer on each write/commit ??? */
snd_pcm_sw_params_get_start_threshold(swparams, &obs);
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0U);
if (err < 0) {
check_error(err,"Unable to set start threshold mode");
return err;
}
snd_pcm_sw_params_get_start_threshold(swparams, &bs);
#ifdef ALSAMM_DEBUG
if(sys_verbose)
post("sw_params: got start_thresh_hold= %d (was %d)",(int) bs,(int)obs);
#endif
/* AUTOSTOP: never stop the machine */
snd_pcm_sw_params_get_stop_threshold(swparams, &obs);
err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, (snd_pcm_uframes_t)-1);
if (err < 0) {
check_error(err,"Unable to set stop threshold mode");
return err;
}
snd_pcm_sw_params_get_stop_threshold(swparams, &bs);
#ifdef ALSAMM_DEBUG
if(sys_verbose)
post("sw_params: set stop_thresh_hold= %d (was %d)", (int) bs,(int)obs);
#endif
/* AUTOSILENCE: silence if overrun.... */
snd_pcm_sw_params_get_silence_threshold (swparams, &ops);
if ((err = snd_pcm_sw_params_set_silence_threshold (handle, swparams, alsamm_period_size)) < 0) {
check_error (err,"cannot set silence threshold for");
return -1;
}
snd_pcm_sw_params_get_silence_threshold (swparams, &ps);
#ifdef ALSAMM_DEBUG
if(sys_verbose)
post("sw_params: set silence_threshold = %d (was %d)", (int) ps,(int)ops);
#endif
snd_pcm_sw_params_get_silence_size (swparams, &ops);
if ((err = snd_pcm_sw_params_set_silence_size(handle, swparams, alsamm_period_size)) < 0) {
check_error (err,"cannot set silence size for");
return -1;
}
snd_pcm_sw_params_get_silence_size (swparams, &ps);
#ifdef ALSAMM_DEBUG
if(sys_verbose)
post("sw_params: set silence_size = %d (was %d)", (int) ps,(int)ops);
#endif
/* AVAIL: allow the transfer when at least period_size samples can be processed */
snd_pcm_sw_params_get_avail_min(swparams, &ops);
err = snd_pcm_sw_params_set_avail_min(handle, swparams, alsamm_transfersize/2);
if (err < 0) {
check_error(err,"Unable to set avail min for");
return err;
}
snd_pcm_sw_params_get_avail_min(swparams, &ps);
#ifdef ALSAMM_DEBUG
if(sys_verbose)
post("sw_params: set avail_min= %d (was %d)", (int) ps, (int) ops);
#endif
/* write the parameters to the playback device */
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
check_error(err,"Unable to set sw params");
return err;
}
#ifdef ALSAMM_DEBUG
if(sys_verbose)
post("set sw finished");
#endif
#else
post("alsa: need version 1.0 or above for mmap operation");
#endif /* ALSAAPI9 */
return 0;
}
static int ao_alsa_init(dtaudio_output_t *aout, dtaudio_para_t *para)
{
memcpy(&wrapper->para, para, sizeof(dtaudio_para_t));
snd_pcm_t *alsa_handle;
snd_pcm_hw_params_t *alsa_hwparams;
snd_pcm_sw_params_t *alsa_swparams;
snd_pcm_uframes_t size;
snd_pcm_uframes_t boundary;
alsa_ctx_t *ctx = (alsa_ctx_t *)malloc(sizeof(*ctx));
if (!ctx) {
return -1;
}
wrapper->ao_priv = ctx;
int afmt = format_to_alsa(wrapper->para.bps);
uint32_t channels = wrapper->para.dst_channels;
uint32_t sr = wrapper->para.dst_samplerate;
int bytes_per_sample = snd_pcm_format_physical_width(afmt) * channels / 8;
int err = 0;
err = snd_pcm_open(&alsa_handle, "default", SND_PCM_STREAM_PLAYBACK, 0);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
free(ctx);
wrapper->ao_priv = NULL;
return -1;
}
snd_pcm_hw_params_alloca(&alsa_hwparams);
snd_pcm_sw_params_alloca(&alsa_swparams);
err = snd_pcm_hw_params_any(alsa_handle, alsa_hwparams);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
err = snd_pcm_hw_params_set_access(alsa_handle, alsa_hwparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
err = snd_pcm_hw_params_set_format(alsa_handle, alsa_hwparams, afmt);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
err = snd_pcm_hw_params_set_channels_near(alsa_handle, alsa_hwparams,
&channels);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
err = snd_pcm_hw_params_set_rate_near(alsa_handle, alsa_hwparams, &sr, NULL);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
err = snd_pcm_hw_params(alsa_handle, alsa_hwparams);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
/******************************************************************
* Set HW Params Finish
******************************************************************/
/* buffer size means the entire size of alsa pcm buffer size*/
err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &size);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
ctx->buf_size = size * bytes_per_sample;
/*period size means count processed every interrupt*/
err = snd_pcm_hw_params_get_period_size(alsa_hwparams, &size, NULL);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
ctx->trunk_size = size * bytes_per_sample;
dt_info(TAG, "outburst: %d, bytes_per_sample: %d, buffersize: %d\n",
ctx->trunk_size, bytes_per_sample, ctx->buf_size);
/******************************************************************
* set sw params
******************************************************************/
err = snd_pcm_sw_params_current(alsa_handle, alsa_swparams);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
#if SND_LIB_VERSION >= 0x000901
err = snd_pcm_sw_params_get_boundary(alsa_swparams, &boundary);
#else
boundary = 0x7fffffff;
#endif
err = snd_pcm_sw_params_set_start_threshold(alsa_handle, alsa_swparams, size);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
err = snd_pcm_sw_params_set_stop_threshold(alsa_handle, alsa_swparams,
boundary);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
#if SND_LIB_VERSION >= 0x000901
err = snd_pcm_sw_params_set_silence_size(alsa_handle, alsa_swparams, boundary);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
#endif
err = snd_pcm_sw_params(alsa_handle, alsa_swparams);
if (err < 0) {
dt_error(TAG, "%s,%d: %s\n", __func__, __LINE__, snd_strerror(err));
return -1;
}
ctx->pause_support = snd_pcm_hw_params_can_pause(alsa_hwparams);
//buf size limit
ctx->buf_threshold = bytes_per_sample * sr * DEFAULT_TIME_SIZE / 1000;
dt_info(TAG, "alsa audio init ok! outburst:%d thres:%d \n", ctx->trunk_size,
ctx->buf_threshold);
ctx->handle = alsa_handle;
ctx->channels = wrapper->para.dst_channels;
ctx->bps = wrapper->para.bps;
ctx->samplerate = wrapper->para.dst_samplerate;
return 0;
}
static int initialize_device(struct audio_info_struct *ai)
{
snd_pcm_hw_params_t *hw;
int i;
snd_pcm_format_t format;
unsigned int rate;
snd_pcm_uframes_t buffer_size;
snd_pcm_uframes_t period_size;
snd_pcm_sw_params_t *sw;
snd_pcm_uframes_t boundary;
snd_pcm_hw_params_alloca(&hw);
if (snd_pcm_hw_params_any(ai->handle, hw) < 0) {
fprintf(stderr, "initialize_device(): no configuration available\n");
return -1;
}
if (snd_pcm_hw_params_set_access(ai->handle, hw, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
fprintf(stderr, "initialize_device(): device does not support interleaved access\n");
return -1;
}
format = SND_PCM_FORMAT_UNKNOWN;
for (i = 0; i < NUM_FORMATS; ++i) {
if (ai->format == format_map[i].mpg123) {
format = format_map[i].alsa;
break;
}
}
if (format == SND_PCM_FORMAT_UNKNOWN) {
fprintf(stderr, "initialize_device(): invalid sample format %d\n", ai->format);
errno = EINVAL;
return -1;
}
if (snd_pcm_hw_params_set_format(ai->handle, hw, format) < 0) {
fprintf(stderr, "initialize_device(): cannot set format %s\n", snd_pcm_format_name(format));
return -1;
}
if (snd_pcm_hw_params_set_channels(ai->handle, hw, ai->channels) < 0) {
fprintf(stderr, "initialize_device(): cannot set %d channels\n", ai->channels);
return -1;
}
rate = ai->rate;
if (snd_pcm_hw_params_set_rate_near(ai->handle, hw, &rate, NULL) < 0) {
fprintf(stderr, "initialize_device(): cannot set rate %u\n", rate);
return -1;
}
if (!rates_match(ai->rate, rate)) {
fprintf(stderr, "initialize_device(): rate %ld not available, using %u\n", ai->rate, rate);
/* return -1; */
}
buffer_size = rate * BUFFER_LENGTH;
if (snd_pcm_hw_params_set_buffer_size_near(ai->handle, hw, &buffer_size) < 0) {
fprintf(stderr, "initialize_device(): cannot set buffer size\n");
return -1;
}
period_size = buffer_size / 4;
if (snd_pcm_hw_params_set_period_size_near(ai->handle, hw, &period_size, NULL) < 0) {
fprintf(stderr, "initialize_device(): cannot set period size\n");
return -1;
}
if (snd_pcm_hw_params(ai->handle, hw) < 0) {
fprintf(stderr, "initialize_device(): cannot set hw params\n");
return -1;
}
snd_pcm_sw_params_alloca(&sw);
if (snd_pcm_sw_params_current(ai->handle, sw) < 0) {
fprintf(stderr, "initialize_device(): cannot get sw params\n");
return -1;
}
/* start playing after the first write */
if (snd_pcm_sw_params_set_start_threshold(ai->handle, sw, 1) < 0) {
fprintf(stderr, "initialize_device(): cannot set start threshold\n");
return -1;
}
if (snd_pcm_sw_params_get_boundary(sw, &boundary) < 0) {
fprintf(stderr, "initialize_device(): cannot get boundary\n");
return -1;
}
/* never stop on underruns */
if (snd_pcm_sw_params_set_stop_threshold(ai->handle, sw, boundary) < 0) {
fprintf(stderr, "initialize_device(): cannot set stop threshold\n");
return -1;
}
/* wake up on every interrupt */
if (snd_pcm_sw_params_set_avail_min(ai->handle, sw, 1) < 0) {
fprintf(stderr, "initialize_device(): cannot set min avail\n");
return -1;
}
#if 0
/* always write as many frames as possible */
if (snd_pcm_sw_params_set_xfer_align(ai->handle, sw, 1) < 0) {
fprintf(stderr, "initialize_device(): cannot set transfer alignment\n");
return -1;
}
#endif
/* play silence when there is an underrun */
if (snd_pcm_sw_params_set_silence_size(ai->handle, sw, boundary) < 0) {
fprintf(stderr, "initialize_device(): cannot set silence size\n");
return -1;
}
if (snd_pcm_sw_params(ai->handle, sw) < 0) {
fprintf(stderr, "initialize_device(): cannot set sw params\n");
return -1;
}
return 0;
}
int
set_speaker_swparams(snd_pcm_t *handle, int channels, int bufferSize)
{
// set software params
snd_pcm_sw_params_t *swparams;
snd_pcm_sw_params_alloca(&swparams);
int thresholdFrames;
/* get the current swparams */
int ret = snd_pcm_sw_params_current(handle, swparams);
if (ret < 0) {
fprintf(stderr,
"Unable to determine current swparams for playback: %s\n",
snd_strerror(ret));
return ret;
}
/* start the transfer when the second buffer is written
ret = snd_pcm_sw_params_set_start_threshold(handle, swparams,
1 * period_frames);
if (ret < 0) {
fprintf(stderr,
"Unable to set start threshold mode for playback: %s\n",
snd_strerror(ret));
return ret;
}
/* Notify asynchronously when data can be written */
// ret = snd_pcm_sw_params_set_avail_min(handle, swparams,
// get_period_frames(handle));
// if (ret < 0) {
// fprintf(stderr, "Unable to set avail min for playback: %s\n",
// snd_strerror(ret));
// return ret;
// }
/* align all transfers to 1 sample */
ret = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);
if (ret < 0) {
fprintf(stderr, "Unable to set transfer align for playback: %s\n",
snd_strerror(ret));
return ret;
}
thresholdFrames = (bufferSize - 20) / 2 / channels;
if (thresholdFrames <= 0) {
thresholdFrames = bufferSize / 2 / channels;
}
fprintf(stderr, "speaker buffer size %d., thresholdFrames %d\n",
bufferSize, thresholdFrames);
/* set silence threshold */
ret = snd_pcm_sw_params_set_silence_threshold(handle, swparams,
thresholdFrames);
if (ret < 0) {
fprintf(stderr, "Unable to set sw params for silence_threshold: %s\n",
snd_strerror(ret));
return ret;
}
/* set silence size */
ret = snd_pcm_sw_params_set_silence_size(handle, swparams,
thresholdFrames);
if (ret < 0) {
fprintf(stderr, "Unable to set sw params for silence_size: %s\n",
snd_strerror(ret));
return ret;
}
/* write the parameters to the playback device */
ret = snd_pcm_sw_params(handle, swparams);
if (ret < 0) {
fprintf(stderr, "Unable to set sw params for playback: %s\n",
snd_strerror(ret));
return ret;
}
dump_swparams(handle);
return 0;
}
bool setParameters (unsigned int sampleRate, int numChannels, int bufferSize)
{
if (handle == nullptr)
return false;
JUCE_ALSA_LOG ("ALSADevice::setParameters(" << deviceID << ", "
<< (int) sampleRate << ", " << numChannels << ", " << bufferSize << ")");
snd_pcm_hw_params_t* hwParams;
snd_pcm_hw_params_alloca (&hwParams);
if (snd_pcm_hw_params_any (handle, hwParams) < 0)
{
// this is the error message that aplay returns when an error happens here,
// it is a bit more explicit that "Invalid parameter"
error = "Broken configuration for this PCM: no configurations available";
return false;
}
if (snd_pcm_hw_params_set_access (handle, hwParams, SND_PCM_ACCESS_RW_INTERLEAVED) >= 0) // works better for plughw..
isInterleaved = true;
else if (snd_pcm_hw_params_set_access (handle, hwParams, SND_PCM_ACCESS_RW_NONINTERLEAVED) >= 0)
isInterleaved = false;
else
{
jassertfalse;
return false;
}
enum { isFloatBit = 1 << 16, isLittleEndianBit = 1 << 17, onlyUseLower24Bits = 1 << 18 };
const int formatsToTry[] = { SND_PCM_FORMAT_FLOAT_LE, 32 | isFloatBit | isLittleEndianBit,
SND_PCM_FORMAT_FLOAT_BE, 32 | isFloatBit,
SND_PCM_FORMAT_S32_LE, 32 | isLittleEndianBit,
SND_PCM_FORMAT_S32_BE, 32,
SND_PCM_FORMAT_S24_3LE, 24 | isLittleEndianBit,
SND_PCM_FORMAT_S24_3BE, 24,
SND_PCM_FORMAT_S24_LE, 32 | isLittleEndianBit | onlyUseLower24Bits,
SND_PCM_FORMAT_S16_LE, 16 | isLittleEndianBit,
SND_PCM_FORMAT_S16_BE, 16 };
bitDepth = 0;
for (int i = 0; i < numElementsInArray (formatsToTry); i += 2)
{
if (snd_pcm_hw_params_set_format (handle, hwParams, (_snd_pcm_format) formatsToTry [i]) >= 0)
{
const int type = formatsToTry [i + 1];
bitDepth = type & 255;
converter.reset (createConverter (isInput, bitDepth,
(type & isFloatBit) != 0,
(type & isLittleEndianBit) != 0,
(type & onlyUseLower24Bits) != 0,
numChannels,
isInterleaved));
break;
}
}
if (bitDepth == 0)
{
error = "device doesn't support a compatible PCM format";
JUCE_ALSA_LOG ("Error: " + error);
return false;
}
int dir = 0;
unsigned int periods = 4;
snd_pcm_uframes_t samplesPerPeriod = (snd_pcm_uframes_t) bufferSize;
if (JUCE_ALSA_FAILED (snd_pcm_hw_params_set_rate_near (handle, hwParams, &sampleRate, 0))
|| JUCE_ALSA_FAILED (snd_pcm_hw_params_set_channels (handle, hwParams, (unsigned int ) numChannels))
|| JUCE_ALSA_FAILED (snd_pcm_hw_params_set_periods_near (handle, hwParams, &periods, &dir))
|| JUCE_ALSA_FAILED (snd_pcm_hw_params_set_period_size_near (handle, hwParams, &samplesPerPeriod, &dir))
|| JUCE_ALSA_FAILED (snd_pcm_hw_params (handle, hwParams)))
{
return false;
}
snd_pcm_uframes_t frames = 0;
if (JUCE_ALSA_FAILED (snd_pcm_hw_params_get_period_size (hwParams, &frames, &dir))
|| JUCE_ALSA_FAILED (snd_pcm_hw_params_get_periods (hwParams, &periods, &dir)))
latency = 0;
else
latency = (int) frames * ((int) periods - 1); // (this is the method JACK uses to guess the latency..)
JUCE_ALSA_LOG ("frames: " << (int) frames << ", periods: " << (int) periods
<< ", samplesPerPeriod: " << (int) samplesPerPeriod);
snd_pcm_sw_params_t* swParams;
snd_pcm_sw_params_alloca (&swParams);
snd_pcm_uframes_t boundary;
if (JUCE_ALSA_FAILED (snd_pcm_sw_params_current (handle, swParams))
|| JUCE_ALSA_FAILED (snd_pcm_sw_params_get_boundary (swParams, &boundary))
|| JUCE_ALSA_FAILED (snd_pcm_sw_params_set_silence_threshold (handle, swParams, 0))
|| JUCE_ALSA_FAILED (snd_pcm_sw_params_set_silence_size (handle, swParams, boundary))
|| JUCE_ALSA_FAILED (snd_pcm_sw_params_set_start_threshold (handle, swParams, samplesPerPeriod))
|| JUCE_ALSA_FAILED (snd_pcm_sw_params_set_stop_threshold (handle, swParams, boundary))
|| JUCE_ALSA_FAILED (snd_pcm_sw_params (handle, swParams)))
{
return false;
}
#if JUCE_ALSA_LOGGING
// enable this to dump the config of the devices that get opened
snd_output_t* out;
snd_output_stdio_attach (&out, stderr, 0);
snd_pcm_hw_params_dump (hwParams, out);
snd_pcm_sw_params_dump (swParams, out);
#endif
numChannelsRunning = numChannels;
return true;
}
/**************************************************************************
* widOpen [internal]
*/
static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
{
WINE_WAVEDEV* wwi;
snd_pcm_hw_params_t * hw_params;
snd_pcm_sw_params_t * sw_params;
snd_pcm_access_t access;
snd_pcm_format_t format;
unsigned int rate;
unsigned int buffer_time = 500000;
unsigned int period_time = 10000;
snd_pcm_uframes_t buffer_size;
snd_pcm_uframes_t period_size;
int flags;
snd_pcm_t * pcm;
int err;
int dir;
DWORD ret;
/* JPW TODO - review this code */
TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
if (lpDesc == NULL) {
WARN("Invalid Parameter !\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= ALSA_WidNumDevs) {
TRACE("Requested device %d, but only %d are known!\n", wDevID, ALSA_WidNumDevs);
return MMSYSERR_BADDEVICEID;
}
/* only PCM format is supported so far... */
if (!ALSA_supportedFormat(lpDesc->lpFormat)) {
WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
lpDesc->lpFormat->nSamplesPerSec);
return WAVERR_BADFORMAT;
}
if (dwFlags & WAVE_FORMAT_QUERY) {
TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
lpDesc->lpFormat->nSamplesPerSec);
return MMSYSERR_NOERROR;
}
wwi = &WInDev[wDevID];
if (wwi->pcm != NULL) {
WARN("already allocated\n");
return MMSYSERR_ALLOCATED;
}
wwi->pcm = 0;
flags = SND_PCM_NONBLOCK;
if ( (err=snd_pcm_open(&pcm, wwi->pcmname, SND_PCM_STREAM_CAPTURE, flags)) < 0 )
{
ERR("Error open: %s\n", snd_strerror(err));
return MMSYSERR_NOTENABLED;
}
wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
wwi->waveDesc = *lpDesc;
ALSA_copyFormat(lpDesc->lpFormat, &wwi->format);
if (wwi->format.Format.wBitsPerSample == 0) {
WARN("Resetting zeroed wBitsPerSample\n");
wwi->format.Format.wBitsPerSample = 8 *
(wwi->format.Format.nAvgBytesPerSec /
wwi->format.Format.nSamplesPerSec) /
wwi->format.Format.nChannels;
}
hw_params = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_hw_params_sizeof() );
sw_params = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_sw_params_sizeof() );
snd_pcm_hw_params_any(pcm, hw_params);
#define EXIT_ON_ERROR(f,e,txt) do \
{ \
int err; \
if ( (err = (f) ) < 0) \
{ \
WARN(txt ": %s\n", snd_strerror(err)); \
ret = (e); \
goto error; \
} \
} while(0)
access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
WARN("mmap not available. switching to standard write.\n");
access = SND_PCM_ACCESS_RW_INTERLEAVED;
EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
wwi->read = snd_pcm_readi;
}
else
wwi->read = snd_pcm_mmap_readi;
EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwi->format.Format.nChannels), WAVERR_BADFORMAT, "unable to set required channels");
if ((wwi->format.Format.wFormatTag == WAVE_FORMAT_PCM) ||
((wwi->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
IsEqualGUID(&wwi->format.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) {
format = (wwi->format.Format.wBitsPerSample == 8) ? SND_PCM_FORMAT_U8 :
(wwi->format.Format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE :
(wwi->format.Format.wBitsPerSample == 24) ? SND_PCM_FORMAT_S24_3LE :
(wwi->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_S32_LE : -1;
} else if ((wwi->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
IsEqualGUID(&wwi->format.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)){
format = (wwi->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_FLOAT_LE : -1;
} else if (wwi->format.Format.wFormatTag == WAVE_FORMAT_MULAW) {
FIXME("unimplemented format: WAVE_FORMAT_MULAW\n");
ret = WAVERR_BADFORMAT;
goto error;
} else if (wwi->format.Format.wFormatTag == WAVE_FORMAT_ALAW) {
FIXME("unimplemented format: WAVE_FORMAT_ALAW\n");
ret = WAVERR_BADFORMAT;
goto error;
} else if (wwi->format.Format.wFormatTag == WAVE_FORMAT_ADPCM) {
FIXME("unimplemented format: WAVE_FORMAT_ADPCM\n");
ret = WAVERR_BADFORMAT;
goto error;
} else {
ERR("invalid format: %0x04x\n", wwi->format.Format.wFormatTag);
ret = WAVERR_BADFORMAT;
goto error;
}
EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), WAVERR_BADFORMAT, "unable to set required format");
rate = wwi->format.Format.nSamplesPerSec;
dir = 0;
err = snd_pcm_hw_params_set_rate_near(pcm, hw_params, &rate, &dir);
if (err < 0) {
WARN("Rate %d Hz not available for playback: %s\n", wwi->format.Format.nSamplesPerSec, snd_strerror(rate));
ret = WAVERR_BADFORMAT;
goto error;
}
if (!ALSA_NearMatch(rate, wwi->format.Format.nSamplesPerSec)) {
WARN("Rate doesn't match (requested %d Hz, got %d Hz)\n", wwi->format.Format.nSamplesPerSec, rate);
ret = WAVERR_BADFORMAT;
goto error;
}
dir=0;
EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, &buffer_time, &dir), MMSYSERR_INVALPARAM, "unable to set buffer time");
dir=0;
EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm, hw_params, &period_time, &dir), MMSYSERR_INVALPARAM, "unable to set period time");
EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
dir=0;
err = snd_pcm_hw_params_get_period_size(hw_params, &period_size, &dir);
err = snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
snd_pcm_sw_params_current(pcm, sw_params);
EXIT_ON_ERROR( snd_pcm_sw_params_set_start_threshold(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set start threshold");
EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence size");
EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
#undef EXIT_ON_ERROR
snd_pcm_prepare(pcm);
if (TRACE_ON(wave))
ALSA_TraceParameters(hw_params, sw_params, FALSE);
/* now, we can save all required data for later use... */
if ( wwi->hw_params )
snd_pcm_hw_params_free(wwi->hw_params);
snd_pcm_hw_params_malloc(&(wwi->hw_params));
snd_pcm_hw_params_copy(wwi->hw_params, hw_params);
wwi->dwBufferSize = snd_pcm_frames_to_bytes(pcm, buffer_size);
wwi->lpQueuePtr = wwi->lpPlayPtr = wwi->lpLoopPtr = NULL;
wwi->pcm = pcm;
ALSA_InitRingMessage(&wwi->msgRing);
wwi->dwPeriodSize = snd_pcm_frames_to_bytes(pcm, period_size);
TRACE("dwPeriodSize=%u\n", wwi->dwPeriodSize);
TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
wwi->format.Format.wBitsPerSample, wwi->format.Format.nAvgBytesPerSec,
wwi->format.Format.nSamplesPerSec, wwi->format.Format.nChannels,
wwi->format.Format.nBlockAlign);
wwi->hStartUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
wwi->hThread = CreateThread(NULL, 0, widRecorder, (LPVOID)(DWORD_PTR)wDevID, 0, &(wwi->dwThreadID));
if (wwi->hThread)
SetThreadPriority(wwi->hThread, THREAD_PRIORITY_TIME_CRITICAL);
WaitForSingleObject(wwi->hStartUpEvent, INFINITE);
CloseHandle(wwi->hStartUpEvent);
wwi->hStartUpEvent = INVALID_HANDLE_VALUE;
HeapFree( GetProcessHeap(), 0, hw_params );
HeapFree( GetProcessHeap(), 0, sw_params );
return widNotifyClient(wwi, WIM_OPEN, 0L, 0L);
error:
snd_pcm_close(pcm);
HeapFree( GetProcessHeap(), 0, hw_params );
HeapFree( GetProcessHeap(), 0, sw_params );
return ret;
}
/**
* Allocate the memory-mapped buffer for direct sound, and set up the
* callback.
*/
static int DSDB_CreateMMAP(IDsDriverBufferImpl* pdbi)
{
snd_pcm_t *pcm = pdbi->pcm;
snd_pcm_format_t format;
snd_pcm_uframes_t frames, ofs, avail, psize, boundary;
unsigned int channels, bits_per_sample, bits_per_frame;
int err, mmap_mode;
const snd_pcm_channel_area_t *areas;
snd_pcm_hw_params_t *hw_params = pdbi->hw_params;
snd_pcm_sw_params_t *sw_params = pdbi->sw_params;
void *buf;
mmap_mode = snd_pcm_type(pcm);
if (mmap_mode == SND_PCM_TYPE_HW)
TRACE("mmap'd buffer is a direct hardware buffer.\n");
else if (mmap_mode == SND_PCM_TYPE_DMIX)
TRACE("mmap'd buffer is an ALSA dmix buffer\n");
else
TRACE("mmap'd buffer is an ALSA type %d buffer\n", mmap_mode);
err = snd_pcm_hw_params_get_period_size(hw_params, &psize, NULL);
err = snd_pcm_hw_params_get_format(hw_params, &format);
err = snd_pcm_hw_params_get_buffer_size(hw_params, &frames);
err = snd_pcm_hw_params_get_channels(hw_params, &channels);
bits_per_sample = snd_pcm_format_physical_width(format);
bits_per_frame = bits_per_sample * channels;
if (TRACE_ON(dsalsa))
ALSA_TraceParameters(hw_params, NULL, FALSE);
TRACE("format=%s frames=%ld channels=%d bits_per_sample=%d bits_per_frame=%d\n",
snd_pcm_format_name(format), frames, channels, bits_per_sample, bits_per_frame);
pdbi->mmap_buflen_frames = frames;
pdbi->mmap_buflen_bytes = snd_pcm_frames_to_bytes( pcm, frames );
snd_pcm_sw_params_current(pcm, sw_params);
snd_pcm_sw_params_set_start_threshold(pcm, sw_params, 0);
snd_pcm_sw_params_get_boundary(sw_params, &boundary);
snd_pcm_sw_params_set_stop_threshold(pcm, sw_params, boundary);
snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, boundary);
snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0);
snd_pcm_sw_params_set_avail_min(pcm, sw_params, 0);
err = snd_pcm_sw_params(pcm, sw_params);
avail = snd_pcm_avail_update(pcm);
if ((snd_pcm_sframes_t)avail < 0)
{
ERR("No buffer is available: %s.\n", snd_strerror(avail));
return DSERR_GENERIC;
}
if (!pdbi->mmap)
{
buf = pdbi->mmap_buffer = HeapAlloc(GetProcessHeap(), 0, pdbi->mmap_buflen_bytes);
if (!buf)
return DSERR_OUTOFMEMORY;
snd_pcm_format_set_silence(format, buf, pdbi->mmap_buflen_frames);
pdbi->mmap_pos = 0;
}
else
{
err = snd_pcm_mmap_begin(pcm, &areas, &ofs, &avail);
if ( err < 0 )
{
ERR("Can't map sound device for direct access: %s/%d\n", snd_strerror(err), err);
return DSERR_GENERIC;
}
snd_pcm_format_set_silence(format, areas->addr, pdbi->mmap_buflen_frames);
pdbi->mmap_pos = ofs + snd_pcm_mmap_commit(pcm, ofs, 0);
pdbi->mmap_buffer = areas->addr;
}
TRACE("created mmap buffer of %ld frames (%d bytes) at %p\n",
frames, pdbi->mmap_buflen_bytes, pdbi->mmap_buffer);
return DS_OK;
}
/*
open & setup audio device
return: 1=success 0=fail
*/
static int init(int rate_hz, int channels, int format, int flags)
{
unsigned int alsa_buffer_time = 500000; /* 0.5 s */
unsigned int alsa_fragcount = 16;
int err;
int block;
strarg_t device;
snd_pcm_uframes_t chunk_size;
snd_pcm_uframes_t bufsize;
snd_pcm_uframes_t boundary;
const opt_t subopts[] = {
{"block", OPT_ARG_BOOL, &block, NULL},
{"device", OPT_ARG_STR, &device, str_maxlen},
{NULL}
};
char alsa_device[ALSA_DEVICE_SIZE + 1];
// make sure alsa_device is null-terminated even when using strncpy etc.
memset(alsa_device, 0, ALSA_DEVICE_SIZE + 1);
mp_msg(MSGT_AO,MSGL_V,"alsa-init: requested format: %d Hz, %d channels, %x\n", rate_hz,
channels, format);
alsa_handler = NULL;
#if SND_LIB_VERSION >= 0x010005
mp_msg(MSGT_AO,MSGL_V,"alsa-init: using ALSA %s\n", snd_asoundlib_version());
#else
mp_msg(MSGT_AO,MSGL_V,"alsa-init: compiled for ALSA-%s\n", SND_LIB_VERSION_STR);
#endif
snd_lib_error_set_handler(alsa_error_handler);
ao_data.samplerate = rate_hz;
ao_data.format = format;
ao_data.channels = channels;
switch (format)
{
case AF_FORMAT_S8:
alsa_format = SND_PCM_FORMAT_S8;
break;
case AF_FORMAT_U8:
alsa_format = SND_PCM_FORMAT_U8;
break;
case AF_FORMAT_U16_LE:
alsa_format = SND_PCM_FORMAT_U16_LE;
break;
case AF_FORMAT_U16_BE:
alsa_format = SND_PCM_FORMAT_U16_BE;
break;
case AF_FORMAT_AC3_LE:
case AF_FORMAT_S16_LE:
case AF_FORMAT_IEC61937_LE:
alsa_format = SND_PCM_FORMAT_S16_LE;
break;
case AF_FORMAT_AC3_BE:
case AF_FORMAT_S16_BE:
case AF_FORMAT_IEC61937_BE:
alsa_format = SND_PCM_FORMAT_S16_BE;
break;
case AF_FORMAT_U32_LE:
alsa_format = SND_PCM_FORMAT_U32_LE;
break;
case AF_FORMAT_U32_BE:
alsa_format = SND_PCM_FORMAT_U32_BE;
break;
case AF_FORMAT_S32_LE:
alsa_format = SND_PCM_FORMAT_S32_LE;
break;
case AF_FORMAT_S32_BE:
alsa_format = SND_PCM_FORMAT_S32_BE;
break;
case AF_FORMAT_U24_LE:
alsa_format = SND_PCM_FORMAT_U24_3LE;
break;
case AF_FORMAT_U24_BE:
alsa_format = SND_PCM_FORMAT_U24_3BE;
break;
case AF_FORMAT_S24_LE:
alsa_format = SND_PCM_FORMAT_S24_3LE;
break;
case AF_FORMAT_S24_BE:
alsa_format = SND_PCM_FORMAT_S24_3BE;
break;
case AF_FORMAT_FLOAT_LE:
alsa_format = SND_PCM_FORMAT_FLOAT_LE;
break;
case AF_FORMAT_FLOAT_BE:
alsa_format = SND_PCM_FORMAT_FLOAT_BE;
break;
case AF_FORMAT_MU_LAW:
alsa_format = SND_PCM_FORMAT_MU_LAW;
break;
case AF_FORMAT_A_LAW:
alsa_format = SND_PCM_FORMAT_A_LAW;
break;
default:
alsa_format = SND_PCM_FORMAT_MPEG; //? default should be -1
break;
}
//subdevice parsing
// set defaults
block = 1;
/* switch for spdif
* sets opening sequence for SPDIF
* sets also the playback and other switches 'on the fly'
* while opening the abstract alias for the spdif subdevice
* 'iec958'
*/
if (AF_FORMAT_IS_IEC61937(format)) {
device.str = "iec958";
mp_msg(MSGT_AO,MSGL_V,"alsa-spdif-init: playing AC3/iec61937/iec958, %i channels\n", channels);
}
else
/* in any case for multichannel playback we should select
* appropriate device
*/
switch (channels) {
case 1:
case 2:
device.str = "default";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: setup for 1/2 channel(s)\n");
break;
case 4:
if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
// hack - use the converter plugin
device.str = "plug:surround40";
else
device.str = "surround40";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround40\n");
break;
case 6:
if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
device.str = "plug:surround51";
else
device.str = "surround51";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround51\n");
break;
case 8:
if (alsa_format == SND_PCM_FORMAT_FLOAT_LE)
device.str = "plug:surround71";
else
device.str = "surround71";
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device set to surround71\n");
break;
default:
device.str = "default";
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ChannelsNotSupported,channels);
}
device.len = strlen(device.str);
if (subopt_parse(ao_subdevice, subopts) != 0) {
print_help();
return 0;
}
parse_device(alsa_device, device.str, device.len);
mp_msg(MSGT_AO,MSGL_V,"alsa-init: using device %s\n", alsa_device);
if (!alsa_handler) {
int open_mode = block ? 0 : SND_PCM_NONBLOCK;
int isac3 = AF_FORMAT_IS_IEC61937(format);
//modes = 0, SND_PCM_NONBLOCK, SND_PCM_ASYNC
mp_msg(MSGT_AO,MSGL_V,"alsa-init: opening device in %sblocking mode\n", block ? "" : "non-");
if ((err = try_open_device(alsa_device, open_mode, isac3)) < 0)
{
if (err != -EBUSY && !block) {
mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_ALSA_OpenInNonblockModeFailed);
if ((err = try_open_device(alsa_device, 0, isac3)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err));
return 0;
}
} else {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_PlaybackOpenError, snd_strerror(err));
return 0;
}
}
if ((err = snd_pcm_nonblock(alsa_handler, 0)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_ErrorSetBlockMode, snd_strerror(err));
} else {
mp_msg(MSGT_AO,MSGL_V,"alsa-init: device reopened in blocking mode\n");
}
snd_pcm_hw_params_alloca(&alsa_hwparams);
snd_pcm_sw_params_alloca(&alsa_swparams);
// setting hw-parameters
if ((err = snd_pcm_hw_params_any(alsa_handler, alsa_hwparams)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetInitialParameters,
snd_strerror(err));
return 0;
}
err = snd_pcm_hw_params_set_access(alsa_handler, alsa_hwparams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetAccessType,
snd_strerror(err));
return 0;
}
/* workaround for nonsupported formats
sets default format to S16_LE if the given formats aren't supported */
if ((err = snd_pcm_hw_params_test_format(alsa_handler, alsa_hwparams,
alsa_format)) < 0)
{
mp_msg(MSGT_AO,MSGL_INFO,
MSGTR_AO_ALSA_FormatNotSupportedByHardware, af_fmt2str_short(format));
alsa_format = SND_PCM_FORMAT_S16_LE;
if (AF_FORMAT_IS_AC3(ao_data.format))
ao_data.format = AF_FORMAT_AC3_LE;
else if (AF_FORMAT_IS_IEC61937(ao_data.format))
ao_data.format = AF_FORMAT_IEC61937_LE;
else
ao_data.format = AF_FORMAT_S16_LE;
}
if ((err = snd_pcm_hw_params_set_format(alsa_handler, alsa_hwparams,
alsa_format)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetFormat,
snd_strerror(err));
return 0;
}
if ((err = snd_pcm_hw_params_set_channels_near(alsa_handler, alsa_hwparams,
&ao_data.channels)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetChannels,
snd_strerror(err));
return 0;
}
/* workaround for buggy rate plugin (should be fixed in ALSA 1.0.11)
prefer our own resampler, since that allows users to choose the resampler,
even per file if desired */
#if SND_LIB_VERSION >= 0x010009
if ((err = snd_pcm_hw_params_set_rate_resample(alsa_handler, alsa_hwparams,
0)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToDisableResampling,
snd_strerror(err));
return 0;
}
#endif
if ((err = snd_pcm_hw_params_set_rate_near(alsa_handler, alsa_hwparams,
&ao_data.samplerate, NULL)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSamplerate2,
snd_strerror(err));
return 0;
}
bytes_per_sample = af_fmt2bits(ao_data.format) / 8;
bytes_per_sample *= ao_data.channels;
ao_data.bps = ao_data.samplerate * bytes_per_sample;
if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_handler, alsa_hwparams,
&alsa_buffer_time, NULL)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetBufferTimeNear,
snd_strerror(err));
return 0;
}
if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams,
&alsa_fragcount, NULL)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetPeriods,
snd_strerror(err));
return 0;
}
/* finally install hardware parameters */
if ((err = snd_pcm_hw_params(alsa_handler, alsa_hwparams)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetHwParameters,
snd_strerror(err));
return 0;
}
// end setting hw-params
// gets buffersize for control
if ((err = snd_pcm_hw_params_get_buffer_size(alsa_hwparams, &bufsize)) < 0)
{
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBufferSize, snd_strerror(err));
return 0;
}
else {
ao_data.buffersize = bufsize * bytes_per_sample;
mp_msg(MSGT_AO,MSGL_V,"alsa-init: got buffersize=%i\n", ao_data.buffersize);
}
if ((err = snd_pcm_hw_params_get_period_size(alsa_hwparams, &chunk_size, NULL)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetPeriodSize, snd_strerror(err));
return 0;
} else {
mp_msg(MSGT_AO,MSGL_V,"alsa-init: got period size %li\n", chunk_size);
}
ao_data.outburst = chunk_size * bytes_per_sample;
/* setting software parameters */
if ((err = snd_pcm_sw_params_current(alsa_handler, alsa_swparams)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,
snd_strerror(err));
return 0;
}
#if SND_LIB_VERSION >= 0x000901
if ((err = snd_pcm_sw_params_get_boundary(alsa_swparams, &boundary)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetBoundary,
snd_strerror(err));
return 0;
}
#else
boundary = 0x7fffffff;
#endif
/* start playing when one period has been written */
if ((err = snd_pcm_sw_params_set_start_threshold(alsa_handler, alsa_swparams, chunk_size)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStartThreshold,
snd_strerror(err));
return 0;
}
/* disable underrun reporting */
if ((err = snd_pcm_sw_params_set_stop_threshold(alsa_handler, alsa_swparams, boundary)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetStopThreshold,
snd_strerror(err));
return 0;
}
#if SND_LIB_VERSION >= 0x000901
/* play silence when there is an underrun */
if ((err = snd_pcm_sw_params_set_silence_size(alsa_handler, alsa_swparams, boundary)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToSetSilenceSize,
snd_strerror(err));
return 0;
}
#endif
if ((err = snd_pcm_sw_params(alsa_handler, alsa_swparams)) < 0) {
mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_ALSA_UnableToGetSwParameters,
snd_strerror(err));
return 0;
}
/* end setting sw-params */
mp_msg(MSGT_AO,MSGL_V,"alsa: %d Hz/%d channels/%d bpf/%d bytes buffer/%s\n",
ao_data.samplerate, ao_data.channels, (int)bytes_per_sample, ao_data.buffersize,
snd_pcm_format_description(alsa_format));
} // end switch alsa_handler (spdif)
alsa_can_pause = snd_pcm_hw_params_can_pause(alsa_hwparams);
return 1;
} // end init
/* setup alsa data transfer behavior */
static inline int alsa_set_swparams(ao_device *device)
{
ao_alsa_internal *internal = (ao_alsa_internal *) device->internal;
snd_pcm_sw_params_t *params;
snd_pcm_uframes_t boundary;
int err;
/* allocate the software parameter structure */
snd_pcm_sw_params_alloca(¶ms);
/* fetch the current software parameters */
err = snd_pcm_sw_params_current(internal->pcm_handle, params);
if (err < 0){
adebug("snd_pcm_sw_params_current() failed.\n");
return err;
}
#if 0 /* the below causes more trouble than it cures */
/* allow transfers to start when there is one period */
err = snd_pcm_sw_params_set_start_threshold(internal->pcm_handle,
params, internal->period_size);
if (err < 0){
adebug("snd_pcm_sw_params_set_start_threshold() failed.\n");
//return err;
}
/* require a minimum of one full transfer in the buffer */
err = snd_pcm_sw_params_set_avail_min(internal->pcm_handle, params,
internal->period_size);
if (err < 0){
adebug("snd_pcm_sw_params_set_avail_min() failed.\n");
//return err;
}
#endif
/* do not align transfers; this is obsolete/deprecated in ALSA
1.x where the transfer alignemnt is always 1 (except for
buggy drivers like VIA 82xx which still demand aligned
transfers regardless of setting, in violation of the ALSA
API docs) */
err = snd_pcm_sw_params_set_xfer_align(internal->pcm_handle, params, 1);
if (err < 0){
adebug("snd_pcm_sw_params_set_xfer_align() failed.\n");
//return err;
}
/* get the boundary size */
err = snd_pcm_sw_params_get_boundary(params,&boundary);
if (err < 0){
adebug("snd_pcm_sw_params_get_boundary() failed.\n");
}else{
/* force a work-ahead silence buffer; this is a fix, again for
VIA 82xx, where non-MMIO transfers will buffer into
period-size transfers, but the last transfer is usually
undersized and playback falls off the end of the submitted
data. */
err = snd_pcm_sw_params_set_silence_size(internal->pcm_handle, params, boundary);
if (err < 0){
adebug("snd_pcm_sw_params_set_silence_size() failed.\n");
//return err;
}
}
/* commit the params structure to ALSA */
err = snd_pcm_sw_params(internal->pcm_handle, params);
if (err < 0){
adebug("snd_pcm_sw_params() failed.\n");
return err;
}
return 1;
}
/**************************************************************************
* wodOpen [internal]
*/
static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
{
WINE_WAVEDEV* wwo;
snd_pcm_t * pcm = NULL;
snd_hctl_t * hctl = NULL;
snd_pcm_hw_params_t * hw_params = NULL;
snd_pcm_sw_params_t * sw_params;
snd_pcm_access_t access;
snd_pcm_format_t format = -1;
unsigned int rate;
unsigned int buffer_time = 120000;
unsigned int period_time = 22000;
snd_pcm_uframes_t buffer_size;
snd_pcm_uframes_t period_size;
int flags;
int err=0;
int dir=0;
DWORD retcode = 0;
TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
if (lpDesc == NULL) {
WARN("Invalid Parameter !\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= ALSA_WodNumDevs) {
TRACE("Asked for device %d, but only %d known!\n", wDevID, ALSA_WodNumDevs);
return MMSYSERR_BADDEVICEID;
}
/* only PCM format is supported so far... */
if (!ALSA_supportedFormat(lpDesc->lpFormat)) {
WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
lpDesc->lpFormat->nSamplesPerSec);
return WAVERR_BADFORMAT;
}
if (dwFlags & WAVE_FORMAT_QUERY) {
TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
lpDesc->lpFormat->nSamplesPerSec);
return MMSYSERR_NOERROR;
}
wwo = &WOutDev[wDevID];
if (wwo->pcm != NULL) {
WARN("%d already allocated\n", wDevID);
return MMSYSERR_ALLOCATED;
}
if (dwFlags & WAVE_DIRECTSOUND)
FIXME("Why are we called with DirectSound flag? It doesn't use MMSYSTEM any more\n");
/* not supported, ignore it */
dwFlags &= ~WAVE_DIRECTSOUND;
flags = SND_PCM_NONBLOCK;
if ( (err = snd_pcm_open(&pcm, wwo->pcmname, SND_PCM_STREAM_PLAYBACK, flags)) < 0)
{
ERR("Error open: %s\n", snd_strerror(err));
return MMSYSERR_NOTENABLED;
}
if (wwo->ctlname)
{
err = snd_hctl_open(&hctl, wwo->ctlname, 0);
if (err >= 0)
{
snd_hctl_load(hctl);
}
else
{
WARN("Could not open hctl for [%s]: %s\n", wwo->ctlname, snd_strerror(err));
hctl = NULL;
}
}
wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
wwo->waveDesc = *lpDesc;
ALSA_copyFormat(lpDesc->lpFormat, &wwo->format);
TRACE("Requested this format: %dx%dx%d %s\n",
wwo->format.Format.nSamplesPerSec,
wwo->format.Format.wBitsPerSample,
wwo->format.Format.nChannels,
ALSA_getFormat(wwo->format.Format.wFormatTag));
if (wwo->format.Format.wBitsPerSample == 0) {
WARN("Resetting zeroed wBitsPerSample\n");
wwo->format.Format.wBitsPerSample = 8 *
(wwo->format.Format.nAvgBytesPerSec /
wwo->format.Format.nSamplesPerSec) /
wwo->format.Format.nChannels;
}
#define EXIT_ON_ERROR(f,e,txt) do \
{ \
int err; \
if ( (err = (f) ) < 0) \
{ \
WARN(txt ": %s\n", snd_strerror(err)); \
retcode=e; \
goto errexit; \
} \
} while(0)
sw_params = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_sw_params_sizeof() );
snd_pcm_hw_params_malloc(&hw_params);
if (! hw_params)
{
retcode = MMSYSERR_NOMEM;
goto errexit;
}
snd_pcm_hw_params_any(pcm, hw_params);
access = SND_PCM_ACCESS_MMAP_INTERLEAVED;
if ( ( err = snd_pcm_hw_params_set_access(pcm, hw_params, access ) ) < 0) {
WARN("mmap not available. switching to standard write.\n");
access = SND_PCM_ACCESS_RW_INTERLEAVED;
EXIT_ON_ERROR( snd_pcm_hw_params_set_access(pcm, hw_params, access ), MMSYSERR_INVALPARAM, "unable to set access for playback");
wwo->write = snd_pcm_writei;
}
else
wwo->write = snd_pcm_mmap_writei;
if ((err = snd_pcm_hw_params_set_channels(pcm, hw_params, wwo->format.Format.nChannels)) < 0) {
WARN("unable to set required channels: %d\n", wwo->format.Format.nChannels);
EXIT_ON_ERROR( snd_pcm_hw_params_set_channels(pcm, hw_params, wwo->format.Format.nChannels ), WAVERR_BADFORMAT, "unable to set required channels" );
}
if ((wwo->format.Format.wFormatTag == WAVE_FORMAT_PCM) ||
((wwo->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
IsEqualGUID(&wwo->format.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) {
format = (wwo->format.Format.wBitsPerSample == 8) ? SND_PCM_FORMAT_U8 :
(wwo->format.Format.wBitsPerSample == 16) ? SND_PCM_FORMAT_S16_LE :
(wwo->format.Format.wBitsPerSample == 24) ? SND_PCM_FORMAT_S24_3LE :
(wwo->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_S32_LE : -1;
} else if ((wwo->format.Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE) &&
IsEqualGUID(&wwo->format.SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)){
format = (wwo->format.Format.wBitsPerSample == 32) ? SND_PCM_FORMAT_FLOAT_LE : -1;
} else {
ERR("invalid format: %0x04x\n", wwo->format.Format.wFormatTag);
retcode = WAVERR_BADFORMAT;
goto errexit;
}
if ((err = snd_pcm_hw_params_set_format(pcm, hw_params, format)) < 0) {
WARN("unable to set required format: %s\n", snd_pcm_format_name(format));
EXIT_ON_ERROR( snd_pcm_hw_params_set_format(pcm, hw_params, format), WAVERR_BADFORMAT, "unable to set required format" );
}
rate = wwo->format.Format.nSamplesPerSec;
dir=0;
err = snd_pcm_hw_params_set_rate_near(pcm, hw_params, &rate, &dir);
if (err < 0) {
WARN("Rate %d Hz not available for playback: %s\n", wwo->format.Format.nSamplesPerSec, snd_strerror(rate));
retcode = WAVERR_BADFORMAT;
goto errexit;
}
if (!ALSA_NearMatch(rate, wwo->format.Format.nSamplesPerSec)) {
WARN("Rate doesn't match (requested %d Hz, got %d Hz)\n", wwo->format.Format.nSamplesPerSec, rate);
retcode = WAVERR_BADFORMAT;
goto errexit;
}
TRACE("Got this format: %dx%dx%d %s\n",
wwo->format.Format.nSamplesPerSec,
wwo->format.Format.wBitsPerSample,
wwo->format.Format.nChannels,
ALSA_getFormat(wwo->format.Format.wFormatTag));
dir=0;
EXIT_ON_ERROR( snd_pcm_hw_params_set_buffer_time_near(pcm, hw_params, &buffer_time, &dir), MMSYSERR_INVALPARAM, "unable to set buffer time");
dir=0;
EXIT_ON_ERROR( snd_pcm_hw_params_set_period_time_near(pcm, hw_params, &period_time, &dir), MMSYSERR_INVALPARAM, "unable to set period time");
EXIT_ON_ERROR( snd_pcm_hw_params(pcm, hw_params), MMSYSERR_INVALPARAM, "unable to set hw params for playback");
err = snd_pcm_hw_params_get_period_size(hw_params, &period_size, &dir);
err = snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
snd_pcm_sw_params_current(pcm, sw_params);
EXIT_ON_ERROR( snd_pcm_sw_params_set_start_threshold(pcm, sw_params, 1), MMSYSERR_ERROR, "unable to set start threshold");
EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_size(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence size");
EXIT_ON_ERROR( snd_pcm_sw_params_set_avail_min(pcm, sw_params, period_size), MMSYSERR_ERROR, "unable to set avail min");
EXIT_ON_ERROR( snd_pcm_sw_params_set_silence_threshold(pcm, sw_params, 0), MMSYSERR_ERROR, "unable to set silence threshold");
EXIT_ON_ERROR( snd_pcm_sw_params(pcm, sw_params), MMSYSERR_ERROR, "unable to set sw params for playback");
#undef EXIT_ON_ERROR
snd_pcm_prepare(pcm);
if (TRACE_ON(wave))
ALSA_TraceParameters(hw_params, sw_params, FALSE);
/* now, we can save all required data for later use... */
wwo->dwBufferSize = snd_pcm_frames_to_bytes(pcm, buffer_size);
wwo->lpQueuePtr = wwo->lpPlayPtr = wwo->lpLoopPtr = NULL;
wwo->dwPlayedTotal = wwo->dwWrittenTotal = 0;
wwo->dwPartialOffset = 0;
ALSA_InitRingMessage(&wwo->msgRing);
wwo->hStartUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
wwo->hThread = CreateThread(NULL, 0, wodPlayer, (LPVOID)(DWORD_PTR)wDevID, 0, &(wwo->dwThreadID));
if (wwo->hThread)
SetThreadPriority(wwo->hThread, THREAD_PRIORITY_TIME_CRITICAL);
else
{
ERR("Thread creation for the wodPlayer failed!\n");
CloseHandle(wwo->hStartUpEvent);
retcode = MMSYSERR_NOMEM;
goto errexit;
}
WaitForSingleObject(wwo->hStartUpEvent, INFINITE);
CloseHandle(wwo->hStartUpEvent);
wwo->hStartUpEvent = INVALID_HANDLE_VALUE;
TRACE("handle=%p\n", pcm);
TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
wwo->format.Format.wBitsPerSample, wwo->format.Format.nAvgBytesPerSec,
wwo->format.Format.nSamplesPerSec, wwo->format.Format.nChannels,
wwo->format.Format.nBlockAlign);
HeapFree( GetProcessHeap(), 0, sw_params );
wwo->pcm = pcm;
wwo->hctl = hctl;
if ( wwo->hw_params )
snd_pcm_hw_params_free(wwo->hw_params);
wwo->hw_params = hw_params;
return wodNotifyClient(wwo, WOM_OPEN, 0L, 0L);
errexit:
if (pcm)
snd_pcm_close(pcm);
if (hctl)
{
snd_hctl_free(hctl);
snd_hctl_close(hctl);
}
if ( hw_params )
snd_pcm_hw_params_free(hw_params);
HeapFree( GetProcessHeap(), 0, sw_params );
if (wwo->msgRing.ring_buffer_size > 0)
ALSA_DestroyRingMessage(&wwo->msgRing);
return retcode;
}
bool setParameters (unsigned int sampleRate, int numChannels, int bufferSize)
{
if (handle == 0)
return false;
snd_pcm_hw_params_t* hwParams;
snd_pcm_hw_params_alloca (&hwParams);
if (failed (snd_pcm_hw_params_any (handle, hwParams)))
return false;
if (snd_pcm_hw_params_set_access (handle, hwParams, SND_PCM_ACCESS_RW_NONINTERLEAVED) >= 0)
isInterleaved = false;
else if (snd_pcm_hw_params_set_access (handle, hwParams, SND_PCM_ACCESS_RW_INTERLEAVED) >= 0)
isInterleaved = true;
else
{
jassertfalse;
return false;
}
enum { isFloatBit = 1 << 16, isLittleEndianBit = 1 << 17 };
const int formatsToTry[] = { SND_PCM_FORMAT_FLOAT_LE, 32 | isFloatBit | isLittleEndianBit,
SND_PCM_FORMAT_FLOAT_BE, 32 | isFloatBit,
SND_PCM_FORMAT_S32_LE, 32 | isLittleEndianBit,
SND_PCM_FORMAT_S32_BE, 32,
SND_PCM_FORMAT_S24_3LE, 24 | isLittleEndianBit,
SND_PCM_FORMAT_S24_3BE, 24,
SND_PCM_FORMAT_S16_LE, 16 | isLittleEndianBit,
SND_PCM_FORMAT_S16_BE, 16 };
bitDepth = 0;
for (int i = 0; i < numElementsInArray (formatsToTry); i += 2)
{
if (snd_pcm_hw_params_set_format (handle, hwParams, (_snd_pcm_format) formatsToTry [i]) >= 0)
{
bitDepth = formatsToTry [i + 1] & 255;
const bool isFloat = (formatsToTry [i + 1] & isFloatBit) != 0;
const bool isLittleEndian = (formatsToTry [i + 1] & isLittleEndianBit) != 0;
converter = createConverter (isInput, bitDepth, isFloat, isLittleEndian, numChannels);
break;
}
}
if (bitDepth == 0)
{
error = "device doesn't support a compatible PCM format";
DBG ("ALSA error: " + error + "\n");
return false;
}
int dir = 0;
unsigned int periods = 4;
snd_pcm_uframes_t samplesPerPeriod = bufferSize;
if (failed (snd_pcm_hw_params_set_rate_near (handle, hwParams, &sampleRate, 0))
|| failed (snd_pcm_hw_params_set_channels (handle, hwParams, numChannels))
|| failed (snd_pcm_hw_params_set_periods_near (handle, hwParams, &periods, &dir))
|| failed (snd_pcm_hw_params_set_period_size_near (handle, hwParams, &samplesPerPeriod, &dir))
|| failed (snd_pcm_hw_params (handle, hwParams)))
{
return false;
}
snd_pcm_uframes_t frames = 0;
if (failed (snd_pcm_hw_params_get_period_size (hwParams, &frames, &dir))
|| failed (snd_pcm_hw_params_get_periods (hwParams, &periods, &dir)))
latency = 0;
else
latency = frames * (periods - 1); // (this is the method JACK uses to guess the latency..)
snd_pcm_sw_params_t* swParams;
snd_pcm_sw_params_alloca (&swParams);
snd_pcm_uframes_t boundary;
if (failed (snd_pcm_sw_params_current (handle, swParams))
|| failed (snd_pcm_sw_params_get_boundary (swParams, &boundary))
|| failed (snd_pcm_sw_params_set_silence_threshold (handle, swParams, 0))
|| failed (snd_pcm_sw_params_set_silence_size (handle, swParams, boundary))
|| failed (snd_pcm_sw_params_set_start_threshold (handle, swParams, samplesPerPeriod))
|| failed (snd_pcm_sw_params_set_stop_threshold (handle, swParams, boundary))
|| failed (snd_pcm_sw_params (handle, swParams)))
{
return false;
}
#if 0
// enable this to dump the config of the devices that get opened
snd_output_t* out;
snd_output_stdio_attach (&out, stderr, 0);
snd_pcm_hw_params_dump (hwParams, out);
snd_pcm_sw_params_dump (swParams, out);
#endif
numChannelsRunning = numChannels;
return true;
}
