comparison src/alsa/audio.c @ 2760:35ac6cb80680

Use glib types.

2759:fd550b4fc79f

/* Number of bytes that we have sent to the sound card */
static guint64 alsa_hw_written;
static guint64 output_time_offset;

/* device buffer/period sizes in bytes */
static int hw_buffer_size, hw_period_size;		/* in output bytes */
static int hw_buffer_size_in, hw_period_size_in;	/* in input bytes */

/* Set/Get volume */
static snd_mixer_elem_t *pcm_element;
static snd_mixer_t *mixer;

static gboolean alsa_can_pause;

/* for audio thread */
static GThread *audio_thread;	 /* audio loop thread */
static int thread_buffer_size;	 /* size of intermediate buffer in bytes */
static char *thread_buffer;	 /* audio intermediate buffer */
static int rd_index, wr_index;	 /* current read/write position in int-buffer */
static gboolean pause_request;	 /* pause status currently requested */
static int flush_request;	 /* flush status (time) currently requested */
static int prebuffer_size;
GStaticMutex alsa_mutex = G_STATIC_MUTEX_INIT;

struct snd_format {
	unsigned int rate;
	unsigned int channels;
	snd_pcm_format_t format;
	AFormat xmms_format;
	int sample_bits;
	int bps;
};

static struct snd_format *inputf = NULL;
static struct snd_format *outputf = NULL;

static int alsa_setup(struct snd_format *f);
static void alsa_write_audio(char *data, int length);
static void alsa_cleanup_mixer(void);
static int get_thread_buffer_filled(void);

static struct snd_format * snd_format_from_xmms(AFormat fmt, int rate, int channels);

static const struct {
	AFormat xmms;
	snd_pcm_format_t alsa;
} format_table[] =

 {FMT_U8, SND_PCM_FORMAT_U8},
 {FMT_S8, SND_PCM_FORMAT_S8},
};


static void debug(char *str, ...) G_GNUC_PRINTF(1, 2);

static void debug(char *str, ...)
{
	va_list args;

	if (alsa_cfg.debug)
	{

               !paused &&
               !prebuffer &&
               get_thread_buffer_filled() > hw_period_size_in;
}

static int
alsa_recovery(int err)
{
	int err2;

	/* if debug mode is enabled, dump ALSA state to console */
	if (alsa_cfg.debug)
	{
		snd_pcm_status_t *alsa_status = NULL;

	g_static_mutex_unlock(&alsa_mutex);
}

/* reopen ALSA PCM */
#if 0
static int alsa_reopen(struct snd_format *f)
{
	/* remember the current position */
	output_time_offset += (alsa_hw_written * 1000) / outputf->bps;
	alsa_hw_written = 0;

	return alsa_setup(f);
}
#endif

/* do flush (drop) operation */
static void alsa_do_flush(int time)
{
	if (alsa_pcm)
	{
		snd_pcm_drop(alsa_pcm);
		snd_pcm_prepare(alsa_pcm);

	output_time_offset = time;
	alsa_total_written = (guint64) time * inputf->bps / 1000;
	rd_index = wr_index = alsa_hw_written = 0;
}

void alsa_flush(int time)
{
	flush_request = time;
	while ((flush_request != -1) && (going))
		g_usleep(10000);
}

static void parse_mixer_name(char *str, char **name, int *index)
{
	char *end;

	while (isspace(*str))
		str++;

	if ((end = strchr(str, ',')) != NULL)

		*name = g_strdup(str);
		*index = 0;
	}
}

int alsa_get_mixer(snd_mixer_t **mixer, int card)
{
	char *dev;
	int err;

	debug("alsa_get_mixer");

	if ((err = snd_mixer_open(mixer, 0)) < 0)
	{

	return (*mixer != NULL);
}


static snd_mixer_elem_t* alsa_get_mixer_elem(snd_mixer_t *mixer, char *name, int index)
{
	snd_mixer_selem_id_t *selem_id;
	snd_mixer_elem_t* elem;
	snd_mixer_selem_id_alloca(&selem_id);

	return elem;
}

static int alsa_setup_mixer(void)
{
	char *name;
	long int a, b;
	long alsa_min_vol, alsa_max_vol;
	int err, index;

	debug("alsa_setup_mixer");

	if ((err = alsa_get_mixer(&mixer, alsa_cfg.mixer_card)) < 0)
		return err;

		snd_mixer_close(mixer);
		mixer = NULL;
	}
}

void alsa_get_volume(int *l, int *r)
{
	long ll = *l, lr = *r;

	if (mixer_start)
	{
		alsa_setup_mixer();
		mixer_start = FALSE;

	*l = ll;
	*r = lr;
}


void alsa_set_volume(int l, int r)
{
	if (!pcm_element)
		return;

	if (snd_mixer_selem_is_playback_mono(pcm_element))

	if (wr_index >= rd_index)
		return wr_index - rd_index;
	return thread_buffer_size - (rd_index - wr_index);
}

int alsa_get_output_time(void)
{
	snd_pcm_sframes_t delay;
	guint64 bytes = alsa_hw_written;

	if (!going || alsa_pcm == NULL)

			bytes -= d;
	}
	return output_time_offset + (bytes * 1000) / outputf->bps;
}

int alsa_get_written_time(void)
{
	if (!going)
		return 0;
	return (alsa_total_written * 1000) / inputf->bps;
}

	alsa_write_audio(data, length);
}

/* write callback */
void alsa_write(gpointer data, int length)
{
	int cnt;
	char *src = (char *)data;
	
	remove_prebuffer = FALSE;
	
	alsa_total_written += length;
	while (length > 0)

		src += cnt;
	}
}

