third_party_alsa-utils/bat/alsa.c

/*
 * Copyright (C) 2013-2015 Intel Corporation
 *
 * 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.
 *
 */

#include "aconfig.h"

#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#include <pthread.h>
#include <errno.h>

#include <alsa/asoundlib.h>

#include "gettext.h"

#include "common.h"
#include "alsa.h"
#include "latencytest.h"
#include "os_compat.h"

struct pcm_container {
	snd_pcm_t *handle;
	snd_pcm_uframes_t period_size;
	snd_pcm_uframes_t buffer_size;
	snd_pcm_format_t format;
	unsigned short channels;
	size_t period_bytes;
	size_t sample_bits;
	size_t frame_bits;
	char *buffer;
};

struct format_map_table {
	enum _bat_pcm_format format_bat;
	snd_pcm_format_t format_alsa;
};

static struct format_map_table map_tables[] = {
	{ BAT_PCM_FORMAT_UNKNOWN, SND_PCM_FORMAT_UNKNOWN },
	{ BAT_PCM_FORMAT_U8, SND_PCM_FORMAT_U8 },
	{ BAT_PCM_FORMAT_S16_LE, SND_PCM_FORMAT_S16_LE },
	{ BAT_PCM_FORMAT_S24_3LE, SND_PCM_FORMAT_S24_3LE },
	{ BAT_PCM_FORMAT_S32_LE, SND_PCM_FORMAT_S32_LE },
	{ BAT_PCM_FORMAT_MAX, 0 },
};

static int format_convert(struct bat *bat, snd_pcm_format_t *fmt)
{
	struct format_map_table *t = map_tables;

	for (; t->format_bat != BAT_PCM_FORMAT_MAX; t++) {
		if (t->format_bat == bat->format) {
			*fmt = t->format_alsa;
			return 0;
		}
	}
	fprintf(bat->err, _("Invalid format!\n"));
	return -EINVAL;
}

