/**********************************************************
File: distort.c
Author: Scot Cunningham

Usage: distort infile outfile begin end algorithm

This program distorts the input file (argv[1]) and puts 
the results in the output file (argv[2]).  It distorts
from the begin point in seconds (argv[3]) to the end point
(argv[4]) using one of the following algorithms:
	suppress
	distort
	invert
	permute
	

The "suppress" algorithm simply replaces the audio with silence.
The "distort" is a custom algorithm that preserves prosidic features.
The "invert" algorithm inverts the sign of every other sample.
The "permute" algoritym performs a uniform block permutation.

Compile with -lm option to get math libraries

**********************************************************/

#define DLEN 32 /* The number of samples to read at one time */
#define SHORT 2 /* The size of each sample */
#define SRATE 8000 /* Our assumed sampling rate. */

/* A couple of useful macros */
#define mmin(A,B)			((A)<(B)?(A):(B))
#define mmax(A,B)			((A)>(B)?(A):(B))

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <sys/file.h>

/**********************************************************
Supress the contents of read_file beginning at "begin"
and ending and "end".  Output results to write_file
*********************************************************/
int suppress(begin, end, read_file, write_file)
int begin;
int end;
int read_file;
int write_file;
{
	int ns; /* Keeps track of the number of suppressed samples */
	int n_read, n_write; /* Number of bytes read/written */
	int i; /* Loop incrementer */
	short ibuff[DLEN]; /* Input buffer */

	/* Keep reading into the buffer and suppressing when in range */
	/* Output suppressed results to write_file */
	n_read = read(read_file, ibuff, DLEN*SHORT);
	ns=0;
	while (n_read != 0)
	{
		if (ns > begin && ns < end)
		{
			for (i=0; i<DLEN; ++i) {
				ibuff[i]=0; // This suppresses with silence
			}
		}
	
		n_write = write(write_file, ibuff, n_read);
		if(n_write < 0)
		{
			perror("ERROR writing the output file");
			exit(0);
		}
		ns = ns + DLEN;
		n_read = read(read_file, ibuff, DLEN*SHORT);
		if(n_read < 0)
		{
			 perror("ERROR reading the input file");
			 exit(0);
		}
	}
	return ns;
}

/**********************************************************
Invert the sign of every other sample.
*********************************************************/
int invert(begin, end, read_file, write_file)
int begin;
int end;
int read_file;
int write_file;
{
	int ns; /* Keeps track of the number of inverted samples */
	int n_read, n_write; /* Number of bytes read/written */
	int i; /* Loop incrementer */
	short ibuff[DLEN]; /* Input buffer */

	/* Keep reading into the buffer and suppressing when in range */
	/* Output inverted results to write_file */
	n_read = read(read_file, ibuff, DLEN*SHORT);
	ns=0;
	while (n_read != 0)
	{
		if (ns > begin && ns < end)
		{
			/* Invert the sign of every other sample */
			for (i=0; i<DLEN; i+=2) {
				ibuff[i]=-ibuff[i]; 
			}
		}
	
		n_write = write(write_file, ibuff, n_read);
		if(n_write < 0)
		{
			perror("ERROR writing the output file");
			exit(0);
		}
		ns = ns + DLEN;
		n_read = read(read_file, ibuff, DLEN*SHORT);
		if(n_read < 0)
		{
			 perror("ERROR reading the input file");
			 exit(0);
		}
	}
	return ns;
}


/**********************************************************
Uniform permutation
*********************************************************/
int permute(begin, end, read_file, write_file, blockNum, invert)
int begin;
int end;
int read_file;
int write_file;
int blockNum;
int invert;
{
	int key = 11;
	int bufSz=1024;
	int blockLen = bufSz/blockNum;
	int ns; /* Keeps track of the number of permuted samples */
	int n_read, n_write; /* Number of bytes read/written */
	int i; /* Loop incrementer */
	int pDLEN=blockNum*blockLen;
	short ibuff[blockNum][blockLen]; /* Input buffer */
	short obuff[blockNum][blockLen]; /* Output buffer */

	/* Keep reading into the buffer and suppressing when in range */
	/* Output permuted results to write_file */
	n_read = read(read_file, ibuff, pDLEN*SHORT);
	ns=0;
	while (n_read != 0)
	{
		if ((ns+bufSz) > begin && ns < end && n_read==(pDLEN*SHORT))
		{
			/* Permute ibuff to obuff */
			int newBlockNum;
			int j;
			printf("************\n");
			for (i=0; i<blockNum; ++i) {
				newBlockNum = (key * i) % blockNum;
				printf("%d to %d\n",i,newBlockNum);
				for (j=0; j<blockLen; ++j) {
					if (invert && (j % 2)==0 ) {
						obuff[newBlockNum][j] = -ibuff[i][j];
					}else{
						obuff[newBlockNum][j] = ibuff[i][j];
					}
				}
			}

			n_write = write(write_file, obuff, n_read);
		}else{
			n_write = write(write_file, ibuff, n_read);
		}
	
		if(n_write < 0)
		{
			perror("ERROR writing the output file");
			exit(0);
		}
		ns = ns + pDLEN;
		n_read = read(read_file, ibuff, pDLEN*SHORT);
		if(n_read < 0)
		{
			 perror("ERROR reading the input file");
			 exit(0);
		}
	}
	return ns;
}

