src/audiofuntest.cc - chromiumos/platform/audiotest - Git at Google

 // Copyright 2016 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <assert.h>
 #include <getopt.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include "include/binary_client.h"
 #include "include/common.h"
 #include "include/evaluator.h"
 #include "include/generator_player.h"
 #include "include/sample_format.h"
 #include "include/tone_generators.h"

 constexpr static const char *short_options =
     "a:m:d:n:o:w:P:f:R:F:r:t:c:C:T:l:g:i:x:hv";

 constexpr static const struct option long_options[] = {
   {"active-speaker-channels", 1, NULL, 'a'},
   {"active-mic-channels", 1, NULL, 'm'},
   {"allowed-delay", 1, NULL, 'd'},
   {"fft-size", 1, NULL, 'n'},
   {"confidence-threshold", 1, NULL, 'o'},
   {"match-window-size", 1, NULL, 'w'},
   {"player-command", 1, NULL, 'P'},
   {"player-fifo", 1, NULL, 'f'},
   {"recorder-command", 1, NULL, 'R'},
   {"recorder-fifo", 1, NULL, 'F'},
   {"sample-rate", 1, NULL, 'r'},
   {"sample-format", 1, NULL, 't'},
   {"num-mic-channels", 1, NULL, 'c'},
   {"num-speaker-channels", 1, NULL, 'C'},
   {"test-rounds", 1, NULL, 'T'},
   {"tone-length", 1, NULL, 'l'},
   {"volume-gain", 1, NULL, 'g'},
   {"min-frequency", 1, NULL, 'i'},
   {"max-frequency", 1, NULL, 'x'},

   // Other helper args.
   {"help", 0, NULL, 'h'},
   {"verbose", 0, NULL, 'v'},
 };

 // Parse the sample format. The input should be one of the string in
 // SampleFormat:Type.
 SampleFormat ParseSampleFormat(const char *arg) {
   SampleFormat sample_format;
   for (int format = SampleFormat::kPcmU8;
        format != SampleFormat::kPcmInvalid;
        format++) {
     sample_format = SampleFormat(SampleFormat::Type(format));
     if (strcmp(sample_format.to_string(), optarg) == 0) {
       return sample_format;
     }
   }
   fprintf(stderr, "Unknown sample format %s, using S16 instead.", arg);
   return SampleFormat(SampleFormat::kPcmS16);
 }

 bool ParseOptions(int argc, char *const argv[], AudioFunTestConfig *config) {
   int opt = 0;
   int optindex = -1;

   while ((opt = getopt_long(argc, argv, short_options,
                             long_options,
                             &optindex)) != -1) {
     switch (opt) {
       case 'a':
         ParseActiveChannels(optarg, &(config->active_speaker_channels));
         break;
       case 'm':
         ParseActiveChannels(optarg, &(config->active_mic_channels));
         break;
       case 'd':
         config->allowed_delay_sec = atof(optarg);
         break;
       case 'n':
         config->fft_size = atoi(optarg);
         if ((config->fft_size == 0) ||
             (config->fft_size & (config->fft_size - 1))) {
           fprintf(stderr, "FFT size needs to be positive & power of 2\n");
           return false;
         }
         break;
       case 'o':
         config->confidence_threshold = atof(optarg);
         break;
       case 'w':
         config->match_window_size = atoi(optarg);
         if (config->match_window_size % 2 == 0) {
           fprintf(stderr, "Match window size must be an odd value.\n");
           return false;
         }
         break;
       case 'P':
         config->player_command = std::string(optarg);
         break;
       case 'f':
         config->player_fifo = std::string(optarg);
         break;
       case 'R':
         config->recorder_command = std::string(optarg);
         break;
       case 'F':
         config->recorder_fifo = std::string(optarg);
         break;
       case 'r':
         config->sample_rate = atoi(optarg);
         break;
       case 't':
         config->sample_format = ParseSampleFormat(optarg);
         break;
       case 'c':
         config->num_mic_channels = atoi(optarg);
         break;
       case 'C':
         config->num_speaker_channels = atoi(optarg);
         break;
       case 'T':
         config->test_rounds = atoi(optarg);
         break;
       case 'l':
         config->tone_length_sec = atof(optarg);
         // Avoid overly short tones.
         if (config->tone_length_sec < 0.01) {
           fprintf(stderr,
                   "Tone length too short. Must be 0.01s or greater.\n");
           return false;
         }
         break;
       case 'g':
         config->volume_gain = atoi(optarg);
         if (config->volume_gain < 0 || config->volume_gain > 100) {
           fprintf(stderr, "Value of volume_gain is out of range.\n");
           return false;
         }
         break;
       case 'i':
         config->min_frequency = atoi(optarg);
         break;
       case 'x':
         config->max_frequency = atoi(optarg);
         break;
       case 'v':
         config->verbose = true;
         break;
       case 'h':
         return false;
       default:
         fprintf(stderr, "Unknown arguments %c\n", opt);
         assert(false);
     }
   }

   if (config->player_command.empty()) {
     fprintf(stderr, "player-command is not set.\n");
     return false;
   }

   if (config->recorder_command.empty()) {
     fprintf(stderr, "recorder-command is not set.\n");
     return false;
   }

   if (config->active_speaker_channels.empty()) {
     for (int i = 0; i < config->num_speaker_channels; ++i) {
       config->active_speaker_channels.insert(i);
     }
   }

   if (config->active_mic_channels.empty()) {
     for (int i = 0; i < config->num_mic_channels; ++i) {
       config->active_mic_channels.insert(i);
     }
   }

   if (config->min_frequency > config->max_frequency) {
     fprintf(stderr, "Range error: min_frequency > max_frequency\n");
     return false;
   }

   if (config->min_frequency < 0) {
     fprintf(stderr, "Range error: min_frequency < 0\n");
     return false;
   }
   return true;
 }

 void PrintUsage(const char *name, FILE *fd = stderr) {
   AudioFunTestConfig default_config;

   fprintf(fd,
           "Usage %s -P <player_command> -R <recorder_command> [options]\n",
           name);
   fprintf(fd,
           "\t-a, --active-speaker-channels:\n"
           "\t\tComma-separated list of speaker channels to play on. "
           "(def all channels)\n");
   fprintf(fd,
           "\t-m, --active-mic-channels:\n"
           "\t\tComma-separated list of mic channels to test. "
           "(def all channels)\n");
   fprintf(fd,
           "\t-d, --allowed-delay:\n"
           "\t\tAllowed latency between player & recorder "
           "(def %.4f).\n", default_config.allowed_delay_sec);
   fprintf(fd,
           "\t-n, --fftsize:\n"
           "\t\tLonger fftsize has more carriers but longer latency."
           " Also, fftsize needs to be power of 2"
           "(def %d)\n", default_config.fft_size);
   fprintf(fd,
           "\t-o, --confidence-threshold:\n"
           "\t\tThreshold of accumulated confidence to pass evaluation "
           "(def %.4f)\n", default_config.confidence_threshold);
   fprintf(fd,
           "\t-w, --match-window-size:\n"
           "\t\tNumber of bin to be used for calculating matching confidence. "
           "Should be an odd number."
           "(def %d)\n", default_config.match_window_size);
   fprintf(fd,
           "\t-P, --player-command:\n"
           "\t\tThe command used to play sound.\n");
   fprintf(fd,
           "\t-f, --player-fifo:\n"
           "\t\tThe named pipe used to send wave to the player. If not set, "
           "wave is send to player program via its stdin.\n");
   fprintf(fd,
           "\t-R, --recorder-command:\n"
           "\t\tThe command used to record sound.\n");
   fprintf(fd,
           "\t-F, --recorder-fifo:\n"
           "\t\tThe named pipe used to read recorded wave from the recorder "
           "program. If not set, wave is read from recorder program via "
           "its stdout.\n");
   fprintf(fd,
           "\t-r, --sample-rate:\n"
           "\t\tSample rate of generated wave in HZ "
           "(def %d)\n", default_config.sample_rate);
   fprintf(fd,
           "\t-t, --sample-format:\n"
           "\t\tFormat of recording & playing samples, should be one of u8, "
           "s16, s24, s32."
           "(def %s).\n", default_config.sample_format.to_string());
   fprintf(fd,
           "\t-c, --num-mic-channels:\n"
           "\t\tThe number of microphone channels "
           "(def %d)\n", default_config.num_mic_channels);
   fprintf(fd,
           "\t-C, --num-speaker-channels:\n"
           "\t\tThe number of speaker channels "
           "(def %d)\n", default_config.num_speaker_channels);
   fprintf(fd,
           "\t-T, --test-rounds:\n"
           "\t\tNumber of test rounds "
           "(def %d)\n", default_config.test_rounds);
   fprintf(fd,
           "\t-l, --tone-length:\n"
           "\t\tDecimal value of tone length in secs "
           "(def %.4f)\n", default_config.tone_length_sec);
   fprintf(fd,
           "\t-g, --volume-gain\n"
           "\t\tControl the volume of generated audio frames. The range is from"
           " 0 to 100.\n");
   fprintf(fd,
           "\t-i, --min-frequency:\n"
           "\t\tThe minimum frequency of generated audio frames."
           "(def %d)\n", default_config.min_frequency);
   fprintf(fd,
           "\t-x, --max-frequency\n"
           "\t\tThe maximum frequency of generated audio frames."
           "(def %d)\n", default_config.max_frequency);

   fprintf(fd,
           "\t-v, --verbose: Show debugging information.\n");
   fprintf(fd,
           "\t-h, --help: Show this page.\n");
 }

 void PrintSet(const std::set<int> &numbers, FILE *fd = stdout) {
   bool first = true;
   for (auto it : numbers) {
     if (!first)
       fprintf(fd, ", ");
     fprintf(fd, "%d", it);
     first = false;
   }
 }

 void PrintConfig(const AudioFunTestConfig &config, FILE *fd = stdout) {
   fprintf(fd, "Config values.\n");

   fprintf(fd, "\tSpeaker active channels: ");
   PrintSet(config.active_speaker_channels, fd);
   fprintf(fd, "\n");
   fprintf(fd, "\tMic active channels: ");
   PrintSet(config.active_mic_channels, fd);
   fprintf(fd, "\n");
   fprintf(fd, "\tAllowed delay: %.4f(s)\n", config.allowed_delay_sec);
   fprintf(fd, "\tFFT size: %d\n", config.fft_size);
   fprintf(fd, "\tConfidence threshold: %.4f\n", config.confidence_threshold);
   fprintf(fd, "\tMatch window size: %d\n", config.match_window_size);
   fprintf(fd, "\tPlayer parameter: %s\n", config.player_command.c_str());
   fprintf(fd, "\tPlayer FIFO name: %s\n", config.player_fifo.c_str());
   fprintf(fd, "\tRecorder parameter: %s\n", config.recorder_command.c_str());
   fprintf(fd, "\tRecorder FIFO name: %s\n", config.recorder_fifo.c_str());
   fprintf(fd, "\tSample format: %s\n", config.sample_format.to_string());
   fprintf(fd, "\tSample rate: %d\n", config.sample_rate);
   fprintf(fd,
           "\tNumber of Microphone channels: %d\n", config.num_mic_channels);
   fprintf(fd, "\tNumber of Speaker channels: %d\n",
           config.num_speaker_channels);
   fprintf(fd, "\tNumber of test rounds: %d\n", config.test_rounds);
   fprintf(fd, "\tTone length: %.4f(s)\n", config.tone_length_sec);
   fprintf(fd, "\tVolume gain: %d\n", config.volume_gain);
   fprintf(fd, "\tMinimum frequency: %d\n", config.min_frequency);
   fprintf(fd, "\tMaximum frequency: %d\n", config.max_frequency);

   if (config.verbose)
     fprintf(fd, "\t** Verbose **.\n");
 }

 // Randomly picks an integer from the given range [min, max],
 // including both end points.
 inline int RandomPick(int min, int max) {
   if (min > max) {
     fprintf(stderr, "Range error: min > max\n");
     assert(false);
   }

   static unsigned int seed = time(NULL) + getpid();
   return (rand_r(&seed) % (max - min + 1)) + min;
 }

 // Controls the main process of audiofuntest.
 void ControlLoop(const AudioFunTestConfig &config,
                  Evaluator *evaluator,
                  PlayClient *player,
                  RecordClient *recorder) {
   const double frequency_resolution =
       static_cast<double>(config.sample_rate) / config.fft_size;
   const int min_bin = config.min_frequency / frequency_resolution;
   const int max_bin = config.max_frequency / frequency_resolution;

   std::vector<int> passes(config.num_mic_channels);
   std::vector<bool> single_round_pass(config.num_mic_channels);

   size_t buf_size = config.fft_size * config.num_speaker_channels *
       config.sample_format.bytes();
   SineWaveGenerator generator(
       config.sample_rate,
       config.tone_length_sec,
       config.volume_gain);
   GeneratorPlayer generatorPlayer(
       buf_size,
       config.num_speaker_channels,
       config.active_speaker_channels,
       config.sample_format,
       player);

   for (int round = 1; round <= config.test_rounds; ++round) {
     std::fill(single_round_pass.begin(), single_round_pass.end(), false);
     int bin = RandomPick(min_bin, max_bin);
     double frequency = bin * frequency_resolution;

     generator.Reset(frequency);
     generatorPlayer.Play(&generator);

     evaluator->Evaluate(bin, recorder, &single_round_pass);
     for (int chn = 0; chn < config.num_mic_channels; ++chn) {
       if (single_round_pass[chn]) {
         ++passes[chn];
       }
     }
     generatorPlayer.Stop();

     printf("carrier = %d\n", bin);
     for (auto c : config.active_mic_channels) {
       const char *res = single_round_pass[c] ? "O" : "X";
       printf("%s: channel = %d, success = %d, fail = %d, rate = %.4f\n",
              res, c, passes[c], round - passes[c], 100.0 * passes[c] / round);
     }
   }
 }

 int main(int argc, char *argv[]) {
   // Parses configuration.ParamConfig
   AudioFunTestConfig config;
   if (!ParseOptions(argc, argv, &config)) {
     PrintUsage(argv[0]);
     return 1;
   }

   PrintConfig(config);

   PlayClient player(config);
   player.Start();

   RecordClient recorder(config);
   recorder.Start();

   Evaluator evaluator(config);

   // Starts evaluation.
   ControlLoop(config, &evaluator, &player, &recorder);

   // Terminates and cleans up.
   recorder.Terminate();
   player.Terminate();

   return 0;
 }
	// Copyright 2016 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <assert.h>
	#include <getopt.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include "include/binary_client.h"
	#include "include/common.h"
	#include "include/evaluator.h"
	#include "include/generator_player.h"
	#include "include/sample_format.h"
	#include "include/tone_generators.h"

	constexpr static const char *short_options =
	"a:m:d:n:o:w:P:f:R:F:r:t:c:C:T:l:g:i:x:hv";

	constexpr static const struct option long_options[] = {
	{"active-speaker-channels", 1, NULL, 'a'},
	{"active-mic-channels", 1, NULL, 'm'},
	{"allowed-delay", 1, NULL, 'd'},
	{"fft-size", 1, NULL, 'n'},
	{"confidence-threshold", 1, NULL, 'o'},
	{"match-window-size", 1, NULL, 'w'},
	{"player-command", 1, NULL, 'P'},
	{"player-fifo", 1, NULL, 'f'},
	{"recorder-command", 1, NULL, 'R'},
	{"recorder-fifo", 1, NULL, 'F'},
	{"sample-rate", 1, NULL, 'r'},
	{"sample-format", 1, NULL, 't'},
	{"num-mic-channels", 1, NULL, 'c'},
	{"num-speaker-channels", 1, NULL, 'C'},
	{"test-rounds", 1, NULL, 'T'},
	{"tone-length", 1, NULL, 'l'},
	{"volume-gain", 1, NULL, 'g'},
	{"min-frequency", 1, NULL, 'i'},
	{"max-frequency", 1, NULL, 'x'},

	// Other helper args.
	{"help", 0, NULL, 'h'},
	{"verbose", 0, NULL, 'v'},
	};

	// Parse the sample format. The input should be one of the string in
	// SampleFormat:Type.
	SampleFormat ParseSampleFormat(const char *arg) {
	SampleFormat sample_format;
	for (int format = SampleFormat::kPcmU8;
	format != SampleFormat::kPcmInvalid;
	format++) {
	sample_format = SampleFormat(SampleFormat::Type(format));
	if (strcmp(sample_format.to_string(), optarg) == 0) {
	return sample_format;
	}
	}
	fprintf(stderr, "Unknown sample format %s, using S16 instead.", arg);
	return SampleFormat(SampleFormat::kPcmS16);
	}

	bool ParseOptions(int argc, char const argv[], AudioFunTestConfig config) {
	int opt = 0;
	int optindex = -1;

	while ((opt = getopt_long(argc, argv, short_options,
	long_options,
	&optindex)) != -1) {
	switch (opt) {
	case 'a':
	ParseActiveChannels(optarg, &(config->active_speaker_channels));
	break;
	case 'm':
	ParseActiveChannels(optarg, &(config->active_mic_channels));
	break;
	case 'd':
	config->allowed_delay_sec = atof(optarg);
	break;
	case 'n':
	config->fft_size = atoi(optarg);
	if ((config->fft_size == 0) \|\|
	(config->fft_size & (config->fft_size - 1))) {
	fprintf(stderr, "FFT size needs to be positive & power of 2\n");
	return false;
	}
	break;
	case 'o':
	config->confidence_threshold = atof(optarg);
	break;
	case 'w':
	config->match_window_size = atoi(optarg);
	if (config->match_window_size % 2 == 0) {
	fprintf(stderr, "Match window size must be an odd value.\n");
	return false;
	}
	break;
	case 'P':
	config->player_command = std::string(optarg);
	break;
	case 'f':
	config->player_fifo = std::string(optarg);
	break;
	case 'R':
	config->recorder_command = std::string(optarg);
	break;
	case 'F':
	config->recorder_fifo = std::string(optarg);
	break;
	case 'r':
	config->sample_rate = atoi(optarg);
	break;
	case 't':
	config->sample_format = ParseSampleFormat(optarg);
	break;
	case 'c':
	config->num_mic_channels = atoi(optarg);
	break;
	case 'C':
	config->num_speaker_channels = atoi(optarg);
	break;
	case 'T':
	config->test_rounds = atoi(optarg);
	break;
	case 'l':
	config->tone_length_sec = atof(optarg);
	// Avoid overly short tones.
	if (config->tone_length_sec < 0.01) {
	fprintf(stderr,
	"Tone length too short. Must be 0.01s or greater.\n");
	return false;
	}
	break;
	case 'g':
	config->volume_gain = atoi(optarg);
	if (config->volume_gain < 0 \|\| config->volume_gain > 100) {
	fprintf(stderr, "Value of volume_gain is out of range.\n");
	return false;
	}
	break;
	case 'i':
	config->min_frequency = atoi(optarg);
	break;
	case 'x':
	config->max_frequency = atoi(optarg);
	break;
	case 'v':
	config->verbose = true;
	break;
	case 'h':
	return false;
	default:
	fprintf(stderr, "Unknown arguments %c\n", opt);
	assert(false);
	}
	}

	if (config->player_command.empty()) {
	fprintf(stderr, "player-command is not set.\n");
	return false;
	}

	if (config->recorder_command.empty()) {
	fprintf(stderr, "recorder-command is not set.\n");
	return false;
	}

	if (config->active_speaker_channels.empty()) {
	for (int i = 0; i < config->num_speaker_channels; ++i) {
	config->active_speaker_channels.insert(i);
	}
	}

	if (config->active_mic_channels.empty()) {
	for (int i = 0; i < config->num_mic_channels; ++i) {
	config->active_mic_channels.insert(i);
	}
	}

	if (config->min_frequency > config->max_frequency) {
	fprintf(stderr, "Range error: min_frequency > max_frequency\n");
	return false;
	}

	if (config->min_frequency < 0) {
	fprintf(stderr, "Range error: min_frequency < 0\n");
	return false;
	}
	return true;
	}

	void PrintUsage(const char name, FILE fd = stderr) {
	AudioFunTestConfig default_config;

	fprintf(fd,
	"Usage %s -P <player_command> -R <recorder_command> [options]\n",
	name);
	fprintf(fd,
	"\t-a, --active-speaker-channels:\n"
	"\t\tComma-separated list of speaker channels to play on. "
	"(def all channels)\n");
	fprintf(fd,
	"\t-m, --active-mic-channels:\n"
	"\t\tComma-separated list of mic channels to test. "
	"(def all channels)\n");
	fprintf(fd,
	"\t-d, --allowed-delay:\n"
	"\t\tAllowed latency between player & recorder "
	"(def %.4f).\n", default_config.allowed_delay_sec);
	fprintf(fd,
	"\t-n, --fftsize:\n"
	"\t\tLonger fftsize has more carriers but longer latency."
	" Also, fftsize needs to be power of 2"
	"(def %d)\n", default_config.fft_size);
	fprintf(fd,
	"\t-o, --confidence-threshold:\n"
	"\t\tThreshold of accumulated confidence to pass evaluation "
	"(def %.4f)\n", default_config.confidence_threshold);
	fprintf(fd,
	"\t-w, --match-window-size:\n"
	"\t\tNumber of bin to be used for calculating matching confidence. "
	"Should be an odd number."
	"(def %d)\n", default_config.match_window_size);
	fprintf(fd,
	"\t-P, --player-command:\n"
	"\t\tThe command used to play sound.\n");
	fprintf(fd,
	"\t-f, --player-fifo:\n"
	"\t\tThe named pipe used to send wave to the player. If not set, "
	"wave is send to player program via its stdin.\n");
	fprintf(fd,
	"\t-R, --recorder-command:\n"
	"\t\tThe command used to record sound.\n");
	fprintf(fd,
	"\t-F, --recorder-fifo:\n"
	"\t\tThe named pipe used to read recorded wave from the recorder "
	"program. If not set, wave is read from recorder program via "
	"its stdout.\n");
	fprintf(fd,
	"\t-r, --sample-rate:\n"
	"\t\tSample rate of generated wave in HZ "
	"(def %d)\n", default_config.sample_rate);
	fprintf(fd,
	"\t-t, --sample-format:\n"
	"\t\tFormat of recording & playing samples, should be one of u8, "
	"s16, s24, s32."
	"(def %s).\n", default_config.sample_format.to_string());
	fprintf(fd,
	"\t-c, --num-mic-channels:\n"
	"\t\tThe number of microphone channels "
	"(def %d)\n", default_config.num_mic_channels);
	fprintf(fd,
	"\t-C, --num-speaker-channels:\n"
	"\t\tThe number of speaker channels "
	"(def %d)\n", default_config.num_speaker_channels);
	fprintf(fd,
	"\t-T, --test-rounds:\n"
	"\t\tNumber of test rounds "
	"(def %d)\n", default_config.test_rounds);
	fprintf(fd,
	"\t-l, --tone-length:\n"
	"\t\tDecimal value of tone length in secs "
	"(def %.4f)\n", default_config.tone_length_sec);
	fprintf(fd,
	"\t-g, --volume-gain\n"
	"\t\tControl the volume of generated audio frames. The range is from"
	" 0 to 100.\n");
	fprintf(fd,
	"\t-i, --min-frequency:\n"
	"\t\tThe minimum frequency of generated audio frames."
	"(def %d)\n", default_config.min_frequency);
	fprintf(fd,
	"\t-x, --max-frequency\n"
	"\t\tThe maximum frequency of generated audio frames."
	"(def %d)\n", default_config.max_frequency);

	fprintf(fd,
	"\t-v, --verbose: Show debugging information.\n");
	fprintf(fd,
	"\t-h, --help: Show this page.\n");
	}

	void PrintSet(const std::set<int> &numbers, FILE *fd = stdout) {
	bool first = true;
	for (auto it : numbers) {
	if (!first)
	fprintf(fd, ", ");
	fprintf(fd, "%d", it);
	first = false;
	}
	}

	void PrintConfig(const AudioFunTestConfig &config, FILE *fd = stdout) {
	fprintf(fd, "Config values.\n");

	fprintf(fd, "\tSpeaker active channels: ");
	PrintSet(config.active_speaker_channels, fd);
	fprintf(fd, "\n");
	fprintf(fd, "\tMic active channels: ");
	PrintSet(config.active_mic_channels, fd);
	fprintf(fd, "\n");
	fprintf(fd, "\tAllowed delay: %.4f(s)\n", config.allowed_delay_sec);
	fprintf(fd, "\tFFT size: %d\n", config.fft_size);
	fprintf(fd, "\tConfidence threshold: %.4f\n", config.confidence_threshold);
	fprintf(fd, "\tMatch window size: %d\n", config.match_window_size);
	fprintf(fd, "\tPlayer parameter: %s\n", config.player_command.c_str());
	fprintf(fd, "\tPlayer FIFO name: %s\n", config.player_fifo.c_str());
	fprintf(fd, "\tRecorder parameter: %s\n", config.recorder_command.c_str());
	fprintf(fd, "\tRecorder FIFO name: %s\n", config.recorder_fifo.c_str());
	fprintf(fd, "\tSample format: %s\n", config.sample_format.to_string());
	fprintf(fd, "\tSample rate: %d\n", config.sample_rate);
	fprintf(fd,
	"\tNumber of Microphone channels: %d\n", config.num_mic_channels);
	fprintf(fd, "\tNumber of Speaker channels: %d\n",
	config.num_speaker_channels);
	fprintf(fd, "\tNumber of test rounds: %d\n", config.test_rounds);
	fprintf(fd, "\tTone length: %.4f(s)\n", config.tone_length_sec);
	fprintf(fd, "\tVolume gain: %d\n", config.volume_gain);
	fprintf(fd, "\tMinimum frequency: %d\n", config.min_frequency);
	fprintf(fd, "\tMaximum frequency: %d\n", config.max_frequency);

	if (config.verbose)
	fprintf(fd, "\t Verbose .\n");
	}

	// Randomly picks an integer from the given range [min, max],
	// including both end points.
	inline int RandomPick(int min, int max) {
	if (min > max) {
	fprintf(stderr, "Range error: min > max\n");
	assert(false);
	}

	static unsigned int seed = time(NULL) + getpid();
	return (rand_r(&seed) % (max - min + 1)) + min;
	}

	// Controls the main process of audiofuntest.
	void ControlLoop(const AudioFunTestConfig &config,
	Evaluator *evaluator,
	PlayClient *player,
	RecordClient *recorder) {
	const double frequency_resolution =
	static_cast<double>(config.sample_rate) / config.fft_size;
	const int min_bin = config.min_frequency / frequency_resolution;
	const int max_bin = config.max_frequency / frequency_resolution;

	std::vector<int> passes(config.num_mic_channels);
	std::vector<bool> single_round_pass(config.num_mic_channels);

	size_t buf_size = config.fft_size * config.num_speaker_channels *
	config.sample_format.bytes();
	SineWaveGenerator generator(
	config.sample_rate,
	config.tone_length_sec,
	config.volume_gain);
	GeneratorPlayer generatorPlayer(
	buf_size,
	config.num_speaker_channels,
	config.active_speaker_channels,
	config.sample_format,
	player);

	for (int round = 1; round <= config.test_rounds; ++round) {
	std::fill(single_round_pass.begin(), single_round_pass.end(), false);
	int bin = RandomPick(min_bin, max_bin);
	double frequency = bin * frequency_resolution;

	generator.Reset(frequency);
	generatorPlayer.Play(&generator);

	evaluator->Evaluate(bin, recorder, &single_round_pass);
	for (int chn = 0; chn < config.num_mic_channels; ++chn) {
	if (single_round_pass[chn]) {
	++passes[chn];
	}
	}
	generatorPlayer.Stop();

	printf("carrier = %d\n", bin);
	for (auto c : config.active_mic_channels) {
	const char *res = single_round_pass[c] ? "O" : "X";
	printf("%s: channel = %d, success = %d, fail = %d, rate = %.4f\n",
	res, c, passes[c], round - passes[c], 100.0 * passes[c] / round);
	}
	}
	}

	int main(int argc, char *argv[]) {
	// Parses configuration.ParamConfig
	AudioFunTestConfig config;
	if (!ParseOptions(argc, argv, &config)) {
	PrintUsage(argv[0]);
	return 1;
	}

	PrintConfig(config);

	PlayClient player(config);
	player.Start();

	RecordClient recorder(config);
	recorder.Start();

	Evaluator evaluator(config);

	// Starts evaluation.
	ControlLoop(config, &evaluator, &player, &recorder);

	// Terminates and cleans up.
	recorder.Terminate();
	player.Terminate();

	return 0;
	}