static int set_snd_pcm_params(struct bat *bat, struct pcm_container *sndpcm)
{
	snd_pcm_hw_params_t *params;
	snd_pcm_format_t format;
	unsigned int buffer_time = 0;
	unsigned int period_time = 0;
	snd_pcm_uframes_t buffer_size = 0;
	snd_pcm_uframes_t period_size = 0;
	unsigned int rate;
	int err;
	const char *device_name = snd_pcm_name(sndpcm->handle);

	/* Convert common format to ALSA format */
	err = format_convert(bat, &format);
	if (err != 0)
		return err;

	/* Allocate a hardware parameters object. */
	snd_pcm_hw_params_alloca(&params);

	/* Fill it in with default values. */
	err = snd_pcm_hw_params_any(sndpcm->handle, params);
	if (err < 0) {
		fprintf(bat->err, _("Set parameter to device error: "));
		fprintf(bat->err, _("default params: %s: %s(%d)\n"),
				device_name, snd_strerror(err), err);
		return err;
	}

	/* Set access mode */
	err = snd_pcm_hw_params_set_access(sndpcm->handle, params,
			SND_PCM_ACCESS_RW_INTERLEAVED);
	if (err < 0) {
		fprintf(bat->err, _("Set parameter to device error: "));
		fprintf(bat->err, _("access type: %s: %s(%d)\n"),
				device_name, snd_strerror(err), err);
		return err;
	}

	/* Set format */
	err = snd_pcm_hw_params_set_format(sndpcm->handle, params, format);
	if (err < 0) {
		fprintf(bat->err, _("Set parameter to device error: "));
		fprintf(bat->err, _("PCM format: %d %s: %s(%d)\n"), format,
				device_name, snd_strerror(err), err);
		return err;
	}

	/* Set channels */
	err = snd_pcm_hw_params_set_channels(sndpcm->handle,
			params, bat->channels);
	if (err < 0) {
		fprintf(bat->err, _("Set parameter to device error: "));
		fprintf(bat->err, _("channel number: %d %s: %s(%d)\n"),
				bat->channels,
				device_name, snd_strerror(err), err);
		return err;
	}

	/* Set sampling rate */
	rate = bat->rate;
	err = snd_pcm_hw_params_set_rate_near(sndpcm->handle,
			params, &bat->rate,
			0);
	if (err < 0) {
		fprintf(bat->err, _("Set parameter to device error: "));
		fprintf(bat->err, _("sample rate: %d %s: %s(%d)\n"),
				bat->rate,
				device_name, snd_strerror(err), err);
		return err;
	}
	if ((float) rate * (1 + RATE_RANGE) < bat->rate
			|| (float) rate * (1 - RATE_RANGE) > bat->rate) {
		fprintf(bat->err, _("Invalid parameters: sample rate: "));
		fprintf(bat->err, _("requested %dHz, got %dHz\n"),
				rate, bat->rate);
		return -EINVAL;
	}

	if (bat->buffer_size > 0 && bat->period_size == 0)
		bat->period_size = bat->buffer_size / DIV_BUFFERSIZE;

	if (bat->roundtriplatency && bat->buffer_size == 0) {
		/* Set to minimum buffer size and period size
		   for latency test */
		if (snd_pcm_hw_params_get_buffer_size_min(params,
				&buffer_size) < 0) {
			fprintf(bat->err,
					_("Get parameter from device error: "));
			fprintf(bat->err, _("buffer size min: %d %s: %s(%d)\n"),
					(int) buffer_size,
					device_name, snd_strerror(err), err);
			return -EINVAL;
		}

		if (snd_pcm_hw_params_get_period_size_min(params,
				&period_size, 0) < 0) {
			fprintf(bat->err,
					_("Get parameter from device error: "));
			fprintf(bat->err, _("period size min: %d %s: %s(%d)\n"),
					(int) period_size,
					device_name, snd_strerror(err), err);
			return -EINVAL;
		}
		bat->buffer_size = (int) buffer_size;
		bat->period_size = (int) period_size;
	}

	if (bat->buffer_size > 0) {
		buffer_size = bat->buffer_size;
		period_size = bat->period_size;

		fprintf(bat->log, _("Set period size: %d  buffer size: %d\n"),
				(int) period_size, (int) buffer_size);

		err = snd_pcm_hw_params_set_buffer_size_near(sndpcm->handle,
				params, &buffer_size);
		if (err < 0) {
			fprintf(bat->err, _("Set parameter to device error: "));
			fprintf(bat->err, _("buffer size: %d %s: %s(%d)\n"),
					(int) buffer_size,
					device_name, snd_strerror(err), err);
			return err;
		}

		err = snd_pcm_hw_params_set_period_size_near(sndpcm->handle,
				params, &period_size, 0);
		if (err < 0) {
			fprintf(bat->err, _("Set parameter to device error: "));
			fprintf(bat->err, _("period size: %d %s: %s(%d)\n"),
					(int) period_size,
					device_name, snd_strerror(err), err);
			return err;
		}
	} else {
		if (snd_pcm_hw_params_get_buffer_time_max(params,
				&buffer_time, 0) < 0) {
			fprintf(bat->err,
					_("Get parameter from device error: "));
			fprintf(bat->err, _("buffer time: %d %s: %s(%d)\n"),
					buffer_time,
					device_name, snd_strerror(err), err);
			return -EINVAL;
		}

		if (buffer_time > MAX_BUFFERTIME)
			buffer_time = MAX_BUFFERTIME;

		period_time = buffer_time / DIV_BUFFERTIME;

		/* Set buffer time and period time */
		err = snd_pcm_hw_params_set_buffer_time_near(sndpcm->handle,
				params, &buffer_time, 0);
		if (err < 0) {
			fprintf(bat->err, _("Set parameter to device error: "));
			fprintf(bat->err, _("buffer time: %d %s: %s(%d)\n"),
					buffer_time,
					device_name, snd_strerror(err), err);
			return err;
		}

		err = snd_pcm_hw_params_set_period_time_near(sndpcm->handle,
				params, &period_time, 0);
		if (err < 0) {
			fprintf(bat->err, _("Set parameter to device error: "));
			fprintf(bat->err, _("period time: %d %s: %s(%d)\n"),
					period_time,
					device_name, snd_strerror(err), err);
			return err;
		}
	}

	/* Write the parameters to the driver */
	if (snd_pcm_hw_params(sndpcm->handle, params) < 0) {
		fprintf(bat->err, _("Set parameter to device error: "));
		fprintf(bat->err, _("hw params: %s: %s(%d)\n"),
				device_name, snd_strerror(err), err);
		return -EINVAL;
	}

	err = snd_pcm_hw_params_get_period_size(params,
			&sndpcm->period_size, 0);
	if (err < 0) {
		fprintf(bat->err, _("Get parameter from device error: "));
		fprintf(bat->err, _("period size: %zd %s: %s(%d)\n"),
				sndpcm->period_size,
				device_name, snd_strerror(err), err);
		return err;
	}

	err = snd_pcm_hw_params_get_buffer_size(params, &sndpcm->buffer_size);
	if (err < 0) {
		fprintf(bat->err, _("Get parameter from device error: "));
		fprintf(bat->err, _("buffer size: %zd %s: %s(%d)\n"),
				sndpcm->buffer_size,
				device_name, snd_strerror(err), err);
		return err;
	}

	if (sndpcm->period_size == sndpcm->buffer_size) {
		fprintf(bat->err, _("Invalid parameters: can't use period "));
		fprintf(bat->err, _("equal to buffer size (%zd)\n"),
				sndpcm->period_size);
		return -EINVAL;
	}

	fprintf(bat->log, _("Get period size: %d  buffer size: %d\n"),
			(int) sndpcm->period_size, (int) sndpcm->buffer_size);

	err = snd_pcm_format_physical_width(format);
	if (err < 0) {
		fprintf(bat->err, _("Invalid parameters: "));
		fprintf(bat->err, _("snd_pcm_format_physical_width: %d\n"),
				err);
		return err;
	}
	sndpcm->sample_bits = err;

	sndpcm->frame_bits = sndpcm->sample_bits * bat->channels;

	/* Calculate the period bytes */
	sndpcm->period_bytes = sndpcm->period_size * sndpcm->frame_bits / 8;
	sndpcm->buffer = (char *) malloc(sndpcm->period_bytes);
	if (sndpcm->buffer == NULL) {
		fprintf(bat->err, _("Not enough memory: size=%zd\n"),
				sndpcm->period_bytes);
		return -ENOMEM;
	}

	return 0;
}

