bool CAESinkALSA::Initialize(AEAudioFormat &format, std::string &device)
{
m_initDevice = device;
m_initFormat = format;
/* if we are raw, correct the data format */
if (AE_IS_RAW(format.m_dataFormat))
{
m_channelLayout = GetChannelLayout(format);
format.m_dataFormat = AE_FMT_S16NE;
m_passthrough = true;
}
else
{
m_channelLayout = GetChannelLayout(format);
m_passthrough = false;
}
if (m_channelLayout.Count() == 0)
{
CLog::Log(LOGERROR, "CAESinkALSA::Initialize - Unable to open the requested channel layout");
return false;
}
format.m_channelLayout = m_channelLayout;
/* if passthrough we need the additional AES flags */
if (m_passthrough)
GetPassthroughDevice(format, device);
m_device = device;
CLog::Log(LOGINFO, "CAESinkALSA::Initialize - Attempting to open device %s", device.c_str());
/* get the sound config */
snd_config_t *config;
snd_config_copy(&config, snd_config);
int error;
error = snd_pcm_open_lconf(&m_pcm, device.c_str(), SND_PCM_STREAM_PLAYBACK, ALSA_OPTIONS, config);
if (error < 0)
{
CLog::Log(LOGERROR, "CAESinkALSA::Initialize - snd_pcm_open_lconf(%d) - %s", error, device.c_str());
snd_config_delete(config);
return false;
}
/* free the sound config */
snd_config_delete(config);
if (!InitializeHW(format) || !InitializeSW(format))
return false;
snd_pcm_nonblock(m_pcm, 1);
snd_pcm_prepare (m_pcm);
m_format = format;
m_formatSampleRateMul = 1.0 / (double)m_format.m_sampleRate;
return true;
}
static int
alsa_locked_pcm_open(snd_pcm_t ** pcm, snd_pcm_stream_t stream, snd_config_t * local_config)
{
int r;
pthread_mutex_lock(&cubeb_alsa_mutex);
if (local_config) {
r = snd_pcm_open_lconf(pcm, CUBEB_ALSA_PCM_NAME, stream, SND_PCM_NONBLOCK, local_config);
} else {
r = snd_pcm_open(pcm, CUBEB_ALSA_PCM_NAME, stream, SND_PCM_NONBLOCK);
}
pthread_mutex_unlock(&cubeb_alsa_mutex);
return r;
}
bool CAESinkALSA::TryDevice(const std::string &name, snd_pcm_t **pcmp, snd_config_t *lconf)
{
/* Check if this device was already open (e.g. when checking for supported
* channel count in EnumerateDevice()) */
if (*pcmp)
{
if (name == snd_pcm_name(*pcmp))
return true;
snd_pcm_close(*pcmp);
*pcmp = NULL;
}
int err = snd_pcm_open_lconf(pcmp, name.c_str(), SND_PCM_STREAM_PLAYBACK, ALSA_OPTIONS, lconf);
if (err < 0)
{
CLog::Log(LOGINFO, "CAESinkALSA - Unable to open device \"%s\" for playback", name.c_str());
}
return err == 0;
}
static inline int alsa_test_open(ao_device *device,
char *dev,
ao_sample_format *format)
{
ao_alsa_internal *internal = (ao_alsa_internal *) device->internal;
snd_pcm_hw_params_t *params;
int err;
adebug("Trying to open ALSA device '%s'\n",dev);
internal->local_config = init_local_config_with_workaround(device,dev);
if(internal->local_config)
err = snd_pcm_open_lconf(&(internal->pcm_handle), dev,
SND_PCM_STREAM_PLAYBACK, 0, internal->local_config);
else
err = snd_pcm_open(&(internal->pcm_handle), dev,
SND_PCM_STREAM_PLAYBACK, 0);
if(err){
adebug("Unable to open ALSA device '%s'\n",dev);
if(internal->local_config)
snd_config_delete(internal->local_config);
internal->local_config=NULL;
return err;
}
/* try to set up hw params */
err = alsa_set_hwparams(device,format);
if(err<0){
adebug("Unable to open ALSA device '%s'\n",dev);
snd_pcm_close(internal->pcm_handle);
if(internal->local_config)
snd_config_delete(internal->local_config);
internal->local_config=NULL;
internal->pcm_handle = NULL;
return err;
}
/* try to set up sw params */
err = alsa_set_swparams(device);
if(err<0){
adebug("Unable to open ALSA device '%s'\n",dev);
snd_pcm_close(internal->pcm_handle);
if(internal->local_config)
snd_config_delete(internal->local_config);
internal->local_config=NULL;
internal->pcm_handle = NULL;
return err;
}
/* this is a hack and fragile if the exact device detection code
flow changes! Nevertheless, this is a useful warning for users.
Never fail silently if we can help it! */
if(!strcasecmp(dev,"default")){
/* default device */
if(device->output_channels>2){
awarn("ALSA 'default' device plays only channels 0,1.\n");
}
}
if(!strcasecmp(dev,"default") || !strncasecmp(dev,"plug",4)){
if(format->bits>16){
awarn("ALSA '%s' device may only simulate >16 bit playback\n",dev);
}
}
/* success! */
return 0;
}
/**
* \brief Opens a ordinary pcm instance
* \param ppcm Returned ordinary pcm handle
* \param playback_name ASCII identifier of the ordinary pcm handle (playback)
* \param capture_name ASCII identifier of the ordinary pcm handle (capture)
* \param lconf Local configuration (might be NULL - use global configuration)
* \return 0 on success otherwise a negative error code
*/
int sndo_pcm_open(sndo_pcm_t **ppcm,
const char *playback_name,
const char *capture_name,
struct alisp_cfg *lconf)
{
int err = 0;
sndo_pcm_t *pcm;
assert(ppcm);
assert(playback_name || capture_name);
*ppcm = NULL;
pcm = calloc(1, sizeof(sndo_pcm_t));
if (pcm == NULL)
return -ENOMEM;
if (playback_name) {
err = snd_pcm_hw_params_malloc(&pcm->p_hw_params);
if (err < 0)
goto __end;
err = snd_pcm_sw_params_malloc(&pcm->p_sw_params);
}
if (capture_name) {
err = snd_pcm_hw_params_malloc(&pcm->c_hw_params);
if (err < 0)
goto __end;
err = snd_pcm_sw_params_malloc(&pcm->p_sw_params);
}
if (err < 0)
goto __end;
if (lconf) {
if (playback_name) {
err = snd_pcm_open_lconf(&pcm->playback, playback_name, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK, NULL);
if (err < 0)
goto __end;
}
if (capture_name) {
err = snd_pcm_open_lconf(&pcm->capture, playback_name, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK, NULL);
if (err < 0)
goto __end;
}
} else {
if (playback_name) {
err = snd_pcm_open(&pcm->playback, playback_name, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
if (err < 0)
goto __end;
}
if (capture_name) {
err = snd_pcm_open(&pcm->capture, playback_name, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
if (err < 0)
goto __end;
}
}
if (pcm->playback && pcm->capture) {
err = snd_pcm_link(pcm->playback, pcm->capture);
if (err < 0)
goto __end;
pcm->master = pcm->playback;
}
__end:
if (err < 0)
sndo_pcm_close(pcm);
return err;
}
void CAESinkALSA::EnumerateDevicesEx(AEDeviceInfoList &list)
{
/* ensure that ALSA has been initialized */
if(!snd_config)
snd_config_update();
snd_ctl_t *ctlhandle;
snd_pcm_t *pcmhandle;
snd_ctl_card_info_t *ctlinfo;
snd_ctl_card_info_alloca(&ctlinfo);
memset(ctlinfo, 0, snd_ctl_card_info_sizeof());
snd_pcm_hw_params_t *hwparams;
snd_pcm_hw_params_alloca(&hwparams);
memset(hwparams, 0, snd_pcm_hw_params_sizeof());
snd_pcm_info_t *pcminfo;
snd_pcm_info_alloca(&pcminfo);
memset(pcminfo, 0, snd_pcm_info_sizeof());
/* get the sound config */
snd_config_t *config;
snd_config_copy(&config, snd_config);
std::string strHwName;
int n_cards = -1;
while (snd_card_next(&n_cards) == 0 && n_cards != -1)
{
std::stringstream sstr;
sstr << "hw:" << n_cards;
std::string strHwName = sstr.str();
if (snd_ctl_open_lconf(&ctlhandle, strHwName.c_str(), 0, config) != 0)
{
CLog::Log(LOGDEBUG, "CAESinkALSA::EnumerateDevicesEx - Unable to open control for device %s", strHwName.c_str());
continue;
}
if (snd_ctl_card_info(ctlhandle, ctlinfo) != 0)
{
CLog::Log(LOGDEBUG, "CAESinkALSA::EnumerateDevicesEx - Unable to get card control info for device %s", strHwName.c_str());
snd_ctl_close(ctlhandle);
continue;
}
snd_hctl_t *hctl;
if (snd_hctl_open_ctl(&hctl, ctlhandle) != 0)
hctl = NULL;
snd_hctl_load(hctl);
int pcm_index = 0;
int iec958_index = 0;
int hdmi_index = 0;
int dev = -1;
while (snd_ctl_pcm_next_device(ctlhandle, &dev) == 0 && dev != -1)
{
snd_pcm_info_set_device (pcminfo, dev);
snd_pcm_info_set_subdevice(pcminfo, 0 );
snd_pcm_info_set_stream (pcminfo, SND_PCM_STREAM_PLAYBACK);
if (snd_ctl_pcm_info(ctlhandle, pcminfo) < 0)
{
CLog::Log(LOGDEBUG, "CAESinkALSA::EnumerateDevicesEx - Skipping device %s,%d as it does not have PCM playback ability", strHwName.c_str(), dev);
continue;
}
int dev_index;
sstr.str(std::string());
CAEDeviceInfo info;
std::string devname = snd_pcm_info_get_name(pcminfo);
bool maybeHDMI = false;
/* detect HDMI */
if (devname.find("HDMI") != std::string::npos)
{
info.m_deviceType = AE_DEVTYPE_HDMI;
dev_index = hdmi_index++;
sstr << "hdmi";
}
else
{
/* detect IEC958 */
/* some HDMI devices (intel) report Digital for HDMI also */
if (devname.find("Digital") != std::string::npos)
maybeHDMI = true;
if (maybeHDMI || devname.find("IEC958" ) != std::string::npos)
{
info.m_deviceType = AE_DEVTYPE_IEC958;
dev_index = iec958_index; /* dont increment, it might be HDMI */
sstr << "iec958";
}
else
{
info.m_deviceType = AE_DEVTYPE_PCM;
dev_index = pcm_index++;
sstr << "hw";
}
}
/* build the driver string to pass to ALSA */
sstr << ":CARD=" << snd_ctl_card_info_get_id(ctlinfo) << ",DEV=" << dev_index;
info.m_deviceName = sstr.str();
/* get the friendly display name*/
info.m_displayName = snd_ctl_card_info_get_name(ctlinfo);
info.m_displayNameExtra = devname;
/* open the device for testing */
int err = snd_pcm_open_lconf(&pcmhandle, info.m_deviceName.c_str(), SND_PCM_STREAM_PLAYBACK, 0, config);
/* if open of possible IEC958 failed and it could be HDMI, try as HDMI */
if (err < 0 && maybeHDMI)
{
/* check for HDMI if it failed */
sstr.str(std::string());
dev_index = hdmi_index;
sstr << "hdmi";
sstr << ":CARD=" << snd_ctl_card_info_get_id(ctlinfo) << ",DEV=" << dev_index;
info.m_deviceName = sstr.str();
err = snd_pcm_open_lconf(&pcmhandle, info.m_deviceName.c_str(), SND_PCM_STREAM_PLAYBACK, 0, config);
/* if it was valid, increment the index and set the type */
if (err >= 0)
{
++hdmi_index;
info.m_deviceType = AE_DEVTYPE_HDMI;
}
}
/* if it's still IEC958, increment the index */
if (info.m_deviceType == AE_DEVTYPE_IEC958)
++iec958_index;
/* final error check */
if (err < 0)
{
CLog::Log(LOGINFO, "CAESinkALSA::EnumerateDevicesEx - Unable to open %s for capability detection", strHwName.c_str());
continue;
}
/* see if we can get ELD for this device */
if (info.m_deviceType == AE_DEVTYPE_HDMI)
{
bool badHDMI = false;
if (hctl && !GetELD(hctl, dev, info, badHDMI))
CLog::Log(LOGDEBUG, "CAESinkALSA::EnumerateDevicesEx - Unable to obtain ELD information for device %s, make sure you have ALSA >= 1.0.25", info.m_deviceName.c_str());
if (badHDMI)
{
CLog::Log(LOGDEBUG, "CAESinkALSA::EnumerateDevicesEx - Skipping HDMI device %s as it has no ELD data", info.m_deviceName.c_str());
continue;
}
}
/* ensure we can get a playback configuration for the device */
if (snd_pcm_hw_params_any(pcmhandle, hwparams) < 0)
{
CLog::Log(LOGINFO, "CAESinkALSA::EnumerateDevicesEx - No playback configurations available for device %s", info.m_deviceName.c_str());
snd_pcm_close(pcmhandle);
continue;
}
/* detect the available sample rates */
for (unsigned int *rate = ALSASampleRateList; *rate != 0; ++rate)
if (snd_pcm_hw_params_test_rate(pcmhandle, hwparams, *rate, 0) >= 0)
info.m_sampleRates.push_back(*rate);
/* detect the channels available */
int channels = 0;
for (int i = 1; i <= ALSA_MAX_CHANNELS; ++i)
if (snd_pcm_hw_params_test_channels(pcmhandle, hwparams, i) >= 0)
channels = i;
CAEChannelInfo alsaChannels;
for (int i = 0; i < channels; ++i)
{
if (!info.m_channels.HasChannel(ALSAChannelMap[i]))
info.m_channels += ALSAChannelMap[i];
alsaChannels += ALSAChannelMap[i];
}
/* remove the channels from m_channels that we cant use */
info.m_channels.ResolveChannels(alsaChannels);
/* detect the PCM sample formats that are available */
for (enum AEDataFormat i = AE_FMT_MAX; i > AE_FMT_INVALID; i = (enum AEDataFormat)((int)i - 1))
{
if (AE_IS_RAW(i) || i == AE_FMT_MAX)
continue;
snd_pcm_format_t fmt = AEFormatToALSAFormat(i);
if (fmt == SND_PCM_FORMAT_UNKNOWN)
continue;
if (snd_pcm_hw_params_test_format(pcmhandle, hwparams, fmt) >= 0)
info.m_dataFormats.push_back(i);
}
snd_pcm_close(pcmhandle);
list.push_back(info);
}
/* snd_hctl_close also closes ctlhandle */
if (hctl)
snd_hctl_close(hctl);
else
snd_ctl_close(ctlhandle);
}
}
