/*
 * SineGenerator.cpp
 *
 *  Created on: 31.03.2011
 *      Author: sven
 */
#ifndef SINEGENERATOR_H_
	#include "SineGenerator.h"
#endif
#ifndef _GLIBCXX_IOSTREAM
	#include <iostream>
#endif
#ifndef _GLIBCXX_CMATH
	#include <cmath>
#endif
#ifndef _GLIBCXX_NUMERIC_LIMITS
	#include <limits>
#endif
#ifndef	_STRING_H
	#include <string.h>
#endif
const double SineGenerator::PI=3.141592654;

SineGenerator::SineGenerator(SineGeneratorParameters& params)
:mParams(params)
{
}

SineGenerator::~SineGenerator() {
}

void SineGenerator::generateWavefile()
{
	std::cout << "Freq: " << mParams.getFrequency()
			<< " Amp: " << mParams.getAmplitude()
			<< " Phase: " << mParams.getPhase()
			<< " Length: " << mParams.getLength()
			<< " File: " << mParams.getFilename()
			<< std::endl;

	std::ofstream wavefile;
	wavefile.open(mParams.getFilename().c_str(), std::ios::out | std::ios::binary);
	int filestart = wavefile.tellp();
	writeWaveHeader(wavefile);
	writeWaveData(wavefile);
	int fileend = wavefile.tellp();
	int filesize = fileend-filestart-8;
	wavefile.seekp(0x4);
	wavefile.write((char*) &filesize,sizeof(filesize));
	wavefile.close();
	std::cout << mParams.getFilename() << " written" << std::endl;
}

void SineGenerator::writeWaveHeader(std::ofstream& wavefile)
{
	const char* riff = "RIFF";
	const char* wave = "WAVE";
	const char* fmt = "fmt ";
	int size = 0;
	int fmtLen = 16;
	short fmtTag = 0x0001;
	short channels = 0x0001;
	int sampleRate = mParams.getSamplerate();
	short bitsPerSample = mParams.getBitrate();
	short blockAlign = channels * (bitsPerSample / 8);
	int bytesPerSecond = sampleRate * blockAlign;

	wavefile.write(riff,strlen(riff));
	wavefile.write((char*)&size,sizeof(size));
	wavefile.write(wave,strlen(wave));
	wavefile.write(fmt,strlen(fmt));
	wavefile.write((char*) &fmtLen,sizeof(fmtLen));
	wavefile.write((char*) &fmtTag,sizeof(fmtTag));
	wavefile.write((char*) &channels,sizeof(channels));
	wavefile.write((char*) &sampleRate,sizeof(sampleRate));
	wavefile.write((char*) &bytesPerSecond,sizeof(bytesPerSecond));
	wavefile.write((char*) &blockAlign,sizeof(blockAlign));
	wavefile.write((char*) &bitsPerSample,sizeof(bitsPerSample));
}

void SineGenerator::writeWaveData(std::ofstream& wavefile)
{
	generateData();
	const char* data = "data";
	int dataLen = mData.size() * sizeof(short);
	short actData = 0;
	DataIter dataIter;
	wavefile.write(data,strlen(data));
	wavefile.write((char*) &dataLen,(sizeof(dataLen)));
	for (dataIter = mData.begin(); dataIter != mData.end(); dataIter++)
	{
		actData = *dataIter;
		wavefile.write((char*) &actData,(sizeof(actData)));
	}
}

void SineGenerator::generateData()
{
	double actData = 0.0;
	double amp = (double)(mParams.getAmplitude()) * ((double) std::numeric_limits<short>::max()) / 100.0;
	double phaseRad = (double)(mParams.getPhase()) * PI / 180.0;
	double freq = (double)(mParams.getFrequency());
	double twoPi = 2.0 * PI;
	short actShort;
	for (short second = 0; second < mParams.getLength(); second++) {
		for(unsigned short actTime = 0; actTime < mParams.getSamplerate(); actTime++)
		{
			actData = amp * std::sin((twoPi * freq * ((double) (actTime) / (double) mParams.getSamplerate() ) ) + phaseRad);
			actShort = (short) std::floor(actData+.5);
			//std::cout << actTime << ". " << actData << " " << actShort << std::endl;
			mData.push_back(actShort);
		}
	}
}