static int write_to_pcm(const struct pcm_container *sndpcm,
		int frames, struct bat *bat)
{
	int err;
	int offset = 0;
	int remain = frames;

	while (remain > 0) {
		err = snd_pcm_writei(sndpcm->handle, sndpcm->buffer + offset,
				remain);
		if (err == -EAGAIN || (err >= 0 && err < frames)) {
			snd_pcm_wait(sndpcm->handle, 500);
		} else if (err == -EPIPE) {
			fprintf(bat->err, _("Underrun: %s(%d)\n"),
					snd_strerror(err), err);
			if (bat->roundtriplatency)
				bat->latency.xrun_error = true;
			snd_pcm_prepare(sndpcm->handle);
		} else if (err == -ESTRPIPE) {
			while ((err = snd_pcm_resume(sndpcm->handle)) == -EAGAIN)
				sleep(1);  /* wait until resume flag is released */
			if (err < 0)
				snd_pcm_prepare(sndpcm->handle);
		} else if (err < 0) {
			fprintf(bat->err, _("Write PCM device error: %s(%d)\n"),
					snd_strerror(err), err);
			return err;
		}

		if (err > 0) {
			remain -= err;
			offset += err * sndpcm->frame_bits / 8;
		}
	}

	return 0;
}

/**
 * Process output data for latency test
 */
static int latencytest_process_output(struct pcm_container *sndpcm,
		struct bat *bat)
{
	int err = 0;
	int bytes = sndpcm->period_bytes; /* playback buffer size */
	int frames = sndpcm->period_size; /* frame count */

	bat->latency.is_playing = true;

	while (1) {
		/* generate output data */
		err = handleoutput(bat, sndpcm->buffer, bytes, frames);
		if (err != 0)
			break;

		err = write_to_pcm(sndpcm, frames, bat);
		if (err != 0)
			break;

		/* Xrun error, terminate the playback thread*/
		if (bat->latency.xrun_error == true)
			break;

		if (bat->latency.state == LATENCY_STATE_COMPLETE_SUCCESS)
			break;

		bat->periods_played++;
	}

	bat->latency.is_playing = false;

	return err;
}

static int write_to_pcm_loop(struct pcm_container *sndpcm, struct bat *bat)
{
	int err = 0;
	int bytes = sndpcm->period_bytes; /* playback buffer size */
	int frames = bytes * 8 / sndpcm->frame_bits; /* frame count */
	FILE *fp = NULL;
	int bytes_total = 0;

	if (bat->debugplay) {
		fp = fopen(bat->debugplay, "wb");
		err = -errno;
		if (fp == NULL) {
			fprintf(bat->err, _("Cannot open file: %s %d\n"),
					bat->debugplay, err);
			return err;
		}
		/* leave space for wav header */
		if (fseek(fp, sizeof(struct wav_container), SEEK_SET) != 0) {
			err = -errno;
			fclose(fp);
			return err;
		}
	}

	while (1) {
		err = generate_input_data(bat, sndpcm->buffer, bytes, frames);
		if (err != 0)
			break;

		if (bat->debugplay) {
			if (fwrite(sndpcm->buffer, 1, bytes, fp) != (size_t)bytes) {
				err = -EIO;
				break;
			}
			bytes_total += bytes;
		}

		bat->periods_played++;
		if (bat->period_is_limited
				&& bat->periods_played >= bat->periods_total)
			break;

		err = write_to_pcm(sndpcm, frames, bat);
		if (err != 0)
			break;
	}

	if (bat->debugplay) {
		update_wav_header(bat, fp, bytes_total);
		fclose(fp);
	}

	snd_pcm_drain(sndpcm->handle);

	return err;
}