/* transfer data to audio h/w via normal write */
static void alsa_write_audio(char *data, int length)
{
	snd_pcm_sframes_t written_frames;

	while (length > 0)
	{

/* audio thread loop */
/* FIXME: proper lock? */
static void *alsa_loop(void *arg)
{
	int npfds = snd_pcm_poll_descriptors_count(alsa_pcm);
	int wr = 0;

	g_static_mutex_lock(&alsa_mutex);

	if (npfds <= 0)
		goto _error;

	g_thread_exit(NULL);
	return(NULL);
}

/* open callback */
int alsa_open(AFormat fmt, int rate, int nch)
{
	debug("Opening device");
	if((inputf = snd_format_from_xmms(fmt, rate, nch)) == NULL) return 0;

	if (alsa_cfg.debug)

	
	audio_thread = g_thread_create((GThreadFunc)alsa_loop, NULL, TRUE, NULL);
	return 1;
}

static struct snd_format * snd_format_from_xmms(AFormat fmt, int rate, int channels)
{
	struct snd_format *f = g_malloc(sizeof(struct snd_format));
	size_t i;
        int found = 0;

	f->xmms_format = fmt;
	f->format = SND_PCM_FORMAT_UNKNOWN;

	for (i = 0; i < sizeof(format_table) / sizeof(format_table[0]); i++)

	f->bps = (rate * f->sample_bits * channels) >> 3;

	return f;
}

static int alsa_setup(struct snd_format *f)
{
	int err;
	snd_pcm_hw_params_t *hwparams = NULL;
	snd_pcm_sw_params_t *swparams = NULL;
	unsigned int alsa_buffer_time, alsa_period_time;
	snd_pcm_uframes_t alsa_buffer_size, alsa_period_size;

	debug("alsa_setup");

	g_free(outputf);

2760:35ac6cb80680

/* Number of bytes that we have sent to the sound card */
static guint64 alsa_hw_written;
static guint64 output_time_offset;

/* device buffer/period sizes in bytes */
static gint hw_buffer_size, hw_period_size;		/* in output bytes */
static gint hw_buffer_size_in, hw_period_size_in;	/* in input bytes */

/* Set/Get volume */
static snd_mixer_elem_t *pcm_element;
static snd_mixer_t *mixer;

static gboolean alsa_can_pause;

/* for audio thread */
static GThread *audio_thread;	 /* audio loop thread */
static gint thread_buffer_size;	 /* size of intermediate buffer in bytes */
static gchar *thread_buffer;	 /* audio intermediate buffer */
static gint rd_index, wr_index;	 /* current read/write position in int-buffer */
static gboolean pause_request;	 /* pause status currently requested */
static gint flush_request;	 /* flush status (time) currently requested */
static gint prebuffer_size;
GStaticMutex alsa_mutex = G_STATIC_MUTEX_INIT;

struct snd_format {
	guint rate;
	guint channels;
	snd_pcm_format_t format;
	AFormat xmms_format;
	gint sample_bits;
	gint bps;
};

static struct snd_format *inputf = NULL;
static struct snd_format *outputf = NULL;

static gint alsa_setup(struct snd_format *f);
static void alsa_write_audio(gchar *data, gint length);
static void alsa_cleanup_mixer(void);
static gint get_thread_buffer_filled(void);

static struct snd_format * snd_format_from_xmms(AFormat fmt, gint rate, gint channels);

static const struct {
	AFormat xmms;
	snd_pcm_format_t alsa;
} format_table[] =

 {FMT_U8, SND_PCM_FORMAT_U8},
 {FMT_S8, SND_PCM_FORMAT_S8},
};


static void debug(gchar *str, ...) G_GNUC_PRINTF(1, 2);

static void debug(gchar *str, ...)
{
	va_list args;

	if (alsa_cfg.debug)
	{

               !paused &&
               !prebuffer &&
               get_thread_buffer_filled() > hw_period_size_in;
}

static gint
alsa_recovery(gint err)
{
	gint err2;

	/* if debug mode is enabled, dump ALSA state to console */
	if (alsa_cfg.debug)
	{
		snd_pcm_status_t *alsa_status = NULL;

	g_static_mutex_unlock(&alsa_mutex);
}

/* reopen ALSA PCM */
#if 0
static gint alsa_reopen(struct snd_format *f)
{
	/* remember the current position */
	output_time_offset += (alsa_hw_written * 1000) / outputf->bps;
	alsa_hw_written = 0;

	return alsa_setup(f);
}
#endif

/* do flush (drop) operation */
static void alsa_do_flush(gint time)
{
	if (alsa_pcm)
	{
		snd_pcm_drop(alsa_pcm);
		snd_pcm_prepare(alsa_pcm);

	output_time_offset = time;
	alsa_total_written = (guint64) time * inputf->bps / 1000;
	rd_index = wr_index = alsa_hw_written = 0;
}

void alsa_flush(gint time)
{
	flush_request = time;
	while ((flush_request != -1) && (going))
		g_usleep(10000);
}

static void parse_mixer_name(gchar *str, gchar **name, gint *index)
{
	gchar *end;

	while (isspace(*str))
		str++;

	if ((end = strchr(str, ',')) != NULL)

		*name = g_strdup(str);
		*index = 0;
	}
}

gint alsa_get_mixer(snd_mixer_t **mixer, gint card)
{
	gchar *dev;
	gint err;

	debug("alsa_get_mixer");

	if ((err = snd_mixer_open(mixer, 0)) < 0)
	{

	return (*mixer != NULL);
}


static snd_mixer_elem_t* alsa_get_mixer_elem(snd_mixer_t *mixer, gchar *name, gint index)
{
	snd_mixer_selem_id_t *selem_id;
	snd_mixer_elem_t* elem;
	snd_mixer_selem_id_alloca(&selem_id);

	return elem;
}

static int alsa_setup_mixer(void)
{
	gchar *name;
	glong a, b;
	glong alsa_min_vol, alsa_max_vol;
	gint err, index;

	debug("alsa_setup_mixer");

	if ((err = alsa_get_mixer(&mixer, alsa_cfg.mixer_card)) < 0)
		return err;

		snd_mixer_close(mixer);
		mixer = NULL;
	}
}

void alsa_get_volume(gint *l, gint *r)
{
	glong ll = *l, lr = *r;

	if (mixer_start)
	{
		alsa_setup_mixer();
		mixer_start = FALSE;

	*l = ll;
	*r = lr;
}


void alsa_set_volume(gint l, gint r)
{
	if (!pcm_element)
		return;

	if (snd_mixer_selem_is_playback_mono(pcm_element))

	if (wr_index >= rd_index)
		return wr_index - rd_index;
	return thread_buffer_size - (rd_index - wr_index);
}

gint alsa_get_output_time(void)
{
	snd_pcm_sframes_t delay;
	guint64 bytes = alsa_hw_written;

	if (!going || alsa_pcm == NULL)

			bytes -= d;
	}
	return output_time_offset + (bytes * 1000) / outputf->bps;
}

gint alsa_get_written_time(void)
{
	if (!going)
		return 0;
	return (alsa_total_written * 1000) / inputf->bps;
}

	alsa_write_audio(data, length);
}

/* write callback */
void alsa_write(gpointer data, gint length)
{
	gint cnt;
	gchar *src = (gchar *)data;
	
	remove_prebuffer = FALSE;
	
	alsa_total_written += length;
	while (length > 0)

		src += cnt;
	}
}

/* transfer data to audio h/w via normal write */
static void alsa_write_audio(gchar *data, gint length)
{
	snd_pcm_sframes_t written_frames;

	while (length > 0)
	{

/* audio thread loop */
/* FIXME: proper lock? */
static void *alsa_loop(void *arg)
{
	gint npfds = snd_pcm_poll_descriptors_count(alsa_pcm);
	gint wr = 0;

	g_static_mutex_lock(&alsa_mutex);

	if (npfds <= 0)
		goto _error;

	g_thread_exit(NULL);
	return(NULL);
}

/* open callback */
gint alsa_open(AFormat fmt, gint rate, gint nch)
{
	debug("Opening device");
	if((inputf = snd_format_from_xmms(fmt, rate, nch)) == NULL) return 0;

	if (alsa_cfg.debug)

	
	audio_thread = g_thread_create((GThreadFunc)alsa_loop, NULL, TRUE, NULL);
	return 1;
}

static struct snd_format * snd_format_from_xmms(AFormat fmt, gint rate, gint channels)
{
	struct snd_format *f = g_malloc(sizeof(struct snd_format));
	size_t i;
    gint found = 0;

	f->xmms_format = fmt;
	f->format = SND_PCM_FORMAT_UNKNOWN;

	for (i = 0; i < sizeof(format_table) / sizeof(format_table[0]); i++)

	f->bps = (rate * f->sample_bits * channels) >> 3;

	return f;
}

static gint alsa_setup(struct snd_format *f)
{
	gint err;
	snd_pcm_hw_params_t *hwparams = NULL;
	snd_pcm_sw_params_t *swparams = NULL;
	guint alsa_buffer_time, alsa_period_time;
	snd_pcm_uframes_t alsa_buffer_size, alsa_period_size;

	debug("alsa_setup");

	g_free(outputf);