@@ -24,6 +24,7 @@ ABOUT-NLS
*~
.deps
+alsabat/alsabat
alsactl/alsactl
alsactl/alsactl_init.7
alsactl/alsa-state.service
@@ -36,7 +37,6 @@ amixer/amixer
aplay/aplay
aplay/arecord
aplay/arecord.1
-bat/bat
iecset/iecset
seq/aconnect/aconnect
seq/aplaymidi/aplaymidi
@@ -18,8 +18,8 @@ SUBDIRS += aplay iecset speaker-test
if ALSALOOP
SUBDIRS += alsaloop
endif
-if BAT
-SUBDIRS += bat
+if ALSABAT
+SUBDIRS += alsabat
endif
endif
if HAVE_SEQ
new file mode 100644
@@ -0,0 +1,24 @@
+bin_PROGRAMS = alsabat
+man_MANS = alsabat.1
+
+EXTRA_DIST = alsabat.1
+
+alsabat_SOURCES = \
+ alsabat.c \
+ common.c \
+ analyze.c \
+ signal.c \
+ convert.c \
+ alsa.c
+
+noinst_HEADERS = \
+ common.h \
+ bat-signal.h \
+ alsa.h \
+ convert.h \
+ analyze.h
+
+AM_CPPFLAGS = \
+ -Wall -I$(top_srcdir)/include
+
+alsabat_LDADD = @FFTW_LIB@
new file mode 100644
@@ -0,0 +1,604 @@
+/*
+ * 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 <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <math.h>
+#include <stdint.h>
+#include <pthread.h>
+
+#include <alsa/asoundlib.h>
+
+#include "aconfig.h"
+#include "gettext.h"
+
+#include "common.h"
+#include "alsa.h"
+#include "bat-signal.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;
+};
+
+static int set_snd_pcm_params(struct bat *bat, struct pcm_container *sndpcm)
+{
+ snd_pcm_hw_params_t *params;
+ unsigned int buffer_time = 0;
+ unsigned int period_time = 0;
+ unsigned int rate;
+ int err;
+ const char *device_name = snd_pcm_name(sndpcm->handle);
+
+ /* Allocate a hardware parameters object. */
+ snd_pcm_hw_params_alloca(¶ms);
+
+ /* 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, bat->format);
+ if (err < 0) {
+ fprintf(bat->err, _("Set parameter to device error: "));
+ fprintf(bat->err, _("PCM format: %d %s: %s(%d)\n"),
+ bat->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 (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;
+ }
+
+ err = snd_pcm_format_physical_width(bat->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;
+}
+
+/*
+ * Generate buffer to be played either from input file or from generated data
+ * Return value
+ * <0 error
+ * 0 ok
+ * >0 break
+ */
+static int generate_input_data(struct pcm_container *sndpcm, int bytes,
+ struct bat *bat)
+{
+ int err;
+ static int load;
+ int frames = bytes * 8 / sndpcm->frame_bits;
+
+ if (bat->playback.file != NULL) {
+ /* From input file */
+ load = 0;
+
+ while (1) {
+ err = fread(sndpcm->buffer + load, 1,
+ bytes - load, bat->fp);
+ if (0 == err) {
+ if (feof(bat->fp)) {
+ fprintf(bat->log,
+ _("End of playing.\n"));
+ return 1;
+ }
+ } else if (err < bytes - load) {
+ if (ferror(bat->fp)) {
+ fprintf(bat->err, _("Read file error"));
+ fprintf(bat->err, _(": %d\n"), err);
+ return -EIO;
+ }
+ load += err;
+ } else {
+ break;
+ }
+ }
+ } else {
+ /* Generate sine wave */
+ if ((bat->sinus_duration) && (load > bat->sinus_duration))
+ return 1;
+
+ err = generate_sine_wave(bat, frames, (void *)sndpcm->buffer);
+ if (err != 0)
+ return err;
+
+ load += frames;
+ }
+
+ 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);
+ 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;
+}
+
+static int write_to_pcm_loop(struct pcm_container *sndpcm, struct bat *bat)
+{
+ int err;
+ int bytes = sndpcm->period_bytes; /* playback buffer size */
+ int frames = bytes * 8 / sndpcm->frame_bits; /* frame count */
+ FILE *fp = NULL;
+ struct wav_container wav;
+ int bytes_total = 0;
+
+ if (bat->debugplay) {
+ fp = fopen(bat->debugplay, "wb");
+ if (fp == NULL) {
+ fprintf(bat->err, _("Cannot open file for capture: "));
+ fprintf(bat->err, _("%s %d\n"), bat->debugplay, -errno);
+ return -errno;
+ }
+ /* leave space for wav header */
+ err = fseek(fp, sizeof(wav), SEEK_SET);
+ if (err != 0) {
+ fprintf(bat->err, _("Seek file error: %d %d\n"),
+ err, -errno);
+ return -errno;
+ }
+ }
+
+ while (1) {
+ err = generate_input_data(sndpcm, bytes, bat);
+ if (err < 0)
+ return err;
+ else if (err > 0)
+ break;
+
+ if (bat->debugplay) {
+ err = fwrite(sndpcm->buffer, 1, bytes, fp);
+ if (err != bytes) {
+ fprintf(bat->err, _("Write file error: "));
+ fprintf(bat->err, _("%s(%d)\n"),
+ snd_strerror(err), err);
+ return -EIO;
+ }
+ 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)
+ return err;
+ }
+
+ if (bat->debugplay) {
+ /* update wav header */
+ prepare_wav_info(&wav, bat);
+ wav.chunk.length = bytes_total;
+ wav.header.length = (wav.chunk.length) + sizeof(wav.chunk)
+ + sizeof(wav.format) + sizeof(wav.header) - 8;
+
+ rewind(fp);
+ err = write_wav_header(fp, &wav, bat);
+ if (err != 0) {
+ fprintf(bat->err, _("Write file error: %s %s(%d)\n"),
+ bat->debugplay, snd_strerror(err), err);
+ return err;
+ }
+ fclose(fp);
+ }
+
+ snd_pcm_drain(sndpcm->handle);
+
+ return 0;
+}
+
+/**
+ * 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));
+
+ if (bat->playback.device == NULL) {
+ fprintf(bat->err, _("No PCM device for playback: exit\n"));
+ retval_play = 1;
+ goto exit1;
+ }
+
+ 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 = 1;
+ goto exit1;
+ }
+
+ err = set_snd_pcm_params(bat, &sndpcm);
+ if (err != 0) {
+ retval_play = 1;
+ 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");
+ if (bat->fp == NULL) {
+ fprintf(bat->err, _("Cannot open file for capture: "));
+ fprintf(bat->err, _("%s %d\n"),
+ bat->playback.file, -errno);
+ retval_play = 1;
+ goto exit3;
+ }
+ /* Skip header */
+ err = read_wav_header(bat, bat->playback.file, bat->fp, true);
+ if (err != 0) {
+ retval_play = 1;
+ goto exit4;
+ }
+ }
+
+ err = write_to_pcm_loop(&sndpcm, bat);
+ if (err != 0) {
+ retval_play = 1;
+ 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);
+ } 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(FILE *fp, int count,
+ struct pcm_container *sndpcm, struct bat *bat)
+{
+ int err = 0;
+ int size, frames;
+ int remain = count;
+
+ 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)
+ return err;
+
+ /* write the chunk to file */
+ err = fwrite(sndpcm->buffer, 1, size, fp);
+ if (err != size) {
+ fprintf(bat->err, _("Write file error: %s(%d)\n"),
+ snd_strerror(err), err);
+ return -EIO;
+ }
+ remain -= size;
+ bat->periods_played++;
+
+ if (bat->period_is_limited
+ && bat->periods_played >= bat->periods_total)
+ break;
+ }
+
+ return 0;
+}
+
+static void pcm_cleanup(void *p)
+{
+ snd_pcm_close(p);
+}
+
+static void file_cleanup(void *p)
+{
+ fclose(p);
+}
+
+/**
+ * Record
+ */
+void *record_alsa(struct bat *bat)
+{
+ int err = 0;
+ FILE *fp = NULL;
+ struct pcm_container sndpcm;
+ struct wav_container wav;
+ int count;
+
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+
+ fprintf(bat->log, _("Entering capture thread (ALSA).\n"));
+
+ retval_record = 0;
+ memset(&sndpcm, 0, sizeof(sndpcm));
+
+ if (bat->capture.device == NULL) {
+ fprintf(bat->err, _("No PCM device for capture: exit\n"));
+ retval_record = 1;
+ goto exit1;
+ }
+
+ 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 = 1;
+ goto exit1;
+ }
+
+ err = set_snd_pcm_params(bat, &sndpcm);
+ if (err != 0) {
+ retval_record = 1;
+ goto exit2;
+ }
+
+ remove(bat->capture.file);
+ fp = fopen(bat->capture.file, "w+");
+ if (fp == NULL) {
+ fprintf(bat->err, _("Cannot open file for capture: %s %d\n"),
+ bat->capture.file, -errno);
+ retval_record = 1;
+ goto exit3;
+ }
+
+ prepare_wav_info(&wav, bat);
+
+ 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);
+ pthread_cleanup_push(file_cleanup, fp);
+
+ err = write_wav_header(fp, &wav, bat);
+ if (err != 0) {
+ retval_record = 1;
+ goto exit4;
+ }
+
+ count = wav.chunk.length;
+ fprintf(bat->log, _("Recording ...\n"));
+ err = read_from_pcm_loop(fp, count, &sndpcm, bat);
+ if (err != 0) {
+ retval_record = 1;
+ goto exit4;
+ }
+
+ /* Normally we will never reach this part of code (before fail_exit) as
+ this thread will be cancelled by end of play thread. */
+ pthread_cleanup_pop(0);
+ pthread_cleanup_pop(0);
+ pthread_cleanup_pop(0);
+
+ snd_pcm_drain(sndpcm.handle);
+
+exit4:
+ fclose(fp);
+exit3:
+ free(sndpcm.buffer);
+exit2:
+ snd_pcm_close(sndpcm.handle);
+exit1:
+ pthread_exit(&retval_record);
+}
new file mode 100644
@@ -0,0 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
+extern int retval_play;
+extern int retval_record;
+
+void *playback_alsa(struct bat *);
+void *record_alsa(struct bat *);
new file mode 100644
@@ -0,0 +1,159 @@
+.TH ALSABAT 1 "20th October 2015"
+.SH NAME
+alsabat \- command\-line sound tester for ALSA sound card driver
+
+.SH SYNOPSIS
+\fBalsabat\fP [\fIflags\fP]
+
+.SH DESCRIPTION
+\fBALSABAT(ALSA Basic Audio Tester)\fP is a simple command\-line utility
+intended to help automate audio driver and sound server testing with little
+human interaction. ALSABAT can be used to test audio quality, stress test
+features and test audio before and after PM state changes.
+
+ALSABAT's design is relatively simple. ALSABAT plays an audio stream and
+captures the same stream in either a digital or analog loop back. It then
+compares the captured stream using a FFT to the original to determine if
+the test case passes or fails.
+
+ALSABAT can either run wholly on the target machine being tested (standalone
+mode) or can run as a client/server mode where by bat client runs on the
+target and runs as a server on a separate tester machine. The client/server
+mode still requires some manual interaction for synchronization, but this
+is actively being developed for future releases.
+
+The hardware testing configuration may require the use of an analog cable
+connecting target to tester machines or a cable to create an analog
+loopback if no loopback mode is not available on the sound hardware that
+is being tested.
+An analog loopback cable can be used to connect the "line in" to "line out"
+jacks to create a loopback. If only headphone and mic jacks (or combo jack)
+are available then the following simple circuit can be used to create an
+analog loopback :-
+
+https://source.android.com/devices/audio/loopback.html
+
+.SH OPTIONS
+.TP
+\fI\-h, \-\-help\fP
+Help: show syntax.
+.TP
+\fI\-D\fP
+Select sound card to be tested by name.
+.TP
+\fI\-P\fP
+Select the playback PCM device.
+.TP
+\fI\-C\fP
+Select the capture PCM device.
+.TP
+\fI\-f\fP
+Sample format
+.br
+Recognized sample formats are: U8 S16_LE S24_3LE S32_LE
+.br
+Some of these may not be available on selected hardware
+.br
+The available format shortcuts are:
+.nf
+\-f cd (16 bit little endian, 44100, stereo) [\-f S16_LE \-c2 \-r44100]
+\-f dat (16 bit little endian, 48000, stereo) [\-f S16_LE \-c2 \-r48000]
+.fi
+If no format is given S16_LE is used.
+.TP
+\fI\-c\fP
+The number of channels. The default is one channel.
+Valid values at the moment are 1 or 2.
+.TP
+\fI\-r\fP
+Sampling rate in Hertz. The default rate is 44100 Hertz.
+Valid values depends on hardware support.
+.TP
+\fI\-n\fP
+Duration of generated signal.
+The value could be either of the two forms:
+.br
+1. Decimal integer, means number of frames;
+.br
+2. Floating point with suffix 's', means number of seconds.
+.br
+The default is 2 seconds.
+.TP
+\fI\-k\fP
+Sigma k value for analysis.
+.br
+The analysis function reads data from WAV file, run FFT against the data
+to get magnitude of frequency vectors, and then calculates the average
+value and standard deviation of frequency vectors. After that, we define
+a threshold:
+.br
+threshold = k * standard_deviation + mean_value
+.br
+Frequencies with amplitude larger than threshold will be recognized as a
+peak, and the frequency with largest peak value will be recognized as a
+detected frequency.
+.br
+ALSABAT then compares the detected frequency to target frequency, to decide
+if the detecting passes or fails.
+.br
+The default value is 3.0.
+.TP
+\fI\-F\fP
+Target frequency for signal generation and analysis, in Hertz.
+The default is 997.0 Hertz.
+Valid range is (DC_THRESHOLD, 40% * Sampling rate).
+.TP
+\fI\-p\fP
+Total number of periods to play or capture.
+.TP
+\fI\-\-log=#\fP
+Write stderr and stdout output to this log file.
+.TP
+\fI\-\-file=#\fP
+Input WAV file for playback.
+.TP
+\fI\-\-saveplay=#\fP
+Target WAV file to save capture test content.
+.TP
+\fI\-\-local\fP
+Internal loopback mode.
+Playback, capture and analysis internal to ALSABAT only. This is intended for
+developers to test new ALSABAT features as no audio is routed outside of
+ALSABAT.
+
+.SH EXAMPLES
+
+.TP
+\fBbat \-P plughw:0,0 \-C plughw:0,0 \-c 2 \-f S32_LE \-F 250\fR
+Generate and play a sine wave of 250 Hertz with 2 channel and S32_LE format,
+and then capture and analyze.
+
+.TP
+\fBbat \-P plughw:0,0 \-C plughw:0,0 \-\-file 500Hz.wav\fR
+Play the RIFF WAV file "500Hz.wav" which contains 500 Hertz waveform LPCM
+data, and then capture and analyze.
+
+.SH RETURN VALUE
+.br
+On success, returns 0.
+.br
+If no peak be detected, returns -1001;
+.br
+If only DC be detected, returns -1002;
+.br
+If peak frequency does not match with the target frequency, returns -1003.
+
+.SH SEE ALSO
+\fB
+aplay(1)
+\fP
+
+.SH BUGS
+Currently only support RIFF WAV format with PCM data. Please report any bugs to
+the alsa-devel mailing list.
+
+.SH AUTHOR
+\fBbat\fP is by Liam Girdwood <liam.r.girdwood@linux.intel.com>, Bernard Gautier
+<bernard.gautier@intel.com> and Han Lu <han.lu@intel.com>.
+This document is by Liam Girdwood <liam.r.girdwood@linux.intel.com> and Han Lu
+<han.lu@intel.com>.
new file mode 100644
@@ -0,0 +1,610 @@
+/*
+ * 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 <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+#include <getopt.h>
+#include <math.h>
+#include <limits.h>
+#include <locale.h>
+
+#include "aconfig.h"
+#include "gettext.h"
+#include "version.h"
+
+#include "common.h"
+
+#include "alsa.h"
+#include "convert.h"
+#include "analyze.h"
+
+static int get_duration(struct bat *bat)
+{
+ float duration_f;
+ long duration_i;
+ char *ptrf, *ptri;
+
+ duration_f = strtof(bat->narg, &ptrf);
+ if (duration_f == HUGE_VALF || duration_f == -HUGE_VALF
+ || (duration_f == 0.0 && errno != 0))
+ goto err_exit;
+
+ duration_i = strtol(bat->narg, &ptri, 10);
+ if (duration_i == LONG_MAX || duration_i == LONG_MIN)
+ goto err_exit;
+
+ if (*ptrf == 's')
+ bat->frames = duration_f * bat->rate;
+ else if (*ptri == 0)
+ bat->frames = duration_i;
+ else
+ bat->frames = -1;
+
+ if (bat->frames <= 0 || bat->frames > MAX_FRAMES) {
+ fprintf(bat->err, _("Invalid duration. Range: (0, %d(%fs))\n"),
+ MAX_FRAMES, (double)MAX_FRAMES / bat->rate);
+ return -EINVAL;
+ }
+
+ return 0;
+
+err_exit:
+ fprintf(bat->err, _("Duration overflow/underflow: %d\n"), -errno);
+
+ return -errno;
+}
+
+static void get_sine_frequencies(struct bat *bat, char *freq)
+{
+ char *tmp1;
+
+ tmp1 = strchr(freq, ':');
+ if (tmp1 == NULL) {
+ bat->target_freq[1] = bat->target_freq[0] = atof(optarg);
+ } else {
+ *tmp1 = '\0';
+ bat->target_freq[0] = atof(optarg);
+ bat->target_freq[1] = atof(tmp1 + 1);
+ }
+}
+
+static void get_format(struct bat *bat, char *optarg)
+{
+ if (strcasecmp(optarg, "cd") == 0) {
+ bat->format = SND_PCM_FORMAT_S16_LE;
+ bat->rate = 44100;
+ bat->channels = 2;
+ } else if (strcasecmp(optarg, "dat") == 0) {
+ bat->format = SND_PCM_FORMAT_S16_LE;
+ bat->rate = 48000;
+ bat->channels = 2;
+ } else {
+ bat->format = snd_pcm_format_value(optarg);
+ if (bat->format == SND_PCM_FORMAT_UNKNOWN) {
+ fprintf(bat->err, _("wrong extended format '%s'\n"),
+ optarg);
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ switch (bat->format) {
+ case SND_PCM_FORMAT_U8:
+ bat->sample_size = 1;
+ break;
+ case SND_PCM_FORMAT_S16_LE:
+ bat->sample_size = 2;
+ break;
+ case SND_PCM_FORMAT_S24_3LE:
+ bat->sample_size = 3;
+ break;
+ case SND_PCM_FORMAT_S32_LE:
+ bat->sample_size = 4;
+ break;
+ default:
+ fprintf(bat->err, _("unsupported format: %d\n"), bat->format);
+ exit(EXIT_FAILURE);
+ }
+}
+
+static inline int thread_wait_completion(struct bat *bat,
+ pthread_t id, int **val)
+{
+ int err;
+
+ err = pthread_join(id, (void **) val);
+ if (err)
+ pthread_cancel(id);
+
+ return err;
+}
+
+/* loopback test where we play sine wave and capture the same sine wave */
+static void test_loopback(struct bat *bat)
+{
+ pthread_t capture_id, playback_id;
+ int err;
+ int *thread_result_capture, *thread_result_playback;
+
+ /* start playback */
+ err = pthread_create(&playback_id, NULL,
+ (void *) bat->playback.fct, bat);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot create playback thread: %d\n"),
+ err);
+ exit(EXIT_FAILURE);
+ }
+
+ /* TODO: use a pipe to signal stream start etc - i.e. to sync threads */
+ /* Let some time for playing something before capturing */
+ usleep(CAPTURE_DELAY * 1000);
+
+ /* start capture */
+ err = pthread_create(&capture_id, NULL, (void *) bat->capture.fct, bat);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot create capture thread: %d\n"), err);
+ pthread_cancel(playback_id);
+ exit(EXIT_FAILURE);
+ }
+
+ /* wait for playback to complete */
+ err = thread_wait_completion(bat, playback_id, &thread_result_playback);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot join playback thread: %d\n"), err);
+ free(thread_result_playback);
+ pthread_cancel(capture_id);
+ exit(EXIT_FAILURE);
+ }
+
+ /* check playback status */
+ if (*thread_result_playback != 0) {
+ fprintf(bat->err, _("Exit playback thread fail: %d\n"),
+ *thread_result_playback);
+ pthread_cancel(capture_id);
+ exit(EXIT_FAILURE);
+ } else {
+ fprintf(bat->log, _("Playback completed.\n"));
+ }
+
+ /* now stop and wait for capture to finish */
+ pthread_cancel(capture_id);
+ err = thread_wait_completion(bat, capture_id, &thread_result_capture);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot join capture thread: %d\n"), err);
+ free(thread_result_capture);
+ exit(EXIT_FAILURE);
+ }
+
+ /* check capture status */
+ if (*thread_result_capture != 0) {
+ fprintf(bat->err, _("Exit capture thread fail: %d\n"),
+ *thread_result_capture);
+ exit(EXIT_FAILURE);
+ } else {
+ fprintf(bat->log, _("Capture completed.\n"));
+ }
+}
+
+/* single ended playback only test */
+static void test_playback(struct bat *bat)
+{
+ pthread_t playback_id;
+ int err;
+ int *thread_result;
+
+ /* start playback */
+ err = pthread_create(&playback_id, NULL,
+ (void *) bat->playback.fct, bat);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot create playback thread: %d\n"),
+ err);
+ exit(EXIT_FAILURE);
+ }
+
+ /* wait for playback to complete */
+ err = thread_wait_completion(bat, playback_id, &thread_result);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot join playback thread: %d\n"), err);
+ free(thread_result);
+ exit(EXIT_FAILURE);
+ }
+
+ /* check playback status */
+ if (*thread_result != 0) {
+ fprintf(bat->err, _("Exit playback thread fail: %d\n"),
+ *thread_result);
+ exit(EXIT_FAILURE);
+ } else {
+ fprintf(bat->log, _("Playback completed.\n"));
+ }
+}
+
+/* single ended capture only test */
+static void test_capture(struct bat *bat)
+{
+ pthread_t capture_id;
+ int err;
+ int *thread_result;
+
+ /* start capture */
+ err = pthread_create(&capture_id, NULL, (void *) bat->capture.fct, bat);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot create capture thread: %d\n"), err);
+ exit(EXIT_FAILURE);
+ }
+
+ /* TODO: stop capture */
+
+ /* wait for capture to complete */
+ err = thread_wait_completion(bat, capture_id, &thread_result);
+ if (err != 0) {
+ fprintf(bat->err, _("Cannot join capture thread: %d\n"), err);
+ free(thread_result);
+ exit(EXIT_FAILURE);
+ }
+
+ /* check playback status */
+ if (*thread_result != 0) {
+ fprintf(bat->err, _("Exit capture thread fail: %d\n"),
+ *thread_result);
+ exit(EXIT_FAILURE);
+ } else {
+ fprintf(bat->log, _("Capture completed.\n"));
+ }
+}
+
+static void usage(struct bat *bat)
+{
+ fprintf(bat->log,
+_("Usage: alsabat [-options]...\n"
+"\n"
+" -h, --help this help\n"
+" -D pcm device for both playback and capture\n"
+" -P pcm device for playback\n"
+" -C pcm device for capture\n"
+" -f sample format\n"
+" -c number of channels\n"
+" -r sampling rate\n"
+" -n frames to playback or capture\n"
+" -k parameter for frequency detecting threshold\n"
+" -F target frequency\n"
+" -p total number of periods to play/capture\n"
+" --log=# file that both stdout and strerr redirecting to\n"
+" --file=# file for playback\n"
+" --saveplay=# file that storing playback content, for debug\n"
+" --local internal loop, set to bypass pcm hardware devices\n"
+));
+ fprintf(bat->log, _("Recognized sample formats are: %s %s %s %s\n"),
+ snd_pcm_format_name(SND_PCM_FORMAT_U8),
+ snd_pcm_format_name(SND_PCM_FORMAT_S16_LE),
+ snd_pcm_format_name(SND_PCM_FORMAT_S24_3LE),
+ snd_pcm_format_name(SND_PCM_FORMAT_S32_LE));
+ fprintf(bat->log, _("The available format shotcuts are:\n"));
+ fprintf(bat->log, _("-f cd (16 bit little endian, 44100, stereo)\n"));
+ fprintf(bat->log, _("-f dat (16 bit little endian, 48000, stereo)\n"));
+}
+
+static void set_defaults(struct bat *bat)
+{
+ memset(bat, 0, sizeof(struct bat));
+
+ /* Set default values */
+ bat->rate = 44100;
+ bat->channels = 1;
+ bat->frame_size = 2;
+ bat->sample_size = 2;
+ bat->format = SND_PCM_FORMAT_S16_LE;
+ bat->convert_float_to_sample = convert_float_to_int16;
+ bat->convert_sample_to_double = convert_int16_to_double;
+ bat->frames = bat->rate * 2;
+ bat->target_freq[0] = 997.0;
+ bat->target_freq[1] = 997.0;
+ bat->sigma_k = 3.0;
+ bat->playback.device = NULL;
+ bat->capture.device = NULL;
+ bat->buf = NULL;
+ bat->local = false;
+ bat->playback.fct = &playback_alsa;
+ bat->capture.fct = &record_alsa;
+ bat->playback.mode = MODE_LOOPBACK;
+ bat->capture.mode = MODE_LOOPBACK;
+ bat->period_is_limited = false;
+ bat->log = stdout;
+ bat->err = stderr;
+}
+
+static void parse_arguments(struct bat *bat, int argc, char *argv[])
+{
+ int c, option_index;
+ static const char short_options[] = "D:P:C:f:n:F:c:r:s:k:p:lth";
+ static const struct option long_options[] = {
+ {"help", 0, 0, 'h'},
+ {"log", 1, 0, OPT_LOG},
+ {"file", 1, 0, OPT_READFILE},
+ {"saveplay", 1, 0, OPT_SAVEPLAY},
+ {"local", 0, 0, OPT_LOCAL},
+ {0, 0, 0, 0}
+ };
+
+ while ((c = getopt_long(argc, argv, short_options, long_options,
+ &option_index)) != -1) {
+ switch (c) {
+ case OPT_LOG:
+ bat->logarg = optarg;
+ break;
+ case OPT_READFILE:
+ bat->playback.file = optarg;
+ break;
+ case OPT_SAVEPLAY:
+ bat->debugplay = optarg;
+ break;
+ case OPT_LOCAL:
+ bat->local = true;
+ break;
+ case 'D':
+ if (bat->playback.device == NULL)
+ bat->playback.device = optarg;
+ if (bat->capture.device == NULL)
+ bat->capture.device = optarg;
+ break;
+ case 'P':
+ if (bat->capture.mode == MODE_SINGLE)
+ bat->capture.mode = MODE_LOOPBACK;
+ else
+ bat->playback.mode = MODE_SINGLE;
+ bat->playback.device = optarg;
+ break;
+ case 'C':
+ if (bat->playback.mode == MODE_SINGLE)
+ bat->playback.mode = MODE_LOOPBACK;
+ else
+ bat->capture.mode = MODE_SINGLE;
+ bat->capture.device = optarg;
+ break;
+ case 'n':
+ bat->narg = optarg;
+ break;
+ case 'F':
+ get_sine_frequencies(bat, optarg);
+ break;
+ case 'c':
+ bat->channels = atoi(optarg);
+ break;
+ case 'r':
+ bat->rate = atoi(optarg);
+ break;
+ case 'f':
+ get_format(bat, optarg);
+ break;
+ case 'k':
+ bat->sigma_k = atof(optarg);
+ break;
+ case 'p':
+ bat->periods_total = atoi(optarg);
+ bat->period_is_limited = true;
+ break;
+ case 'h':
+ default:
+ usage(bat);
+ exit(EXIT_SUCCESS);
+ }
+ }
+}
+
+static int validate_options(struct bat *bat)
+{
+ int c;
+ float freq_low, freq_high;
+
+ /* check if we have an input file for local mode */
+ if ((bat->local == true) && (bat->capture.file == NULL)) {
+ fprintf(bat->err, _("no input file for local testing\n"));
+ return -EINVAL;
+ }
+
+ /* check supported channels */
+ if (bat->channels > MAX_CHANNELS || bat->channels < MIN_CHANNELS) {
+ fprintf(bat->err, _("%d channels not supported\n"),
+ bat->channels);
+ return -EINVAL;
+ }
+
+ /* check single ended is in either playback or capture - not both */
+ if ((bat->playback.mode == MODE_SINGLE)
+ && (bat->capture.mode == MODE_SINGLE)) {
+ fprintf(bat->err, _("single ended mode is simplex\n"));
+ return -EINVAL;
+ }
+
+ /* check sine wave frequency range */
+ freq_low = DC_THRESHOLD;
+ freq_high = bat->rate * RATE_FACTOR;
+ for (c = 0; c < bat->channels; c++) {
+ if (bat->target_freq[c] < freq_low
+ || bat->target_freq[c] > freq_high) {
+ fprintf(bat->err, _("sine wave frequency out of"));
+ fprintf(bat->err, _(" range: (%.1f, %.1f)\n"),
+ freq_low, freq_high);
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+}
+
+static int bat_init(struct bat *bat)
+{
+ int err = 0;
+ char name[] = TEMP_RECORD_FILE_NAME;
+
+ /* Determine logging to a file or stdout and stderr */
+ if (bat->logarg) {
+ bat->log = NULL;
+ bat->log = fopen(bat->logarg, "wb");
+ if (bat->log == NULL) {
+ fprintf(bat->err, _("Cannot open file for capture:"));
+ fprintf(bat->err, _(" %s %d\n"),
+ bat->logarg, -errno);
+ return -errno;
+ }
+ bat->err = bat->log;
+ }
+
+ /* Determine duration of playback and/or capture */
+ if (bat->narg) {
+ err = get_duration(bat);
+ if (err < 0)
+ return err;
+ }
+
+ /* Determine capture file */
+ if (bat->local) {
+ bat->capture.file = bat->playback.file;
+ } else {
+ /* create temp file for sound record and analysis */
+ err = mkstemp(name);
+ if (err == -1) {
+ fprintf(bat->err, _("Fail to create record file: %d\n"),
+ -errno);
+ return -errno;
+ }
+ /* store file name which is dynamically created */
+ bat->capture.file = strdup(name);
+ if (bat->capture.file == NULL)
+ return -errno;
+ /* close temp file */
+ close(err);
+ }
+
+ /* Initial for playback */
+ if (bat->playback.file == NULL) {
+ /* No input file so we will generate our own sine wave */
+ if (bat->frames) {
+ if (bat->playback.mode == MODE_SINGLE) {
+ /* Play nb of frames given by -n argument */
+ bat->sinus_duration = bat->frames;
+ } else {
+ /* Play CAPTURE_DELAY msec +
+ * 150% of the nb of frames to be analyzed */
+ bat->sinus_duration = bat->rate *
+ CAPTURE_DELAY / 1000;
+ bat->sinus_duration +=
+ (bat->frames + bat->frames / 2);
+ }
+ } else {
+ /* Special case where we want to generate a sine wave
+ * endlessly without capturing */
+ bat->sinus_duration = 0;
+ bat->playback.mode = MODE_SINGLE;
+ }
+ } else {
+ bat->fp = fopen(bat->playback.file, "rb");
+ if (bat->fp == NULL) {
+ fprintf(bat->err, _("Cannot open file for playback:"));
+ fprintf(bat->err, _(" %s %d\n"),
+ bat->playback.file, -errno);
+ return -errno;
+ }
+ err = read_wav_header(bat, bat->playback.file, bat->fp, false);
+ fclose(bat->fp);
+ if (err != 0)
+ return err;
+ }
+
+ bat->frame_size = bat->sample_size * bat->channels;
+
+ /* Set conversion functions */
+ switch (bat->sample_size) {
+ case 1:
+ bat->convert_float_to_sample = convert_float_to_uint8;
+ bat->convert_sample_to_double = convert_uint8_to_double;
+ break;
+ case 2:
+ bat->convert_float_to_sample = convert_float_to_int16;
+ bat->convert_sample_to_double = convert_int16_to_double;
+ break;
+ case 3:
+ bat->convert_float_to_sample = convert_float_to_int24;
+ bat->convert_sample_to_double = convert_int24_to_double;
+ break;
+ case 4:
+ bat->convert_float_to_sample = convert_float_to_int32;
+ bat->convert_sample_to_double = convert_int32_to_double;
+ break;
+ default:
+ fprintf(bat->err, _("Invalid PCM format: size=%d\n"),
+ bat->sample_size);
+ return -EINVAL;
+ }
+
+ return err;
+}
+
+int main(int argc, char *argv[])
+{
+ struct bat bat;
+ int err = 0;
+
+ set_defaults(&bat);
+
+#ifdef ENABLE_NLS
+ setlocale(LC_ALL, "");
+ textdomain(PACKAGE);
+#endif
+
+ fprintf(bat.log, _("%s version %s\n\n"), PACKAGE_NAME, PACKAGE_VERSION);
+
+ parse_arguments(&bat, argc, argv);
+
+ err = bat_init(&bat);
+ if (err < 0)
+ goto out;
+
+ err = validate_options(&bat);
+ if (err < 0)
+ goto out;
+
+ /* single line playback thread: playback only, no capture */
+ if (bat.playback.mode == MODE_SINGLE) {
+ test_playback(&bat);
+ goto out;
+ }
+
+ /* single line capture thread: capture only, no playback */
+ if (bat.capture.mode == MODE_SINGLE) {
+ test_capture(&bat);
+ goto analyze;
+ }
+
+ /* loopback thread: playback and capture in a loop */
+ if (bat.local == false)
+ test_loopback(&bat);
+
+analyze:
+ err = analyze_capture(&bat);
+out:
+ fprintf(bat.log, _("\nReturn value is %d\n"), err);
+
+ if (bat.logarg)
+ fclose(bat.log);
+ if (!bat.local)
+ free(bat.capture.file);
+
+ return err;
+}
new file mode 100644
@@ -0,0 +1,314 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <math.h>
+#include <fftw3.h>
+
+#include "aconfig.h"
+#include "gettext.h"
+
+#include "common.h"
+
+static void check_amplitude(struct bat *bat, double *buf)
+{
+ double sum, average, amplitude;
+ int i, percent;
+
+ /* calculate average value */
+ for (i = 0, sum = 0.0; i < bat->frames; i++)
+ sum += buf[i];
+ average = sum / bat->frames;
+
+ /* calculate peak-to-average amplitude */
+ for (i = 0, sum = 0.0; i < bat->frames; i++)
+ sum += abs(buf[i] - average);
+ amplitude = sum / bat->frames * M_PI / 2.0;
+
+ /* calculate amplitude percentage against full range */
+ percent = amplitude * 100 / ((1 << ((bat->sample_size << 3) - 1)) - 1);
+
+ fprintf(bat->log, _("Amplitude: %.1f; Percentage: [%d]\n"),
+ amplitude, percent);
+ if (percent < 0)
+ fprintf(bat->err, _("ERROR: Amplitude can't be negative!\n"));
+ else if (percent < 1)
+ fprintf(bat->err, _("WARNING: Signal too weak!\n"));
+ else if (percent > 100)
+ fprintf(bat->err, _("WARNING: Signal overflow!\n"));
+}
+
+/**
+ *
+ * @return 0 if peak detected at right frequency,
+ * 1 if peak detected somewhere else
+ * 2 if DC detected
+ */
+int check_peak(struct bat *bat, struct analyze *a, int end, int peak, float hz,
+ float mean, float p, int channel, int start)
+{
+ int err;
+ float hz_peak = (float) (peak) * hz;
+ float delta_rate = DELTA_RATE * bat->target_freq[channel];
+ float delta_HZ = DELTA_HZ;
+ float tolerance = (delta_rate > delta_HZ) ? delta_rate : delta_HZ;
+
+ fprintf(bat->log, _("Detected peak at %2.2f Hz of %2.2f dB\n"), hz_peak,
+ 10.0 * log10(a->mag[peak] / mean));
+ fprintf(bat->log, _(" Total %3.1f dB from %2.2f to %2.2f Hz\n"),
+ 10.0 * log10(p / mean), start * hz, end * hz);
+
+ if (hz_peak < DC_THRESHOLD) {
+ fprintf(bat->err, _(" WARNING: Found low peak %2.2f Hz,"),
+ hz_peak);
+ fprintf(bat->err, _(" very close to DC\n"));
+ err = FOUND_DC;
+ } else if (hz_peak < bat->target_freq[channel] - tolerance) {
+ fprintf(bat->err, _(" FAIL: Peak freq too low %2.2f Hz\n"),
+ hz_peak);
+ err = FOUND_WRONG_PEAK;
+ } else if (hz_peak > bat->target_freq[channel] + tolerance) {
+ fprintf(bat->err, _(" FAIL: Peak freq too high %2.2f Hz\n"),
+ hz_peak);
+ err = FOUND_WRONG_PEAK;
+ } else {
+ fprintf(bat->log, _(" PASS: Peak detected"));
+ fprintf(bat->log, _(" at target frequency\n"));
+ err = 0;
+ }
+
+ return err;
+}
+
+/**
+ * Search for main frequencies in fft results and compare it to target
+ */
+static int check(struct bat *bat, struct analyze *a, int channel)
+{
+ float hz = 1.0 / ((float) bat->frames / (float) bat->rate);
+ float mean = 0.0, t, sigma = 0.0, p = 0.0;
+ int i, start = -1, end = -1, peak = 0, signals = 0;
+ int err = 0, N = bat->frames / 2;
+
+ /* calculate mean */
+ for (i = 0; i < N; i++)
+ mean += a->mag[i];
+ mean /= (float) N;
+
+ /* calculate standard deviation */
+ for (i = 0; i < N; i++) {
+ t = a->mag[i] - mean;
+ t *= t;
+ sigma += t;
+ }
+ sigma /= (float) N;
+ sigma = sqrtf(sigma);
+
+ /* clip any data less than k sigma + mean */
+ for (i = 0; i < N; i++) {
+ if (a->mag[i] > mean + bat->sigma_k * sigma) {
+
+ /* find peak start points */
+ if (start == -1) {
+ start = peak = end = i;
+ signals++;
+ } else {
+ if (a->mag[i] > a->mag[peak])
+ peak = i;
+ end = i;
+ }
+ p += a->mag[i];
+ } else if (start != -1) {
+ /* Check if peak is as expected */
+ err |= check_peak(bat, a, end, peak, hz, mean,
+ p, channel, start);
+ end = start = -1;
+ if (signals == MAX_PEAKS)
+ break;
+ }
+ }
+ if (signals == 0)
+ err = -ENOPEAK; /* No peak detected */
+ else if ((err == FOUND_DC) && (signals == 1))
+ err = -EONLYDC; /* Only DC detected */
+ else if ((err & FOUND_WRONG_PEAK) == FOUND_WRONG_PEAK)
+ err = -EBADPEAK; /* Bad peak detected */
+ else
+ err = 0; /* Correct peak detected */
+
+ fprintf(bat->log, _("Detected at least %d signal(s) in total\n"),
+ signals);
+
+ return err;
+}
+
+static void calc_magnitude(struct bat *bat, struct analyze *a, int N)
+{
+ double r2, i2;
+ int i;
+
+ for (i = 1; i < N / 2; i++) {
+ r2 = a->out[i] * a->out[i];
+ i2 = a->out[N - i] * a->out[N - i];
+
+ a->mag[i] = sqrtf(r2 + i2);
+ }
+ a->mag[0] = 0.0;
+}
+
+static int find_and_check_harmonics(struct bat *bat, struct analyze *a,
+ int channel)
+{
+ fftw_plan p;
+ int err = -ENOMEM, N = bat->frames;
+
+ /* Allocate FFT buffers */
+ a->in = (double *) fftw_malloc(sizeof(double) * bat->frames);
+ if (a->in == NULL)
+ goto out1;
+
+ a->out = (double *) fftw_malloc(sizeof(double) * bat->frames);
+ if (a->out == NULL)
+ goto out2;
+
+ a->mag = (double *) fftw_malloc(sizeof(double) * bat->frames);
+ if (a->mag == NULL)
+ goto out3;
+
+ /* create FFT plan */
+ p = fftw_plan_r2r_1d(N, a->in, a->out, FFTW_R2HC,
+ FFTW_MEASURE | FFTW_PRESERVE_INPUT);
+ if (p == NULL)
+ goto out4;
+
+ /* convert source PCM to doubles */
+ bat->convert_sample_to_double(a->buf, a->in, bat->frames);
+
+ /* check amplitude */
+ check_amplitude(bat, a->in);
+
+ /* run FFT */
+ fftw_execute(p);
+
+ /* FFT out is real and imaginary numbers - calc magnitude for each */
+ calc_magnitude(bat, a, N);
+
+ /* check data */
+ err = check(bat, a, channel);
+
+ fftw_destroy_plan(p);
+
+out4:
+ fftw_free(a->mag);
+out3:
+ fftw_free(a->out);
+out2:
+ fftw_free(a->in);
+out1:
+ return err;
+}
+
+/**
+ * Convert interleaved samples from channels in samples from a single channel
+ */
+static int reorder_data(struct bat *bat)
+{
+ char *p, *new_bat_buf;
+ int ch, i, j;
+
+ if (bat->channels == 1)
+ return 0; /* No need for reordering */
+
+ p = malloc(bat->frames * bat->frame_size);
+ new_bat_buf = p;
+ if (p == NULL)
+ return -ENOMEM;
+
+ for (ch = 0; ch < bat->channels; ch++) {
+ for (j = 0; j < bat->frames; j++) {
+ for (i = 0; i < bat->sample_size; i++) {
+ *p++ = ((char *) (bat->buf))[j * bat->frame_size
+ + ch * bat->sample_size + i];
+ }
+ }
+ }
+
+ free(bat->buf);
+ bat->buf = new_bat_buf;
+
+ return 0;
+}
+
+int analyze_capture(struct bat *bat)
+{
+ int err = 0;
+ size_t items;
+ int c;
+ struct analyze a;
+
+ fprintf(bat->log, _("\nBAT analysis: signal has %d frames at %d Hz,"),
+ bat->frames, bat->rate);
+ fprintf(bat->log, _(" %d channels, %d bytes per sample.\n"),
+ bat->channels, bat->sample_size);
+
+ bat->buf = malloc(bat->frames * bat->frame_size);
+ if (bat->buf == NULL)
+ return -ENOMEM;
+
+ bat->fp = fopen(bat->capture.file, "rb");
+ if (bat->fp == NULL) {
+ fprintf(bat->err, _("Cannot open file for capture: %s %d\n"),
+ bat->capture.file, -errno);
+ err = -errno;
+ goto exit1;
+ }
+
+ /* Skip header */
+ err = read_wav_header(bat, bat->capture.file, bat->fp, true);
+ if (err != 0)
+ goto exit2;
+
+ items = fread(bat->buf, bat->frame_size, bat->frames, bat->fp);
+ if (items != bat->frames) {
+ err = -EIO;
+ goto exit2;
+ }
+
+ err = reorder_data(bat);
+ if (err != 0)
+ goto exit2;
+
+ for (c = 0; c < bat->channels; c++) {
+ fprintf(bat->log, _("\nChannel %i - "), c + 1);
+ fprintf(bat->log, _("Checking for target frequency %2.2f Hz\n"),
+ bat->target_freq[c]);
+ a.buf = bat->buf +
+ c * bat->frames * bat->frame_size
+ / bat->channels;
+ err = find_and_check_harmonics(bat, &a, c);
+ }
+
+exit2:
+ fclose(bat->fp);
+exit1:
+ free(bat->buf);
+
+ return err;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/*
+ * 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.
+ *
+ */
+
+int analyze_capture(struct bat *);
new file mode 100644
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2015 Caleb Crome
+ * 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.
+ *
+ */
+
+/*
+ * Here's a generic sine wave generator that will work indefinitely
+ * for any frequency.
+ *
+ * Note: the state & phasor are stored as doubles (and updated as
+ * doubles) because after a million samples the magnitude drifts a
+ * bit. If we really need floats, it can be done with periodic
+ * renormalization of the state_real+state_imag magnitudes.
+ */
+
+int sin_generator_init(struct sin_generator *, float, float, float);
+float sin_generator_next_sample(struct sin_generator *);
+void sin_generator_vfill(struct sin_generator *, float *, int);
+int generate_sine_wave(struct bat *, int, void *);
new file mode 100644
@@ -0,0 +1,198 @@
+/*
+ * 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 <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <errno.h>
+
+#include "aconfig.h"
+#include "gettext.h"
+
+#include "common.h"
+#include "alsa.h"
+
+int retval_play;
+int retval_record;
+
+/* update chunk_fmt data to bat */
+static int update_fmt_to_bat(struct bat *bat, struct chunk_fmt *fmt)
+{
+ bat->channels = fmt->channels;
+ bat->rate = fmt->sample_rate;
+ bat->sample_size = fmt->sample_length / 8;
+ if (bat->sample_size > 4) {
+ fprintf(bat->err, _("Invalid format: sample size=%d\n"),
+ bat->sample_size);
+ return -EINVAL;
+ }
+ bat->frame_size = fmt->blocks_align;
+
+ return 0;
+}
+
+/* calculate frames and update to bat */
+static int update_frames_to_bat(struct bat *bat,
+ struct wav_chunk_header *header, FILE *fp)
+{
+ /* The number of analyzed captured frames is arbitrarily set to half of
+ the number of frames of the wav file or the number of frames of the
+ wav file when doing direct analysis (--local) */
+ bat->frames = header->length / bat->frame_size;
+ if (!bat->local)
+ bat->frames /= 2;
+
+ return 0;
+}
+
+static int read_chunk_fmt(struct bat *bat, char *file, FILE *fp, bool skip,
+ struct wav_chunk_header *header)
+{
+ size_t err;
+ int header_skip;
+ struct chunk_fmt chunk_fmt;
+
+ err = fread(&chunk_fmt, sizeof(chunk_fmt), 1, fp);
+ if (err != 1) {
+ fprintf(bat->err, _("Read chunk fmt error: %s:%zd\n"),
+ file, err);
+ return -EIO;
+ }
+ /* If the format header is larger, skip the rest */
+ header_skip = header->length - sizeof(chunk_fmt);
+ if (header_skip > 0) {
+ err = fseek(fp, header_skip, SEEK_CUR);
+ if (err == -1) {
+ fprintf(bat->err, _("Seek fmt header error: %s:%zd\n"),
+ file, err);
+ return -EINVAL;
+ }
+ }
+ /* If the file is opened for playback, update BAT data;
+ If the file is opened for analysis, no update */
+ if (skip == false) {
+ err = update_fmt_to_bat(bat, &chunk_fmt);
+ if (err != 0)
+ return err;
+ }
+
+ return 0;
+}
+
+int read_wav_header(struct bat *bat, char *file, FILE *fp, bool skip)
+{
+ struct wav_header riff_wave_header;
+ struct wav_chunk_header chunk_header;
+ int more_chunks = 1;
+ size_t err;
+
+ /* Read header of RIFF wav file */
+ err = fread(&riff_wave_header, sizeof(riff_wave_header), 1, fp);
+ if (err != 1) {
+ fprintf(bat->err, _("Read header error: %s:%zd\n"), file, err);
+ return -EIO;
+ }
+ if ((riff_wave_header.magic != WAV_RIFF)
+ || (riff_wave_header.type != WAV_WAVE)) {
+ fprintf(bat->err, _("%s is not a riff/wave file\n"), file);
+ return -EINVAL;
+ }
+
+ /* Read chunks in RIFF wav file */
+ do {
+ err = fread(&chunk_header, sizeof(chunk_header), 1, fp);
+ if (err != 1) {
+ fprintf(bat->err, _("Read chunk header error: "));
+ fprintf(bat->err, _("%s:%zd\n"), file, err);
+ return -EIO;
+ }
+
+ switch (chunk_header.type) {
+ case WAV_FMT:
+ /* WAV_FMT chunk, read and analyze */
+ err = read_chunk_fmt(bat, file, fp, skip,
+ &chunk_header);
+ if (err != 0)
+ return err;
+ break;
+ case WAV_DATA:
+ /* WAV_DATA chunk, break looping */
+ /* If the file is opened for playback, update BAT data;
+ If the file is opened for analysis, no update */
+ if (skip == false) {
+ err = update_frames_to_bat(bat, &chunk_header,
+ fp);
+ if (err != 0)
+ return err;
+ }
+ /* Stop looking for chunks */
+ more_chunks = 0;
+ break;
+ default:
+ /* Unknown chunk, skip bytes */
+ err = fseek(fp, chunk_header.length, SEEK_CUR);
+ if (err == -1) {
+ fprintf(bat->err, _("Fail to skip unknown"));
+ fprintf(bat->err, _(" chunk of %s:%zd\n"),
+ file, err);
+ return -EINVAL;
+ }
+ }
+ } while (more_chunks);
+
+ return 0;
+}
+
+void prepare_wav_info(struct wav_container *wav, struct bat *bat)
+{
+ wav->header.magic = WAV_RIFF;
+ wav->header.type = WAV_WAVE;
+ wav->format.magic = WAV_FMT;
+ wav->format.fmt_size = 16;
+ wav->format.format = WAV_FORMAT_PCM;
+ wav->format.channels = bat->channels;
+ wav->format.sample_rate = bat->rate;
+ wav->format.sample_length = bat->sample_size * 8;
+ wav->format.blocks_align = bat->channels * bat->sample_size;
+ wav->format.bytes_p_second = wav->format.blocks_align * bat->rate;
+ wav->chunk.length = bat->frames * bat->frame_size;
+ wav->chunk.type = WAV_DATA;
+ wav->header.length = (wav->chunk.length) + sizeof(wav->chunk)
+ + sizeof(wav->format) + sizeof(wav->header) - 8;
+}
+
+int write_wav_header(FILE *fp, struct wav_container *wav, struct bat *bat)
+{
+ int err = 0;
+
+ err = fwrite(&wav->header, 1, sizeof(wav->header), fp);
+ if (err != sizeof(wav->header)) {
+ fprintf(bat->err, _("Write file error: header %d\n"), err);
+ return -EIO;
+ }
+ err = fwrite(&wav->format, 1, sizeof(wav->format), fp);
+ if (err != sizeof(wav->format)) {
+ fprintf(bat->err, _("Write file error: format %d\n"), err);
+ return -EIO;
+ }
+ err = fwrite(&wav->chunk, 1, sizeof(wav->chunk), fp);
+ if (err != sizeof(wav->chunk)) {
+ fprintf(bat->err, _("Write file error: chunk %d\n"), err);
+ return -EIO;
+ }
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,176 @@
+/*
+ * 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 <alsa/asoundlib.h>
+
+#define TEMP_RECORD_FILE_NAME "/tmp/bat.wav.XXXXXX"
+
+#define OPT_BASE 300
+#define OPT_LOG (OPT_BASE + 1)
+#define OPT_READFILE (OPT_BASE + 2)
+#define OPT_SAVEPLAY (OPT_BASE + 3)
+#define OPT_LOCAL (OPT_BASE + 4)
+
+#define COMPOSE(a, b, c, d) ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24))
+#define WAV_RIFF COMPOSE('R', 'I', 'F', 'F')
+#define WAV_WAVE COMPOSE('W', 'A', 'V', 'E')
+#define WAV_FMT COMPOSE('f', 'm', 't', ' ')
+#define WAV_DATA COMPOSE('d', 'a', 't', 'a')
+#define WAV_FORMAT_PCM 1 /* PCM WAVE file encoding */
+
+#define MAX_CHANNELS 2
+#define MIN_CHANNELS 1
+#define MAX_PEAKS 10
+#define MAX_FRAMES (10 * 1024 * 1024)
+/* Given in ms */
+#define CAPTURE_DELAY 500
+/* signal frequency should be less than samplerate * RATE_FACTOR */
+#define RATE_FACTOR 0.4
+/* valid range of samplerate: (1 - RATE_RANGE, 1 + RATE_RANGE) * samplerate */
+#define RATE_RANGE 0.05
+/* Given in us */
+#define MAX_BUFFERTIME 500000
+/* devide factor, was 4, changed to 8 to remove reduce capture overrun */
+#define DIV_BUFFERTIME 8
+/* margin to avoid sign inversion when generate sine wav */
+#define RANGE_FACTOR 0.95
+
+#define EBATBASE 1000
+#define ENOPEAK (EBATBASE + 1)
+#define EONLYDC (EBATBASE + 2)
+#define EBADPEAK (EBATBASE + 3)
+
+#define DC_THRESHOLD 7.01
+
+/* tolerance of detected peak = max (DELTA_HZ, DELTA_RATE * target_freq).
+ * If DELTA_RATE is too high, BAT may not be able to recognize negative result;
+ * if too low, BAT may be too sensitive and results in uncecessary failure. */
+#define DELTA_RATE 0.005
+#define DELTA_HZ 1
+
+#define FOUND_DC (1<<1)
+#define FOUND_WRONG_PEAK (1<<0)
+
+struct wav_header {
+ unsigned int magic; /* 'RIFF' */
+ unsigned int length; /* file len */
+ unsigned int type; /* 'WAVE' */
+};
+
+struct wav_chunk_header {
+ unsigned int type; /* 'data' */
+ unsigned int length; /* sample count */
+};
+
+struct wav_fmt {
+ unsigned int magic; /* 'FMT '*/
+ unsigned int fmt_size; /* 16 or 18 */
+ unsigned short format; /* see WAV_FMT_* */
+ unsigned short channels;
+ unsigned int sample_rate; /* Frequency of sample */
+ unsigned int bytes_p_second;
+ unsigned short blocks_align; /* sample size; 1 or 2 bytes */
+ unsigned short sample_length; /* 8, 12 or 16 bit */
+};
+
+struct chunk_fmt {
+ unsigned short format; /* see WAV_FMT_* */
+ unsigned short channels;
+ unsigned int sample_rate; /* Frequency of sample */
+ unsigned int bytes_p_second;
+ unsigned short blocks_align; /* sample size; 1 or 2 bytes */
+ unsigned short sample_length; /* 8, 12 or 16 bit */
+};
+
+struct wav_container {
+ struct wav_header header;
+ struct wav_fmt format;
+ struct wav_chunk_header chunk;
+};
+
+struct bat;
+
+enum _bat_op_mode {
+ MODE_UNKNOWN = -1,
+ MODE_SINGLE = 0,
+ MODE_LOOPBACK,
+ MODE_LAST
+};
+
+struct pcm {
+ char *device;
+ char *file;
+ enum _bat_op_mode mode;
+ void *(*fct)(struct bat *);
+};
+
+struct sin_generator;
+
+struct sin_generator {
+ double state_real;
+ double state_imag;
+ double phasor_real;
+ double phasor_imag;
+ float frequency;
+ float sample_rate;
+ float magnitude;
+};
+
+struct bat {
+ unsigned int rate; /* sampling rate */
+ int channels; /* nb of channels */
+ int frames; /* nb of frames */
+ int frame_size; /* size of frame */
+ int sample_size; /* size of sample */
+ snd_pcm_format_t format; /* PCM format */
+
+ float sigma_k; /* threshold for peak detection */
+ float target_freq[MAX_CHANNELS];
+
+ int sinus_duration; /* number of frames for playback */
+ char *narg; /* argument string of duration */
+ char *logarg; /* path name of log file */
+ char *debugplay; /* path name to store playback signal */
+
+ struct pcm playback;
+ struct pcm capture;
+
+ unsigned int periods_played;
+ unsigned int periods_total;
+ bool period_is_limited;
+
+ FILE *fp;
+
+ FILE *log;
+ FILE *err;
+
+ void (*convert_sample_to_double)(void *, double *, int);
+ void (*convert_float_to_sample)(float *, void *, int, int);
+
+ void *buf; /* PCM Buffer */
+
+ bool local; /* true for internal test */
+};
+
+struct analyze {
+ void *buf;
+ double *in;
+ double *out;
+ double *mag;
+};
+
+void prepare_wav_info(struct wav_container *, struct bat *);
+int read_wav_header(struct bat *, char *, FILE *, bool);
+int write_wav_header(FILE *, struct wav_container *, struct bat *);
new file mode 100644
@@ -0,0 +1,113 @@
+/*
+ * 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 <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+void convert_uint8_to_double(void *buf, double *val, int samples)
+{
+ int i;
+
+ for (i = 0; i < samples; i++)
+ val[i] = ((uint8_t *) buf)[i];
+}
+
+void convert_int16_to_double(void *buf, double *val, int samples)
+{
+ int i;
+
+ for (i = 0; i < samples; i++)
+ val[i] = ((int16_t *) buf)[i];
+}
+
+void convert_int24_to_double(void *buf, double *val, int samples)
+{
+ int i;
+ int32_t tmp;
+
+ for (i = 0; i < samples; i++) {
+ tmp = ((uint8_t *) buf)[i * 3 + 2] << 24;
+ tmp |= ((uint8_t *) buf)[i * 3 + 1] << 16;
+ tmp |= ((uint8_t *) buf)[i * 3] << 8;
+ tmp >>= 8;
+ val[i] = tmp;
+ }
+}
+
+void convert_int32_to_double(void *buf, double *val, int samples)
+{
+ int i;
+
+ for (i = 0; i < samples; i++)
+ val[i] = ((int32_t *) buf)[i];
+}
+
+void convert_float_to_uint8(float *val, void *buf, int samples, int channels)
+{
+ int i, c, idx;
+
+ for (i = 0; i < samples; i++) {
+ for (c = 0; c < channels; c++) {
+ idx = i * channels + c;
+ ((uint8_t *) buf)[idx] = (uint8_t) val[idx];
+ }
+ }
+}
+
+void convert_float_to_int16(float *val, void *buf, int samples, int channels)
+{
+ int i, c, idx;
+
+ for (i = 0; i < samples; i++) {
+ for (c = 0; c < channels; c++) {
+ idx = i * channels + c;
+ ((int16_t *) buf)[idx] = (int16_t) val[idx];
+ }
+ }
+}
+
+void convert_float_to_int24(float *val, void *buf, int samples, int channels)
+{
+ int i, c, idx_f, idx_i;
+ int32_t val_f_i;
+
+ for (i = 0; i < samples; i++) {
+ for (c = 0; c < channels; c++) {
+ idx_f = i * channels + c;
+ idx_i = 3 * idx_f;
+ val_f_i = (int32_t) val[idx_f];
+ ((int8_t *) buf)[idx_i + 0] =
+ (int8_t) (val_f_i & 0xff);
+ ((int8_t *) buf)[idx_i + 1] =
+ (int8_t) ((val_f_i >> 8) & 0xff);
+ ((int8_t *) buf)[idx_i + 2] =
+ (int8_t) ((val_f_i >> 16) & 0xff);
+ }
+ }
+}
+
+void convert_float_to_int32(float *val, void *buf, int samples, int channels)
+{
+ int i, c, idx;
+
+ for (i = 0; i < samples; i++) {
+ for (c = 0; c < channels; c++) {
+ idx = i * channels + c;
+ ((int32_t *) buf)[idx] = (int32_t) val[idx];
+ }
+ }
+}
new file mode 100644
@@ -0,0 +1,23 @@
+/*
+ * 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.
+ *
+ */
+
+void convert_uint8_to_double(void *, double *, int);
+void convert_int16_to_double(void *, double *, int);
+void convert_int24_to_double(void *, double *, int);
+void convert_int32_to_double(void *, double *, int);
+void convert_float_to_uint8(float *, void *, int, int);
+void convert_float_to_int16(float *, void *, int, int);
+void convert_float_to_int24(float *, void *, int, int);
+void convert_float_to_int32(float *, void *, int, int);
new file mode 100644
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2015 Caleb Crome
+ * 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.
+ *
+ */
+
+/*
+ * This is a general purpose sine wave generator that will stay stable
+ * for a long time, and with a little renormalization, could stay stay
+ * stable indefinitely
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "gettext.h"
+#include "common.h"
+#include "signal.h"
+
+/*
+ * Initialize the sine wave generator.
+ * sin_generator: gets initialized by this call.
+ * frequency: the frequency for the sine wave. must be < 0.5*sample_rate
+ * sample_rate: the sample rate...
+ * returns 0 on success, -1 on error.
+ */
+int sin_generator_init(struct sin_generator *sg, float magnitude,
+ float frequency, float sample_rate)
+{
+ /* angular frequency: cycles/sec / (samp/sec) * rad/cycle = rad/samp */
+ float w = frequency / sample_rate * 2 * M_PI;
+
+ if (frequency >= sample_rate / 2)
+ return -1;
+ sg->phasor_real = cos(w);
+ sg->phasor_imag = sin(w);
+ sg->magnitude = magnitude;
+ sg->state_real = 0.0;
+ sg->state_imag = magnitude;
+ sg->frequency = frequency;
+ sg->sample_rate = sample_rate;
+ return 0;
+}
+
+/*
+ * Generates the next sample in the sine wave.
+ * should be much faster than calling a sin function
+ * if it's inlined and optimized.
+ *
+ * returns the next value. no possibility of error.
+ */
+float sin_generator_next_sample(struct sin_generator *sg)
+{
+ /* get shorthand to pointers */
+ const double pr = sg->phasor_real;
+ const double pi = sg->phasor_imag;
+ const double sr = sg->state_real;
+ const double si = sg->state_imag;
+ /* step the phasor -- complex multiply */
+ sg->state_real = sr * pr - si * pi;
+ sg->state_imag = sr * pi + pr * si;
+ /* return the input value so sine wave starts at exactly 0.0 */
+ return sr;
+}
+
+/* fills a vector with a sine wave */
+void sin_generator_vfill(struct sin_generator *sg, float *buf, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ *buf++ = sin_generator_next_sample(sg);
+}
+
+static int reorder(struct bat *bat, float *val, int frames)
+{
+ float *new_buf = NULL;
+ int i, c, bytes;
+
+ bytes = frames * bat->channels * sizeof(float);
+
+ new_buf = (float *) malloc(bytes);
+ if (new_buf == NULL) {
+ fprintf(bat->err, _("Not enough memory.\n"));
+ return -ENOMEM;
+ }
+
+ memcpy(new_buf, val, bytes);
+ for (i = 0; i < frames; i++)
+ for (c = 0; c < bat->channels; c++)
+ val[i * bat->channels + c] =
+ new_buf[c * frames + i];
+ free(new_buf);
+
+ return 0;
+}
+
+static int adjust_waveform(struct bat *bat, float *val, int frames)
+{
+ int i, nsamples, max;
+ float factor, offset = 0.0;
+
+ switch (bat->format) {
+ case SND_PCM_FORMAT_U8:
+ max = INT8_MAX;
+ offset = max; /* shift for unsigned format */
+ break;
+ case SND_PCM_FORMAT_S16_LE:
+ max = INT16_MAX;
+ break;
+ case SND_PCM_FORMAT_S24_3LE:
+ max = (1 << 23) - 1;
+ break;
+ case SND_PCM_FORMAT_S32_LE:
+ max = INT32_MAX;
+ break;
+ default:
+ fprintf(bat->err, _("Invalid PCM format: %s\n"),
+ snd_pcm_format_name(bat->format));
+ return -EINVAL;
+ }
+
+ factor = max * RANGE_FACTOR;
+ nsamples = bat->channels * frames;
+
+ for (i = 0; i < nsamples; i++)
+ val[i] = val[i] * factor + offset;
+
+ return 0;
+}
+
+int generate_sine_wave(struct bat *bat, int frames, void *buf)
+{
+ int err = 0;
+ int c, nsamples;
+ float *sinus_f = NULL;
+ static struct sin_generator sg[MAX_CHANNELS];
+
+ nsamples = bat->channels * frames;
+ sinus_f = (float *) malloc(nsamples * sizeof(float));
+ if (sinus_f == NULL) {
+ fprintf(bat->err, _("Not enough memory.\n"));
+ return -ENOMEM;
+ }
+
+ for (c = 0; c < bat->channels; c++) {
+ /* initialize static struct at the first time */
+ if (sg[c].frequency != bat->target_freq[c])
+ sin_generator_init(&sg[c], 1.0, bat->target_freq[c],
+ bat->rate);
+ /* fill buffer for each channel */
+ sin_generator_vfill(&sg[c], sinus_f + c * frames, frames);
+ }
+
+ /* reorder samples to interleaved mode */
+ err = reorder(bat, sinus_f, frames);
+ if (err != 0)
+ return err;
+
+ /* adjust amplitude and offset of waveform */
+ err = adjust_waveform(bat, sinus_f, frames);
+ if (err != 0)
+ return err;
+
+ bat->convert_float_to_sample(sinus_f, buf, frames, bat->channels);
+
+ free(sinus_f);
+
+ return 0;
+}
deleted file mode 100644
@@ -1,24 +0,0 @@
-bin_PROGRAMS = bat
-man_MANS = bat.1
-
-EXTRA_DIST = bat.1
-
-bat_SOURCES = \
- bat.c \
- common.c \
- analyze.c \
- signal.c \
- convert.c \
- alsa.c
-
-noinst_HEADERS = \
- common.h \
- bat-signal.h \
- alsa.h \
- convert.h \
- analyze.h
-
-AM_CPPFLAGS = \
- -Wall -I$(top_srcdir)/include
-
-bat_LDADD = @FFTW_LIB@
deleted file mode 100644
@@ -1,604 +0,0 @@
-/*
- * 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 <stdio.h>
-#include <string.h>
-#include <stdbool.h>
-#include <math.h>
-#include <stdint.h>
-#include <pthread.h>
-
-#include <alsa/asoundlib.h>
-
-#include "aconfig.h"
-#include "gettext.h"
-
-#include "common.h"
-#include "alsa.h"
-#include "bat-signal.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;
-};
-
-static int set_snd_pcm_params(struct bat *bat, struct pcm_container *sndpcm)
-{
- snd_pcm_hw_params_t *params;
- unsigned int buffer_time = 0;
- unsigned int period_time = 0;
- unsigned int rate;
- int err;
- const char *device_name = snd_pcm_name(sndpcm->handle);
-
- /* Allocate a hardware parameters object. */
- snd_pcm_hw_params_alloca(¶ms);
-
- /* 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, bat->format);
- if (err < 0) {
- fprintf(bat->err, _("Set parameter to device error: "));
- fprintf(bat->err, _("PCM format: %d %s: %s(%d)\n"),
- bat->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 (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;
- }
-
- err = snd_pcm_format_physical_width(bat->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;
-}
-
-/*
- * Generate buffer to be played either from input file or from generated data
- * Return value
- * <0 error
- * 0 ok
- * >0 break
- */
-static int generate_input_data(struct pcm_container *sndpcm, int bytes,
- struct bat *bat)
-{
- int err;
- static int load;
- int frames = bytes * 8 / sndpcm->frame_bits;
-
- if (bat->playback.file != NULL) {
- /* From input file */
- load = 0;
-
- while (1) {
- err = fread(sndpcm->buffer + load, 1,
- bytes - load, bat->fp);
- if (0 == err) {
- if (feof(bat->fp)) {
- fprintf(bat->log,
- _("End of playing.\n"));
- return 1;
- }
- } else if (err < bytes - load) {
- if (ferror(bat->fp)) {
- fprintf(bat->err, _("Read file error"));
- fprintf(bat->err, _(": %d\n"), err);
- return -EIO;
- }
- load += err;
- } else {
- break;
- }
- }
- } else {
- /* Generate sine wave */
- if ((bat->sinus_duration) && (load > bat->sinus_duration))
- return 1;
-
- err = generate_sine_wave(bat, frames, (void *)sndpcm->buffer);
- if (err != 0)
- return err;
-
- load += frames;
- }
-
- 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);
- 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;
-}
-
-static int write_to_pcm_loop(struct pcm_container *sndpcm, struct bat *bat)
-{
- int err;
- int bytes = sndpcm->period_bytes; /* playback buffer size */
- int frames = bytes * 8 / sndpcm->frame_bits; /* frame count */
- FILE *fp = NULL;
- struct wav_container wav;
- int bytes_total = 0;
-
- if (bat->debugplay) {
- fp = fopen(bat->debugplay, "wb");
- if (fp == NULL) {
- fprintf(bat->err, _("Cannot open file for capture: "));
- fprintf(bat->err, _("%s %d\n"), bat->debugplay, -errno);
- return -errno;
- }
- /* leave space for wav header */
- err = fseek(fp, sizeof(wav), SEEK_SET);
- if (err != 0) {
- fprintf(bat->err, _("Seek file error: %d %d\n"),
- err, -errno);
- return -errno;
- }
- }
-
- while (1) {
- err = generate_input_data(sndpcm, bytes, bat);
- if (err < 0)
- return err;
- else if (err > 0)
- break;
-
- if (bat->debugplay) {
- err = fwrite(sndpcm->buffer, 1, bytes, fp);
- if (err != bytes) {
- fprintf(bat->err, _("Write file error: "));
- fprintf(bat->err, _("%s(%d)\n"),
- snd_strerror(err), err);
- return -EIO;
- }
- 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)
- return err;
- }
-
- if (bat->debugplay) {
- /* update wav header */
- prepare_wav_info(&wav, bat);
- wav.chunk.length = bytes_total;
- wav.header.length = (wav.chunk.length) + sizeof(wav.chunk)
- + sizeof(wav.format) + sizeof(wav.header) - 8;
-
- rewind(fp);
- err = write_wav_header(fp, &wav, bat);
- if (err != 0) {
- fprintf(bat->err, _("Write file error: %s %s(%d)\n"),
- bat->debugplay, snd_strerror(err), err);
- return err;
- }
- fclose(fp);
- }
-
- snd_pcm_drain(sndpcm->handle);
-
- return 0;
-}
-
-/**
- * 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));
-
- if (bat->playback.device == NULL) {
- fprintf(bat->err, _("No PCM device for playback: exit\n"));
- retval_play = 1;
- goto exit1;
- }
-
- 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 = 1;
- goto exit1;
- }
-
- err = set_snd_pcm_params(bat, &sndpcm);
- if (err != 0) {
- retval_play = 1;
- 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");
- if (bat->fp == NULL) {
- fprintf(bat->err, _("Cannot open file for capture: "));
- fprintf(bat->err, _("%s %d\n"),
- bat->playback.file, -errno);
- retval_play = 1;
- goto exit3;
- }
- /* Skip header */
- err = read_wav_header(bat, bat->playback.file, bat->fp, true);
- if (err != 0) {
- retval_play = 1;
- goto exit4;
- }
- }
-
- err = write_to_pcm_loop(&sndpcm, bat);
- if (err != 0) {
- retval_play = 1;
- 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);
- } 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(FILE *fp, int count,
- struct pcm_container *sndpcm, struct bat *bat)
-{
- int err = 0;
- int size, frames;
- int remain = count;
-
- 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)
- return err;
-
- /* write the chunk to file */
- err = fwrite(sndpcm->buffer, 1, size, fp);
- if (err != size) {
- fprintf(bat->err, _("Write file error: %s(%d)\n"),
- snd_strerror(err), err);
- return -EIO;
- }
- remain -= size;
- bat->periods_played++;
-
- if (bat->period_is_limited
- && bat->periods_played >= bat->periods_total)
- break;
- }
-
- return 0;
-}
-
-static void pcm_cleanup(void *p)
-{
- snd_pcm_close(p);
-}
-
-static void file_cleanup(void *p)
-{
- fclose(p);
-}
-
-/**
- * Record
- */
-void *record_alsa(struct bat *bat)
-{
- int err = 0;
- FILE *fp = NULL;
- struct pcm_container sndpcm;
- struct wav_container wav;
- int count;
-
- pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
-
- fprintf(bat->log, _("Entering capture thread (ALSA).\n"));
-
- retval_record = 0;
- memset(&sndpcm, 0, sizeof(sndpcm));
-
- if (bat->capture.device == NULL) {
- fprintf(bat->err, _("No PCM device for capture: exit\n"));
- retval_record = 1;
- goto exit1;
- }
-
- 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 = 1;
- goto exit1;
- }
-
- err = set_snd_pcm_params(bat, &sndpcm);
- if (err != 0) {
- retval_record = 1;
- goto exit2;
- }
-
- remove(bat->capture.file);
- fp = fopen(bat->capture.file, "w+");
- if (fp == NULL) {
- fprintf(bat->err, _("Cannot open file for capture: %s %d\n"),
- bat->capture.file, -errno);
- retval_record = 1;
- goto exit3;
- }
-
- prepare_wav_info(&wav, bat);
-
- 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);
- pthread_cleanup_push(file_cleanup, fp);
-
- err = write_wav_header(fp, &wav, bat);
- if (err != 0) {
- retval_record = 1;
- goto exit4;
- }
-
- count = wav.chunk.length;
- fprintf(bat->log, _("Recording ...\n"));
- err = read_from_pcm_loop(fp, count, &sndpcm, bat);
- if (err != 0) {
- retval_record = 1;
- goto exit4;
- }
-
- /* Normally we will never reach this part of code (before fail_exit) as
- this thread will be cancelled by end of play thread. */
- pthread_cleanup_pop(0);
- pthread_cleanup_pop(0);
- pthread_cleanup_pop(0);
-
- snd_pcm_drain(sndpcm.handle);
-
-exit4:
- fclose(fp);
-exit3:
- free(sndpcm.buffer);
-exit2:
- snd_pcm_close(sndpcm.handle);
-exit1:
- pthread_exit(&retval_record);
-}
deleted file mode 100644
@@ -1,20 +0,0 @@
-/*
- * 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.
- *
- */
-
-extern int retval_play;
-extern int retval_record;
-
-void *playback_alsa(struct bat *);
-void *record_alsa(struct bat *);
deleted file mode 100644
@@ -1,314 +0,0 @@
-/*
- * 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 <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <math.h>
-#include <fftw3.h>
-
-#include "aconfig.h"
-#include "gettext.h"
-
-#include "common.h"
-
-static void check_amplitude(struct bat *bat, double *buf)
-{
- double sum, average, amplitude;
- int i, percent;
-
- /* calculate average value */
- for (i = 0, sum = 0.0; i < bat->frames; i++)
- sum += buf[i];
- average = sum / bat->frames;
-
- /* calculate peak-to-average amplitude */
- for (i = 0, sum = 0.0; i < bat->frames; i++)
- sum += abs(buf[i] - average);
- amplitude = sum / bat->frames * M_PI / 2.0;
-
- /* calculate amplitude percentage against full range */
- percent = amplitude * 100 / ((1 << ((bat->sample_size << 3) - 1)) - 1);
-
- fprintf(bat->log, _("Amplitude: %.1f; Percentage: [%d]\n"),
- amplitude, percent);
- if (percent < 0)
- fprintf(bat->err, _("ERROR: Amplitude can't be negative!\n"));
- else if (percent < 1)
- fprintf(bat->err, _("WARNING: Signal too weak!\n"));
- else if (percent > 100)
- fprintf(bat->err, _("WARNING: Signal overflow!\n"));
-}
-
-/**
- *
- * @return 0 if peak detected at right frequency,
- * 1 if peak detected somewhere else
- * 2 if DC detected
- */
-int check_peak(struct bat *bat, struct analyze *a, int end, int peak, float hz,
- float mean, float p, int channel, int start)
-{
- int err;
- float hz_peak = (float) (peak) * hz;
- float delta_rate = DELTA_RATE * bat->target_freq[channel];
- float delta_HZ = DELTA_HZ;
- float tolerance = (delta_rate > delta_HZ) ? delta_rate : delta_HZ;
-
- fprintf(bat->log, _("Detected peak at %2.2f Hz of %2.2f dB\n"), hz_peak,
- 10.0 * log10(a->mag[peak] / mean));
- fprintf(bat->log, _(" Total %3.1f dB from %2.2f to %2.2f Hz\n"),
- 10.0 * log10(p / mean), start * hz, end * hz);
-
- if (hz_peak < DC_THRESHOLD) {
- fprintf(bat->err, _(" WARNING: Found low peak %2.2f Hz,"),
- hz_peak);
- fprintf(bat->err, _(" very close to DC\n"));
- err = FOUND_DC;
- } else if (hz_peak < bat->target_freq[channel] - tolerance) {
- fprintf(bat->err, _(" FAIL: Peak freq too low %2.2f Hz\n"),
- hz_peak);
- err = FOUND_WRONG_PEAK;
- } else if (hz_peak > bat->target_freq[channel] + tolerance) {
- fprintf(bat->err, _(" FAIL: Peak freq too high %2.2f Hz\n"),
- hz_peak);
- err = FOUND_WRONG_PEAK;
- } else {
- fprintf(bat->log, _(" PASS: Peak detected"));
- fprintf(bat->log, _(" at target frequency\n"));
- err = 0;
- }
-
- return err;
-}
-
-/**
- * Search for main frequencies in fft results and compare it to target
- */
-static int check(struct bat *bat, struct analyze *a, int channel)
-{
- float hz = 1.0 / ((float) bat->frames / (float) bat->rate);
- float mean = 0.0, t, sigma = 0.0, p = 0.0;
- int i, start = -1, end = -1, peak = 0, signals = 0;
- int err = 0, N = bat->frames / 2;
-
- /* calculate mean */
- for (i = 0; i < N; i++)
- mean += a->mag[i];
- mean /= (float) N;
-
- /* calculate standard deviation */
- for (i = 0; i < N; i++) {
- t = a->mag[i] - mean;
- t *= t;
- sigma += t;
- }
- sigma /= (float) N;
- sigma = sqrtf(sigma);
-
- /* clip any data less than k sigma + mean */
- for (i = 0; i < N; i++) {
- if (a->mag[i] > mean + bat->sigma_k * sigma) {
-
- /* find peak start points */
- if (start == -1) {
- start = peak = end = i;
- signals++;
- } else {
- if (a->mag[i] > a->mag[peak])
- peak = i;
- end = i;
- }
- p += a->mag[i];
- } else if (start != -1) {
- /* Check if peak is as expected */
- err |= check_peak(bat, a, end, peak, hz, mean,
- p, channel, start);
- end = start = -1;
- if (signals == MAX_PEAKS)
- break;
- }
- }
- if (signals == 0)
- err = -ENOPEAK; /* No peak detected */
- else if ((err == FOUND_DC) && (signals == 1))
- err = -EONLYDC; /* Only DC detected */
- else if ((err & FOUND_WRONG_PEAK) == FOUND_WRONG_PEAK)
- err = -EBADPEAK; /* Bad peak detected */
- else
- err = 0; /* Correct peak detected */
-
- fprintf(bat->log, _("Detected at least %d signal(s) in total\n"),
- signals);
-
- return err;
-}
-
-static void calc_magnitude(struct bat *bat, struct analyze *a, int N)
-{
- double r2, i2;
- int i;
-
- for (i = 1; i < N / 2; i++) {
- r2 = a->out[i] * a->out[i];
- i2 = a->out[N - i] * a->out[N - i];
-
- a->mag[i] = sqrtf(r2 + i2);
- }
- a->mag[0] = 0.0;
-}
-
-static int find_and_check_harmonics(struct bat *bat, struct analyze *a,
- int channel)
-{
- fftw_plan p;
- int err = -ENOMEM, N = bat->frames;
-
- /* Allocate FFT buffers */
- a->in = (double *) fftw_malloc(sizeof(double) * bat->frames);
- if (a->in == NULL)
- goto out1;
-
- a->out = (double *) fftw_malloc(sizeof(double) * bat->frames);
- if (a->out == NULL)
- goto out2;
-
- a->mag = (double *) fftw_malloc(sizeof(double) * bat->frames);
- if (a->mag == NULL)
- goto out3;
-
- /* create FFT plan */
- p = fftw_plan_r2r_1d(N, a->in, a->out, FFTW_R2HC,
- FFTW_MEASURE | FFTW_PRESERVE_INPUT);
- if (p == NULL)
- goto out4;
-
- /* convert source PCM to doubles */
- bat->convert_sample_to_double(a->buf, a->in, bat->frames);
-
- /* check amplitude */
- check_amplitude(bat, a->in);
-
- /* run FFT */
- fftw_execute(p);
-
- /* FFT out is real and imaginary numbers - calc magnitude for each */
- calc_magnitude(bat, a, N);
-
- /* check data */
- err = check(bat, a, channel);
-
- fftw_destroy_plan(p);
-
-out4:
- fftw_free(a->mag);
-out3:
- fftw_free(a->out);
-out2:
- fftw_free(a->in);
-out1:
- return err;
-}
-
-/**
- * Convert interleaved samples from channels in samples from a single channel
- */
-static int reorder_data(struct bat *bat)
-{
- char *p, *new_bat_buf;
- int ch, i, j;
-
- if (bat->channels == 1)
- return 0; /* No need for reordering */
-
- p = malloc(bat->frames * bat->frame_size);
- new_bat_buf = p;
- if (p == NULL)
- return -ENOMEM;
-
- for (ch = 0; ch < bat->channels; ch++) {
- for (j = 0; j < bat->frames; j++) {
- for (i = 0; i < bat->sample_size; i++) {
- *p++ = ((char *) (bat->buf))[j * bat->frame_size
- + ch * bat->sample_size + i];
- }
- }
- }
-
- free(bat->buf);
- bat->buf = new_bat_buf;
-
- return 0;
-}
-
-int analyze_capture(struct bat *bat)
-{
- int err = 0;
- size_t items;
- int c;
- struct analyze a;
-
- fprintf(bat->log, _("\nBAT analysis: signal has %d frames at %d Hz,"),
- bat->frames, bat->rate);
- fprintf(bat->log, _(" %d channels, %d bytes per sample.\n"),
- bat->channels, bat->sample_size);
-
- bat->buf = malloc(bat->frames * bat->frame_size);
- if (bat->buf == NULL)
- return -ENOMEM;
-
- bat->fp = fopen(bat->capture.file, "rb");
- if (bat->fp == NULL) {
- fprintf(bat->err, _("Cannot open file for capture: %s %d\n"),
- bat->capture.file, -errno);
- err = -errno;
- goto exit1;
- }
-
- /* Skip header */
- err = read_wav_header(bat, bat->capture.file, bat->fp, true);
- if (err != 0)
- goto exit2;
-
- items = fread(bat->buf, bat->frame_size, bat->frames, bat->fp);
- if (items != bat->frames) {
- err = -EIO;
- goto exit2;
- }
-
- err = reorder_data(bat);
- if (err != 0)
- goto exit2;
-
- for (c = 0; c < bat->channels; c++) {
- fprintf(bat->log, _("\nChannel %i - "), c + 1);
- fprintf(bat->log, _("Checking for target frequency %2.2f Hz\n"),
- bat->target_freq[c]);
- a.buf = bat->buf +
- c * bat->frames * bat->frame_size
- / bat->channels;
- err = find_and_check_harmonics(bat, &a, c);
- }
-
-exit2:
- fclose(bat->fp);
-exit1:
- free(bat->buf);
-
- return err;
-}
deleted file mode 100644
@@ -1,16 +0,0 @@
-/*
- * 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.
- *
- */
-
-int analyze_capture(struct bat *);
deleted file mode 100644
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2015 Caleb Crome
- * 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.
- *
- */
-
-/*
- * Here's a generic sine wave generator that will work indefinitely
- * for any frequency.
- *
- * Note: the state & phasor are stored as doubles (and updated as
- * doubles) because after a million samples the magnitude drifts a
- * bit. If we really need floats, it can be done with periodic
- * renormalization of the state_real+state_imag magnitudes.
- */
-
-int sin_generator_init(struct sin_generator *, float, float, float);
-float sin_generator_next_sample(struct sin_generator *);
-void sin_generator_vfill(struct sin_generator *, float *, int);
-int generate_sine_wave(struct bat *, int, void *);
deleted file mode 100644
@@ -1,158 +0,0 @@
-.TH BAT 1 "20th October 2015"
-.SH NAME
-bat \- command\-line sound tester for ALSA sound card driver
-
-.SH SYNOPSIS
-\fBbat\fP [\fIflags\fP]
-
-.SH DESCRIPTION
-\fBBAT(Basic Audio Tester)\fP is a simple command\-line utility intended
-to help automate audio driver and sound server testing with little human
-interaction. BAT can be used to test audio quality, stress test features
-and test audio before and after PM state changes.
-
-BAT's design is relatively simple. BAT plays an audio stream and captures
-the same stream in either a digital or analog loop back. It then compares
-the captured stream using a FFT to the original to determine if the test
-case passes or fails.
-
-BAT can either run wholly on the target machine being tested (standalone
-mode) or can run as a client/server mode where by bat client runs on the
-target and runs as a server on a separate tester machine. The client/server
-mode still requires some manual interaction for synchronization, but this
-is actively being developed for future releases.
-
-The hardware testing configuration may require the use of an analog cable
-connecting target to tester machines or a cable to create an analog
-loopback if no loopback mode is not available on the sound hardware that
-is being tested.
-An analog loopback cable can be used to connect the "line in" to "line out"
-jacks to create a loopback. If only headphone and mic jacks (or combo jack)
-are available then the following simple circuit can be used to create an
-analog loopback :-
-
-https://source.android.com/devices/audio/loopback.html
-
-.SH OPTIONS
-.TP
-\fI\-h, \-\-help\fP
-Help: show syntax.
-.TP
-\fI\-D\fP
-Select sound card to be tested by name.
-.TP
-\fI\-P\fP
-Select the playback PCM device.
-.TP
-\fI\-C\fP
-Select the capture PCM device.
-.TP
-\fI\-f\fP
-Sample format
-.br
-Recognized sample formats are: U8 S16_LE S24_3LE S32_LE
-.br
-Some of these may not be available on selected hardware
-.br
-The available format shortcuts are:
-.nf
-\-f cd (16 bit little endian, 44100, stereo) [\-f S16_LE \-c2 \-r44100]
-\-f dat (16 bit little endian, 48000, stereo) [\-f S16_LE \-c2 \-r48000]
-.fi
-If no format is given S16_LE is used.
-.TP
-\fI\-c\fP
-The number of channels. The default is one channel.
-Valid values at the moment are 1 or 2.
-.TP
-\fI\-r\fP
-Sampling rate in Hertz. The default rate is 44100 Hertz.
-Valid values depends on hardware support.
-.TP
-\fI\-n\fP
-Duration of generated signal.
-The value could be either of the two forms:
-.br
-1. Decimal integer, means number of frames;
-.br
-2. Floating point with suffix 's', means number of seconds.
-.br
-The default is 2 seconds.
-.TP
-\fI\-k\fP
-Sigma k value for analysis.
-.br
-The analysis function reads data from WAV file, run FFT against the data
-to get magnitude of frequency vectors, and then calculates the average
-value and standard deviation of frequency vectors. After that, we define
-a threshold:
-.br
-threshold = k * standard_deviation + mean_value
-.br
-Frequencies with amplitude larger than threshold will be recognized as a
-peak, and the frequency with largest peak value will be recognized as a
-detected frequency.
-.br
-BAT then compares the detected frequency to target frequency, to decide
-if the detecting passes or fails.
-.br
-The default value is 3.0.
-.TP
-\fI\-F\fP
-Target frequency for signal generation and analysis, in Hertz.
-The default is 997.0 Hertz.
-Valid range is (DC_THRESHOLD, 40% * Sampling rate).
-.TP
-\fI\-p\fP
-Total number of periods to play or capture.
-.TP
-\fI\-\-log=#\fP
-Write stderr and stdout output to this log file.
-.TP
-\fI\-\-file=#\fP
-Input WAV file for playback.
-.TP
-\fI\-\-saveplay=#\fP
-Target WAV file to save capture test content.
-.TP
-\fI\-\-local\fP
-Internal loopback mode.
-Playback, capture and analysis internal to BAT only. This is intended for
-developers to test new BAT features as no audio is routed outside of BAT.
-
-.SH EXAMPLES
-
-.TP
-\fBbat \-P plughw:0,0 \-C plughw:0,0 \-c 2 \-f S32_LE \-F 250\fR
-Generate and play a sine wave of 250 Hertz with 2 channel and S32_LE format,
-and then capture and analyze.
-
-.TP
-\fBbat \-P plughw:0,0 \-C plughw:0,0 \-\-file 500Hz.wav\fR
-Play the RIFF WAV file "500Hz.wav" which contains 500 Hertz waveform LPCM
-data, and then capture and analyze.
-
-.SH RETURN VALUE
-.br
-On success, returns 0.
-.br
-If no peak be detected, returns -1001;
-.br
-If only DC be detected, returns -1002;
-.br
-If peak frequency does not match with the target frequency, returns -1003.
-
-.SH SEE ALSO
-\fB
-aplay(1)
-\fP
-
-.SH BUGS
-Currently only support RIFF WAV format with PCM data. Please report any bugs to
-the alsa-devel mailing list.
-
-.SH AUTHOR
-\fBbat\fP is by Liam Girdwood <liam.r.girdwood@linux.intel.com>, Bernard Gautier
-<bernard.gautier@intel.com> and Han Lu <han.lu@intel.com>.
-This document is by Liam Girdwood <liam.r.girdwood@linux.intel.com> and Han Lu
-<han.lu@intel.com>.
deleted file mode 100644
@@ -1,610 +0,0 @@
-/*
- * 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 <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <string.h>
-#include <errno.h>
-#include <pthread.h>
-#include <getopt.h>
-#include <math.h>
-#include <limits.h>
-#include <locale.h>
-
-#include "aconfig.h"
-#include "gettext.h"
-#include "version.h"
-
-#include "common.h"
-
-#include "alsa.h"
-#include "convert.h"
-#include "analyze.h"
-
-static int get_duration(struct bat *bat)
-{
- float duration_f;
- long duration_i;
- char *ptrf, *ptri;
-
- duration_f = strtof(bat->narg, &ptrf);
- if (duration_f == HUGE_VALF || duration_f == -HUGE_VALF
- || (duration_f == 0.0 && errno != 0))
- goto err_exit;
-
- duration_i = strtol(bat->narg, &ptri, 10);
- if (duration_i == LONG_MAX || duration_i == LONG_MIN)
- goto err_exit;
-
- if (*ptrf == 's')
- bat->frames = duration_f * bat->rate;
- else if (*ptri == 0)
- bat->frames = duration_i;
- else
- bat->frames = -1;
-
- if (bat->frames <= 0 || bat->frames > MAX_FRAMES) {
- fprintf(bat->err, _("Invalid duration. Range: (0, %d(%fs))\n"),
- MAX_FRAMES, (double)MAX_FRAMES / bat->rate);
- return -EINVAL;
- }
-
- return 0;
-
-err_exit:
- fprintf(bat->err, _("Duration overflow/underflow: %d\n"), -errno);
-
- return -errno;
-}
-
-static void get_sine_frequencies(struct bat *bat, char *freq)
-{
- char *tmp1;
-
- tmp1 = strchr(freq, ':');
- if (tmp1 == NULL) {
- bat->target_freq[1] = bat->target_freq[0] = atof(optarg);
- } else {
- *tmp1 = '\0';
- bat->target_freq[0] = atof(optarg);
- bat->target_freq[1] = atof(tmp1 + 1);
- }
-}
-
-static void get_format(struct bat *bat, char *optarg)
-{
- if (strcasecmp(optarg, "cd") == 0) {
- bat->format = SND_PCM_FORMAT_S16_LE;
- bat->rate = 44100;
- bat->channels = 2;
- } else if (strcasecmp(optarg, "dat") == 0) {
- bat->format = SND_PCM_FORMAT_S16_LE;
- bat->rate = 48000;
- bat->channels = 2;
- } else {
- bat->format = snd_pcm_format_value(optarg);
- if (bat->format == SND_PCM_FORMAT_UNKNOWN) {
- fprintf(bat->err, _("wrong extended format '%s'\n"),
- optarg);
- exit(EXIT_FAILURE);
- }
- }
-
- switch (bat->format) {
- case SND_PCM_FORMAT_U8:
- bat->sample_size = 1;
- break;
- case SND_PCM_FORMAT_S16_LE:
- bat->sample_size = 2;
- break;
- case SND_PCM_FORMAT_S24_3LE:
- bat->sample_size = 3;
- break;
- case SND_PCM_FORMAT_S32_LE:
- bat->sample_size = 4;
- break;
- default:
- fprintf(bat->err, _("unsupported format: %d\n"), bat->format);
- exit(EXIT_FAILURE);
- }
-}
-
-static inline int thread_wait_completion(struct bat *bat,
- pthread_t id, int **val)
-{
- int err;
-
- err = pthread_join(id, (void **) val);
- if (err)
- pthread_cancel(id);
-
- return err;
-}
-
-/* loopback test where we play sine wave and capture the same sine wave */
-static void test_loopback(struct bat *bat)
-{
- pthread_t capture_id, playback_id;
- int err;
- int *thread_result_capture, *thread_result_playback;
-
- /* start playback */
- err = pthread_create(&playback_id, NULL,
- (void *) bat->playback.fct, bat);
- if (err != 0) {
- fprintf(bat->err, _("Cannot create playback thread: %d\n"),
- err);
- exit(EXIT_FAILURE);
- }
-
- /* TODO: use a pipe to signal stream start etc - i.e. to sync threads */
- /* Let some time for playing something before capturing */
- usleep(CAPTURE_DELAY * 1000);
-
- /* start capture */
- err = pthread_create(&capture_id, NULL, (void *) bat->capture.fct, bat);
- if (err != 0) {
- fprintf(bat->err, _("Cannot create capture thread: %d\n"), err);
- pthread_cancel(playback_id);
- exit(EXIT_FAILURE);
- }
-
- /* wait for playback to complete */
- err = thread_wait_completion(bat, playback_id, &thread_result_playback);
- if (err != 0) {
- fprintf(bat->err, _("Cannot join playback thread: %d\n"), err);
- free(thread_result_playback);
- pthread_cancel(capture_id);
- exit(EXIT_FAILURE);
- }
-
- /* check playback status */
- if (*thread_result_playback != 0) {
- fprintf(bat->err, _("Exit playback thread fail: %d\n"),
- *thread_result_playback);
- pthread_cancel(capture_id);
- exit(EXIT_FAILURE);
- } else {
- fprintf(bat->log, _("Playback completed.\n"));
- }
-
- /* now stop and wait for capture to finish */
- pthread_cancel(capture_id);
- err = thread_wait_completion(bat, capture_id, &thread_result_capture);
- if (err != 0) {
- fprintf(bat->err, _("Cannot join capture thread: %d\n"), err);
- free(thread_result_capture);
- exit(EXIT_FAILURE);
- }
-
- /* check capture status */
- if (*thread_result_capture != 0) {
- fprintf(bat->err, _("Exit capture thread fail: %d\n"),
- *thread_result_capture);
- exit(EXIT_FAILURE);
- } else {
- fprintf(bat->log, _("Capture completed.\n"));
- }
-}
-
-/* single ended playback only test */
-static void test_playback(struct bat *bat)
-{
- pthread_t playback_id;
- int err;
- int *thread_result;
-
- /* start playback */
- err = pthread_create(&playback_id, NULL,
- (void *) bat->playback.fct, bat);
- if (err != 0) {
- fprintf(bat->err, _("Cannot create playback thread: %d\n"),
- err);
- exit(EXIT_FAILURE);
- }
-
- /* wait for playback to complete */
- err = thread_wait_completion(bat, playback_id, &thread_result);
- if (err != 0) {
- fprintf(bat->err, _("Cannot join playback thread: %d\n"), err);
- free(thread_result);
- exit(EXIT_FAILURE);
- }
-
- /* check playback status */
- if (*thread_result != 0) {
- fprintf(bat->err, _("Exit playback thread fail: %d\n"),
- *thread_result);
- exit(EXIT_FAILURE);
- } else {
- fprintf(bat->log, _("Playback completed.\n"));
- }
-}
-
-/* single ended capture only test */
-static void test_capture(struct bat *bat)
-{
- pthread_t capture_id;
- int err;
- int *thread_result;
-
- /* start capture */
- err = pthread_create(&capture_id, NULL, (void *) bat->capture.fct, bat);
- if (err != 0) {
- fprintf(bat->err, _("Cannot create capture thread: %d\n"), err);
- exit(EXIT_FAILURE);
- }
-
- /* TODO: stop capture */
-
- /* wait for capture to complete */
- err = thread_wait_completion(bat, capture_id, &thread_result);
- if (err != 0) {
- fprintf(bat->err, _("Cannot join capture thread: %d\n"), err);
- free(thread_result);
- exit(EXIT_FAILURE);
- }
-
- /* check playback status */
- if (*thread_result != 0) {
- fprintf(bat->err, _("Exit capture thread fail: %d\n"),
- *thread_result);
- exit(EXIT_FAILURE);
- } else {
- fprintf(bat->log, _("Capture completed.\n"));
- }
-}
-
-static void usage(struct bat *bat)
-{
- fprintf(bat->log,
-_("Usage: bat [-options]...\n"
-"\n"
-" -h, --help this help\n"
-" -D pcm device for both playback and capture\n"
-" -P pcm device for playback\n"
-" -C pcm device for capture\n"
-" -f sample format\n"
-" -c number of channels\n"
-" -r sampling rate\n"
-" -n frames to playback or capture\n"
-" -k parameter for frequency detecting threshold\n"
-" -F target frequency\n"
-" -p total number of periods to play/capture\n"
-" --log=# file that both stdout and strerr redirecting to\n"
-" --file=# file for playback\n"
-" --saveplay=# file that storing playback content, for debug\n"
-" --local internal loop, set to bypass pcm hardware devices\n"
-));
- fprintf(bat->log, _("Recognized sample formats are: %s %s %s %s\n"),
- snd_pcm_format_name(SND_PCM_FORMAT_U8),
- snd_pcm_format_name(SND_PCM_FORMAT_S16_LE),
- snd_pcm_format_name(SND_PCM_FORMAT_S24_3LE),
- snd_pcm_format_name(SND_PCM_FORMAT_S32_LE));
- fprintf(bat->log, _("The available format shotcuts are:\n"));
- fprintf(bat->log, _("-f cd (16 bit little endian, 44100, stereo)\n"));
- fprintf(bat->log, _("-f dat (16 bit little endian, 48000, stereo)\n"));
-}
-
-static void set_defaults(struct bat *bat)
-{
- memset(bat, 0, sizeof(struct bat));
-
- /* Set default values */
- bat->rate = 44100;
- bat->channels = 1;
- bat->frame_size = 2;
- bat->sample_size = 2;
- bat->format = SND_PCM_FORMAT_S16_LE;
- bat->convert_float_to_sample = convert_float_to_int16;
- bat->convert_sample_to_double = convert_int16_to_double;
- bat->frames = bat->rate * 2;
- bat->target_freq[0] = 997.0;
- bat->target_freq[1] = 997.0;
- bat->sigma_k = 3.0;
- bat->playback.device = NULL;
- bat->capture.device = NULL;
- bat->buf = NULL;
- bat->local = false;
- bat->playback.fct = &playback_alsa;
- bat->capture.fct = &record_alsa;
- bat->playback.mode = MODE_LOOPBACK;
- bat->capture.mode = MODE_LOOPBACK;
- bat->period_is_limited = false;
- bat->log = stdout;
- bat->err = stderr;
-}
-
-static void parse_arguments(struct bat *bat, int argc, char *argv[])
-{
- int c, option_index;
- static const char short_options[] = "D:P:C:f:n:F:c:r:s:k:p:lth";
- static const struct option long_options[] = {
- {"help", 0, 0, 'h'},
- {"log", 1, 0, OPT_LOG},
- {"file", 1, 0, OPT_READFILE},
- {"saveplay", 1, 0, OPT_SAVEPLAY},
- {"local", 0, 0, OPT_LOCAL},
- {0, 0, 0, 0}
- };
-
- while ((c = getopt_long(argc, argv, short_options, long_options,
- &option_index)) != -1) {
- switch (c) {
- case OPT_LOG:
- bat->logarg = optarg;
- break;
- case OPT_READFILE:
- bat->playback.file = optarg;
- break;
- case OPT_SAVEPLAY:
- bat->debugplay = optarg;
- break;
- case OPT_LOCAL:
- bat->local = true;
- break;
- case 'D':
- if (bat->playback.device == NULL)
- bat->playback.device = optarg;
- if (bat->capture.device == NULL)
- bat->capture.device = optarg;
- break;
- case 'P':
- if (bat->capture.mode == MODE_SINGLE)
- bat->capture.mode = MODE_LOOPBACK;
- else
- bat->playback.mode = MODE_SINGLE;
- bat->playback.device = optarg;
- break;
- case 'C':
- if (bat->playback.mode == MODE_SINGLE)
- bat->playback.mode = MODE_LOOPBACK;
- else
- bat->capture.mode = MODE_SINGLE;
- bat->capture.device = optarg;
- break;
- case 'n':
- bat->narg = optarg;
- break;
- case 'F':
- get_sine_frequencies(bat, optarg);
- break;
- case 'c':
- bat->channels = atoi(optarg);
- break;
- case 'r':
- bat->rate = atoi(optarg);
- break;
- case 'f':
- get_format(bat, optarg);
- break;
- case 'k':
- bat->sigma_k = atof(optarg);
- break;
- case 'p':
- bat->periods_total = atoi(optarg);
- bat->period_is_limited = true;
- break;
- case 'h':
- default:
- usage(bat);
- exit(EXIT_SUCCESS);
- }
- }
-}
-
-static int validate_options(struct bat *bat)
-{
- int c;
- float freq_low, freq_high;
-
- /* check if we have an input file for local mode */
- if ((bat->local == true) && (bat->capture.file == NULL)) {
- fprintf(bat->err, _("no input file for local testing\n"));
- return -EINVAL;
- }
-
- /* check supported channels */
- if (bat->channels > MAX_CHANNELS || bat->channels < MIN_CHANNELS) {
- fprintf(bat->err, _("%d channels not supported\n"),
- bat->channels);
- return -EINVAL;
- }
-
- /* check single ended is in either playback or capture - not both */
- if ((bat->playback.mode == MODE_SINGLE)
- && (bat->capture.mode == MODE_SINGLE)) {
- fprintf(bat->err, _("single ended mode is simplex\n"));
- return -EINVAL;
- }
-
- /* check sine wave frequency range */
- freq_low = DC_THRESHOLD;
- freq_high = bat->rate * RATE_FACTOR;
- for (c = 0; c < bat->channels; c++) {
- if (bat->target_freq[c] < freq_low
- || bat->target_freq[c] > freq_high) {
- fprintf(bat->err, _("sine wave frequency out of"));
- fprintf(bat->err, _(" range: (%.1f, %.1f)\n"),
- freq_low, freq_high);
- return -EINVAL;
- }
- }
-
- return 0;
-}
-
-static int bat_init(struct bat *bat)
-{
- int err = 0;
- char name[] = TEMP_RECORD_FILE_NAME;
-
- /* Determine logging to a file or stdout and stderr */
- if (bat->logarg) {
- bat->log = NULL;
- bat->log = fopen(bat->logarg, "wb");
- if (bat->log == NULL) {
- fprintf(bat->err, _("Cannot open file for capture:"));
- fprintf(bat->err, _(" %s %d\n"),
- bat->logarg, -errno);
- return -errno;
- }
- bat->err = bat->log;
- }
-
- /* Determine duration of playback and/or capture */
- if (bat->narg) {
- err = get_duration(bat);
- if (err < 0)
- return err;
- }
-
- /* Determine capture file */
- if (bat->local) {
- bat->capture.file = bat->playback.file;
- } else {
- /* create temp file for sound record and analysis */
- err = mkstemp(name);
- if (err == -1) {
- fprintf(bat->err, _("Fail to create record file: %d\n"),
- -errno);
- return -errno;
- }
- /* store file name which is dynamically created */
- bat->capture.file = strdup(name);
- if (bat->capture.file == NULL)
- return -errno;
- /* close temp file */
- close(err);
- }
-
- /* Initial for playback */
- if (bat->playback.file == NULL) {
- /* No input file so we will generate our own sine wave */
- if (bat->frames) {
- if (bat->playback.mode == MODE_SINGLE) {
- /* Play nb of frames given by -n argument */
- bat->sinus_duration = bat->frames;
- } else {
- /* Play CAPTURE_DELAY msec +
- * 150% of the nb of frames to be analyzed */
- bat->sinus_duration = bat->rate *
- CAPTURE_DELAY / 1000;
- bat->sinus_duration +=
- (bat->frames + bat->frames / 2);
- }
- } else {
- /* Special case where we want to generate a sine wave
- * endlessly without capturing */
- bat->sinus_duration = 0;
- bat->playback.mode = MODE_SINGLE;
- }
- } else {
- bat->fp = fopen(bat->playback.file, "rb");
- if (bat->fp == NULL) {
- fprintf(bat->err, _("Cannot open file for playback:"));
- fprintf(bat->err, _(" %s %d\n"),
- bat->playback.file, -errno);
- return -errno;
- }
- err = read_wav_header(bat, bat->playback.file, bat->fp, false);
- fclose(bat->fp);
- if (err != 0)
- return err;
- }
-
- bat->frame_size = bat->sample_size * bat->channels;
-
- /* Set conversion functions */
- switch (bat->sample_size) {
- case 1:
- bat->convert_float_to_sample = convert_float_to_uint8;
- bat->convert_sample_to_double = convert_uint8_to_double;
- break;
- case 2:
- bat->convert_float_to_sample = convert_float_to_int16;
- bat->convert_sample_to_double = convert_int16_to_double;
- break;
- case 3:
- bat->convert_float_to_sample = convert_float_to_int24;
- bat->convert_sample_to_double = convert_int24_to_double;
- break;
- case 4:
- bat->convert_float_to_sample = convert_float_to_int32;
- bat->convert_sample_to_double = convert_int32_to_double;
- break;
- default:
- fprintf(bat->err, _("Invalid PCM format: size=%d\n"),
- bat->sample_size);
- return -EINVAL;
- }
-
- return err;
-}
-
-int main(int argc, char *argv[])
-{
- struct bat bat;
- int err = 0;
-
- set_defaults(&bat);
-
-#ifdef ENABLE_NLS
- setlocale(LC_ALL, "");
- textdomain(PACKAGE);
-#endif
-
- fprintf(bat.log, _("%s version %s\n\n"), PACKAGE_NAME, PACKAGE_VERSION);
-
- parse_arguments(&bat, argc, argv);
-
- err = bat_init(&bat);
- if (err < 0)
- goto out;
-
- err = validate_options(&bat);
- if (err < 0)
- goto out;
-
- /* single line playback thread: playback only, no capture */
- if (bat.playback.mode == MODE_SINGLE) {
- test_playback(&bat);
- goto out;
- }
-
- /* single line capture thread: capture only, no playback */
- if (bat.capture.mode == MODE_SINGLE) {
- test_capture(&bat);
- goto analyze;
- }
-
- /* loopback thread: playback and capture in a loop */
- if (bat.local == false)
- test_loopback(&bat);
-
-analyze:
- err = analyze_capture(&bat);
-out:
- fprintf(bat.log, _("\nReturn value is %d\n"), err);
-
- if (bat.logarg)
- fclose(bat.log);
- if (!bat.local)
- free(bat.capture.file);
-
- return err;
-}
deleted file mode 100644
@@ -1,198 +0,0 @@
-/*
- * 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 <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <errno.h>
-
-#include "aconfig.h"
-#include "gettext.h"
-
-#include "common.h"
-#include "alsa.h"
-
-int retval_play;
-int retval_record;
-
-/* update chunk_fmt data to bat */
-static int update_fmt_to_bat(struct bat *bat, struct chunk_fmt *fmt)
-{
- bat->channels = fmt->channels;
- bat->rate = fmt->sample_rate;
- bat->sample_size = fmt->sample_length / 8;
- if (bat->sample_size > 4) {
- fprintf(bat->err, _("Invalid format: sample size=%d\n"),
- bat->sample_size);
- return -EINVAL;
- }
- bat->frame_size = fmt->blocks_align;
-
- return 0;
-}
-
-/* calculate frames and update to bat */
-static int update_frames_to_bat(struct bat *bat,
- struct wav_chunk_header *header, FILE *fp)
-{
- /* The number of analyzed captured frames is arbitrarily set to half of
- the number of frames of the wav file or the number of frames of the
- wav file when doing direct analysis (--local) */
- bat->frames = header->length / bat->frame_size;
- if (!bat->local)
- bat->frames /= 2;
-
- return 0;
-}
-
-static int read_chunk_fmt(struct bat *bat, char *file, FILE *fp, bool skip,
- struct wav_chunk_header *header)
-{
- size_t err;
- int header_skip;
- struct chunk_fmt chunk_fmt;
-
- err = fread(&chunk_fmt, sizeof(chunk_fmt), 1, fp);
- if (err != 1) {
- fprintf(bat->err, _("Read chunk fmt error: %s:%zd\n"),
- file, err);
- return -EIO;
- }
- /* If the format header is larger, skip the rest */
- header_skip = header->length - sizeof(chunk_fmt);
- if (header_skip > 0) {
- err = fseek(fp, header_skip, SEEK_CUR);
- if (err == -1) {
- fprintf(bat->err, _("Seek fmt header error: %s:%zd\n"),
- file, err);
- return -EINVAL;
- }
- }
- /* If the file is opened for playback, update BAT data;
- If the file is opened for analysis, no update */
- if (skip == false) {
- err = update_fmt_to_bat(bat, &chunk_fmt);
- if (err != 0)
- return err;
- }
-
- return 0;
-}
-
-int read_wav_header(struct bat *bat, char *file, FILE *fp, bool skip)
-{
- struct wav_header riff_wave_header;
- struct wav_chunk_header chunk_header;
- int more_chunks = 1;
- size_t err;
-
- /* Read header of RIFF wav file */
- err = fread(&riff_wave_header, sizeof(riff_wave_header), 1, fp);
- if (err != 1) {
- fprintf(bat->err, _("Read header error: %s:%zd\n"), file, err);
- return -EIO;
- }
- if ((riff_wave_header.magic != WAV_RIFF)
- || (riff_wave_header.type != WAV_WAVE)) {
- fprintf(bat->err, _("%s is not a riff/wave file\n"), file);
- return -EINVAL;
- }
-
- /* Read chunks in RIFF wav file */
- do {
- err = fread(&chunk_header, sizeof(chunk_header), 1, fp);
- if (err != 1) {
- fprintf(bat->err, _("Read chunk header error: "));
- fprintf(bat->err, _("%s:%zd\n"), file, err);
- return -EIO;
- }
-
- switch (chunk_header.type) {
- case WAV_FMT:
- /* WAV_FMT chunk, read and analyze */
- err = read_chunk_fmt(bat, file, fp, skip,
- &chunk_header);
- if (err != 0)
- return err;
- break;
- case WAV_DATA:
- /* WAV_DATA chunk, break looping */
- /* If the file is opened for playback, update BAT data;
- If the file is opened for analysis, no update */
- if (skip == false) {
- err = update_frames_to_bat(bat, &chunk_header,
- fp);
- if (err != 0)
- return err;
- }
- /* Stop looking for chunks */
- more_chunks = 0;
- break;
- default:
- /* Unknown chunk, skip bytes */
- err = fseek(fp, chunk_header.length, SEEK_CUR);
- if (err == -1) {
- fprintf(bat->err, _("Fail to skip unknown"));
- fprintf(bat->err, _(" chunk of %s:%zd\n"),
- file, err);
- return -EINVAL;
- }
- }
- } while (more_chunks);
-
- return 0;
-}
-
-void prepare_wav_info(struct wav_container *wav, struct bat *bat)
-{
- wav->header.magic = WAV_RIFF;
- wav->header.type = WAV_WAVE;
- wav->format.magic = WAV_FMT;
- wav->format.fmt_size = 16;
- wav->format.format = WAV_FORMAT_PCM;
- wav->format.channels = bat->channels;
- wav->format.sample_rate = bat->rate;
- wav->format.sample_length = bat->sample_size * 8;
- wav->format.blocks_align = bat->channels * bat->sample_size;
- wav->format.bytes_p_second = wav->format.blocks_align * bat->rate;
- wav->chunk.length = bat->frames * bat->frame_size;
- wav->chunk.type = WAV_DATA;
- wav->header.length = (wav->chunk.length) + sizeof(wav->chunk)
- + sizeof(wav->format) + sizeof(wav->header) - 8;
-}
-
-int write_wav_header(FILE *fp, struct wav_container *wav, struct bat *bat)
-{
- int err = 0;
-
- err = fwrite(&wav->header, 1, sizeof(wav->header), fp);
- if (err != sizeof(wav->header)) {
- fprintf(bat->err, _("Write file error: header %d\n"), err);
- return -EIO;
- }
- err = fwrite(&wav->format, 1, sizeof(wav->format), fp);
- if (err != sizeof(wav->format)) {
- fprintf(bat->err, _("Write file error: format %d\n"), err);
- return -EIO;
- }
- err = fwrite(&wav->chunk, 1, sizeof(wav->chunk), fp);
- if (err != sizeof(wav->chunk)) {
- fprintf(bat->err, _("Write file error: chunk %d\n"), err);
- return -EIO;
- }
-
- return 0;
-}
deleted file mode 100644
@@ -1,176 +0,0 @@
-/*
- * 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 <alsa/asoundlib.h>
-
-#define TEMP_RECORD_FILE_NAME "/tmp/bat.wav.XXXXXX"
-
-#define OPT_BASE 300
-#define OPT_LOG (OPT_BASE + 1)
-#define OPT_READFILE (OPT_BASE + 2)
-#define OPT_SAVEPLAY (OPT_BASE + 3)
-#define OPT_LOCAL (OPT_BASE + 4)
-
-#define COMPOSE(a, b, c, d) ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24))
-#define WAV_RIFF COMPOSE('R', 'I', 'F', 'F')
-#define WAV_WAVE COMPOSE('W', 'A', 'V', 'E')
-#define WAV_FMT COMPOSE('f', 'm', 't', ' ')
-#define WAV_DATA COMPOSE('d', 'a', 't', 'a')
-#define WAV_FORMAT_PCM 1 /* PCM WAVE file encoding */
-
-#define MAX_CHANNELS 2
-#define MIN_CHANNELS 1
-#define MAX_PEAKS 10
-#define MAX_FRAMES (10 * 1024 * 1024)
-/* Given in ms */
-#define CAPTURE_DELAY 500
-/* signal frequency should be less than samplerate * RATE_FACTOR */
-#define RATE_FACTOR 0.4
-/* valid range of samplerate: (1 - RATE_RANGE, 1 + RATE_RANGE) * samplerate */
-#define RATE_RANGE 0.05
-/* Given in us */
-#define MAX_BUFFERTIME 500000
-/* devide factor, was 4, changed to 8 to remove reduce capture overrun */
-#define DIV_BUFFERTIME 8
-/* margin to avoid sign inversion when generate sine wav */
-#define RANGE_FACTOR 0.95
-
-#define EBATBASE 1000
-#define ENOPEAK (EBATBASE + 1)
-#define EONLYDC (EBATBASE + 2)
-#define EBADPEAK (EBATBASE + 3)
-
-#define DC_THRESHOLD 7.01
-
-/* tolerance of detected peak = max (DELTA_HZ, DELTA_RATE * target_freq).
- * If DELTA_RATE is too high, BAT may not be able to recognize negative result;
- * if too low, BAT may be too sensitive and results in uncecessary failure. */
-#define DELTA_RATE 0.005
-#define DELTA_HZ 1
-
-#define FOUND_DC (1<<1)
-#define FOUND_WRONG_PEAK (1<<0)
-
-struct wav_header {
- unsigned int magic; /* 'RIFF' */
- unsigned int length; /* file len */
- unsigned int type; /* 'WAVE' */
-};
-
-struct wav_chunk_header {
- unsigned int type; /* 'data' */
- unsigned int length; /* sample count */
-};
-
-struct wav_fmt {
- unsigned int magic; /* 'FMT '*/
- unsigned int fmt_size; /* 16 or 18 */
- unsigned short format; /* see WAV_FMT_* */
- unsigned short channels;
- unsigned int sample_rate; /* Frequency of sample */
- unsigned int bytes_p_second;
- unsigned short blocks_align; /* sample size; 1 or 2 bytes */
- unsigned short sample_length; /* 8, 12 or 16 bit */
-};
-
-struct chunk_fmt {
- unsigned short format; /* see WAV_FMT_* */
- unsigned short channels;
- unsigned int sample_rate; /* Frequency of sample */
- unsigned int bytes_p_second;
- unsigned short blocks_align; /* sample size; 1 or 2 bytes */
- unsigned short sample_length; /* 8, 12 or 16 bit */
-};
-
-struct wav_container {
- struct wav_header header;
- struct wav_fmt format;
- struct wav_chunk_header chunk;
-};
-
-struct bat;
-
-enum _bat_op_mode {
- MODE_UNKNOWN = -1,
- MODE_SINGLE = 0,
- MODE_LOOPBACK,
- MODE_LAST
-};
-
-struct pcm {
- char *device;
- char *file;
- enum _bat_op_mode mode;
- void *(*fct)(struct bat *);
-};
-
-struct sin_generator;
-
-struct sin_generator {
- double state_real;
- double state_imag;
- double phasor_real;
- double phasor_imag;
- float frequency;
- float sample_rate;
- float magnitude;
-};
-
-struct bat {
- unsigned int rate; /* sampling rate */
- int channels; /* nb of channels */
- int frames; /* nb of frames */
- int frame_size; /* size of frame */
- int sample_size; /* size of sample */
- snd_pcm_format_t format; /* PCM format */
-
- float sigma_k; /* threshold for peak detection */
- float target_freq[MAX_CHANNELS];
-
- int sinus_duration; /* number of frames for playback */
- char *narg; /* argument string of duration */
- char *logarg; /* path name of log file */
- char *debugplay; /* path name to store playback signal */
-
- struct pcm playback;
- struct pcm capture;
-
- unsigned int periods_played;
- unsigned int periods_total;
- bool period_is_limited;
-
- FILE *fp;
-
- FILE *log;
- FILE *err;
-
- void (*convert_sample_to_double)(void *, double *, int);
- void (*convert_float_to_sample)(float *, void *, int, int);
-
- void *buf; /* PCM Buffer */
-
- bool local; /* true for internal test */
-};
-
-struct analyze {
- void *buf;
- double *in;
- double *out;
- double *mag;
-};
-
-void prepare_wav_info(struct wav_container *, struct bat *);
-int read_wav_header(struct bat *, char *, FILE *, bool);
-int write_wav_header(FILE *, struct wav_container *, struct bat *);
deleted file mode 100644
@@ -1,113 +0,0 @@
-/*
- * 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 <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdint.h>
-
-void convert_uint8_to_double(void *buf, double *val, int samples)
-{
- int i;
-
- for (i = 0; i < samples; i++)
- val[i] = ((uint8_t *) buf)[i];
-}
-
-void convert_int16_to_double(void *buf, double *val, int samples)
-{
- int i;
-
- for (i = 0; i < samples; i++)
- val[i] = ((int16_t *) buf)[i];
-}
-
-void convert_int24_to_double(void *buf, double *val, int samples)
-{
- int i;
- int32_t tmp;
-
- for (i = 0; i < samples; i++) {
- tmp = ((uint8_t *) buf)[i * 3 + 2] << 24;
- tmp |= ((uint8_t *) buf)[i * 3 + 1] << 16;
- tmp |= ((uint8_t *) buf)[i * 3] << 8;
- tmp >>= 8;
- val[i] = tmp;
- }
-}
-
-void convert_int32_to_double(void *buf, double *val, int samples)
-{
- int i;
-
- for (i = 0; i < samples; i++)
- val[i] = ((int32_t *) buf)[i];
-}
-
-void convert_float_to_uint8(float *val, void *buf, int samples, int channels)
-{
- int i, c, idx;
-
- for (i = 0; i < samples; i++) {
- for (c = 0; c < channels; c++) {
- idx = i * channels + c;
- ((uint8_t *) buf)[idx] = (uint8_t) val[idx];
- }
- }
-}
-
-void convert_float_to_int16(float *val, void *buf, int samples, int channels)
-{
- int i, c, idx;
-
- for (i = 0; i < samples; i++) {
- for (c = 0; c < channels; c++) {
- idx = i * channels + c;
- ((int16_t *) buf)[idx] = (int16_t) val[idx];
- }
- }
-}
-
-void convert_float_to_int24(float *val, void *buf, int samples, int channels)
-{
- int i, c, idx_f, idx_i;
- int32_t val_f_i;
-
- for (i = 0; i < samples; i++) {
- for (c = 0; c < channels; c++) {
- idx_f = i * channels + c;
- idx_i = 3 * idx_f;
- val_f_i = (int32_t) val[idx_f];
- ((int8_t *) buf)[idx_i + 0] =
- (int8_t) (val_f_i & 0xff);
- ((int8_t *) buf)[idx_i + 1] =
- (int8_t) ((val_f_i >> 8) & 0xff);
- ((int8_t *) buf)[idx_i + 2] =
- (int8_t) ((val_f_i >> 16) & 0xff);
- }
- }
-}
-
-void convert_float_to_int32(float *val, void *buf, int samples, int channels)
-{
- int i, c, idx;
-
- for (i = 0; i < samples; i++) {
- for (c = 0; c < channels; c++) {
- idx = i * channels + c;
- ((int32_t *) buf)[idx] = (int32_t) val[idx];
- }
- }
-}
deleted file mode 100644
@@ -1,23 +0,0 @@
-/*
- * 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.
- *
- */
-
-void convert_uint8_to_double(void *, double *, int);
-void convert_int16_to_double(void *, double *, int);
-void convert_int24_to_double(void *, double *, int);
-void convert_int32_to_double(void *, double *, int);
-void convert_float_to_uint8(float *, void *, int, int);
-void convert_float_to_int16(float *, void *, int, int);
-void convert_float_to_int24(float *, void *, int, int);
-void convert_float_to_int32(float *, void *, int, int);
deleted file mode 100644
@@ -1,182 +0,0 @@
-/*
- * Copyright (C) 2015 Caleb Crome
- * 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.
- *
- */
-
-/*
- * This is a general purpose sine wave generator that will stay stable
- * for a long time, and with a little renormalization, could stay stay
- * stable indefinitely
- */
-
-#include <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#include "gettext.h"
-#include "common.h"
-#include "signal.h"
-
-/*
- * Initialize the sine wave generator.
- * sin_generator: gets initialized by this call.
- * frequency: the frequency for the sine wave. must be < 0.5*sample_rate
- * sample_rate: the sample rate...
- * returns 0 on success, -1 on error.
- */
-int sin_generator_init(struct sin_generator *sg, float magnitude,
- float frequency, float sample_rate)
-{
- /* angular frequency: cycles/sec / (samp/sec) * rad/cycle = rad/samp */
- float w = frequency / sample_rate * 2 * M_PI;
- if (frequency >= sample_rate / 2)
- return -1;
- sg->phasor_real = cos(w);
- sg->phasor_imag = sin(w);
- sg->magnitude = magnitude;
- sg->state_real = 0.0;
- sg->state_imag = magnitude;
- sg->frequency = frequency;
- sg->sample_rate = sample_rate;
- return 0;
-}
-
-/*
- * Generates the next sample in the sine wave.
- * should be much faster than calling a sin function
- * if it's inlined and optimized.
- *
- * returns the next value. no possibility of error.
- */
-float sin_generator_next_sample(struct sin_generator *sg)
-{
- /* get shorthand to pointers */
- const double pr = sg->phasor_real;
- const double pi = sg->phasor_imag;
- const double sr = sg->state_real;
- const double si = sg->state_imag;
- /* step the phasor -- complex multiply */
- sg->state_real = sr * pr - si * pi;
- sg->state_imag = sr * pi + pr * si;
- /* return the input value so sine wave starts at exactly 0.0 */
- return sr;
-}
-
-/* fills a vector with a sine wave */
-void sin_generator_vfill(struct sin_generator *sg, float *buf, int n)
-{
- int i;
- for (i = 0; i < n; i++)
- *buf++ = sin_generator_next_sample(sg);
-}
-
-static int reorder(struct bat *bat, float *val, int frames)
-{
- float *new_buf = NULL;
- int i, c, bytes;
-
- bytes = frames * bat->channels * sizeof(float);
-
- new_buf = (float *) malloc(bytes);
- if (new_buf == NULL) {
- fprintf(bat->err, _("Not enough memory.\n"));
- return -ENOMEM;
- }
-
- memcpy(new_buf, val, bytes);
- for (i = 0; i < frames; i++)
- for (c = 0; c < bat->channels; c++)
- val[i * bat->channels + c] =
- new_buf[c * frames + i];
- free(new_buf);
-
- return 0;
-}
-
-static int adjust_waveform(struct bat *bat, float *val, int frames)
-{
- int i, nsamples, max;
- float factor, offset = 0.0;
-
- switch (bat->format) {
- case SND_PCM_FORMAT_U8:
- max = INT8_MAX;
- offset = max; /* shift for unsigned format */
- break;
- case SND_PCM_FORMAT_S16_LE:
- max = INT16_MAX;
- break;
- case SND_PCM_FORMAT_S24_3LE:
- max = (1 << 23) - 1;
- break;
- case SND_PCM_FORMAT_S32_LE:
- max = INT32_MAX;
- break;
- default:
- fprintf(bat->err, _("Invalid PCM format: %s\n"),
- snd_pcm_format_name(bat->format));
- return -EINVAL;
- }
-
- factor = max * RANGE_FACTOR;
- nsamples = bat->channels * frames;
-
- for (i = 0; i < nsamples; i++)
- val[i] = val[i] * factor + offset;
-
- return 0;
-}
-
-int generate_sine_wave(struct bat *bat, int frames, void *buf)
-{
- int err = 0;
- int c, nsamples;
- float *sinus_f = NULL;
- static struct sin_generator sg[MAX_CHANNELS];
-
- nsamples = bat->channels * frames;
- sinus_f = (float *) malloc(nsamples * sizeof(float));
- if (sinus_f == NULL) {
- fprintf(bat->err, _("Not enough memory.\n"));
- return -ENOMEM;
- }
-
- for (c = 0; c < bat->channels; c++) {
- /* initialize static struct at the first time */
- if (sg[c].frequency != bat->target_freq[c])
- sin_generator_init(&sg[c], 1.0, bat->target_freq[c],
- bat->rate);
- /* fill buffer for each channel */
- sin_generator_vfill(&sg[c], sinus_f + c * frames, frames);
- }
-
- /* reorder samples to interleaved mode */
- err = reorder(bat, sinus_f, frames);
- if (err != 0)
- return err;
-
- /* adjust amplitude and offset of waveform */
- err = adjust_waveform(bat, sinus_f, frames);
- if (err != 0)
- return err;
-
- bat->convert_float_to_sample(sinus_f, buf, frames, bat->channels);
-
- free(sinus_f);
-
- return 0;
-}
@@ -49,20 +49,20 @@ AM_CONDITIONAL(HAVE_UCM, test "$have_ucm" = "yes")
AM_CONDITIONAL(HAVE_TOPOLOGY, test "$have_topology" = "yes")
AM_CONDITIONAL(HAVE_SAMPLERATE, test "$have_samplerate" = "yes")
-dnl Disable bat
-bat=
+dnl Disable alsabat
+alsabat=
if test "$have_pcm" = "yes"; then
-AC_ARG_ENABLE(bat,
- AS_HELP_STRING([--disable-bat], [Disable bat compilation]),
+AC_ARG_ENABLE(alsabat,
+ AS_HELP_STRING([--disable-alsabat], [Disable alsabat compilation]),
[case "${enableval}" in
- yes) bat=true ;;
- no) bat=false ;;
- *) AC_MSG_ERROR(bad value ${enableval} for --enable-bat) ;;
- esac],[bat=true])
+ yes) alsabat=true ;;
+ no) alsabat=false ;;
+ *) AC_MSG_ERROR(bad value ${enableval} for --enable-alsabat) ;;
+ esac],[alsabat=true])
fi
-AM_CONDITIONAL(BAT, test x$bat = xtrue)
+AM_CONDITIONAL(ALSABAT, test x$alsabat = xtrue)
-if test x$bat = xtrue; then
+if test x$alsabat = xtrue; then
saved_CFLAGS="$CFLAGS"
saved_LDFLAGS="$LDFLAGS"
@@ -382,7 +382,7 @@ AC_OUTPUT(Makefile alsactl/Makefile alsactl/init/Makefile \
m4/Makefile po/Makefile.in \
alsaconf/alsaconf alsaconf/Makefile \
alsaconf/po/Makefile \
- alsaucm/Makefile topology/Makefile bat/Makefile \
+ alsaucm/Makefile topology/Makefile alsabat/Makefile \
aplay/Makefile include/Makefile iecset/Makefile utils/Makefile \
utils/alsa-utils.spec seq/Makefile seq/aconnect/Makefile \
seq/aplaymidi/Makefile seq/aseqdump/Makefile seq/aseqnet/Makefile \