/// ------------------------------------------------------------------------------------
private void WriteAudioStreamToChannel(AnnotationChannel channel, WaveStream inputStream)
{
var silentBlocksForOrig = new float[_srcRecStreamProvider.Stream.WaveFormat.Channels];
var blocksRead = 0;
var totalBlocks = inputStream.Length / inputStream.WaveFormat.BlockAlign;
var provider = new SampleChannel(inputStream);
var buffer = new float[provider.WaveFormat.Channels];
while (provider.Read(buffer, 0, provider.WaveFormat.Channels) > 0 && blocksRead < totalBlocks)
{
blocksRead += 1;
switch (channel)
{
case AnnotationChannel.Source:
_audioFileWriter.WriteSamples(buffer, 0, _srcRecStreamProvider.Stream.WaveFormat.Channels);
_audioFileWriter.WriteSample(0f);
_audioFileWriter.WriteSample(0f);
break;
case AnnotationChannel.Careful:
_audioFileWriter.WriteSamples(silentBlocksForOrig, 0, silentBlocksForOrig.Length);
_audioFileWriter.WriteSample(buffer[0]);
_audioFileWriter.WriteSample(0f);
break;
case AnnotationChannel.Translation:
_audioFileWriter.WriteSamples(silentBlocksForOrig, 0, silentBlocksForOrig.Length);
_audioFileWriter.WriteSample(0f);
_audioFileWriter.WriteSample(buffer[0]);
break;
}
}
}
private static void Send(string filename, BCH bch = null)
{
var fax = new Fax(16000);
Log.Information($"loading: {filename}");
using var original = Image.FromFile(filename);
Log.Information($"original image: {original.Width}x{original.Height}");
var scalingFactor = fax.ImageWidth / (float)original.Width;
using var scaled = new Bitmap(fax.ImageWidth, (int)Math.Round(original.Height * scalingFactor));
using var graphics = Graphics.FromImage(scaled);
graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
graphics.DrawImage(original, 0, 0, scaled.Width, scaled.Height);
Log.Information($"scaled image: {scaled.Width}x{scaled.Height}");
var wavFilename = Path.Combine(Path.GetDirectoryName(filename), $"{Path.GetFileNameWithoutExtension(filename)}.wav");
using var writer = new WaveFileWriter(wavFilename, new WaveFormat(fax.SampleRate, 1));
var start = fax.GetStart();
writer.WriteSamples(start, 0, start.Length);
var phasing = fax.GetPhasing();
writer.WriteSamples(phasing, 0, phasing.Length);
if (bch != null)
{
var header = fax.GetBCH(bch);
writer.WriteSamples(header, 0, header.Length);
//var debug = fax.GetBCH(bch, true);
//writer.WriteSamples(debug, 0, debug.Length);
}
for (int y = 0; y < scaled.Height; y++)
{
var pixels = Enumerable.Range(0, scaled.Width).Select(x => scaled.GetPixel(x, y).GetBrightness() * 2f - 1).ToArray();
var samples = fax.GetLine(pixels);
writer.WriteSamples(samples, 0, samples.Length);
}
var stop = fax.GetStop();
writer.WriteSamples(stop, 0, stop.Length);
Log.Information($"wrote: {wavFilename}");
}
public void WriteToWavFile(string outputPath)
{
if (Encrypted)
{
throw new Exception("Audio stream is encrypted! Cannot proceed!");
}
bool skipMode = true;
int audioOffset = 0, reckonOffset = 0;
OpusDecoder decoder = OpusDecoder.Create(SampleRate, (int)Channels);
using (WaveFileWriter writer = new WaveFileWriter(outputPath, new WaveFormat(SampleRate, 16, (int)Channels))) // 16-bit PCM
{
while (reckonOffset < ReckoningSize)
{
int numPackets = Reckoning[reckonOffset];
// Checks if first bit is 1
if ((numPackets & 0x80) == 0x80)
{
numPackets = ((numPackets ^ 0x80) << 8) | Reckoning[++reckonOffset];
}
if (skipMode)
{
short[] outputShorts = new short[numPackets * FrameSize * Channels];
writer.WriteSamples(outputShorts, 0, outputShorts.Length);
}
else
{
int packetOffset = 0;
short[] outputShorts = new short[FrameSize * Channels];
// Decoding loop
while (packetOffset++ < numPackets && audioOffset < PacketStreamSize)
{
int packetSize = ((PacketStream[audioOffset++] & 0x0F) << 8) | PacketStream[audioOffset++]; // 12-bit encoding
// Decodes OPUS packet
decoder.Decode(PacketStream, audioOffset, packetSize, outputShorts, 0, FrameSize);
// Writes frame
writer.WriteSamples(outputShorts, 0, outputShorts.Length);
audioOffset += packetSize;
}
}
reckonOffset++;
skipMode = !skipMode;
}
}
}
/// <summary>
/// This method uses NAudio to create .wav file on disk using a given AudioClip.
/// </summary>
/// <param name="filePath">Path with filename</param>
/// <param name="audio">AudioClip to export</param>
/// <returns>Returns if the AudioClip could was written to a file on disk.</returns>
public bool TryWriteAudioClipToFile(AudioClip audio, string filePath)
{
try
{
WaveFormat format = new WaveFormat(audio.frequency, audio.channels);
using (WaveFileWriter writer = new WaveFileWriter(File.Create(filePath), format))
{
float[] buffer = new float[audio.samples];
if (audio.GetData(buffer, 0))
{
writer.WriteSamples(buffer, 0, audio.samples);
writer.Flush();
return(true);
}
}
}
catch (UnauthorizedAccessException ex)
{
Debug.LogErrorFormat("Could not write to disk, not authorized\n{0}", ex.Message);
}
catch (Exception ex)
{
Debug.LogErrorFormat("Unknown exception occurred: '{0}'", ex.Message);
}
return(false);
}
private void btnPlayFFT_Click(object sender, EventArgs e)
{
WaveFormat wf = new WaveFormat(fft.samplingRate, 1);
short[] data = new short[fft.getDataSize()];
for (int i = 0; i < fft.getDataSize(); i++)
{
data[i] = Convert.ToInt16(fft.X[i + 1].Real * 10);
}
using (WaveFileWriter wfw = new WaveFileWriter("temp.wav", wf)) {
wfw.WriteSamples(data, 0, data.Length);
}
WaveOut wo = new WaveOut();
WaveFileReader wfr = new WaveFileReader("temp.wav");
wo.Init(wfr);
wo.Play();
wo.PlaybackStopped += (a, b) => {
wo.Stop();
wo.Dispose();
wfr.Dispose();
};
}
private void decodeG711(string filename, Codecs codec)
{
WaveFileReader reader = new WaveFileReader(filename);
byte[] buffer = new byte[reader.Length];
short[] samples = new short[buffer.Length];
reader.Read(buffer, 0, buffer.Length);
for (int i = 0; i < buffer.Length; i++)
{
if (codec == Codecs.ALAW)
{
samples[i] = ALawDecoder.ALawToLinearSample(buffer[i]);
}
else if (codec == Codecs.MULAW)
{
samples[i] = MuLawDecoder.MuLawToLinearSample(buffer[i]);
}
}
WaveFileWriter writer = new WaveFileWriter("tmp_" + (++this.tmpCount) + ".wav", new WaveFormat(44100, 16, 2));
writer.WriteSamples(samples, 0, samples.Length);
writer.Close();
WaveFileReader tmpReader = new WaveFileReader("tmp_" + this.tmpCount + ".wav");
WaveStream pcm = new WaveChannel32(tmpReader);
BlockAlignReductionStream stream = new BlockAlignReductionStream(pcm);
AudioFile file = new WaveFile(tmpReader, stream, filename);
this.files.Add(file);
this.addFileToListView(file);
this.initAudio(file);
}
private static void writeWave(string filename, float[] data, int sampleRate)
{
using (var writer = new WaveFileWriter(Path.Combine(outPath, filename), WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1)))
{
writer.WriteSamples(data, 0, data.Length);
}
}
/// <summary>
/// Create a wavefile using audiodata
/// </summary>
/// <param name="audioData">the input audio data</param>
/// <param name="fileName">the audio file to save</param>
/// <param name="waveFormat">waveformat</param>
public static void CreateWaveFile(float[] audioData, string fileName, WaveFormat waveFormat)
{
using (WaveFileWriter writer = new WaveFileWriter(fileName, waveFormat))
{
writer.WriteSamples(audioData, 0, audioData.Length);
}
}
void OnAsioOutAudioAvailable(object sender, AsioAudioAvailableEventArgs e)
{
#pragma warning disable 618
var samples = e.GetAsInterleavedSamples();
#pragma warning restore 618
writer.WriteSamples(samples, 0, samples.Length);
}
public void WriteSamplesToWaveFile(string pathToFile, float[] samples, int sampleRate)
{
using (var writer = new WaveFileWriter(pathToFile, WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1)))
{
writer.WriteSamples(samples, 0, samples.Length);
}
}
/// <summary>指定したパーセンテージで音量を増減させた新しいwavデータを生成します。</summary>
/// <param name="wav">元のwavデータ</param>
/// <param name="factorPercent">音量のパーセンテージ(0～200くらいを想定)</param>
/// <returns>音量を変更したあとのwavデータ</returns>
public static byte[] ChangeVolume(byte[] wav, int factorPercent)
{
var result = new byte[wav.Length];
using (var msIn = new MemoryStream(wav))
using (var fr = new WaveFileReader(msIn))
using (var msOut = new MemoryStream(result))
using (var fw = new WaveFileWriter(msOut, fr.WaveFormat))
{
var allVolumes = new List <float>();
while (fr.CurrentTime < fr.TotalTime)
{
var vs = fr.ReadNextSampleFrame();
foreach (var v in vs)
{
allVolumes.Add(v);
}
}
fw.WriteSamples(
allVolumes.Select(v => v * factorPercent / 100.0f).ToArray(),
0,
allVolumes.Count
);
}
return(result);
}
public static void PlayMidiToFile(string midiFile, string destFile, IMidiSampleProvider msp, SynthData data)
{
float sampleNum = 0;
var file = new MidiFile(midiFile);
int ticksPerQuarterNote = file.DeltaTicksPerQuarterNote;
var events = file.Events.Aggregate((IEnumerable <MidiEvent>) new List <MidiEvent>(), (totalList, list) => totalList.Concat(list)).OrderBy(me => me.AbsoluteTime);
var totalEvents = events.Count();
var board = msp.Clone(data);
var midi = new Midi(ticksPerQuarterNote);
midi.NoteOn += board.HandleNoteOn;
midi.NoteOff += board.HandleNoteOff;
using (var output = new WaveFileWriter(destFile, WaveFormat.CreateIeeeFloatWaveFormat(data.SampleRate, 2)))
{
int eventCount = 0;
foreach (var me in events)
{
var absSample = midi.MidiTicksToSamples(me.AbsoluteTime, board.SampleRate);
var samples = (int)(absSample - sampleNum);
var result = new float[samples];
board.Next(result, 0, samples, 1);
output.WriteSamples(result, 0, samples);
sampleNum = absSample;
midi.HandleMidiEvent(me);
Console.WriteLine($"{++eventCount}/{totalEvents}");
}
}
}
//Va a generar una sñal con una frecuencia de 440
//y la uardará en un wav
private void btnCrearFrecuencia_Click(object sender, RoutedEventArgs e)
{
var sampleRate = 44100;
var channelCount = 1;
var signalGenerator = new SignalGenerator(sampleRate, channelCount);
signalGenerator.Type =
SignalGeneratorType.Sin;
signalGenerator.Frequency = 440;
signalGenerator.Gain = 0.5;
var WaveFormat = new WaveFormat(sampleRate, 16, channelCount);
var writer =
new WaveFileWriter("tono.wac", WaveFormat);
var muestrasPorSegundo =
sampleRate * channelCount;
var buffer =
new float[muestrasPorSegundo];
for (int i = 0; i < 5; i++)
{
var muestras =
signalGenerator.Read(buffer, 0, muestrasPorSegundo);
writer.WriteSamples(buffer, 0, muestras);
}
writer.Dispose();
}
internal void Export(int hz, byte[] fileBytes)
{
var samples = new List <short>();
Functions.Reset();
for (var i = StartAddress; i <= EndAddress; i++)
{
//First nibble
samples.Add(Functions.Clock(fileBytes[i] >> 4));
//Second nibble
samples.Add(Functions.Clock(fileBytes[i] & 0xf));
}
var fileName = StartAddress + "-" + EndAddress + ".wav";
var waveFormat = new WaveFormat(hz, 16, 1);
using (var writer = new WaveFileWriter(fileName, waveFormat))
{
writer.WriteSamples(samples.ToArray(), 0, samples.Count);
}
Program.ExportedSamples += 1;
}
private void WriteSamplesToBuffer(float[] buffer, int offset, int samplesRead)
{
if (isBackwardsLoop)
{
for (int i = 0; i < samplesRead - 1; i += 2)
{
int j = samplesRead - 2 - i;
float sample = overlapBuffer[j];
buffer[i + offset] = sample;
writer.WriteSample(sample);
sample = overlapBuffer[j + 1];
buffer[i + offset + 1] = sample;
writer.WriteSample(sample);
}
}
else
{
for (int i = 0; i < samplesRead; i++)
{
buffer[i + offset] = overlapBuffer[i];
}
writer.WriteSamples(overlapBuffer, 0, samplesRead);
}
}
/// <summary>
/// Write a audio float array to a 32 bit float audio file
/// </summary>
/// <param name="outputFilePath">file path to output file</param>
/// <param name="sampleRate">sample rate</param>
/// <param name="audioData">the audio float array</param>
public static void WriteIEEE32WaveFileMono(string outputFilePath, int sampleRate, float[] audioData)
{
using (WaveFileWriter wavWriter = new WaveFileWriter(outputFilePath, WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1)))
{
wavWriter.WriteSamples(audioData, 0, audioData.Length);
}
}
private unsafe void OnAudioAvailable(object sender, NAudio.Wave.AsioAudioAvailableEventArgs e)
{
var floatsamples = new float[e.SamplesPerBuffer * e.InputBuffers.Length];
e.GetAsInterleavedSamples(floatsamples);
AsioWaveFileWriter.WriteSamples(floatsamples, 0, floatsamples.Length);
AsioWaveFileWriter.Flush();
}
public static void writeWav(string path, WaveFormat format, float[] samples)
{
using (WaveFileWriter writer = new WaveFileWriter(path, format))
{
writer.WriteSamples(samples, 0, samples.Length);
writer.Flush();
}
}
/// <summary>
/// demo function fo reading and saving sound files
/// </summary>
/// <param name="testWavFile"></param>
/// <param name="testOutWavFile"></param>
public static void ReadAndWriteSound(string testWavFile, string testOutWavFile)
{
string testFile = testWavFile;
if (!File.Exists(testFile))
{
Program.LogError("No file " + testFile); return;
}
using (var reader = new AudioFileReader(testFile))
{
Program.LogInfo("TotalTime:" + reader.TotalTime);
Program.LogInfo("Length:" + reader.Length);
Program.LogInfo("Volume:" + reader.Volume);
var waveFormat = reader.WaveFormat;
Program.LogInfo("SampleRate:" + waveFormat.SampleRate);
Program.LogInfo("AverageBytesPerSecond:" + waveFormat.AverageBytesPerSecond);
Program.LogInfo("BitsPerSample:" + waveFormat.BitsPerSample);
Program.LogInfo("BlockAlign:" + waveFormat.BlockAlign);
Program.LogInfo("Channels:" + waveFormat.Channels);
Program.LogInfo("Encoding:" + waveFormat.Encoding);
Program.LogInfo("Values per second:" + reader.Length / reader.TotalTime.TotalSeconds);
var resampler = new WdlResamplingSampleProvider(reader, 44100);
var wp = new SampleToWaveProvider(reader);
var rdr = wp.ToSampleProvider();
var wf2 = rdr.WaveFormat;
Program.LogInfo("SampleRate:" + wf2.SampleRate);
Program.LogInfo("AverageBytesPerSecond:" + wf2.AverageBytesPerSecond);
Program.LogInfo("BitsPerSample:" + wf2.BitsPerSample);
Program.LogInfo("BlockAlign:" + wf2.BlockAlign);
Program.LogInfo("Channels:" + wf2.Channels);
Program.LogInfo("Encoding:" + wf2.Encoding);
var wf = WaveFormat.CreateIeeeFloatWaveFormat(rdr.WaveFormat.SampleRate, rdr.WaveFormat.Channels);
using (WaveFileWriter writer = new WaveFileWriter(testOutWavFile, wf))
{
var buf = new float[rdr.WaveFormat.SampleRate];
while (true)
{
int read = rdr.Read(buf, 0, buf.Length);
if (read > 0)
{
writer.WriteSamples(buf, 0, read);
}
else
{
break;
}
}
}
}
}
public int Read(float[] buffer, int offset, int count)
{
var read = sourceSampleProvider.Read(buffer, offset, count);
if (count > 0 && !isWriterDisposed)
{
writer.WriteSamples(buffer, offset, count);
}
return(read);
}
/// <summary>
/// Записывает массив float в wav файл
/// </summary>
/// <param name="signal"></param>
/// <param name="fileName"></param>
private void WriteParameter(float[] signal, string fileName)
{
var max = signal.Max(x => Math.Abs(x));
var scaledSignal = signal.Select(x => x / Math.Abs(max)).ToArray();
using (var writer = new WaveFileWriter(fileName, _speechFileFormat))
{
writer.WriteSamples(scaledSignal, 0, signal.Length);
}
}
private void AudioAvailable(object sender, MyAsioAudioAvailableEventArgs e)
{
if (asioWriter != null)
{
var floatsamples = new float[e.SamplesPerBuffer * (desiredInputChannels.Length + desiredOutputChannels.Length)];
e.GetAsInterleavedCombinedSamples(floatsamples, desiredInputChannels, desiredOutputChannels);
asioWriter.WriteSamples(floatsamples, 0, floatsamples.Length);
asioWriter.Flush();
}
}
public static byte[] WaveSamplesToWav(WaveSamples samples)
{
using (var wavStream = new MemoryStream())
using (var wavWriter = new WaveFileWriter(wavStream, samples.WaveFormat))
{
wavWriter.WriteSamples(samples.Samples, 0, samples.Samples.Length);
wavWriter.Flush();
return(wavStream.ToArray());
}
}
private void ExportMP3File(object sender, RoutedEventArgs e)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
var audioItem = AudioItemManager.GetAudioItem();
if (audioItem != null)
{
saveFileDialog.FileName = System.IO.Path.GetFileName(audioItem.FilePath) + "processed"; // Default file name
saveFileDialog.DefaultExt = ".mp3";
saveFileDialog.Filter = "MP3 files (.mp3)|*.mp3";
if (saveFileDialog.ShowDialog() == true)
{
string filename = saveFileDialog.FileName;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(filename.Remove(filename.Length - 4, 4));
stringBuilder.Append(".wav");
filename = stringBuilder.ToString();
stringBuilder.Clear();
using (WaveFileWriter writer = new WaveFileWriter(filename, AudioItemManager.GetAudioItem().WaveFormat))
{
if (AudioItemManager.GetAudioItem() != null)
{
writer.WriteSamples(AudioItemManager.GetAudioItem().AudioBuffer, 0, AudioItemManager.GetAudioItem().AudioBuffer.Length / 2);
writer.Dispose();
writer.Close();
filename = ConvertWAVToMp3File(filename, stringBuilder);
DeleteWAVFileAfterConversion(filename, stringBuilder);
}
else
{
MainWindowLogAction("Cannot export not changed file! " + filename);
}
}
if (MainWindowLogAction != null)
{
MainWindowLogAction("Exported edited audio file, filePath: " + filename);
}
}
}
else
{
if (MainWindowLogAction != null)
{
MainWindowLogAction("Cannot export empty file!");
}
}
}
public static void SaveSound(string prefix, string fileName, int sampleRate, float[] samples)
{
string resultFileName = "result_" + prefix + "_" + fileName;
WaveFormat waveFormat = new WaveFormat(sampleRate: sampleRate, channels: 1);
using (WaveFileWriter writer = new WaveFileWriter(resultFileName, waveFormat))
{
writer.WriteSamples(samples, 0, samples.Length);
}
}
public override int Read(float[] arr, int offset, int count)
{
var read = base.Read(arr, offset, count);
// Write to the writer
if (writer != null)
{
writer.WriteSamples(arr, offset, read);
}
return(read);
}
static void Main(string[] args)
{
// TODO: REPLACE IT
var readWavFilePath = "";
var writeWavFilePath = "";
using var waveReader = new WaveFileReader(readWavFilePath);
if (waveReader.WaveFormat.Channels != 1)
{
Console.WriteLine("Support 1 channel wav only");
return;
}
var samples = new float[waveReader.Length / waveReader.BlockAlign];
for (var i = 0; i < samples.Length; i++)
{
samples[i] = waveReader.ReadNextSampleFrame()[0];
}
using var fvadCore = FvadBuilder.Create()
.SetMode(Constants.FvadModeAggressiveness.Quality)
.SetSampleRate(waveReader.WaveFormat.SampleRate)
.Build();
// per 10msec
var samplePerMsec = waveReader.WaveFormat.SampleRate / 1000 * 10;
var result = Enumerable.Range(0, (int)Math.Floor(samples.Length / samplePerMsec * 1f))
.Select(i =>
{
var shortSample = samples.AsSpan(samplePerMsec * i, samplePerMsec)
.ToArray()
.Select(v => (short)(v * short.MaxValue))
.ToArray();
return(index: i, isActive: fvadCore.IsVoiceActive(shortSample));
});
foreach (var(i, active) in result)
{
Console.WriteLine($"index: {i}, active: {active}");
}
var activeSamples = result.Where(v => v.isActive)
.SelectMany(v => samples.AsSpan(samplePerMsec * v.index, samplePerMsec).ToArray())
.ToArray();
using var waveWriter = new WaveFileWriter(writeWavFilePath, new WaveFormat(
waveReader.WaveFormat.SampleRate,
waveReader.WaveFormat.BitsPerSample,
waveReader.WaveFormat.Channels));
waveWriter.WriteSamples(activeSamples, 0, activeSamples.Length);
}
public static void SaveSong(Song song, string path)
{
WaveFormat format = new WaveFormat(song.sampleRate, song.channels);
WaveFileWriter waveFileWriter = new WaveFileWriter(path, format);
float[] samples = new float[song.samples.LongLength];
for (long i = 0; i < samples.LongLength; i++)
{
samples[i] = (float)song.samples[i];
}
waveFileWriter.WriteSamples(samples, 0, samples.Length);
waveFileWriter.Close();
}
public void WriteAll(List <double> data, int soundLength)
{
float[] newData = data.Select(x => (float)x).ToArray();
using (WaveFileWriter waveFileWriter = new WaveFileWriter(fileStream, new WaveFormat(sampleRate, 16, numChannels)))
{
for (int i = 0; i < soundLength; i++)
{
waveFileWriter.WriteSamples(newData, 0, newData.Length);
}
}
/*
* byte[] chunkID = Encoding.ASCII.GetBytes("RIFF");
* byte[] format = Encoding.ASCII.GetBytes("WAVE");
* byte[] subChunk1ID = Encoding.ASCII.GetBytes("fmt ");
* byte[] subChunk2ID = Encoding.ASCII.GetBytes("data");
* int subChunk1Size = 16;
* short audioFormat = 1;
* short bitsPerSample = 16;
* //short numChannels = 1;
* //int sampleRate = 22050 * 2 * 2;
* int byteRate = sampleRate * numChannels * (bitsPerSample / 8);
* //int numSamples = 1000000;
* short blockAlign = (short)(numChannels * (bitsPerSample / 8));
* int subChunk2Size = numSamples * numChannels * (bitsPerSample / 8);
* int chunkSize = 4 + (8 + subChunk1Size) + (8 + subChunk2Size);
*
* using (BinaryWriter bw = new BinaryWriter(fileStream))
* {
* bw.Write(chunkID);
* bw.Write(chunkSize);
* bw.Write(format);
* bw.Write(subChunk1ID);
* bw.Write(subChunk1Size);
* bw.Write(audioFormat);
* bw.Write(numChannels);
* bw.Write(sampleRate);
* bw.Write(byteRate);
* bw.Write(blockAlign);
* bw.Write(bitsPerSample);
* bw.Write(subChunk2ID);
* bw.Write(subChunk2Size);
*
* for (int i = 0; i < numSamples; i++)
* {
* bw.Write((byte)Math.Round(data[i % data.Count]));
* }
* }
* //*/
}
//Hamming window
private void GenerateWindow()
{
int steps = (bitDepth / 8);
int byteRangeStart = selectedWindow != 0?((selectedWindow - 1) * 150) + 45:45;
int byteRangeEnd = byteRangeStart + 399;
int counter = 0;
byteRangeStart = byteRangeStart * steps;
byteRangeEnd = byteRangeEnd * steps;
byte[] window = new byte[400 * steps];
if (byteRangeEnd > audioSample.Length)
{
return;
}
for (int i = byteRangeStart; i < byteRangeEnd; i++)
{
window[counter] = audioSample[i];
counter++;
}
if (DisplayNoise)
{
modifiedWindow = Denoise(window, steps);
}
else if (DisplayHammer)
{
modifiedWindow = Denoise(window, steps);
modifiedWindow = Hamming(modifiedWindow, steps);
}
else if (DisplayFourier)
{
modifiedWindow = Denoise(window, steps);
modifiedWindow = Hamming(modifiedWindow, steps);
modifiedWindow = Fourier(modifiedWindow);
}
using (WaveFileWriter writer = new WaveFileWriter(tempOutputFilePath, new WaveFormat(sampleRate, bitDepth, channels)))
{
if (!DisplayFourier && !DisplayHammer && !DisplayNoise)
{
writer.Write(window, 0, window.Length);
}
else
{
writer.WriteSamples(modifiedWindow, 0, modifiedWindow.Length);
}
writer.Close();
}
}
public void WriteSamplesToWaveFile(string pathToFile, float[] samples, int sampleRate)
{
using (var writer = new WaveFileWriter(pathToFile, WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1)))
{
writer.WriteSamples(samples, 0, samples.Length);
}
}
