2009-03-13 18:43:16 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2003-2009 The Music Player Daemon Project
|
|
|
|
* http://www.musicpd.org
|
2005-03-05 06:22:30 +01:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2009-03-13 18:43:16 +01:00
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2005-03-05 06:22:30 +01:00
|
|
|
*/
|
|
|
|
|
2008-09-07 22:41:17 +02:00
|
|
|
#include "../output_api.h"
|
2009-03-14 11:36:59 +01:00
|
|
|
#include "mixer_list.h"
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2008-11-01 14:04:14 +01:00
|
|
|
#include <glib.h>
|
2008-10-26 21:58:37 +01:00
|
|
|
#include <alsa/asoundlib.h>
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2008-12-29 17:29:42 +01:00
|
|
|
#undef G_LOG_DOMAIN
|
|
|
|
#define G_LOG_DOMAIN "alsa"
|
|
|
|
|
2005-03-05 06:22:30 +01:00
|
|
|
#define ALSA_PCM_NEW_HW_PARAMS_API
|
|
|
|
#define ALSA_PCM_NEW_SW_PARAMS_API
|
|
|
|
|
2008-09-08 20:42:39 +02:00
|
|
|
static const char default_device[] = "default";
|
|
|
|
|
2008-12-01 22:37:05 +01:00
|
|
|
enum {
|
|
|
|
MPD_ALSA_BUFFER_TIME_US = 500000,
|
|
|
|
};
|
|
|
|
|
2006-07-24 03:38:51 +02:00
|
|
|
#define MPD_ALSA_RETRY_NR 5
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
typedef snd_pcm_sframes_t alsa_writei_t(snd_pcm_t * pcm, const void *buffer,
|
|
|
|
snd_pcm_uframes_t size);
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
struct alsa_data {
|
2009-01-25 13:13:24 +01:00
|
|
|
/** the configured name of the ALSA device; NULL for the
|
|
|
|
default device */
|
2008-11-01 14:04:14 +01:00
|
|
|
char *device;
|
2008-10-14 17:21:49 +02:00
|
|
|
|
2009-01-25 13:13:24 +01:00
|
|
|
/** use memory mapped I/O? */
|
|
|
|
bool use_mmap;
|
|
|
|
|
|
|
|
/** libasound's buffer_time setting (in microseconds) */
|
|
|
|
unsigned int buffer_time;
|
|
|
|
|
|
|
|
/** libasound's period_time setting (in microseconds) */
|
|
|
|
unsigned int period_time;
|
|
|
|
|
2008-10-14 17:21:49 +02:00
|
|
|
/** the mode flags passed to snd_pcm_open */
|
|
|
|
int mode;
|
|
|
|
|
2009-01-25 13:13:24 +01:00
|
|
|
/** the libasound PCM device handle */
|
2009-01-25 13:05:16 +01:00
|
|
|
snd_pcm_t *pcm;
|
2009-01-25 13:13:24 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* a pointer to the libasound writei() function, which is
|
|
|
|
* snd_pcm_writei() or snd_pcm_mmap_writei(), depending on the
|
|
|
|
* use_mmap configuration
|
|
|
|
*/
|
2006-07-20 18:02:40 +02:00
|
|
|
alsa_writei_t *writei;
|
2009-01-25 13:13:24 +01:00
|
|
|
|
|
|
|
/** the size of one audio frame */
|
2009-01-25 13:07:06 +01:00
|
|
|
size_t frame_size;
|
2009-01-25 13:05:16 +01:00
|
|
|
};
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2009-02-26 22:04:59 +01:00
|
|
|
/**
|
|
|
|
* The quark used for GError.domain.
|
|
|
|
*/
|
|
|
|
static inline GQuark
|
|
|
|
alsa_output_quark(void)
|
|
|
|
{
|
|
|
|
return g_quark_from_static_string("alsa_output");
|
|
|
|
}
|
|
|
|
|
2008-11-01 14:04:14 +01:00
|
|
|
static const char *
|
2009-01-25 13:05:16 +01:00
|
|
|
alsa_device(const struct alsa_data *ad)
|
2008-11-01 14:04:14 +01:00
|
|
|
{
|
|
|
|
return ad->device != NULL ? ad->device : default_device;
|
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static struct alsa_data *
|
|
|
|
alsa_data_new(void)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2009-01-25 13:05:16 +01:00
|
|
|
struct alsa_data *ret = g_new(struct alsa_data, 1);
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2008-10-14 17:21:49 +02:00
|
|
|
ret->mode = 0;
|
2005-03-05 06:22:30 +01:00
|
|
|
ret->writei = snd_pcm_writei;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static void
|
|
|
|
alsa_data_free(struct alsa_data *ad)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-11-01 14:04:14 +01:00
|
|
|
g_free(ad->device);
|
2009-01-25 18:47:21 +01:00
|
|
|
g_free(ad);
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
2008-10-12 11:47:33 +02:00
|
|
|
static void
|
2009-01-25 16:03:49 +01:00
|
|
|
alsa_configure(struct alsa_data *ad, const struct config_param *param)
|
2008-10-12 11:47:33 +02:00
|
|
|
{
|
2009-01-18 19:37:27 +01:00
|
|
|
ad->device = config_dup_block_string(param, "device", NULL);
|
2008-11-01 14:04:14 +01:00
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
ad->use_mmap = config_get_block_bool(param, "use_mmap", false);
|
2009-01-17 20:23:56 +01:00
|
|
|
|
2009-01-25 12:52:37 +01:00
|
|
|
ad->buffer_time = config_get_block_unsigned(param, "buffer_time",
|
|
|
|
MPD_ALSA_BUFFER_TIME_US);
|
2009-03-08 03:55:01 +01:00
|
|
|
ad->period_time = config_get_block_unsigned(param, "period_time", 0);
|
2008-10-14 17:21:49 +02:00
|
|
|
|
2008-10-14 22:37:27 +02:00
|
|
|
#ifdef SND_PCM_NO_AUTO_RESAMPLE
|
2009-01-17 20:23:56 +01:00
|
|
|
if (!config_get_block_bool(param, "auto_resample", true))
|
2008-10-14 17:21:49 +02:00
|
|
|
ad->mode |= SND_PCM_NO_AUTO_RESAMPLE;
|
2008-10-14 22:37:27 +02:00
|
|
|
#endif
|
2008-10-14 17:21:49 +02:00
|
|
|
|
2008-10-14 22:37:27 +02:00
|
|
|
#ifdef SND_PCM_NO_AUTO_CHANNELS
|
2009-01-17 20:23:56 +01:00
|
|
|
if (!config_get_block_bool(param, "auto_channels", true))
|
2008-10-14 17:21:49 +02:00
|
|
|
ad->mode |= SND_PCM_NO_AUTO_CHANNELS;
|
2008-10-14 22:37:27 +02:00
|
|
|
#endif
|
2008-10-14 17:21:49 +02:00
|
|
|
|
2008-10-14 22:37:27 +02:00
|
|
|
#ifdef SND_PCM_NO_AUTO_FORMAT
|
2009-01-17 20:23:56 +01:00
|
|
|
if (!config_get_block_bool(param, "auto_format", true))
|
2008-10-14 17:21:49 +02:00
|
|
|
ad->mode |= SND_PCM_NO_AUTO_FORMAT;
|
2008-10-14 22:37:27 +02:00
|
|
|
#endif
|
2008-10-12 11:47:33 +02:00
|
|
|
}
|
|
|
|
|
2009-01-17 20:23:27 +01:00
|
|
|
static void *
|
2009-02-25 18:34:02 +01:00
|
|
|
alsa_init(G_GNUC_UNUSED const struct audio_format *audio_format,
|
2009-02-26 22:04:59 +01:00
|
|
|
const struct config_param *param,
|
|
|
|
G_GNUC_UNUSED GError **error)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2009-01-25 13:05:16 +01:00
|
|
|
struct alsa_data *ad = alsa_data_new();
|
2006-07-16 18:52:19 +02:00
|
|
|
|
2009-01-25 16:04:03 +01:00
|
|
|
alsa_configure(ad, param);
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2008-09-24 07:20:55 +02:00
|
|
|
return ad;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static void
|
|
|
|
alsa_finish(void *data)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2009-01-25 13:05:16 +01:00
|
|
|
struct alsa_data *ad = data;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
alsa_data_free(ad);
|
2009-04-21 22:47:12 +02:00
|
|
|
|
|
|
|
/* free libasound's config cache */
|
|
|
|
snd_config_update_free_global();
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static bool
|
|
|
|
alsa_test_default_device(void)
|
2005-03-12 04:10:09 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
snd_pcm_t *handle;
|
2005-03-12 04:10:09 +01:00
|
|
|
|
2008-09-08 20:42:39 +02:00
|
|
|
int ret = snd_pcm_open(&handle, default_device,
|
|
|
|
SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (ret) {
|
2008-12-29 17:29:42 +01:00
|
|
|
g_message("Error opening default ALSA device: %s\n",
|
|
|
|
snd_strerror(-ret));
|
2008-10-29 20:40:27 +01:00
|
|
|
return false;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else
|
|
|
|
snd_pcm_close(handle);
|
2005-03-12 04:10:09 +01:00
|
|
|
|
2008-10-29 20:40:27 +01:00
|
|
|
return true;
|
2005-03-12 04:10:09 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static snd_pcm_format_t
|
|
|
|
get_bitformat(const struct audio_format *af)
|
2008-09-08 20:42:51 +02:00
|
|
|
{
|
|
|
|
switch (af->bits) {
|
|
|
|
case 8: return SND_PCM_FORMAT_S8;
|
|
|
|
case 16: return SND_PCM_FORMAT_S16;
|
|
|
|
case 24: return SND_PCM_FORMAT_S24;
|
|
|
|
case 32: return SND_PCM_FORMAT_S32;
|
|
|
|
}
|
|
|
|
return SND_PCM_FORMAT_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2009-07-19 17:43:08 +02:00
|
|
|
static snd_pcm_format_t
|
|
|
|
byteswap_bitformat(snd_pcm_format_t fmt)
|
|
|
|
{
|
|
|
|
switch(fmt) {
|
|
|
|
case SND_PCM_FORMAT_S16_LE: return SND_PCM_FORMAT_S16_BE;
|
|
|
|
case SND_PCM_FORMAT_S24_LE: return SND_PCM_FORMAT_S24_BE;
|
|
|
|
case SND_PCM_FORMAT_S32_LE: return SND_PCM_FORMAT_S32_BE;
|
|
|
|
case SND_PCM_FORMAT_S16_BE: return SND_PCM_FORMAT_S16_LE;
|
|
|
|
case SND_PCM_FORMAT_S24_BE: return SND_PCM_FORMAT_S24_LE;
|
|
|
|
case SND_PCM_FORMAT_S32_BE: return SND_PCM_FORMAT_S32_LE;
|
|
|
|
default: return SND_PCM_FORMAT_UNKNOWN;
|
|
|
|
}
|
|
|
|
}
|
2009-02-25 22:01:30 +01:00
|
|
|
/**
|
|
|
|
* Set up the snd_pcm_t object which was opened by the caller. Set up
|
|
|
|
* the configured settings and the audio format.
|
|
|
|
*/
|
2009-01-25 13:05:16 +01:00
|
|
|
static bool
|
2009-02-25 22:01:30 +01:00
|
|
|
alsa_setup(struct alsa_data *ad, struct audio_format *audio_format,
|
2009-02-26 22:04:59 +01:00
|
|
|
snd_pcm_format_t bitformat,
|
|
|
|
GError **error)
|
2005-03-05 06:22:30 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
snd_pcm_hw_params_t *hwparams;
|
|
|
|
snd_pcm_sw_params_t *swparams;
|
2009-01-25 13:05:16 +01:00
|
|
|
unsigned int sample_rate = audio_format->sample_rate;
|
|
|
|
unsigned int channels = audio_format->channels;
|
2005-03-05 06:22:30 +01:00
|
|
|
snd_pcm_uframes_t alsa_buffer_size;
|
|
|
|
snd_pcm_uframes_t alsa_period_size;
|
|
|
|
int err;
|
2006-07-24 03:38:51 +02:00
|
|
|
const char *cmd = NULL;
|
|
|
|
int retry = MPD_ALSA_RETRY_NR;
|
2006-08-12 20:20:55 +02:00
|
|
|
unsigned int period_time, period_time_ro;
|
|
|
|
unsigned int buffer_time;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2006-08-12 20:20:55 +02:00
|
|
|
period_time_ro = period_time = ad->period_time;
|
2006-07-24 03:38:51 +02:00
|
|
|
configure_hw:
|
2005-03-05 06:45:39 +01:00
|
|
|
/* configure HW params */
|
2005-03-05 06:22:30 +01:00
|
|
|
snd_pcm_hw_params_alloca(&hwparams);
|
2005-03-13 17:42:04 +01:00
|
|
|
cmd = "snd_pcm_hw_params_any";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_any(ad->pcm, hwparams);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
if (ad->use_mmap) {
|
|
|
|
err = snd_pcm_hw_params_set_access(ad->pcm, hwparams,
|
2006-07-20 18:02:40 +02:00
|
|
|
SND_PCM_ACCESS_MMAP_INTERLEAVED);
|
|
|
|
if (err < 0) {
|
2008-12-29 17:29:42 +01:00
|
|
|
g_warning("Cannot set mmap'ed mode on ALSA device \"%s\": %s\n",
|
|
|
|
alsa_device(ad), snd_strerror(-err));
|
|
|
|
g_warning("Falling back to direct write mode\n");
|
2009-01-25 13:05:16 +01:00
|
|
|
ad->use_mmap = false;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else
|
|
|
|
ad->writei = snd_pcm_mmap_writei;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
if (!ad->use_mmap) {
|
2005-03-13 17:42:04 +01:00
|
|
|
cmd = "snd_pcm_hw_params_set_access";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_set_access(ad->pcm, hwparams,
|
2006-07-20 18:02:40 +02:00
|
|
|
SND_PCM_ACCESS_RW_INTERLEAVED);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-03-05 06:45:39 +01:00
|
|
|
ad->writei = snd_pcm_writei;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_set_format(ad->pcm, hwparams, bitformat);
|
2009-07-19 17:43:08 +02:00
|
|
|
if (err == -EINVAL &&
|
|
|
|
byteswap_bitformat(bitformat) != SND_PCM_FORMAT_UNKNOWN) {
|
|
|
|
err = snd_pcm_hw_params_set_format(ad->pcm, hwparams,
|
|
|
|
byteswap_bitformat(bitformat));
|
|
|
|
if (err == 0) {
|
|
|
|
g_debug("ALSA device \"%s\": converting %u bit to reverse-endian\n",
|
|
|
|
alsa_device(ad), audio_format->bits);
|
|
|
|
audio_format->reverse_endian = 1;
|
|
|
|
}
|
|
|
|
}
|
2009-03-03 07:58:18 +01:00
|
|
|
if (err == -EINVAL && (audio_format->bits == 24 ||
|
|
|
|
audio_format->bits == 16)) {
|
2009-03-02 16:41:38 +01:00
|
|
|
/* fall back to 32 bit, let pcm_convert.c do the conversion */
|
|
|
|
err = snd_pcm_hw_params_set_format(ad->pcm, hwparams,
|
|
|
|
SND_PCM_FORMAT_S32);
|
2009-07-19 17:43:08 +02:00
|
|
|
if (err == 0) {
|
|
|
|
g_debug("ALSA device \"%s\": converting %u bit to 32 bit\n",
|
|
|
|
alsa_device(ad), audio_format->bits);
|
|
|
|
audio_format->bits = 32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (err == -EINVAL && (audio_format->bits == 24 ||
|
|
|
|
audio_format->bits == 16)) {
|
|
|
|
/* fall back to 32 bit, let pcm_convert.c do the conversion */
|
|
|
|
err = snd_pcm_hw_params_set_format(ad->pcm, hwparams,
|
|
|
|
byteswap_bitformat(SND_PCM_FORMAT_S32));
|
|
|
|
if (err == 0) {
|
|
|
|
g_debug("ALSA device \"%s\": converting %u bit to 32 bit backward-endian\n",
|
|
|
|
alsa_device(ad), audio_format->bits);
|
2009-03-02 16:41:38 +01:00
|
|
|
audio_format->bits = 32;
|
2009-07-19 17:43:08 +02:00
|
|
|
audio_format->reverse_endian = 1;
|
|
|
|
}
|
2009-03-02 16:41:38 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
if (err == -EINVAL && audio_format->bits != 16) {
|
2009-01-07 18:53:36 +01:00
|
|
|
/* fall back to 16 bit, let pcm_convert.c do the conversion */
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_set_format(ad->pcm, hwparams,
|
2008-10-12 12:02:55 +02:00
|
|
|
SND_PCM_FORMAT_S16);
|
|
|
|
if (err == 0) {
|
2008-12-29 17:29:42 +01:00
|
|
|
g_debug("ALSA device \"%s\": converting %u bit to 16 bit\n",
|
2009-01-25 13:05:16 +01:00
|
|
|
alsa_device(ad), audio_format->bits);
|
|
|
|
audio_format->bits = 16;
|
2008-10-12 12:02:55 +02:00
|
|
|
}
|
|
|
|
}
|
2009-07-19 17:43:08 +02:00
|
|
|
if (err == -EINVAL && audio_format->bits != 16) {
|
|
|
|
/* fall back to 16 bit, let pcm_convert.c do the conversion */
|
|
|
|
err = snd_pcm_hw_params_set_format(ad->pcm, hwparams,
|
|
|
|
byteswap_bitformat(SND_PCM_FORMAT_S16));
|
|
|
|
if (err == 0) {
|
|
|
|
g_debug("ALSA device \"%s\": converting %u bit to 16 bit backward-endian\n",
|
|
|
|
alsa_device(ad), audio_format->bits);
|
|
|
|
audio_format->bits = 16;
|
|
|
|
audio_format->reverse_endian = 1;
|
|
|
|
}
|
|
|
|
}
|
2008-10-12 12:02:55 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (err < 0) {
|
2009-02-26 22:04:59 +01:00
|
|
|
g_set_error(error, alsa_output_quark(), err,
|
|
|
|
"ALSA device \"%s\" does not support %u bit audio: %s",
|
|
|
|
alsa_device(ad), audio_format->bits,
|
|
|
|
snd_strerror(-err));
|
2009-02-25 22:01:30 +01:00
|
|
|
return false;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_set_channels_near(ad->pcm, hwparams,
|
2006-07-20 18:02:40 +02:00
|
|
|
&channels);
|
|
|
|
if (err < 0) {
|
2009-02-26 22:04:59 +01:00
|
|
|
g_set_error(error, alsa_output_quark(), err,
|
|
|
|
"ALSA device \"%s\" does not support %i channels: %s",
|
|
|
|
alsa_device(ad), (int)audio_format->channels,
|
|
|
|
snd_strerror(-err));
|
2009-02-25 22:01:30 +01:00
|
|
|
return false;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
2009-01-25 13:05:16 +01:00
|
|
|
audio_format->channels = (int8_t)channels;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_set_rate_near(ad->pcm, hwparams,
|
2008-10-10 14:40:54 +02:00
|
|
|
&sample_rate, NULL);
|
|
|
|
if (err < 0 || sample_rate == 0) {
|
2009-02-26 22:04:59 +01:00
|
|
|
g_set_error(error, alsa_output_quark(), err,
|
|
|
|
"ALSA device \"%s\" does not support %u Hz audio",
|
|
|
|
alsa_device(ad), audio_format->sample_rate);
|
2009-02-25 22:01:30 +01:00
|
|
|
return false;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
2009-01-25 13:05:16 +01:00
|
|
|
audio_format->sample_rate = sample_rate;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2008-10-11 12:52:48 +02:00
|
|
|
if (ad->buffer_time > 0) {
|
|
|
|
buffer_time = ad->buffer_time;
|
|
|
|
cmd = "snd_pcm_hw_params_set_buffer_time_near";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_set_buffer_time_near(ad->pcm, hwparams,
|
2008-10-11 12:52:48 +02:00
|
|
|
&buffer_time, NULL);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2009-03-08 04:11:30 +01:00
|
|
|
} else {
|
|
|
|
err = snd_pcm_hw_params_get_buffer_time(hwparams, &buffer_time,
|
|
|
|
NULL);
|
|
|
|
if (err < 0)
|
|
|
|
buffer_time = 0;
|
2008-10-11 12:52:48 +02:00
|
|
|
}
|
2006-07-16 18:52:06 +02:00
|
|
|
|
2009-03-08 03:55:01 +01:00
|
|
|
if (period_time_ro == 0 && buffer_time >= 10000) {
|
|
|
|
period_time_ro = period_time = buffer_time / 4;
|
|
|
|
|
|
|
|
g_debug("default period_time = buffer_time/4 = %u/4 = %u",
|
|
|
|
buffer_time, period_time);
|
|
|
|
}
|
|
|
|
|
2008-10-11 12:52:48 +02:00
|
|
|
if (period_time_ro > 0) {
|
|
|
|
period_time = period_time_ro;
|
|
|
|
cmd = "snd_pcm_hw_params_set_period_time_near";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params_set_period_time_near(ad->pcm, hwparams,
|
2008-10-11 12:52:48 +02:00
|
|
|
&period_time, NULL);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
|
|
|
}
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2005-03-13 17:42:04 +01:00
|
|
|
cmd = "snd_pcm_hw_params";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_hw_params(ad->pcm, hwparams);
|
2008-10-11 12:52:48 +02:00
|
|
|
if (err == -EPIPE && --retry > 0 && period_time_ro > 0) {
|
2006-08-12 20:20:55 +02:00
|
|
|
period_time_ro = period_time_ro >> 1;
|
2006-07-24 03:38:51 +02:00
|
|
|
goto configure_hw;
|
|
|
|
} else if (err < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
goto error;
|
2006-07-24 03:38:51 +02:00
|
|
|
if (retry != MPD_ALSA_RETRY_NR)
|
2008-12-29 17:29:42 +01:00
|
|
|
g_debug("ALSA period_time set to %d\n", period_time);
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2005-03-13 17:42:04 +01:00
|
|
|
cmd = "snd_pcm_hw_params_get_buffer_size";
|
2005-03-05 06:22:30 +01:00
|
|
|
err = snd_pcm_hw_params_get_buffer_size(hwparams, &alsa_buffer_size);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2005-03-13 17:42:04 +01:00
|
|
|
cmd = "snd_pcm_hw_params_get_period_size";
|
2006-07-17 02:15:52 +02:00
|
|
|
err = snd_pcm_hw_params_get_period_size(hwparams, &alsa_period_size,
|
2006-07-20 18:02:40 +02:00
|
|
|
NULL);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2005-03-05 06:45:39 +01:00
|
|
|
/* configure SW params */
|
2005-03-05 06:22:30 +01:00
|
|
|
snd_pcm_sw_params_alloca(&swparams);
|
|
|
|
|
2005-03-13 17:42:04 +01:00
|
|
|
cmd = "snd_pcm_sw_params_current";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_sw_params_current(ad->pcm, swparams);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-03-13 17:42:04 +01:00
|
|
|
|
|
|
|
cmd = "snd_pcm_sw_params_set_start_threshold";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_sw_params_set_start_threshold(ad->pcm, swparams,
|
2006-07-20 18:02:40 +02:00
|
|
|
alsa_buffer_size -
|
|
|
|
alsa_period_size);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2005-03-13 17:42:04 +01:00
|
|
|
cmd = "snd_pcm_sw_params_set_avail_min";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_sw_params_set_avail_min(ad->pcm, swparams,
|
2006-07-20 18:02:40 +02:00
|
|
|
alsa_period_size);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-03-13 17:42:04 +01:00
|
|
|
|
|
|
|
cmd = "snd_pcm_sw_params";
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_sw_params(ad->pcm, swparams);
|
2006-07-20 18:02:40 +02:00
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
|
|
|
|
2009-03-03 22:19:37 +01:00
|
|
|
g_debug("buffer_size=%u period_size=%u",
|
|
|
|
(unsigned)alsa_buffer_size, (unsigned)alsa_period_size);
|
|
|
|
|
2008-10-29 20:40:27 +01:00
|
|
|
return true;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2006-08-20 12:13:54 +02:00
|
|
|
error:
|
2009-02-26 22:04:59 +01:00
|
|
|
g_set_error(error, alsa_output_quark(), err,
|
|
|
|
"Error opening ALSA device \"%s\" (%s): %s",
|
|
|
|
alsa_device(ad), cmd, snd_strerror(-err));
|
2009-02-25 22:01:30 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
2009-02-26 22:04:59 +01:00
|
|
|
alsa_open(void *data, struct audio_format *audio_format, GError **error)
|
2009-02-25 22:01:30 +01:00
|
|
|
{
|
|
|
|
struct alsa_data *ad = data;
|
|
|
|
snd_pcm_format_t bitformat;
|
|
|
|
int err;
|
|
|
|
bool success;
|
|
|
|
|
2009-02-25 22:01:32 +01:00
|
|
|
bitformat = get_bitformat(audio_format);
|
|
|
|
if (bitformat == SND_PCM_FORMAT_UNKNOWN) {
|
|
|
|
/* sample format is not supported by this plugin -
|
|
|
|
fall back to 16 bit samples */
|
|
|
|
|
|
|
|
audio_format->bits = 16;
|
|
|
|
bitformat = SND_PCM_FORMAT_S16;
|
|
|
|
}
|
2009-02-25 22:01:30 +01:00
|
|
|
|
|
|
|
err = snd_pcm_open(&ad->pcm, alsa_device(ad),
|
|
|
|
SND_PCM_STREAM_PLAYBACK, ad->mode);
|
|
|
|
if (err < 0) {
|
2009-02-26 22:04:59 +01:00
|
|
|
g_set_error(error, alsa_output_quark(), err,
|
|
|
|
"Failed to open ALSA device \"%s\": %s",
|
|
|
|
alsa_device(ad), snd_strerror(err));
|
2009-02-25 22:01:30 +01:00
|
|
|
return false;
|
2005-03-13 17:42:04 +01:00
|
|
|
}
|
2009-02-25 22:01:30 +01:00
|
|
|
|
2009-02-26 22:04:59 +01:00
|
|
|
success = alsa_setup(ad, audio_format, bitformat, error);
|
2009-02-25 22:01:30 +01:00
|
|
|
if (!success) {
|
2009-01-25 13:05:16 +01:00
|
|
|
snd_pcm_close(ad->pcm);
|
2009-02-25 22:01:30 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
ad->frame_size = audio_format_frame_size(audio_format);
|
|
|
|
|
|
|
|
return true;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static int
|
|
|
|
alsa_recover(struct alsa_data *ad, int err)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
if (err == -EPIPE) {
|
2008-12-29 17:29:42 +01:00
|
|
|
g_debug("Underrun on ALSA device \"%s\"\n", alsa_device(ad));
|
2006-07-20 18:02:40 +02:00
|
|
|
} else if (err == -ESTRPIPE) {
|
2008-12-29 17:29:42 +01:00
|
|
|
g_debug("ALSA device \"%s\" was suspended\n", alsa_device(ad));
|
2005-03-05 15:01:13 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
switch (snd_pcm_state(ad->pcm)) {
|
2005-03-05 21:51:36 +01:00
|
|
|
case SND_PCM_STATE_PAUSED:
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_pause(ad->pcm, /* disable */ 0);
|
2005-03-05 21:51:36 +01:00
|
|
|
break;
|
|
|
|
case SND_PCM_STATE_SUSPENDED:
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_resume(ad->pcm);
|
2008-09-08 09:45:05 +02:00
|
|
|
if (err == -EAGAIN)
|
|
|
|
return 0;
|
|
|
|
/* fall-through to snd_pcm_prepare: */
|
2005-03-05 15:01:13 +01:00
|
|
|
case SND_PCM_STATE_SETUP:
|
|
|
|
case SND_PCM_STATE_XRUN:
|
2009-01-25 13:05:16 +01:00
|
|
|
err = snd_pcm_prepare(ad->pcm);
|
2005-03-05 21:51:36 +01:00
|
|
|
break;
|
2006-07-16 18:52:29 +02:00
|
|
|
case SND_PCM_STATE_DISCONNECTED:
|
|
|
|
break;
|
2008-04-12 06:07:44 +02:00
|
|
|
/* this is no error, so just keep running */
|
|
|
|
case SND_PCM_STATE_RUNNING:
|
|
|
|
err = 0;
|
|
|
|
break;
|
2005-03-05 15:01:13 +01:00
|
|
|
default:
|
|
|
|
/* unknown state, do nothing */
|
|
|
|
break;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static void
|
|
|
|
alsa_cancel(void *data)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2009-01-25 13:05:16 +01:00
|
|
|
struct alsa_data *ad = data;
|
2005-12-12 04:22:27 +01:00
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
alsa_recover(ad, snd_pcm_drop(ad->pcm));
|
2005-12-12 04:22:27 +01:00
|
|
|
}
|
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
static void
|
|
|
|
alsa_close(void *data)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2009-01-25 13:05:16 +01:00
|
|
|
struct alsa_data *ad = data;
|
2005-03-05 15:01:13 +01:00
|
|
|
|
2009-03-10 21:25:45 +01:00
|
|
|
if (snd_pcm_state(ad->pcm) == SND_PCM_STATE_RUNNING)
|
|
|
|
snd_pcm_drain(ad->pcm);
|
2009-01-25 13:05:16 +01:00
|
|
|
|
2009-03-10 21:25:45 +01:00
|
|
|
snd_pcm_close(ad->pcm);
|
2005-03-05 15:01:13 +01:00
|
|
|
}
|
|
|
|
|
2009-02-23 09:29:56 +01:00
|
|
|
static size_t
|
2009-02-26 22:04:59 +01:00
|
|
|
alsa_play(void *data, const void *chunk, size_t size, GError **error)
|
2005-03-05 06:22:30 +01:00
|
|
|
{
|
2009-01-25 13:05:16 +01:00
|
|
|
struct alsa_data *ad = data;
|
2005-03-05 06:22:30 +01:00
|
|
|
|
2009-01-25 13:05:16 +01:00
|
|
|
size /= ad->frame_size;
|
2005-03-05 06:45:39 +01:00
|
|
|
|
2009-02-23 09:29:56 +01:00
|
|
|
while (true) {
|
2009-03-10 21:31:13 +01:00
|
|
|
snd_pcm_sframes_t ret = ad->writei(ad->pcm, chunk, size);
|
2009-02-23 09:29:56 +01:00
|
|
|
if (ret > 0)
|
|
|
|
return ret * ad->frame_size;
|
|
|
|
|
|
|
|
if (ret < 0 && ret != -EAGAIN && ret != -EINTR &&
|
|
|
|
alsa_recover(ad, ret) < 0) {
|
2009-02-26 22:04:59 +01:00
|
|
|
g_set_error(error, alsa_output_quark(), errno,
|
|
|
|
"%s", snd_strerror(-errno));
|
2009-02-23 09:29:56 +01:00
|
|
|
return 0;
|
2005-03-05 06:22:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-08 11:43:38 +02:00
|
|
|
const struct audio_output_plugin alsaPlugin = {
|
2008-09-29 15:55:17 +02:00
|
|
|
.name = "alsa",
|
2009-01-25 13:05:16 +01:00
|
|
|
.test_default_device = alsa_test_default_device,
|
|
|
|
.init = alsa_init,
|
|
|
|
.finish = alsa_finish,
|
|
|
|
.open = alsa_open,
|
|
|
|
.play = alsa_play,
|
|
|
|
.cancel = alsa_cancel,
|
|
|
|
.close = alsa_close,
|
2009-03-26 18:23:23 +01:00
|
|
|
.mixer_plugin = &alsa_mixer,
|
2005-03-05 06:22:30 +01:00
|
|
|
};
|