/**********************************************************
Distort the contents of read_file beginning at "begin"
and ending and "end".  Output results to write_file
*********************************************************/
int distort(begin, end, read_file, write_file, lowbar)
int begin; // The start of the sample range to suppress
int end; // The end of the sample range to suppress
int read_file; // The input file id
int write_file; // The output file id
int lowbar; // Anything below this level will be reduced to silence
{
	int ns; // Remember number of samples processed
	int n_read, n_write; // Number of bytes read/written 
	int i; // Loop incrementer 
	int distlevel; // The suppression level
	short ibuff[DLEN]; // Input buffer
	short orig; // Remembers original value of the input sample
	int maxsamp; // Remembers largest sample value (absolute value)
	int ampcnt; // Can be used to calculate average amplitude
	long totamp; // Can be used to calculate average amplitude

	n_read = read(read_file, ibuff, DLEN*SHORT);
	ns=0;
	ampcnt=0;
	totamp=0;
	maxsamp=0;
	srand(1);
	while (n_read != 0)
	{

		if (ns>1024)
		{
			for (i=0; i<DLEN; ++i) {
				totamp += abs(ibuff[i]);
				++ampcnt;
				if (abs(ibuff[i]) > maxsamp) maxsamp=abs(ibuff[i]);
			}
		}

		if ((ns+DLEN) > begin && ns < end)
		{
			for (i=0; i<DLEN; ++i) {

				// Remember the original value
				orig = ibuff[i];

				// Generate a random number between 1 and the value of the sample
				// This is the distortion level
				distlevel = rand() % (abs(ibuff[i])+1);

				// Amplify the amount of the distortion
				distlevel *= 1.5;

				// Amplify the signal to counteract the amplified distortion level
				// By setting this higher than the distlevel, noise may exceed
				// the original amplitute of the sample.
				ibuff[i] *= 2;

				// Reduce the signal by the distortion level
				if (ibuff[i]>0) {
					ibuff[i] = ibuff[i] - distlevel;
				}else{
					ibuff[i] = ibuff[i] + distlevel;
				}

				// Completely suppress lower level audio
				if (abs(ibuff[i]) < lowbar)
					ibuff[i] = 0;

				// Don't exceed max levels
				if (abs(ibuff[i]) > maxsamp) 
					ibuff[i] = rand() % mmax(maxsamp,1);

			}
		}
	
		n_write = write(write_file, ibuff, n_read);
		if(n_write < 0)
		{
			perror("ERROR writing the output file");
			exit(0);
		}
		ns = ns + DLEN;
		n_read = read(read_file, ibuff, DLEN*SHORT);
		if(n_read < 0)
		{
			 perror("ERROR reading the input file");
			 exit(0);
		}
	}
	return ns;
}

main(argc, argv)
int argc;
char *argv[];
{ 

	int i; // Loop incrementer
	int ns; // Number of samples processed
	double sec_begin, sec_end; // These mark the range to distort in seconds
	int samp_begin, samp_end; // That same range in samples, not seconds
	int read_file, write_file; // The input and output files
	char input_file[100], output_file[100]; // Input and output file names
	char algorithm[100]; // The name of the algorithm to run
	int lowbar; // Suppression range for distort algorithm

	// Get the input arguments
	if (argc < 6 )
	{
		printf("Usage error: distort infile outfile begin end algorithm\n");
		exit(0);
	}
	strcpy(input_file, argv[1]);
	strcpy(output_file, argv[2]);
	sec_begin = atof(argv[3]);
	sec_end = atof(argv[4]);
	samp_begin = sec_begin * SRATE;
	samp_end = sec_end * SRATE;
	strcpy(algorithm, argv[5]);

	printf("Distorting from %d to %d \n", samp_begin, samp_end);

	read_file = open(input_file, O_RDONLY, 0);
	if (read_file < 0)
	{
		perror("ERROR opening the input file for reading");
		exit(0);
	}
	write_file = open(output_file, O_WRONLY|O_CREAT, 0644);
	if (write_file < 0)
	{
		perror("ERROR opening the output file for writing");
		exit(0);
	}

	// Invoke the requested algorithm
	if (strcmp(algorithm, "distort") == 0) 
	{
		lowbar = atoi(argv[6]);
		ns = distort(samp_begin, samp_end, read_file, write_file, lowbar);
	}
	else if (strcmp(algorithm, "suppress") == 0) 
	{
		ns = suppress(samp_begin, samp_end, read_file, write_file);
	}
	else if (strcmp(algorithm, "invert") == 0) 
	{
		ns = invert(samp_begin, samp_end, read_file, write_file);
	}
	else if (strcmp(algorithm, "permute") == 0) 
	{
		int numblocks = atoi(argv[6]);
		ns = permute(samp_begin, samp_end, read_file, write_file, numblocks, 0);
	}
	else if (strcmp(algorithm, "permuteinvert") == 0) 
	{
		int numblocks = atoi(argv[6]);
		ns = permute(samp_begin, samp_end, read_file, write_file, numblocks, 1);
	}
	else
	{
		perror("Unknown algorithm\n");
		exit(0);
	}

	// Output number of samples processed to stdout
	if (ns < 0)
	{
		printf("No Samples\n");
		exit(0);
	}else{
		printf("%d Samples processed\n",ns);
	}

}