/**
 * Play
 */
void *playback_alsa(struct bat *bat)
{
	int err = 0;
	struct pcm_container sndpcm;

	fprintf(bat->log, _("Entering playback thread (ALSA).\n"));

	retval_play = 0;
	memset(&sndpcm, 0, sizeof(sndpcm));

	err = snd_pcm_open(&sndpcm.handle, bat->playback.device,
			SND_PCM_STREAM_PLAYBACK, 0);
	if (err != 0) {
		fprintf(bat->err, _("Cannot open PCM playback device: "));
		fprintf(bat->err, _("%s(%d)\n"), snd_strerror(err), err);
		retval_play = err;
		goto exit1;
	}

	err = set_snd_pcm_params(bat, &sndpcm);
	if (err != 0) {
		retval_play = err;
		goto exit2;
	}

	if (bat->playback.file == NULL) {
		fprintf(bat->log, _("Playing generated audio sine wave"));
		bat->sinus_duration == 0 ?
			fprintf(bat->log, _(" endlessly\n")) :
			fprintf(bat->log, _("\n"));
	} else {
		fprintf(bat->log, _("Playing input audio file: %s\n"),
				bat->playback.file);
		bat->fp = fopen(bat->playback.file, "rb");
		err = -errno;
		if (bat->fp == NULL) {
			fprintf(bat->err, _("Cannot open file: %s %d\n"),
					bat->playback.file, err);
			retval_play = err;
			goto exit3;
		}
		/* Skip header */
		err = read_wav_header(bat, bat->playback.file, bat->fp, true);
		if (err != 0) {
			retval_play = err;
			goto exit4;
		}
	}

	if (bat->roundtriplatency)
		err = latencytest_process_output(&sndpcm, bat);
	else
		err = write_to_pcm_loop(&sndpcm, bat);
	if (err < 0) {
		retval_play = err;
		goto exit4;
	}

exit4:
	if (bat->playback.file)
		fclose(bat->fp);
exit3:
	free(sndpcm.buffer);
exit2:
	snd_pcm_close(sndpcm.handle);
exit1:
	pthread_exit(&retval_play);
}

static int read_from_pcm(struct pcm_container *sndpcm,
		int frames, struct bat *bat)
{
	int err = 0;
	int offset = 0;
	int remain = frames;

	while (remain > 0) {
		err = snd_pcm_readi(sndpcm->handle,
				sndpcm->buffer + offset, remain);
		if (err == -EAGAIN || (err >= 0 && err < remain)) {
			snd_pcm_wait(sndpcm->handle, 500);
		} else if (err == -EPIPE) {
			snd_pcm_prepare(sndpcm->handle);
			fprintf(bat->err, _("Overrun: %s(%d)\n"),
					snd_strerror(err), err);
			if (bat->roundtriplatency)
				bat->latency.xrun_error = true;
		} else if (err == -ESTRPIPE) {
			while ((err = snd_pcm_resume(sndpcm->handle)) == -EAGAIN)
				sleep(1);  /* wait until resume flag is released */
			if (err < 0)
				snd_pcm_prepare(sndpcm->handle);
		} else if (err < 0) {
			fprintf(bat->err, _("Read PCM device error: %s(%d)\n"),
					snd_strerror(err), err);
			return err;
		}

		if (err > 0) {
			remain -= err;
			offset += err * sndpcm->frame_bits / 8;
		}
	}

	return 0;
}

