public void SplitWavData()
{
if (RIFFData.ChunkID != null)
{
List <List <byte> > output = new List <List <byte> >();
RIFFData data = RIFFData;
for (int i = 0; i < data.Channels; i++)
{
List <byte> channel = new List <byte>(data.SubChunkSize / data.Channels);
output.Add(channel);
}
int inc = data.Channels * (data.BitsPerSample / 8);
for (int b = 0; b < data.Data.Length; b += inc)
{
for (int ch = 0; ch < data.Channels; ch++)
{
for (int s = 0; s < data.BitsPerSample / 8; s++)
{
output[ch].Add(data.Data[b + s + (ch * data.BitsPerSample / 8)]);
}
}
}
RawChannelData = output;
PreSaveBuffer = new List <List <byte> >(RawChannelData);
}
}
public void WriteFile(RIFFData riff)
{
try {
FileStream fs = new FileStream(filePath, FileMode.Create);
BinaryWriter wr = new BinaryWriter(fs);
// RIFF Properties
wr.Write(riff.ChunkID);
wr.Write(riff.FileSize);
wr.Write(riff.RIFFType);
// FMT Properties
wr.Write(riff.FormatID);
wr.Write(riff.FormatSize);
wr.Write(riff.FormatCode);
wr.Write(riff.Channels);
wr.Write(riff.SampleRate);
wr.Write(riff.ByteRate);
wr.Write(riff.BlockAlign);
wr.Write(riff.BitsPerSample);
wr.Write(riff.SubChunkID);
wr.Write(riff.SubChunkSize);
wr.Write(riff.Data);
wr.Close();
fs.Close();
} catch (Exception e) {
System.Diagnostics.Debug.WriteLine(e.StackTrace);
}
}
public RIFFData GenerateRIFFData(AudioPanel panel)
{
RIFFData riff = new RIFFData();
// RIFF Properties
char[] chunkID = { 'R', 'I', 'F', 'F' };
riff.ChunkID = Encoding.ASCII.GetBytes(chunkID);
char[] riffType = { 'W', 'A', 'V', 'E' };
riff.RIFFType = Encoding.ASCII.GetBytes(riffType);
// FMT Properties
char[] formatID = { 'f', 'm', 't', ' ' };
riff.FormatID = Encoding.ASCII.GetBytes(formatID);
riff.FormatSize = 16;
riff.FormatCode = 1;
if (panel.Menu.IsMono)
{
riff.Channels = 1;
}
else
{
riff.Channels = 2;
}
riff.BitsPerSample = panel.Menu.manager.bits[panel.Menu.manager.checkedBits].Value;
// Check that loaded file is standard samplerate
// Use the loaded value if not selectable
if (panel.PanelData.RIFFData.SampleRate != panel.Menu.manager.khz[panel.Menu.manager.checkedKHZ].Value && panel.PanelData.RIFFData.SampleRate != 0)
{
riff.SampleRate = panel.PanelData.RIFFData.SampleRate;
}
else
{
riff.SampleRate = panel.Menu.manager.khz[panel.Menu.manager.checkedKHZ].Value;
}
riff.ByteRate = riff.BitsPerSample / 8 * riff.SampleRate * riff.Channels;
riff.BlockAlign = (short)(riff.Channels * riff.BitsPerSample / 8);
char[] subChunkID = { 'd', 'a', 't', 'a' };
riff.SubChunkID = Encoding.ASCII.GetBytes(subChunkID);
// Set the data chunk to be loaded data or null
if (panel.PanelData.RawChannelData != null)
{
riff.Data = Interleave_Bytes(panel, riff);
riff.SubChunkSize = riff.Data.Length;
Console.WriteLine("Data size:" + riff.Data.Length);
}
else
{
riff.SubChunkSize = 0;
riff.Data = null;
}
riff.FileSize = 36 + riff.SubChunkSize;
return(riff);
}
public RIFFData ParseBytes()
{
RIFFData output = new RIFFData();
// RIFF Properties
output.ChunkID = new byte[4];
Array.Copy(file, 0, output.ChunkID, 0, 4);
output.FileSize = BitConverter.ToInt32(file, 4);
Console.WriteLine(output.FileSize + ", " + (output.FileSize - 44));
output.RIFFType = new byte[4];
Array.Copy(file, 8, output.RIFFType, 0, 4);
// FMT Properties
output.FormatID = new byte[4];
Array.Copy(file, 12, output.FormatID, 0, 4);
output.FormatSize = BitConverter.ToInt32(file, 16);
output.FormatCode = BitConverter.ToInt16(file, 20);
output.Channels = BitConverter.ToInt16(file, 22);
output.SampleRate = BitConverter.ToInt32(file, 24);
output.ByteRate = BitConverter.ToInt32(file, 28);
output.BlockAlign = BitConverter.ToInt16(file, 32);
output.BitsPerSample = BitConverter.ToInt16(file, 34);
output.SubChunkID = new byte[4];
Array.Copy(file, 36, output.SubChunkID, 0, 4);
output.SubChunkSize = BitConverter.ToInt32(file, 40);
// Skip non 'data' SubChunks
int i = 44;
while (!Encoding.ASCII.GetString(output.SubChunkID).Equals("data"))
{
i += output.SubChunkSize;
Array.Copy(file, i, output.SubChunkID, 0, 4);
i += 4;
output.SubChunkSize = BitConverter.ToInt32(file, i);
i += 4;
}
output.Data = new byte[output.SubChunkSize];
Array.Copy(file, i, output.Data, 0, output.SubChunkSize);
return(output);
}
public byte[] Interleave_Bytes(AudioPanel panel, RIFFData riff)
{
int size = panel.PanelData.RawChannelData[0].Count;
List <byte> output = new List <byte>();
int inc = riff.BitsPerSample / 8;
for (int i = 0; i < size; i += inc)
{
for (int ch = 0; ch < riff.Channels; ch++)
{
for (int b = 0; b < inc; b++)
{
output.Add(panel.PanelData.RawChannelData[ch][i + b]);
}
}
}
return(output.ToArray());
}
public List <byte> IntToByteList(List <int> input, RIFFData riff)
{
List <byte> output = new List <byte>();
switch (riff.BitsPerSample)
{
case 8:
for (int i = 0; i < input.Count; i++)
{
output.Add(Convert.ToByte(input[i]));
}
break;
case 16:
for (int i = 0; i < input.Count; i++)
{
output.AddRange(BitConverter.GetBytes((Int16)input[i]));
}
break;
case 24:
for (int i = 0; i < input.Count; i++)
{
byte[] temp = BitConverter.GetBytes((Int32)input[i]);
output.Add(temp[1]);
output.Add(temp[2]);
output.Add(temp[3]);
}
break;
case 32:
for (int i = 0; i < input.Count; i++)
{
output.AddRange(BitConverter.GetBytes((Int32)input[i]));
}
break;
}
return(output);
}
public void Record_Click(object sender, EventArgs e)
{
if (Service.DLLWrapper.Safe)
{
if (panel.PanelData.RIFFData.SubChunkSize == 0)
{
recording = !recording;
if (recording)
{
play.Enabled = false;
record.Text = "Stop";
WavPackager packager = new WavPackager(null);
RIFFData riff = packager.GenerateRIFFData(panel);
panel.PanelData.RIFFData = riff;
Service.DLLWrapper.Record(riff);
}
else
{
play.Enabled = true;
Enable_Record(false);
RIFFData riff = panel.PanelData.RIFFData;
riff.Data = Service.DLLWrapper.RecordStop();
riff.SubChunkSize = riff.Data.Length;
panel.PanelData.RIFFData = riff;
panel.PanelData.SplitWavData();
panel.ClearAllCharts();
panel.PanelData.RawChartData.Add(panel.PanelData.GetReadableChannel(0));
Workers.ChartRenderWorker worker = new Workers.ChartRenderWorker(panel, 0, true);
worker.RunWorkerAsync();
if (panel.PanelData.RawChannelData.Count > 1)
{
panel.Menu.manager.Stereo_Click();
panel.Menu.manager.Mono.Enabled = false;
panel.PanelData.RawChartData.Add(panel.PanelData.GetReadableChannel(1));
Workers.ChartRenderWorker worker2 = new Workers.ChartRenderWorker(panel, 1, true);
worker2.RunWorkerAsync();
}
else
{
panel.Menu.manager.Mono_Click();
panel.Menu.manager.Stereo.Enabled = false;
}
}
panel.Menu.manager.Open_Click();
}
else
{
ScrollPanel scroll = (ScrollPanel)panel.ParentRef;
scroll.Click_AddChannel(null, EventArgs.Empty);
scroll.audioPanels.Last.Value.PlayBar.Record_Click(null, EventArgs.Empty);
}
}
else
{
Console.WriteLine("Unsafe Record action attempted and ignored.");
}
}
public static List <ComplexNumber> DFTIntegers(List <int> input, TypeKey.Windowing type, RIFFData riff, int binStart, int binEnd)
{
List <ComplexNumber> output = new List <ComplexNumber>();
for (int f = binStart; f < binEnd; f++)
{
double reSum = 0;
double imSum = 0;
for (int t = 0; t < input.Count; t++)
{
double weight = GetWindowing(t, input.Count, type);
double angle = (2 * Math.PI * t * f) / input.Count;
reSum += weight * input[t] * Math.Cos(angle);
imSum -= weight * input[t] * Math.Sin(angle);
}
reSum /= input.Count;
imSum /= input.Count;
ComplexNumber n = new ComplexNumber();
n.Real = reSum;
n.Imaginary = imSum;
n.SetLength();
output.Add(n);
}
return(output);
}
protected void Paste(object sender, EventArgs e)
{
if (Service.DLLWrapper.Safe)
{
Cursor cursor = panel.TimeChannel1.ChartArea.CursorX;
if (panel.PanelData.RawChartData.Count > 0 && panel.ParentRef.ScrollData.IntBuffer.Count > 0)
{
for (int i = 0; i < panel.PanelData.RIFFData.Channels; i++)
{
int pos = (int)cursor.Position * (panel.PanelData.RIFFData.BitsPerSample / 8);
List <int> copyBuffer;
if (i < panel.ParentRef.ScrollData.IntBuffer.Count)
{
copyBuffer = panel.ParentRef.ScrollData.IntBuffer[i];
}
else
{
copyBuffer = panel.ParentRef.ScrollData.IntBuffer[0];
}
RIFFData copyRiff = panel.ParentRef.ScrollData.BufferRIFF;
RIFFData curChRiff = panel.PanelData.RIFFData;
// Downsample
if (copyRiff.SampleRate > panel.PanelData.RIFFData.SampleRate)
{
// Generate filter
double freqPBin = (double)copyRiff.SampleRate / copyBuffer.Count;
int pasteFMax = curChRiff.SampleRate / 2;
int bin = (int)(pasteFMax / freqPBin);
bool bitOffset = (copyRiff.BitsPerSample == 8) != (panel.PanelData.RIFFData.BitsPerSample == 8);
FilterAndConvolve(copyBuffer, bin, bitOffset);
// Trim copy buffer
double sampleRatio = (double)curChRiff.SampleRate / copyRiff.SampleRate;
Func <int, int> mapFunction = Structure.BitMapper.GetMapper(copyRiff.BitsPerSample, panel.PanelData.RIFFData.BitsPerSample);
List <int> trimCopy = Service.SignalProcessing.Downsample(convolutionResult, sampleRatio, mapFunction);
if (i < 2)
{
List <int> input = panel.PanelData.RawChartData[i];
int index = (int)cursor.Position;
input.InsertRange((int)cursor.Position, trimCopy);
}
// Move new list into channel data
panel.PanelData.RawChannelData[i].InsertRange(pos, panel.PanelData.IntToByteList(trimCopy, copyRiff));
Console.WriteLine("Downsample complete");
}
// Upsample
else if (copyRiff.SampleRate < panel.PanelData.RIFFData.SampleRate)
{
// Load stuffed copy samples
double sampleRatio = (double)panel.PanelData.RIFFData.SampleRate / panel.ParentRef.ScrollData.BufferRIFF.SampleRate;
Func <int, int> mapFunction = Structure.BitMapper.GetMapper(copyRiff.BitsPerSample, panel.PanelData.RIFFData.BitsPerSample);
List <int> padCopy = Service.SignalProcessing.Upsample(copyBuffer, sampleRatio, mapFunction);
// Filter frequencies above receiver buffer fmax from copy
double freqPBin = (double)panel.PanelData.RIFFData.SampleRate / copyBuffer.Count;
int pasteFMax = panel.ParentRef.ScrollData.BufferRIFF.SampleRate / 2;
int bin = (int)(pasteFMax / freqPBin);
bool bitOffset = (copyRiff.BitsPerSample != panel.PanelData.RIFFData.BitsPerSample);
FilterAndConvolve(padCopy, bin, bitOffset);
// Move new list into channel data
if (i < 2)
{
List <int> input = panel.PanelData.RawChartData[i];
int index = (int)cursor.Position;
input.InsertRange((int)cursor.Position, convolutionResult);
}
List <byte> temp = panel.PanelData.IntToByteList(convolutionResult, panel.PanelData.RIFFData);
panel.PanelData.RawChannelData[i].InsertRange(pos, temp);
Console.WriteLine("Upsample complete");
}
// Copy is same sample rate
else
{
// Modify bits per sample values
if (copyRiff.BitsPerSample != panel.PanelData.RIFFData.BitsPerSample)
{
Func <int, int> mapFunction = Structure.BitMapper.GetMapper(copyRiff.BitsPerSample, panel.PanelData.RIFFData.BitsPerSample);
List <int> adjustedBitRate = new List <int>();
foreach (int sample in copyBuffer)
{
adjustedBitRate.Add(mapFunction(sample));
}
if (i < 2)
{
List <int> input = panel.PanelData.RawChartData[i];
int index = (int)cursor.Position;
input.InsertRange((int)cursor.Position, adjustedBitRate);
}
panel.PanelData.RawChannelData[i].InsertRange(pos, panel.PanelData.IntToByteList(adjustedBitRate, panel.PanelData.RIFFData));
}
else
{
if (i < 2)
{
List <int> input = panel.PanelData.RawChartData[i];
int index = (int)cursor.Position;
input.InsertRange((int)cursor.Position, copyBuffer);
}
panel.PanelData.RawChannelData[i].InsertRange(pos, panel.PanelData.IntToByteList(copyBuffer, copyRiff));
}
}
}
}
}
else
{
Console.WriteLine("Unsafe Paste() attempted; ignored");
}
}
