Attachment 871083 Details for Bug 982660 – Patch for 2.0.3 that adds enhancements, including support for configuration file

[patch] Patch for 2.0.3 that adds enhancements, including support for configuration file

audio-entropyd-allow-32bit.patch (text/plain), 71.92 KB, created by stan on 2014-03-05 18:40:53 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: stan

Created: 2014-03-05 18:40:53 UTC

Size: 71.92 KB

patch

obsolete

>--- audio-entropyd.c	2010-02-28 06:21:33.000000000 -0700
>+++ audio-entropyd.c	2014-03-05 10:45:29.688013075 -0700
>@@ -17,10 +17,11 @@
> #include <getopt.h>
> #include <unistd.h>
> #include <string.h>
> #include <syslog.h>
> #include <signal.h>
>+#include <time.h>
> #include <fcntl.h>
> #include <sys/stat.h>
> #include <sys/types.h>
> #include <sys/ioctl.h>
> #include <sys/wait.h>
>@@ -36,511 +37,1444 @@
> #include "proc.h"
> #include "val.h"
> #include "RNGTEST.h"
> #include "error.h"
> 
>-#define RANDOM_DEVICE				"/dev/random"
>-#define DEFAULT_SAMPLE_RATE			11025
>-#define PID_FILE				"/var/run/audio-entropyd.pid"
>-#define DEFAULT_CLICK_READ			(1 * DEFAULT_SAMPLE_RATE)
>-#define DEFAULT_POOLSIZE_FN                     "/proc/sys/kernel/random/poolsize"
>-#define	RNGTEST_PENALTY				(20000 / 8) /* how many bytes to skip when the rng-test fails */
>+#define RANDOM_DEVICE                     "/dev/random"
>+#define DEFAULT_FRAME_RATE                22050  
>+#define DEFAULT_SAMPLE_SIZE               11072
>+#define DEFAULT_SKIP_SIZE                 11025
>+#define DEFAULT_CONFIGURATION_FILE        "/etc/sysconfig/audio-entropyd"
>+#define PID_FILE                          "/var/run/audio-entropyd.pid"
>+#define DEFAULT_POOLSIZE_FN               "/proc/sys/kernel/random/poolsize"
>+#define RNGTEST_PENALTY                   (20000 / 8) /* how many bytes to skip when the rng-test fails */
> 
> void dolog(int level, char *format, ...);
> 
>+/* Global Variables - they all have a leading capital case, and
>+ * they are used throughout the program without passing.  That's why
>+ * the case is different, so they can be recognized.  
>+ * Not optimal as it can obscure the logic flow, but simple.  */
> extern int loggingstate;
>-int treshold = 0;
>-char skip_test = 0;
>-int error_state = 0;
>-char dofork = 1;
>-char *file = NULL;
>-
>-static char *cdevice = "hw:0";				/* capture device */
>-const char *id = "capture";
>-int err;
>-int verbose=0;
>-int format = -1;
>+int Always_Close = 0;
>+unsigned Frame_Rate = (unsigned) DEFAULT_FRAME_RATE;
>+unsigned Process_Frames = (unsigned) DEFAULT_SAMPLE_SIZE;
>+unsigned Skip_Frames = (unsigned) DEFAULT_SAMPLE_SIZE;
>+char Internal_Test = 0;
>+int Error_State = 0;
>+int Entropy_Filter = 30;
>+float Lower_Threshold = .0;
>+float Upper_Threshold = .5;
>+char Do_Fork = 1;
>+char *Capture_File = NULL;
>+static char *Capture_Device = "plughw:0";        /* capture device */
>+const char *Stream_Mode = "capture";
>+int Snd_Pcm_Err;
>+int Verbose=0;
>+int Snd_Pcm_Format = -1;
> 
>-#define max(x, y)	((x)>(y)?(x):(y))
>+#define max(x, y)  ((x)>(y)?(x):(y))
> 
> /* Prototypes */
>-void main_loop(const char *cdevice, int sample_rate);
>-int setparams(snd_pcm_t *chandle, int sample_rate);
>+void main_loop(void);
>+int parse_options (int option_count, char **options);
>+int read_config_file (FILE * infile, char ***config_options);
>+void * Alloc (size_t len);
>+char * StrnDup (char *str);
>+char * StrMem (size_t slen);
>+int setparams(snd_pcm_t *chandle);
> void usage(void);
> void credit_krng(int random_fd, struct rand_pool_info *entropy);
> void daemonise(void);
> void gracefully_exit(int signum);
> void logging_handler(int signum);
>-void get_random_data(int sample_rate, int skip_samples, int process_samples, int *n_output_bytes, char **output_buffer);
>-int add_to_kernel_entropyspool(int handle, char *buffer, int nbytes);
>+void get_random_data (snd_pcm_t *chandle, unsigned char *input_buffer, unsigned char *output_buffer, int *n_output_bytes);
>+void add_entropy_bit (char bit, unsigned char *output_buffer, int *n_output_bytes);
>+int add_to_kernel_entropyspool(int handle, unsigned char *buffer, int nbytes);
> 
> /* Functions */
> 
> int main(int argc, char **argv)
> {
>-	int sample_rate = DEFAULT_SAMPLE_RATE;
>-	int c;
>-	static struct option long_options[] =
>-	{
>-		{"device",	1, NULL, 'd' },
>-		{"do-not-fork",	1, NULL, 'n' },
>-		{"sample-rate", 1, NULL, 'N' },
>-		{"skip-test",	0, NULL, 's' },
>-		{"file",	1, NULL, 'f' },
>-		{"verbose",	0, NULL, 'v' },
>-		{"help",	0, NULL, 'h' },
>-		{NULL,		0, NULL, 0   }
>-	};
>-
>-	/* Process commandline options */
>-	while(1)
>-	{
>-		c = getopt_long (argc, argv, "f:nsr:d:N:vh", long_options, NULL);
>-		if (c == -1)
>-			break;
>-
>-		switch(c)
>-		{
>-			case 'f':
>-				file = optarg;
>-				break;
>-
>-			case 'n':
>-				dofork = 0;
>-				break;
>-
>-			case 'N':
>-				sample_rate = atoi(optarg);
>-				break;
>-
>-			case 'v':
>-				loggingstate = 1;
>-				verbose++;
>-				break;
>-
>-			case 's':
>-				skip_test = 1;
>-				break;
>-
>-			case 'd':
>-				cdevice = strdup(optarg);
>-				break;
>-
>-			case 'h':
>-				usage();
>-				exit(0);
>-
>-			case '?':
>-			default:
>-				fprintf(stderr, "Invalid commandline options.\n\n");
>-				usage();
>-				exit(1);
>-		}
>-	}
>-
>-	RNGTEST_init();
>-
>-	signal(SIGPIPE, SIG_IGN);
>-	signal(SIGHUP, gracefully_exit);
>-	signal(SIGINT, gracefully_exit);
>-	signal(SIGTERM, gracefully_exit);
>-	signal(SIGUSR1, logging_handler);
>-	signal(SIGUSR2, logging_handler);
>-
>-	openlog("audio-entropyd", LOG_CONS, LOG_DAEMON);
>-
>-	dolog(LOG_NOTICE, "audio-entropyd starting up");
>-
>-	if (mlockall(MCL_FUTURE | MCL_CURRENT) == -1)
>-		error_exit("mlockall failed");
>-
>-	if (dofork)
>-		daemonise();
>-
>-	main_loop(cdevice, sample_rate);
>+  int option_count = 0, iii;
>+  FILE *config_file;
>+  char **config_file_options;
>+
>+  config_file = fopen(DEFAULT_CONFIGURATION_FILE, "rt");
>+  if (!config_file)
>+    error_exit("Couldn't open configuration file: %s", DEFAULT_CONFIGURATION_FILE);
>+  option_count = read_config_file (config_file, &config_file_options);
>+  fclose(config_file);
>+  parse_options ( option_count, config_file_options);  // Process configuration file
>+  for (iii=0; iii < option_count; iii++)
>+  { free (config_file_options [iii]);
>+  }
>+  free (config_file_options);
>+  if (argc > 1)
>+  { optind = 0;  // start at first option
>+    opterr = 0;  // reset any error
>+    optopt = 0;  // reset any error
>+    optarg = NULL;  // reset any error
>+    parse_options (argc, argv);  // Process command line
>+  }
>+  RNGTEST_init();
>+  signal(SIGPIPE, SIG_IGN);
>+  signal(SIGHUP, gracefully_exit);
>+  signal(SIGINT, gracefully_exit);
>+  signal(SIGTERM, gracefully_exit);
>+  signal(SIGUSR1, logging_handler);
>+  signal(SIGUSR2, logging_handler);
>+  openlog("audio-entropyd", LOG_CONS, LOG_DAEMON);
>+  dolog(LOG_NOTICE, "audio-entropyd starting up with entropy filter %d", Entropy_Filter);
>+  if (mlockall(MCL_FUTURE | MCL_CURRENT) == -1)
>+    error_exit("mlockall failed");
>+  if (Do_Fork)
>+    daemonise();
>+  main_loop();
>+  exit(0);
>+}
> 
>-	exit(0);
>+/*
>+   Parse the options passed in the char** array.
>+   lines and comments.  Rets: 0 on success.
>+*/
>+int
>+parse_options (int option_count, char **options)
>+{ int c;
>+  static struct option long_options[] =
>+  {
>+    {"always_close",  0, NULL, 'a' },
>+    {"device",  1, NULL, 'd' },
>+    {"do-not-fork",  0, NULL, 'n' },
>+    {"entropy-filter",  1, NULL, 'e' },
>+    {"sample-rate", 1, NULL, 'r' },
>+    {"sample-size", 1, NULL, 'z' },
>+    {"skip-size", 1, NULL, 's' },
>+    {"internal-test",  0, NULL, 'i' },
>+    {"store-in-file",  1, NULL, 'f' },
>+    {"lower-threshold",  1, NULL, 'l' },
>+    {"upper-threshold",  1, NULL, 'u' },
>+    {"verbose",  0, NULL, 'v' },
>+    {"help",  0, NULL, 'h' },
>+    {NULL,    0, NULL, 0   }
>+  };
>+
>+  while(1)
>+  { c = getopt_long (option_count, options, "ad:e:f:hil:nr:s:u:vz:", long_options, NULL);
>+    if (c == -1)
>+      break;
>+    switch(c)
>+    { case 'f':
>+        Capture_File = StrnDup (optarg);
>+        break;
>+      case 'a':
>+        Always_Close = 1;
>+        break;
>+      case 'n':
>+        Do_Fork = 0;
>+        break;
>+      case 'r':
>+        Frame_Rate = (unsigned) atoi(optarg);
>+        break;
>+      case 'z':
>+        Process_Frames = (unsigned) atoi(optarg);
>+        break;
>+      case 's':
>+        Skip_Frames = (unsigned) atoi(optarg);
>+        break;
>+      case 'v':
>+        loggingstate = 1;
>+        Verbose++;
>+        break;
>+      case 'i':
>+        Internal_Test = 1;
>+        break;
>+      case 'e':
>+        Entropy_Filter = atoi(optarg);
>+        break;
>+      case 'l':
>+        Lower_Threshold = (float) atof(optarg);
>+        break;
>+      case 'u':
>+        Upper_Threshold = (float) atof(optarg);
>+        break;
>+      case 'd':
>+        Capture_Device = StrnDup(optarg);
>+        break;
>+      case 'h':
>+        usage();
>+        exit(0);
>+      case '?':
>+      default:
>+        fprintf(stderr, "Invalid commandline options.\n\n");
>+        usage();
>+        exit(1);
>+        break;
>+    }
>+  }
>+  return 0;
> }
> 
>-int setparams(snd_pcm_t *chandle, int sample_rate)
>+/*
>+   Read a configuration file, discarding blank
>+   lines and comments.  Rets: option count on success.
>+   Everything from the file is put into an argv like array.
>+*/
>+
>+int
>+read_config_file (FILE * infile, char ***config_options)
> {
>-	snd_pcm_hw_params_t *ct_params;		/* templates with rate, format and channels */
>-	snd_pcm_hw_params_alloca(&ct_params);
>+  char *curr_option, *retptr, *workline, *cmnt, *token;
>+  char **all_options;
>+  int iii, line_count = 0, configuration_count = 0;
>+
>+  workline= StrMem (256);
>+  curr_option = StrnDup ("audio_entropyd");  // save the program name to simulate argv
>+  all_options = (char **) StrMem ((sizeof (char *)) * (configuration_count+1));  // allocate an array for option char pointers, including the new option
>+  configuration_count++;  // update the option count
>+  *(all_options + configuration_count - 1) = curr_option;  // append the new option pointer
>+  *config_options = all_options;  // point to the new option pointer array
>+  retptr = fgets (workline, 256, infile);
>+  if (retptr == NULL)
>+    error_exit ("Unable to read line from configuration file");
>+  while (*workline != '\0')
>+  { line_count++;
>+    token = strtok (workline, " \t\n");    // get first token separated by spaces, tabs, or newline
>+    if (token)                  // not an empty line
>+    { cmnt = strchr (workline, '#');
>+      if (token[0] == '-')      // options line
>+      { if (cmnt)
>+          strncpy (cmnt, "\0", 1);     // truncate at comment
>+        curr_option = StrnDup (workline);  // duplicate the option
>+        all_options = (char **) StrMem ((sizeof (char *)) * (configuration_count+1));  // allocate an array for option char pointers, including the new option
>+        for (iii = 0; iii < configuration_count; iii++)  // transfer existing pointers to the new array of option pointers
>+        { *(all_options + iii) = *((*config_options) + iii);
>+        }
>+        configuration_count++;  // update the option count
>+        *(all_options + configuration_count - 1) = curr_option;  // append the new option pointer
>+        free (*config_options);  // free the existing option pointer array
>+        *config_options = all_options;  // point to the new option pointer array
>+      }
>+      else if (token[0] == '#') // line is a comment
>+        ;  // do nothing
>+      else
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "Skipped line %d in configuration file with invalid %s at start of line", line_count, token);
>+      }
>+    }
>+    memset (workline, 0x00, 256);
>+    retptr = fgets (workline, 256, infile);
>+  }
>+  curr_option = NULL;  // terminate like argv is terminated, with a null char*.
>+  all_options = (char **) StrMem ((sizeof (char *)) * (configuration_count+1));  // allocate an array for option char pointers, including the new option
>+  for (iii = 0; iii < configuration_count; iii++)  // transfer existing pointers to the new array of option pointers
>+  { *(all_options + iii) = *((*config_options) + iii);
>+  }
>+  *(all_options + configuration_count) = curr_option;
>+  free (*config_options);  // free the existing option pointer array
>+  //config_options = &all_options;  // point to the new option pointer array
>+  *config_options = all_options;  // point to the new option pointer array
>+  if (*workline == '\0')
>+  { if (feof (infile))
>+    { free (workline);
>+      return configuration_count;
>+    }
>+    free (workline);
>+    error_exit ("Read error on configuration file");
>+  }
>+  free (workline);
>+  return configuration_count;
>+}
> 
>-	err = snd_pcm_hw_params_any(chandle, ct_params);
>-	if (err < 0)
>-		error_exit("Broken configuration for %s PCM: no configurations available: %s", id, snd_strerror(err));
>-
>-	/* Disable rate resampling */
>-	err = snd_pcm_hw_params_set_rate_resample(chandle, ct_params, 0);
>-	if (err < 0)
>-		error_exit("Could not disable rate resampling: %s", snd_strerror(err));
>-
>-	/* Set access to SND_PCM_ACCESS_RW_INTERLEAVED */
>-	err = snd_pcm_hw_params_set_access(chandle, ct_params, SND_PCM_ACCESS_RW_INTERLEAVED);
>-	if (err < 0)
>-		error_exit("Could not set access to SND_PCM_ACCESS_RW_INTERLEAVED: %s", snd_strerror(err));
>-
>-	/* Restrict a configuration space to have rate nearest to our target rate */
>-	err = snd_pcm_hw_params_set_rate_near(chandle, ct_params, &sample_rate, 0);
>-	if (err < 0)
>-		error_exit("Rate %iHz not available for %s: %s", sample_rate, id, snd_strerror(err));
>-
>-	/* Set sample format */
>-	format = SND_PCM_FORMAT_S16_BE;
>-	err = snd_pcm_hw_params_set_format(chandle, ct_params, format);
>-	if (err < 0)
>-	{
>-		format = SND_PCM_FORMAT_S16_LE;
>-		err = snd_pcm_hw_params_set_format(chandle, ct_params, format);
>-	}
>-	if (err < 0)
>-		error_exit("Sample format (SND_PCM_FORMAT_S16_BE and _LE) not available for %s: %s", id, snd_strerror(err));
>-
>-	/* Set stereo */
>-	err = snd_pcm_hw_params_set_channels(chandle, ct_params, 2);
>-	if (err < 0)
>-		error_exit("Channels count (%i) not available for %s: %s", 2, id, snd_strerror(err));
>-
>-	/* Apply settings to sound device */
>-	err = snd_pcm_hw_params(chandle, ct_params);
>-	if (err < 0)
>-		error_exit("Could not apply settings to sound device!");
>+void *
>+Alloc (size_t len)
>+{ void *p = calloc (1, len);
>+  if (!p)
>+    error_exit ("Out of memory in request for %u", len);
>+  return p;
>+}
> 
>-	return 0;
>+char *
>+StrnDup (char *str)
>+{ size_t len = strlen (str);
>+  char *rv = strndup (str, len);
>+  if (!rv)
>+    error_exit ("Out of memory in StrnDup");
>+  return rv;
> }
> 
>-void main_loop(const char *cdevice, int sample_rate)
>-{
>-	unsigned char *output_buffer = NULL;
>-	int n_output_bytes = -1;
>-	int random_fd = -1, max_bits;
>-	FILE *poolsize_fh;
>-
>-	/* Open kernel random device */
>-	random_fd = open(RANDOM_DEVICE, O_RDWR);
>-	if (random_fd == -1)
>-		error_exit("Couldn't open random device: %m");
>-
>-	/* find out poolsize */
>-	poolsize_fh = fopen(DEFAULT_POOLSIZE_FN, "rb");
>-	if (!poolsize_fh)
>-		error_exit("Couldn't open poolsize file: %m");
>-	fscanf(poolsize_fh, "%d", &max_bits);
>-	fclose(poolsize_fh);
>-
>-	/* first get some data so that we can immediately submit something when the
>-	 * kernel entropy-buffer gets below some limit
>-	 */
>-	get_random_data(sample_rate, DEFAULT_CLICK_READ, DEFAULT_SAMPLE_RATE, &n_output_bytes, &output_buffer);
>-
>-	/* Main read loop */
>-	for(;;)
>-	{	
>-		int added = 0, before, loop, after;
>-		fd_set write_fd;
>-		FD_ZERO(&write_fd);
>-		FD_SET(random_fd, &write_fd);
>-
>-		if (!file)
>-		{
>-			for(;;) 
>-			{ 
>-				int rc = select(random_fd+1, NULL, &write_fd, NULL, NULL); /* wait for krng */ 
>-				if (rc >= 0) break; 
>-				if (errno != EINTR) 
>-					error_exit("Select error: %m"); 
>-			}
>-		}
>-
>-		/* find out how many bits to add */
>-		if (ioctl(random_fd, RNDGETENTCNT, &before) == -1)
>-			error_exit("Couldn't query entropy-level from kernel");
>-
>-		dolog(LOG_DEBUG, "woke up due to low entropy state (%d bits left)", before);
>-
>-		/* loop until the buffer is (supposed to be) full: we do NOT check the number of bits
>-		 * currently in the buffer each iteration, since (on a heavily used random-driver)
>-		 * audio-entropyd might run constantly, using a lot of cpu-usage
>-		 */
>-		if (verbose > 1)
>-			printf("max_bits: %d\n", max_bits);
>-		for(loop=0; loop < max_bits;)
>-		{
>-			if (verbose > 1)
>-				dolog(LOG_DEBUG, "n_output_bytes: %d", n_output_bytes);
>-
>-			if (n_output_bytes > 0)
>-			{
>-				int cur_added;
>-
>-				if (file)
>-				{
>-					FILE *fh = fopen(file, "a+");
>-					if (!fh)
>-						error_exit("error accessing file %s", file);
>-
>-					if (fwrite(output_buffer, 1, n_output_bytes, fh) != n_output_bytes)
>-						error_exit("error writeing to file");
>-
>-					fclose(fh);
>-
>-					cur_added = n_output_bytes * 8;
>-				}
>-				else
>-				{
>-					cur_added = add_to_kernel_entropyspool(random_fd, output_buffer, n_output_bytes);
>-				}
>-
>-				added += cur_added;
>-				loop += cur_added;
>-
>-				if (verbose > 1)
>-					dolog(LOG_DEBUG, "%d bits of data, %d bits usable were added, total %d added", n_output_bytes * 8, cur_added, added);
>-			}
>-
>-			/* Get number of bits in KRNG after credit */
>-			if (ioctl(random_fd, RNDGETENTCNT, &after) == -1)
>-				error_exit("Coundn't query entropy-level from kernel: %m");
>-
>-			if (verbose > 1 && after < max_bits)
>-				dolog(LOG_DEBUG, "minimum level not reached: %d", after);
>-
>-			free(output_buffer);
>-			output_buffer = NULL;
>-			get_random_data(sample_rate, DEFAULT_CLICK_READ, DEFAULT_SAMPLE_RATE, &n_output_bytes, &output_buffer);
>-		}
>+/* Allocate a string of the passed in size from memory.
>+ * Strings allocated with this routine can use the StrCat
>+ * routine below safely.  Does *not* allocate an extra
>+ * position for the NULL terminator.  Callers responsibility. */
>+char *
>+StrMem (size_t slen)
>+{ char *nstr = NULL;
>+  nstr = (char *) Alloc (slen);
>+  if (!nstr)
>+    error_exit ("Out of memory in StrMem");
>+  return nstr;
>+}
>+
>+int setparams(snd_pcm_t *chandle)
>+{ 
>+  snd_pcm_hw_params_t *ct_params;    /* templates with rate, format and channels */
>+  snd_pcm_hw_params_alloca(&ct_params);
>+
>+  Snd_Pcm_Err = snd_pcm_hw_params_any(chandle, ct_params);
>+  if (Snd_Pcm_Err < 0)
>+    error_exit("Broken configuration for %s PCM: no configurations available: %s", Stream_Mode, snd_strerror(Snd_Pcm_Err));
>+
>+  /* Disable rate resampling */
>+  // redundant with set_rate_near, as set_rate_near always picks a native rate of the device that would not be resampled.
>+  //Snd_Pcm_Err = snd_pcm_hw_params_set_rate_resample(chandle, ct_params, 0);
>+  //if (Snd_Pcm_Err < 0)
>+  //  error_exit("Could not disable rate resampling: %s", snd_strerror(Snd_Pcm_Err));
>+
>+  /* Set access to SND_PCM_ACCESS_RW_INTERLEAVED */
>+  Snd_Pcm_Err = snd_pcm_hw_params_set_access(chandle, ct_params, SND_PCM_ACCESS_RW_INTERLEAVED);
>+  if (Snd_Pcm_Err < 0)
>+    error_exit("Could not set access to SND_PCM_ACCESS_RW_INTERLEAVED: %s", snd_strerror(Snd_Pcm_Err));
>+
>+  /* Restrict a configuration space to have rate nearest to our target rate */
>+  Snd_Pcm_Err = snd_pcm_hw_params_set_rate_near(chandle, ct_params, &Frame_Rate, 0);
>+  if (Snd_Pcm_Err < 0)
>+    error_exit("Rate %iHz not available for %s: %s", Frame_Rate, Stream_Mode, snd_strerror(Snd_Pcm_Err));
>+
>+  /* Set sample format appropriate for architecture */
>+  int test_int = 1;
>+  if ((* (char *) &test_int) == 1)
>+  { Snd_Pcm_Format = SND_PCM_FORMAT_S32_LE;
>+    Snd_Pcm_Err = snd_pcm_hw_params_set_format(chandle, ct_params, Snd_Pcm_Format);
>+    if (Snd_Pcm_Err < 0)
>+    { error_exit("Sample format SND_PCM_FORMAT_S32_LE not available for %s: %s", Stream_Mode, snd_strerror(Snd_Pcm_Err));
>+    }
>+  } 
>+  else
>+  { Snd_Pcm_Format = SND_PCM_FORMAT_S32_BE;
>+    Snd_Pcm_Err = snd_pcm_hw_params_set_format(chandle, ct_params, Snd_Pcm_Format);
>+    if (Snd_Pcm_Err < 0)
>+    { error_exit("Sample format SND_PCM_FORMAT_S32_BE not available for %s: %s", Stream_Mode, snd_strerror(Snd_Pcm_Err));
>+    }
>+  }
>+
>+  /* Set stereo */
>+  Snd_Pcm_Err = snd_pcm_hw_params_set_channels(chandle, ct_params, 2);
>+  if (Snd_Pcm_Err < 0)
>+    error_exit("Channels count (%i) not available for %s: %s", 2, Stream_Mode, snd_strerror(Snd_Pcm_Err));
>+
>+  /* Apply settings to sound device */
>+  Snd_Pcm_Err = snd_pcm_hw_params(chandle, ct_params);
>+  if (Snd_Pcm_Err < 0)
>+    error_exit("Could not apply settings to sound device!");
>+
>+  int can_pause = snd_pcm_hw_params_can_pause (ct_params);
>+  int can_resume = snd_pcm_hw_params_can_resume (ct_params);
>+  if (can_pause == 1 && can_resume == 1)
>+    return 1;
>+  else
>+    return 0;
>+}
> 
>-		dolog(LOG_INFO, "Entropy credit of %i bits made (%i bits before, %i bits after)", added, before, after);
>-	}
>+void main_loop(void)
>+{ unsigned input_buffer_size, output_buffer_size;
>+  unsigned char *input_buffer = NULL;
>+  unsigned char *output_buffer = NULL;
>+  int can_pause_resume = 0, pause = 1, resume = 0;
>+  int n_output_bytes = -1;
>+  int random_fd = -1, max_bits;
>+  FILE *poolsize_fh;
>+  snd_pcm_t *chandle = NULL;
>+
>+  if ((Snd_Pcm_Err = snd_pcm_open(&chandle, Capture_Device, SND_PCM_STREAM_CAPTURE, 0)) < 0)
>+    error_exit("Record open error: %s", snd_strerror(Snd_Pcm_Err));
>+
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "main loop chandle %p", chandle);
>+
>+  /* Open and set up ALSA device for reading */
>+  can_pause_resume = setparams(chandle);
>+
>+  input_buffer_size = snd_pcm_frames_to_bytes(chandle, Process_Frames);
>+  input_buffer = (unsigned char *)malloc(input_buffer_size);
>+  output_buffer_size = (Process_Frames / 8) + (8 - ((Process_Frames / 8) % 8));  // max of 1 bit of entropy per frame
>+  output_buffer = (unsigned char *)malloc(output_buffer_size);
>+  if (!input_buffer || !output_buffer)
>+    error_exit("problem allocating %d bytes of memory", input_buffer_size);
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "Input buffer size: %d bytes", input_buffer_size);
>+
>+  /* Discard the first data read */
>+  /* it often contains weird looking data - probably a click from */
>+  /* driver loading / card initialisation */
>+  /* Read a buffer of audio */
>+  int total = Skip_Frames;
>+  int n_to_do = Process_Frames;
>+  if (Skip_Frames < Process_Frames)
>+    n_to_do = Skip_Frames;
>+  unsigned char *dummy = input_buffer;
>+  while (total > 0)
>+  { while (n_to_do > 0)
>+    { snd_pcm_sframes_t frames_read = snd_pcm_readi(chandle, dummy, Process_Frames);
>+      /* Make  sure we  aren't hitting a disconnect/suspend case */
>+      if (frames_read < 0)
>+        snd_pcm_recover(chandle, frames_read, 0);
>+      /* Nope, something else is wrong. Bail.  */
>+      if (frames_read < 0)
>+      { snd_pcm_close(chandle);
>+        free(input_buffer);
>+        free(output_buffer);
>+         error_exit("Read initial throw away data error: %m");
>+      } 
>+      else
>+      { n_to_do -= frames_read;
>+        total -= frames_read;
>+        dummy += frames_read;  
>+      }
>+    }
>+    n_to_do = Process_Frames;
>+    dummy = input_buffer;
>+  }
>+  /* Open kernel random device */
>+  random_fd = open(RANDOM_DEVICE, O_RDWR);
>+  if (random_fd == -1)
>+    error_exit("Couldn't open random device: %m");
>+
>+  /* find out poolsize */
>+  poolsize_fh = fopen(DEFAULT_POOLSIZE_FN, "rb");
>+  if (!poolsize_fh)
>+    error_exit("Couldn't open poolsize file: %m");
>+  fscanf(poolsize_fh, "%d", &max_bits);
>+  fclose(poolsize_fh);
>+  /* first get some data so that we can immediately submit something when the
>+   * kernel entropy-buffer gets below some limit
>+   */
>+  get_random_data(chandle, input_buffer, output_buffer, &n_output_bytes);
>+  if (can_pause_resume && Always_Close == 0)
>+    snd_pcm_pause (chandle, pause);
>+  else
>+    snd_pcm_close(chandle);
>+  /* Main read loop */
>+  for(;;)
>+  {  int added = 0, before, loop, after;
>+    fd_set write_fd;
>+    FD_ZERO(&write_fd);
>+    FD_SET(random_fd, &write_fd);
>+    if (!Capture_File)
>+    { for(;;) 
>+      { int rc = select(random_fd+1, NULL, &write_fd, NULL, NULL); /* wait for krng */ 
>+        if (Verbose > 1)
>+          dolog(LOG_DEBUG, "select return code rc %d", rc);
>+        if (rc >= 0)
>+          break; 
>+        else if (errno != EINTR) 
>+          error_exit("Select error: %m"); 
>+      }
>+    }
>+    /* find out how many bits to add */
>+    if (ioctl(random_fd, RNDGETENTCNT, &before) == -1)
>+      error_exit("Couldn't query entropy-level from kernel");
>+    dolog(LOG_DEBUG, "woke up due to low entropy state (%d bits left)", before);
>+    /* loop until the buffer is (supposed to be) full: we do NOT check the number of bits
>+     * currently in the buffer each iteration, since (on a heavily used random-driver)
>+     * audio-entropyd might run constantly, using a lot of cpu-usage
>+     */
>+    if (Verbose > 1)
>+      printf("max_bits: %d\n", max_bits);
>+    if (can_pause_resume && Always_Close == 0)
>+      snd_pcm_pause (chandle, resume);
>+    else  // no pause resume on this device, have to re initialize each time to avoid overrun errors
>+    { if ((Snd_Pcm_Err = snd_pcm_open(&chandle, Capture_Device, SND_PCM_STREAM_CAPTURE, 0)) < 0)
>+        error_exit("Record open error: %s", snd_strerror(Snd_Pcm_Err));
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "main loop chandle %p", chandle);
>+      /* Open and set up ALSA device for reading */
>+      setparams(chandle);
>+      /* Discard the first data read */
>+      /* it often contains weird looking data - probably a click from */
>+      /* driver loading / card initialisation */
>+      /* Read a buffer of audio */
>+      int total = Skip_Frames;
>+      int n_to_do = Process_Frames;
>+      if (Skip_Frames < Process_Frames)
>+        n_to_do = Skip_Frames;
>+      unsigned char *dummy = input_buffer;
>+      while (total > 0)
>+      { while (n_to_do > 0)
>+        { snd_pcm_sframes_t frames_read = snd_pcm_readi(chandle, dummy, Process_Frames);
>+          /* Make  sure we  aren't hitting a disconnect/suspend case */
>+          if (frames_read < 0)
>+            snd_pcm_recover(chandle, frames_read, 0);
>+          /* Nope, something else is wrong. Bail.  */
>+          if (frames_read < 0)
>+          { snd_pcm_close(chandle);
>+            free(input_buffer);
>+            free(output_buffer);
>+            error_exit("Read initial throw away data error: %m");
>+          } 
>+          else
>+          { n_to_do -= frames_read;
>+            total -= frames_read;
>+            dummy += frames_read;  
>+          }
>+        }
>+        n_to_do = Process_Frames;
>+        dummy = input_buffer;
>+      }
>+    }
>+    for(loop=0; loop < max_bits;)
>+    { if (Verbose > 1)
>+        dolog(LOG_DEBUG, "n_output_bytes: %d", n_output_bytes);
>+      if (n_output_bytes > 0)
>+      { int cur_added;
>+        if (Capture_File)
>+        { FILE *fh = fopen(Capture_File, "a+");
>+          if (!fh)
>+            error_exit("error accessing Capture_File %s", Capture_File);
>+          if (fwrite(output_buffer, 1, n_output_bytes, fh) != n_output_bytes)
>+            error_exit("error writeing to Capture_File");
>+          fclose(fh);
>+          cur_added = n_output_bytes * 8;
>+        } 
>+        else
>+          cur_added = add_to_kernel_entropyspool(random_fd, output_buffer, n_output_bytes);
>+        added += cur_added;
>+        loop += cur_added;
>+        if (Verbose > 1)
>+          dolog(LOG_DEBUG, "%d bits of data, %d bits usable were added, total %d added", n_output_bytes * 8, cur_added, added);
>+      }
>+      /* Get number of bits in KRNG after credit */
>+      if (ioctl(random_fd, RNDGETENTCNT, &after) == -1)
>+        error_exit("Coundn't query entropy-level from kernel: %m");
>+      if (Verbose > 1 && after < max_bits)
>+        dolog(LOG_DEBUG, "minimum level not reached: %d", after);
>+      memset (output_buffer, 0x00, output_buffer_size);
>+      get_random_data(chandle, input_buffer, output_buffer, &n_output_bytes);
>+    }
>+    dolog(LOG_INFO, "Entropy credit of %i bits made (%i bits before, %i bits after)", added, before, after);
>+    if (can_pause_resume && Always_Close == 0)
>+      snd_pcm_pause (chandle, pause);
>+    else
>+      snd_pcm_close(chandle);
>+  }
>+  if (can_pause_resume && Always_Close == 0)
>+    snd_pcm_close(chandle);
>+  free(input_buffer);
>+  free(output_buffer);
> }
> 
>-int add_to_kernel_entropyspool(int handle, char *buffer, int nbytes)
>+int add_to_kernel_entropyspool(int handle, unsigned char *buffer, int nbytes)
> {
>-	double nbits;
>-	struct rand_pool_info *output;
>+  double nbits;
>+  struct rand_pool_info *output;
> 
>-	output = (struct rand_pool_info *)malloc(sizeof(struct rand_pool_info) + nbytes);
>-	if (!output)
>-		error_exit("malloc failure in add_to_kernel_entropyspool");
>-
>-	// calculate number of bits in the block of
>-	// data. put in structure
>-	nbits = calc_nbits_in_data((unsigned char *)buffer, nbytes);
>-	if (nbits >= 1.0)
>-	{
>-		output -> entropy_count = (int)nbits;
>-		output -> buf_size      = nbytes;
>-		memcpy(output -> buf, buffer, nbytes);
>-
>-		if (ioctl(handle, RNDADDENTROPY, output) == -1)
>-			error_exit("RNDADDENTROPY failed!");
>-	}
>+  output = (struct rand_pool_info *)malloc(sizeof(struct rand_pool_info) + nbytes);
>+  if (!output)
>+    error_exit("malloc failure in add_to_kernel_entropyspool");
>+
>+  // calculate number of bits in the block of
>+  // data. put in structure
>+  nbits = calc_nbits_in_data((unsigned char *)buffer, nbytes);
>+  if (nbits >= 1.0)
>+  {
>+    output -> entropy_count = (int)nbits;
>+    output -> buf_size      = nbytes;
>+    memcpy(output -> buf, buffer, nbytes);
>+
>+    if (ioctl(handle, RNDADDENTROPY, output) == -1)
>+      error_exit("RNDADDENTROPY failed!");
>+  }
> 
>-	free(output);
>+  free(output);
> 
>-	return (int)nbits;
>+  return (int)nbits;
> }
> 
> #define order(a, b)     (((a) == (b)) ? -1 : (((a) > (b)) ? 1 : 0))
> 
>-void get_random_data(int sample_rate, int skip_samples, int process_samples, int *n_output_bytes, char **output_buffer)
>+void get_random_data (snd_pcm_t *chandle, unsigned char *input_buffer, unsigned char *output_buffer, int *n_output_bytes)
> {
>-	int n_to_do, bits_out=0, loop;
>-	char *dummy;
>-	static short psl=0, psr=0; /* previous samples */
>+  int n_to_do, loop;
>+  unsigned char *dummy;
>+	static int psl=0, psr=0; /* previous samples */
> 	static char a=1; /* alternater */
>-	unsigned char byte_out=0;
>-	int input_buffer_size;
>-	char *input_buffer;
>-	snd_pcm_t *chandle;
>-
>-	if (verbose > 1)
>-		dolog(LOG_DEBUG, "get_random_data(%p, %d, %d, %p, %p)", chandle, skip_samples, process_samples, n_output_bytes, output_buffer);
>-
>-	if ((err = snd_pcm_open(&chandle, cdevice, SND_PCM_STREAM_CAPTURE, 0)) < 0)
>-		error_exit("Record open error: %s", snd_strerror(err));
>-
>-	/* Open and set up ALSA device for reading */
>-	setparams(chandle, sample_rate);
>-
>-	*n_output_bytes=0;
>-
>-	input_buffer_size = snd_pcm_frames_to_bytes(chandle, max(skip_samples, process_samples)) * 2; /* *2: stereo! */
>-	input_buffer = (char *)malloc(input_buffer_size);
>-	*output_buffer = (char *)malloc(input_buffer_size);
>-	if (!input_buffer || !output_buffer)
>-		error_exit("problem allocating %d bytes of memory", input_buffer_size);
>-	if (verbose > 1)
>-		dolog(LOG_DEBUG, "Input buffer size: %d bytes", input_buffer_size);
>-
>-	/* Discard the first data read */
>-	/* it often contains weird looking data - probably a click from */
>-	/* driver loading / card initialisation */
>-	snd_pcm_sframes_t garbage_frames_read = snd_pcm_readi(chandle, input_buffer, skip_samples);
>-	/* Make sure we aren't hitting a disconnect/suspend case */
>-	if (garbage_frames_read < 0)
>-		snd_pcm_recover(chandle, garbage_frames_read, 0);
>-	/* Nope, something else is wrong. Bail. */
>-	if (garbage_frames_read < 0)
>-		error_exit("Get random data: read error: %m");
>-
>-	/* Read a buffer of audio */
>-	n_to_do = process_samples * 2;
>-	dummy = input_buffer;
>-	while (n_to_do > 0)
>-	{
>-		snd_pcm_sframes_t frames_read = snd_pcm_readi(chandle, dummy, n_to_do);
>-		/* Make	sure we	aren't hitting a disconnect/suspend case */
>-		if (frames_read < 0)
>-			frames_read = snd_pcm_recover(chandle, frames_read, 0);
>-		/* Nope, something else is wrong. Bail.	*/
>-		if (frames_read < 0)
>-			error_exit("Read error: %m");
>-		if (frames_read == -1) 
>-		{
>-			if (errno != EINTR)
>-				error_exit("Read error: %m");
>-		}
>-		else
>-		{
>-			n_to_do -= frames_read;
>-			dummy += frames_read;	
>-		}
>-	}
>-	snd_pcm_close(chandle);
>-
>-	/* de-biase the data */
>-	for(loop=0; loop<(process_samples * 2/*16bits*/ * 2/*stereo*/ * 2); loop+=8)
>-	{
>-		int w1, w2, w3, w4, o1, o2;
>-
>-		if (format == SND_PCM_FORMAT_S16_BE)
>-		{
>-			w1 = (input_buffer[loop+0]<<8) + input_buffer[loop+1];
>-			w2 = (input_buffer[loop+2]<<8) + input_buffer[loop+3];
>-			w3 = (input_buffer[loop+4]<<8) + input_buffer[loop+5];
>-			w4 = (input_buffer[loop+6]<<8) + input_buffer[loop+7];
>-		}
>-		else
>-		{
>-			w1 = (input_buffer[loop+1]<<8) + input_buffer[loop+0];
>-			w2 = (input_buffer[loop+3]<<8) + input_buffer[loop+2];
>-			w3 = (input_buffer[loop+5]<<8) + input_buffer[loop+4];
>-			w4 = (input_buffer[loop+7]<<8) + input_buffer[loop+6];
>-		}
>-
>-		/* Determine order of channels for each sample, subtract previous sample
>-		 * to compensate for unbalanced audio devices */
>-		o1 = order(w1-psl, w2-psr);
>-		o2 = order(w3-psl, w4-psr);
>-		if (a > 0)
>-		{
>-			psl = w3;
>-			psr = w4;
>-		}
>-		else
>-		{
>-			psl = w1;
>-			psr = w2;
>-		}
>-
>-		/* If both samples have the same order, there is bias in the samples, so we
>-		 * discard them; if both channels are equal on either sample, we discard
>-		 * them too; additionally, alternate the sample we'll use next (even more
>-		 * bias removal) */
>-		if (o1 == o2 || o1 < 0 || o2 < 0)
>-		{
>-			a = -a;
>-		}
>-		else
>-		{
>-			/* We've got a random bit; the bit is either the order from the first or
>-			 * the second sample, determined by the alternator 'a' */
>-			char bit = (a > 0) ? o1 : o2;
>-
>-			byte_out <<= 1;
>-			byte_out += bit;
>-
>-			bits_out++;
>-
>-			if (bits_out>=8)
>-			{
>-				if (error_state == 0 || skip_test == 0)
>-				{
>-					(*output_buffer)[*n_output_bytes]=byte_out;
>-					(*n_output_bytes)++;
>-				}
>-				bits_out=0;
>-
>-				RNGTEST_add(byte_out);
>-				if (skip_test == 0 && RNGTEST() == -1)
>-				{
>-					if (error_state == 0)
>-						dolog(LOG_CRIT, "test of random data failed, skipping %d bytes before re-using data-stream (%d bytes in flush)", RNGTEST_PENALTY, error_state);
>-					error_state = RNGTEST_PENALTY;
>-					*n_output_bytes = 0;
>-				}
>-				else
>-				{
>-					if (error_state > 0)
>-					{
>-						error_state--;
>-
>-						if (error_state == 0)
>-							dolog(LOG_INFO, "Restarting fetching of entropy data");
>-					}
>-				}
>-			}
>-		}
>-	}
>+  int min_left_val = 0x0fffffff, max_left_val = 0, min_right_val = 0x0fffffff, max_right_val = 0;
>+  long left_input_total = 0, right_input_total = 0;
>+  float dc_offset_left = 0.0, dc_offset_right = 0.0;
>+
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "get_random_data(%p, %u, %d, %d, %p, %p)", chandle, Frame_Rate, Process_Frames, input_buffer, output_buffer, n_output_bytes);
>+  *n_output_bytes=0;
>+  /* Read a buffer of audio */
>+  n_to_do = Process_Frames;
>+  dummy = input_buffer;
>+  while (n_to_do > 0)
>+  { snd_pcm_sframes_t frames_read = snd_pcm_readi(chandle, dummy, n_to_do);
>+    /* Make  sure we  aren't hitting a disconnect/suspend case */
>+    if (frames_read < 0)
>+      frames_read = snd_pcm_recover(chandle, frames_read, 0);
>+    /* Nope, something else is wrong. Bail.  */
>+    if (frames_read < 0)
>+      error_exit("Read error: %m");
>+    if (frames_read == -1) 
>+    { if (errno != EINTR)
>+        error_exit("Read error: %m");
>+    } else
>+    { n_to_do -= frames_read;
>+      dummy += frames_read;  
>+      if (n_to_do > 0)
>+      { double time_for_frames = (double) n_to_do / (double) Frame_Rate;  // how long to create that many frames?
>+        long nanoseconds = floor ((time_for_frames * 1000000.));  // how many nanoseconds is that?
>+        struct timespec time_to_wait, time_left; 
>+        time_to_wait.tv_sec = (long) floor (time_for_frames);
>+        time_to_wait.tv_nsec = (nanoseconds % 1000000);
>+        int wait_retval = nanosleep (&time_to_wait, &time_left);  // wait for that many nanoseconds
>+      }
>+    }
>+  }
>+  /* de-bias the data */
>+  for (loop = 0; loop < (Process_Frames*2); loop += 2)
>+  { int32_t w1, w2;
>+    /* because we are using plughw, alsa (or pulse) will have formatted the data
>+     * to be signed 32 as requested by shifting, regardless of device internal format.
>+     * 32 bits should take care of
>+     * sound cards for now as there is really no discernable difference above that 
>+     * for human ears, while it allows for extracting maximum entropy from cards
>+     * with larger internal formats.  I think the new hda-intel standard defaults to 
>+     * 32 bit.  Most systems will have this onboard now.
>+     * Note that big endian or little endian doesn't matter as we are reading in native
>+     * format we requested, whatever it is for int32_t.
>+     */
>+    w1 = ((int32_t *) input_buffer) [loop + 0];
>+    left_input_total += w1;
>+    if (w1 < min_left_val)
>+    { min_left_val = w1;
>+    } else if (w1 > max_left_val)
>+      max_left_val = w1;
>+    w2 = ((int32_t *) input_buffer) [loop + 1];
>+    right_input_total += w2;
>+    if (w2 < min_right_val)
>+    { min_right_val = w2;
>+    } else if (w2 > max_right_val)
>+      max_right_val = w2;
>+    if (Verbose > 2)
>+      dolog(LOG_DEBUG, "w1 %d  w2 %d", w1, w2);
>+    else if (Verbose > 1 && loop % 1024 == 0)
>+      dolog(LOG_DEBUG, "w1 %d  w2 %d", w1, w2);
>+  }
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "left_input_total %ld  right_input_total %ld", left_input_total, right_input_total);
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "min_left_val %d  max_left_val %d", min_left_val, max_left_val);
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "min_right_val %d  max_right_val %d", min_right_val, max_right_val);
>+  dc_offset_left = (float) ((double) left_input_total / (double) (Process_Frames));
>+  dc_offset_right = (float) ((double) right_input_total / (double) (Process_Frames));
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "dc_offset_left %8.3f  dc_offset_right %8.3f", dc_offset_left, dc_offset_right);
>+  char bit = 0;
>+  int iii = 0;
>+  if (Entropy_Filter == 0)  // absolute normalized distance change between channels, more less or less more
>+  { for (iii = 0; iii < (Process_Frames*2) - 4; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [3];
>+      int jjj;
>+      for (jjj = 0; jjj < 3; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] < Lower_Threshold  &&  delta [2] - delta [1] > Upper_Threshold)  // change less, change more
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] > Upper_Threshold  &&  delta [2] - delta [1] < Lower_Threshold)  // change more, change less
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 1)  // absolute normalized distance change between channels with second difference == 0
>+  { for (iii = 0; iii < (Process_Frames*2) - 4; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [3];
>+      int jjj;
>+      for (jjj = 0; jjj < 3; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] < Lower_Threshold
>+          &&  delta [2] - delta [1] > Upper_Threshold
>+          &&  delta [2] - delta [0] == 0.)  // change less, change more, back at beginning value
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] > Upper_Threshold
>+          &&  delta [2] - delta [1] < Lower_Threshold
>+          &&  delta [2] - delta [0] == 0.)  // change more, change less, back at beginning value
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 2)  // absolute normalized distance change between channels with second difference != 0
>+  { for (iii = 0; iii < (Process_Frames*2) - 4; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [3];
>+      int jjj;
>+      for (jjj = 0; jjj < 3; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] < Lower_Threshold
>+          &&  delta [2] - delta [1] > Upper_Threshold
>+          && delta [2] - delta [0] != 0.)  // change less, change more, not at beginning value
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] > Upper_Threshold
>+          &&  delta [2] - delta [1] < Lower_Threshold
>+          && delta [2] - delta [0] != 0.)  // change more, change less, not at beginning value
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 3)  // absolute normalized distance change between channels using 5 samples, less more less more or more less more less
>+  { for (iii = 0; iii < (Process_Frames*2) - 8; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [5];
>+      int jjj;
>+      for (jjj = 0; jjj < 5; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] < Lower_Threshold 
>+          && delta [2] - delta [1] > Upper_Threshold 
>+          && delta [3] - delta [2] < Lower_Threshold 
>+          && delta [4] - delta [3] > Upper_Threshold)  // change less, change more, change less, change more
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] > Upper_Threshold 
>+                && delta [2] - delta [1] < Lower_Threshold 
>+                && delta [3] - delta [2] > Upper_Threshold 
>+                && delta [4] - delta [3] < Lower_Threshold)  // change more, change less, change more, change less
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 4)  // absolute normalized distance change between channels using 5 samples, less more more less or more less less more
>+  { for (iii = 0; iii < (Process_Frames*2) - 8; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [5];
>+      int jjj;
>+      for (jjj = 0; jjj < 5; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] < Lower_Threshold 
>+          && delta [2] - delta [1] > Upper_Threshold 
>+          && delta [3] - delta [2] > Upper_Threshold 
>+          && delta [4] - delta [3] < Lower_Threshold)  // change less, change more, change more, change less
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] > Upper_Threshold 
>+                && delta [2] - delta [1] < Lower_Threshold 
>+                && delta [3] - delta [2] < Lower_Threshold 
>+                && delta [4] - delta [3] > Upper_Threshold)  // change more, change less, change less, change more
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 5)  // absolute normalized distance change between channels using 5 samples, less more same less or more less same more
>+  { for (iii = 0; iii < (Process_Frames*2) - 8; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [5];
>+      int jjj;
>+      for (jjj = 0; jjj < 5; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] < Lower_Threshold 
>+          && delta [2] - delta [1] > Upper_Threshold 
>+          && delta [3] - delta [2] == 0. 
>+          && delta [4] - delta [3] < Lower_Threshold)  // change less, change more, stay, change less
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] > Upper_Threshold 
>+                && delta [2] - delta [1] < Lower_Threshold 
>+                && delta [3] - delta [2] == 0. 
>+                && delta [4] - delta [3] > Upper_Threshold)  // change more, change less, stay, change more
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 6)  // absolute normalized distance change between channels using 5 samples, same same more same or same same less same
>+  { for (iii = 0; iii < (Process_Frames*2) - 8; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [5];
>+      int jjj;
>+      for (jjj = 0; jjj < 5; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] == 0. 
>+          && delta [2] - delta [1] == 0. 
>+          && delta [3] - delta [2] < Lower_Threshold 
>+          && delta [4] - delta [3] == 0.)  // step down
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] == 0. 
>+                && delta [2] - delta [1] == 0. 
>+                && delta [3] - delta [2] > Upper_Threshold 
>+                && delta [4] - delta [3] == 0.)  // step up
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 7)  // absolute normalized distance change between channels with pattern same same more or same same less
>+  { for (iii = 0; iii < (Process_Frames*2) - 6; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [4];
>+      int jjj;
>+      for (jjj = 0; jjj < 4; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if (delta [1] - delta [0] == 0. 
>+          && delta [2] - delta [1] == 0. 
>+          && delta [3] - delta [2] < 0.)  // same, change less
>+      { bit = 0;
>+      } else if (delta [1] - delta [0] == 0. 
>+                && delta [2] - delta [1] == 0. 
>+                && delta [3] - delta [2] > 0.) // same, change more
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 8)  // absolute normalized distance change between channels, less more or more less, uses time mod 2 to set entropy bit
>+  { for (iii = 0; iii < (Process_Frames*2) - 4; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta [3];
>+      int jjj;
>+      for (jjj = 0; jjj < 3; jjj++)
>+      { w1 = ((int32_t *) input_buffer) [iii + (2*jjj) + 0];
>+        w2 = ((int32_t *) input_buffer) [iii + (2*jjj) + 1];
>+        leftval = ((float) w1 - dc_offset_left);
>+        if (leftval < 0.)
>+          leftval = leftval / (dc_offset_left - (float) min_left_val);
>+        else
>+          leftval = leftval / ((float) max_left_val - dc_offset_left);
>+        rightval = ((float) w2 - dc_offset_right);
>+        if (rightval < 0.)
>+          rightval = rightval / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval = rightval / ((float) max_right_val - dc_offset_right);
>+        delta [jjj] = fabs (leftval - rightval);
>+      }
>+      if ((delta [1] - delta [0] < Lower_Threshold  &&  delta [2] - delta [1] > Upper_Threshold)
>+          || (delta [1] - delta [0] > Upper_Threshold  &&  delta [2] - delta [1] < Lower_Threshold))  // change less, change more or change more, change less
>+      { clock_t used_time = clock ();
>+        if (used_time != (clock_t) -1)
>+          bit = (char) (used_time % 2);
>+        else
>+        { struct timespec current_time;
>+          clock_gettime(CLOCK_REALTIME, &current_time);
>+          bit = (char) current_time.tv_nsec % 2;
>+        }
>+      } 
>+      else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 10)  // original style Entropy_Filter for entropy
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 4)
>+    { int32_t w1, w2, w3, w4;
>+      char o1, o2;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w2 = ((int32_t *) input_buffer) [iii + 1];
>+      w3 = ((int32_t *) input_buffer) [iii + 2];
>+      w4 = ((int32_t *) input_buffer) [iii + 3];
>+      /* Determine order of channels for each sample, subtract previous sample
>+       * to compensate for unbalanced audio devices */
>+      if ((w1-psl) > (w2-psr))
>+        o1 = 1;
>+      else if ((w1-psl) < (w2-psr))
>+        o1 = 0;
>+      else
>+        o1 = -1;
>+      if ((w3-psl) > (w4-psr))
>+        o2 = 1;
>+      else if ((w3-psl) < (w4-psr))
>+        o2 = 0;
>+      else
>+        o2 = -1;
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "w1-psl %d  w2-psr %d", w1-psl, w2-psr);
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "w3-psl %d  w4-psr %d", w3-psl, w4-psr);
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "o1 %d  o2 %d", (int) o1, (int) o2);
>+      if (a > 0)
>+      { psl = w3;
>+        psr = w4;
>+      }
>+      else
>+      { psl = w1;
>+        psr = w2;
>+      }
>+      /* If both samples have the same order, there is bias in the samples, so we
>+       * discard them; if both channels are equal on either sample, we discard
>+       * them too; additionally, alternate the sample we'll use next (even more
>+       * bias removal) */
>+      if (o1 == o2 || o1 < 0 || o2 < 0)
>+      { a = -a;
>+      }
>+      else
>+      { /* We've got a random bit; the bit is either the order from the first or
>+         * the second sample, determined by the alternator 'a' */
>+        bit = (a > 0) ? o1 : o2;
>+        if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 11)  // original style Entropy_Filter for entropy but using dc_offset values for bias elimination
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 4)
>+    { int32_t w1, w2, w3, w4;
>+      char o1, o2;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w2 = ((int32_t *) input_buffer) [iii + 1];
>+      w3 = ((int32_t *) input_buffer) [iii + 2];
>+      w4 = ((int32_t *) input_buffer) [iii + 3];
>+      /* Determine order of channels for each sample, subtract previous sample
>+       * to compensate for unbalanced audio devices */
>+      if ((w1-dc_offset_left) > (w2-dc_offset_right))
>+        o1 = 1;
>+      else if ((w1-dc_offset_left) < (w2-dc_offset_right))
>+        o1 = 0;
>+      else
>+        o1 = -1;
>+      if ((w3-dc_offset_left) > (w4-dc_offset_right))
>+        o2 = 1;
>+      else if ((w3-dc_offset_left) < (w4-dc_offset_right))
>+        o2 = 0;
>+      else
>+        o2 = -1;
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "w1-dc_offset_left %d  w2-dc_offset_right %d", w1-dc_offset_left, w2-dc_offset_right);
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "w3-dc_offset_left %d  w4-dc_offset_right %d", w3-dc_offset_left, w4-dc_offset_right);
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "o1 %d  o2 %d", (int) o1, (int) o2);
>+      /* If both samples have the same order, there is bias in the samples, so we
>+       * discard them; if both channels are equal on either sample, we discard
>+       * them too; additionally, alternate the sample we'll use next (even more
>+       * bias removal) */
>+      if (o1 == o2 || o1 < 0 || o2 < 0)
>+      { a = -a;
>+      }
>+      else
>+      { /* We've got a random bit; the bit is either the order from the first or
>+         * the second sample, determined by the alternator 'a' */
>+        bit = (a > 0) ? o1 : o2;
>+        if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 12)  // original style Entropy_Filter for entropy, use system time mod 2 for bit
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 4)
>+    { int32_t w1, w2, w3, w4;
>+      char o1, o2;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w2 = ((int32_t *) input_buffer) [iii + 1];
>+      w3 = ((int32_t *) input_buffer) [iii + 2];
>+      w4 = ((int32_t *) input_buffer) [iii + 3];
>+      /* Determine order of channels for each sample, subtract previous sample
>+       * to compensate for unbalanced audio devices */
>+      if ((w1-psl) > (w2-psr))
>+        o1 = 1;
>+      else if ((w1-psl) < (w2-psr))
>+        o1 = 0;
>+      else
>+        o1 = -1;
>+      if ((w3-psl) > (w4-psr))
>+        o2 = 1;
>+      else if ((w3-psl) < (w4-psr))
>+        o2 = 0;
>+      else
>+        o2 = -1;
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "w1-psl %d  w2-psr %d", w1-psl, w2-psr);
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "w3-psl %d  w4-psr %d", w3-psl, w4-psr);
>+      if (Verbose > 1)
>+        dolog(LOG_DEBUG, "o1 %d  o2 %d", (int) o1, (int) o2);
>+      if (a > 0)
>+      { psl = w3;
>+        psr = w4;
>+      }
>+      else
>+      { psl = w1;
>+        psr = w2;
>+      }
>+      /* If both samples have the same order, there is bias in the samples, so we
>+       * discard them; if both channels are equal on either sample, we discard
>+       * them too; additionally, alternate the sample we'll use next (even more
>+       * bias removal) */
>+      if (o1 == o2 || o1 < 0 || o2 < 0)
>+      { a = -a;
>+      }
>+      else
>+      { // We've matched our pattern, the orders are 0 and 1, and are different, make a bit
>+        clock_t used_time = clock ();
>+        if (used_time != (clock_t) -1)
>+          bit = (char) (used_time % 2);
>+        else
>+        { struct timespec current_time;
>+          clock_gettime(CLOCK_REALTIME, &current_time);
>+          bit = (char) current_time.tv_nsec % 2;
>+        }
>+        if (Verbose > 1)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 20)  // pattern in individual channels, both normalized get less or both get more
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 2)
>+    { int32_t w1, w2, w3, w4;
>+      float leftval0, leftval1, rightval0, rightval1;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w3 = ((int32_t *) input_buffer) [iii + 2];
>+      leftval0 = ((float) w1 - dc_offset_left);
>+      if (leftval0 < 0.)
>+        leftval0 = leftval0 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval0 = leftval0 / ((float) max_left_val - dc_offset_left);
>+      leftval1 = ((float) w3 - dc_offset_left);
>+      if (leftval1 < 0.)
>+        leftval1 = leftval1 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval1 = leftval1 / ((float) max_left_val - dc_offset_left);
>+      if ((leftval1 - leftval0) < Lower_Threshold || (leftval1 - leftval0) > Upper_Threshold)  // finding a bit is feasible
>+      { w2 = ((int32_t *) input_buffer) [iii + 1];
>+        w4 = ((int32_t *) input_buffer) [iii + 3];
>+        rightval0 = ((float) w2 - dc_offset_right);
>+        if (rightval0 < 0.)
>+          rightval0 = rightval0 / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval0 = rightval0 / ((float) max_right_val - dc_offset_right);
>+        rightval1 = ((float) w4 - dc_offset_right);
>+        if (rightval1 < 0.)
>+          rightval1 = rightval1 / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval1 = rightval1 / ((float) max_right_val - dc_offset_right);
>+        if ((leftval1 - leftval0) < Lower_Threshold  &&  (rightval1 - rightval0) > Upper_Threshold)  // left channel less, right channel more
>+        { bit = 0;
>+        } 
>+        else if ((leftval1 - leftval0) > Upper_Threshold  &&  (rightval1 - rightval0) < Lower_Threshold)  // left channel more, right channel less
>+        { bit = 1;
>+        } 
>+        else
>+          bit = -1;
>+        if (bit != -1)
>+        { if (Verbose > 2)
>+            dolog(LOG_DEBUG, "bit %d", (int) bit);
>+          add_entropy_bit (bit, output_buffer, n_output_bytes);
>+        }
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 21)  // pattern in individual channels, both normalized, one significantly changes relative to the other
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 2)
>+    { int32_t w1, w2, w3, w4;
>+      float leftval0, leftval1, rightval0, rightval1;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w3 = ((int32_t *) input_buffer) [iii + 2];
>+      leftval0 = ((float) w1 - dc_offset_left);
>+      if (leftval0 < 0.)
>+        leftval0 = leftval0 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval0 = leftval0 / ((float) max_left_val - dc_offset_left);
>+      leftval1 = ((float) w3 - dc_offset_left);
>+      if (leftval1 < 0.)
>+        leftval1 = leftval1 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval1 = leftval1 / ((float) max_left_val - dc_offset_left);
>+      w2 = ((int32_t *) input_buffer) [iii + 1];
>+      w4 = ((int32_t *) input_buffer) [iii + 3];
>+      rightval0 = ((float) w2 - dc_offset_right);
>+      if (rightval0 < 0.)
>+        rightval0 = rightval0 / (dc_offset_right - (float) min_right_val);
>+      else
>+        rightval0 = rightval0 / ((float) max_right_val - dc_offset_right);
>+      rightval1 = ((float) w4 - dc_offset_right);
>+      if (rightval1 < 0.)
>+        rightval1 = rightval1 / (dc_offset_right - (float) min_right_val);
>+      else
>+        rightval1 = rightval1 / ((float) max_right_val - dc_offset_right);
>+      if  (fabs (leftval1 - leftval0) < Lower_Threshold
>+          &&  fabs (rightval1 - rightval0) > Upper_Threshold)  // left channel minimal change, right channel significant change more or less
>+      { bit = 0;
>+      } else if (fabs (leftval1 - leftval0) > Upper_Threshold
>+          &&  fabs (rightval1 - rightval0) < Lower_Threshold)  // left channel significant change more or less, right channel minimal change
>+      { bit = 1;
>+      } else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 2)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 22)  // pattern in individual channels, both normalized get less or both get more, use time mod 2 for bit
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 2)
>+    { int32_t w1, w2, w3, w4;
>+      float leftval0, leftval1, rightval0, rightval1;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w3 = ((int32_t *) input_buffer) [iii + 2];
>+      leftval0 = ((float) w1 - dc_offset_left);
>+      if (leftval0 < 0.)
>+        leftval0 = leftval0 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval0 = leftval0 / ((float) max_left_val - dc_offset_left);
>+      leftval1 = ((float) w3 - dc_offset_left);
>+      if (leftval1 < 0.)
>+        leftval1 = leftval1 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval1 = leftval1 / ((float) max_left_val - dc_offset_left);
>+      if ((leftval1 - leftval0) != 0.)
>+      { w2 = ((int32_t *) input_buffer) [iii + 1];
>+        w4 = ((int32_t *) input_buffer) [iii + 3];
>+        rightval0 = ((float) w2 - dc_offset_right);
>+        if (rightval0 < 0.)
>+          rightval0 = rightval0 / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval0 = rightval0 / ((float) max_right_val - dc_offset_right);
>+        rightval1 = ((float) w4 - dc_offset_right);
>+        if (rightval1 < 0.)
>+          rightval1 = rightval1 / (dc_offset_right - (float) min_right_val);
>+        else
>+          rightval1 = rightval1 / ((float) max_right_val - dc_offset_right);
>+        if (((leftval1 - leftval0) > Upper_Threshold  &&  (rightval1 - rightval0) < Lower_Threshold) 
>+            || ((leftval1 - leftval0) < Lower_Threshold  &&  (rightval1 - rightval0) > Upper_Threshold))  // either pattern of filter 20, make a bit
>+        { clock_t used_time = clock ();
>+          if (used_time != (clock_t) -1)
>+            bit = (char) (used_time % 2);
>+          else
>+          { struct timespec current_time;
>+            clock_gettime(CLOCK_REALTIME, &current_time);
>+            bit = (char) current_time.tv_nsec % 2;
>+          }
>+        }
>+        else
>+          bit = -1;
>+        if (bit != -1)
>+        { if (Verbose > 2)
>+            dolog(LOG_DEBUG, "bit %d", (int) bit);
>+          add_entropy_bit (bit, output_buffer, n_output_bytes);
>+        }
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 23)  // pattern in individual channels, both normalized, one significantly changes relative to the other, use time mod 2 for bit
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 2)
>+    { int32_t w1, w2, w3, w4;
>+      float leftval0, leftval1, rightval0, rightval1;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w3 = ((int32_t *) input_buffer) [iii + 2];
>+      leftval0 = ((float) w1 - dc_offset_left);
>+      if (leftval0 < 0.)
>+        leftval0 = leftval0 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval0 = leftval0 / ((float) max_left_val - dc_offset_left);
>+      leftval1 = ((float) w3 - dc_offset_left);
>+      if (leftval1 < 0.)
>+        leftval1 = leftval1 / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval1 = leftval1 / ((float) max_left_val - dc_offset_left);
>+      w2 = ((int32_t *) input_buffer) [iii + 1];
>+      w4 = ((int32_t *) input_buffer) [iii + 3];
>+      rightval0 = ((float) w2 - dc_offset_right);
>+      if (rightval0 < 0.)
>+        rightval0 = rightval0 / (dc_offset_right - (float) min_right_val);
>+      else
>+        rightval0 = rightval0 / ((float) max_right_val - dc_offset_right);
>+      rightval1 = ((float) w4 - dc_offset_right);
>+      if (rightval1 < 0.)
>+        rightval1 = rightval1 / (dc_offset_right - (float) min_right_val);
>+      else
>+        rightval1 = rightval1 / ((float) max_right_val - dc_offset_right);
>+      if ((fabs (leftval1 - leftval0) <= Lower_Threshold &&  fabs (rightval1 - rightval0) >= Upper_Threshold)
>+           || (fabs (leftval1 - leftval0) >= Upper_Threshold &&  fabs (rightval1 - rightval0) <= Lower_Threshold))  // either pattern of filter 21, make bit
>+      { clock_t used_time = clock ();
>+        if (used_time != (clock_t) -1)
>+          bit = (char) (used_time % 2);
>+        else
>+        { struct timespec current_time;
>+          clock_gettime(CLOCK_REALTIME, &current_time);
>+          bit = (char) current_time.tv_nsec % 2;
>+        }
>+      } 
>+      else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 2)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  else if (Entropy_Filter == 30)  // if absolute normalized delta greater or less than threshold, generate a bit using system time mod 2
>+  { for (iii = 0; iii < (Process_Frames*2) - 2; iii += 2)
>+    { int32_t w1, w2;
>+      float leftval, rightval, delta;
>+      w1 = ((int32_t *) input_buffer) [iii + 0];
>+      w2 = ((int32_t *) input_buffer) [iii + 1];
>+      leftval = ((float) w1 - dc_offset_left);
>+      if (leftval < 0.)
>+        leftval = leftval / (dc_offset_left - (float) min_left_val);
>+      else
>+        leftval = leftval / ((float) max_left_val - dc_offset_left);
>+      rightval = ((float) w2 - dc_offset_right);
>+      if (rightval < 0.)
>+        rightval = rightval / (dc_offset_right - (float) min_right_val);
>+      else
>+        rightval = rightval / ((float) max_right_val - dc_offset_right);
>+      delta = fabs (leftval - rightval);
>+      if (delta  >= Upper_Threshold)  // max delta is 2, min is 0.  How different are channels in normalized terms?  Above threshold, make a bit.
>+      { clock_t used_time = clock ();
>+        if (used_time != (clock_t) -1)
>+          bit = (char) (used_time % 2);
>+        else
>+        { struct timespec current_time;
>+          clock_gettime(CLOCK_REALTIME, &current_time);
>+          bit = (char) current_time.tv_nsec % 2;
>+        }
>+      } 
>+      else
>+        bit = -1;
>+      if (bit != -1)
>+      { if (Verbose > 2)
>+          dolog(LOG_DEBUG, "bit %d", (int) bit);
>+        add_entropy_bit (bit, output_buffer, n_output_bytes);
>+      }
>+    }
>+  }
>+  if (Verbose > 1)
>+    dolog(LOG_DEBUG, "get_random_data() finished");
>+}
> 
>-	if (verbose > 1)
>-		dolog(LOG_DEBUG, "get_random_data() finished");
>+void add_entropy_bit (char bit, unsigned char *output_buffer, int *n_output_bytes)
>+{
>+  static int bits_out=0;
>+  static unsigned char byte_out=0;
> 
>-	free(input_buffer);
>+  byte_out <<= 1;
>+  byte_out += bit;
>+  bits_out++;
>+  if (bits_out>=8)
>+  { if (Error_State == 0 || Internal_Test == 1)
>+    { (output_buffer)[*n_output_bytes]=byte_out;
>+      (*n_output_bytes)++;
>+    }
>+    bits_out=0;
>+    RNGTEST_add(byte_out);
>+    if (Internal_Test == 1 && RNGTEST() == -1)
>+    { if (Error_State == 0)
>+        dolog(LOG_CRIT, "test of random data failed, skipping %d bytes before re-using data-stream (%d bytes in flush)", RNGTEST_PENALTY, Error_State);
>+      Error_State = RNGTEST_PENALTY;
>+      *n_output_bytes = 0;
>+    } else
>+    { if (Error_State > 0)
>+      { Error_State--;
>+        if (Error_State == 0)
>+          dolog(LOG_INFO, "Restarting fetching of entropy data");
>+      }
>+    }
>+  }
> }
> 
> void usage(void)
> {
>-	fprintf(stderr, "Usage: audio-entropyd [options]\n\n");
>-	fprintf(stderr, "Collect entropy from a soundcard and feed it into the kernel random pool.\n");
>-	fprintf(stderr, "\n");
>-	fprintf(stderr, "Options:\n");
>-	fprintf(stderr, "--device,       -d []  Specify sound device to use. (Default %s)\n", cdevice);
>-	fprintf(stderr, "--sample-rate,  -N []  Audio sampling rate. (default %i)\n", DEFAULT_SAMPLE_RATE);
>-	fprintf(stderr, "--skip-test,    -s     Do not check if data is random enough.\n");
>-	fprintf(stderr, "--do-not-fork   -n     Do not fork.\n");
>-	fprintf(stderr, "--verbose,      -v     Be verbose.\n");
>-	fprintf(stderr, "--help,         -h     This help.\n");
>-	fprintf(stderr, "\n");
>+  fprintf(stderr, "Usage: audio-entropyd [options]\n\n");
>+  fprintf(stderr, "Collect entropy from a soundcard and feed it into the kernel random pool.\n");
>+  fprintf(stderr, "\n");
>+  fprintf(stderr, "Options:\n");
>+  fprintf(stderr, "--always_close,    -a     Always close sound device after use, even if pause-resume available. (Default no)\n");
>+  fprintf(stderr, "--device,          -d []  Specify sound device to use. (Default %s)\n", Capture_Device);
>+  fprintf(stderr, "--entropy_filter,  -e []  Filter to use for extracting entropy from the capture data. (Default %i)\n", Entropy_Filter);
>+  fprintf(stderr, "--lower_threshodd, -l []  When an entropy filter needs thresholds, this is the lower. (Default %5.3f)\n", Lower_Threshold);
>+  fprintf(stderr, "--upper_threshodd, -u []  When an entropy filter needs thresholds, this is the upper. (Default %5.3f)\n", Upper_Threshold);
>+  fprintf(stderr, "--sample-rate,     -r []  Audio sampling rate. (Default %i)\n", Frame_Rate);
>+  fprintf(stderr, "--sample-size,     -z []  Size of sample to get for analysis each time. (Default %i)\n", Process_Frames);
>+  fprintf(stderr, "--skip-size,       -s []  Size of sample to skip each time device opened. No skip for pause-resume. (Default %i)\n", Skip_Frames);
>+  fprintf(stderr, "--internal_test,   -i []  Test the gathered entropy internally. (Default no)\n");
>+  fprintf(stderr, "--do-not-fork      -n     Do not fork. (Default fork)\n");
>+  fprintf(stderr, "--store_in_file,   -f []  Path to save file. (Default no)\n");
>+  fprintf(stderr, "--verbose,         -v     Be Verbose, up to 3 times. (Default no)\n");
>+  fprintf(stderr, "--help,            -h     This help. (Default no)\n");
>+  fprintf(stderr, "Configuration file at /etc/sysconfig/audio-entropyd has more detail and sample values.\n");
>+  fprintf(stderr, "\n");
> }
> 
> void daemonise(void)
> {
>-	if (become_daemon() == -1)
>-		error_exit("cannot fork into the background");
>+  if (become_daemon() == -1)
>+    error_exit("cannot fork into the background");
> 
>-	if (write_pidfile(PID_FILE) == -1)
>-		error_exit("Couldn't open PID file \"%s\" for writing: %m.", PID_FILE);
>+  if (write_pidfile(PID_FILE) == -1)
>+    error_exit("Couldn't open PID file \"%s\" for writing: %m.", PID_FILE);
> }
> 
> void gracefully_exit(int signum)
> {
>-	if (munlockall() == -1)
>-		error_exit("problem unlocking pages");
>-	unlink(PID_FILE);
>-	dolog(LOG_NOTICE, "audio-entropyd stopping due to signal %d", signum);
>-	exit(0);
>+  if (munlockall() == -1)
>+    error_exit("problem unlocking pages");
>+  unlink(PID_FILE);
>+  dolog(LOG_NOTICE, "audio-entropyd stopping due to signal %d", signum);
>+  exit(0);
> }
> 
> void logging_handler(int signum)
> {
>-	if (signum == SIGUSR1) 
>-	{
>-		loggingstate = 1; 
>-		dolog(LOG_WARNING, "Currently in flush state: entropy data is not random enough");
>-	}
>+  if (signum == SIGUSR1) 
>+  {
>+    loggingstate = 1; 
>+    dolog(LOG_WARNING, "Currently in flush state: entropy data is not random enough");
>+  }
> 
>-	if (signum == SIGUSR2) 
>-		loggingstate = 0; 
>+  if (signum == SIGUSR2) 
>+    loggingstate = 0; 
> }

Actions: View | Diff

Attachments on bug 982660: 815407 | 815408 | 815823 | 815824 | 869266 | 869267 | 869681 | 869682 | 871083 | 871096