static int read_from_pcm_loop(struct pcm_container *sndpcm, struct bat *bat)
{
	int err = 0;
	FILE *fp = NULL;
	int size, frames;
	int bytes_read = 0;
	int bytes_count = bat->frames * bat->frame_size;
	unsigned int remain = bytes_count;

	remove(bat->capture.file);
	fp = fopen(bat->capture.file, "wb");
	err = -errno;
	if (fp == NULL) {
		fprintf(bat->err, _("Cannot open file: %s %d\n"),
				bat->capture.file, err);
		return err;
	}
	/* leave space for file header */
	if (fseek(fp, sizeof(struct wav_container), SEEK_SET) != 0) {
		err = -errno;
		fclose(fp);
		return err;
	}

	while (remain > 0) {
		size = (remain <= sndpcm->period_bytes) ?
			remain : sndpcm->period_bytes;
		frames = size * 8 / sndpcm->frame_bits;

		/* read a chunk from pcm device */
		err = read_from_pcm(sndpcm, frames, bat);
		if (err != 0)
			break;

		/* write the chunk to file */
		if (fwrite(sndpcm->buffer, 1, size, fp) != (size_t)size) {
			err = -EIO;
			break;
		}

		bytes_read += size;
		remain -= size;
		bat->periods_played++;

		if (bat->period_is_limited
				&& bat->periods_played >= bat->periods_total)
			break;
	}

	update_wav_header(bat, fp, bytes_read);

	fclose(fp);
	return err;
}

/**
 * Process input data for latency test
 */
static int latencytest_process_input(struct pcm_container *sndpcm,
		struct bat *bat)
{
	int err = 0;
	FILE *fp = NULL;
	int bytes_read = 0;
	int frames = sndpcm->period_size;
	int size = sndpcm->period_bytes;
	int bytes_count = bat->frames * bat->frame_size;

	remove(bat->capture.file);
	fp = fopen(bat->capture.file, "wb");
	err = -errno;
	if (fp == NULL) {
		fprintf(bat->err, _("Cannot open file: %s %d\n"),
				bat->capture.file, err);
		return err;
	}
	/* leave space for file header */
	if (fseek(fp, sizeof(struct wav_container), SEEK_SET) != 0) {
		fclose(fp);
		return err;
	}

	bat->latency.is_capturing = true;

	while (bytes_read < bytes_count) {
		/* read a chunk from pcm device */
		err = read_from_pcm(sndpcm, frames, bat);
		if (err != 0)
			break;

		/* Xrun error, terminate the capture thread*/
		if (bat->latency.xrun_error == true)
			break;

		err = handleinput(bat, sndpcm->buffer, frames);
		if (err != 0)
			break;

		if (bat->latency.is_playing == false)
			break;

		/* write the chunk to file */
		if (fwrite(sndpcm->buffer, 1, size, fp) != (size_t)size) {
			err = -EIO;
			break;
		}

		bytes_read += size;
	}

	bat->latency.is_capturing = false;

	update_wav_header(bat, fp, bytes_read);

	fclose(fp);
	return err;
}


static void pcm_cleanup(void *p)
{
	snd_pcm_close(p);
}

/**
 * Record
 */
void *record_alsa(struct bat *bat)
{
	int err = 0;
	struct pcm_container sndpcm;

	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

	fprintf(bat->log, _("Entering capture thread (ALSA).\n"));

	retval_record = 0;
	memset(&sndpcm, 0, sizeof(sndpcm));

	err = snd_pcm_open(&sndpcm.handle, bat->capture.device,
			SND_PCM_STREAM_CAPTURE, 0);
	if (err != 0) {
		fprintf(bat->err, _("Cannot open PCM capture device: "));
		fprintf(bat->err, _("%s(%d)\n"), snd_strerror(err), err);
		retval_record = err;
		goto exit1;
	}

	err = set_snd_pcm_params(bat, &sndpcm);
	if (err != 0) {
		retval_record = err;
		goto exit2;
	}

	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
	pthread_cleanup_push(pcm_cleanup, sndpcm.handle);
	pthread_cleanup_push(free, sndpcm.buffer);

	fprintf(bat->log, _("Recording ...\n"));
	if (bat->roundtriplatency)
		err = latencytest_process_input(&sndpcm, bat);
	else
		err = read_from_pcm_loop(&sndpcm, bat);

	pthread_cleanup_pop(0);
	pthread_cleanup_pop(0);

	if (err != 0) {
		retval_record = err;
		goto exit3;
	}

	/* Normally we will never reach this part of code (unless error in
	 * previous call) (before exit3) as this thread will be cancelled
	 * by end of play thread. Except in single line mode. */
	snd_pcm_drain(sndpcm.handle);
	pthread_exit(&retval_record);

exit3:
	free(sndpcm.buffer);
exit2:
	snd_pcm_close(sndpcm.handle);
exit1:
	pthread_exit(&retval_record);
}