private static void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
{
Console.WriteLine(e.BytesRecorded);
}
void wi_DataAvailable(object sender, WaveInEventArgs e)
{
if (progressBar1.Value > trackBar1.Value)
{
record = true;
}
else
{
record = false;
}
byte[] buffer = e.Buffer;
///
///
///
//Преобразование байтов по фурье
System.Numerics.Complex[] c = new System.Numerics.Complex[n];
for (int i = 0; i < n; i += 2)
{
c[i] = new System.Numerics.Complex(BitConverter.ToInt16(buffer, i), 0);
c[i + 1] = new System.Numerics.Complex(BitConverter.ToInt16(buffer, i), 0);
}
var fft = FFT.fft(c);
var nfft = FFT.nfft(fft);
//Заполняем лист с данными спектрального анализа (собственно теми самыми фурье :))
for (int i = 0; i < n; i += 1)
{
if (record)
{
spec.Add(fft[i].Magnitude * int.Parse(label3.Text));
spec.RemoveAt(0);
}
else
{
spec.Add(1);
spec.RemoveAt(0);
}
}
spec.Reverse();
label4.Text = spec.IndexOf(spec.Max(a => a)).ToString();
///
///
///
//Заполняем лист с данными о звуковой волне
for (int i = 0; i < e.BytesRecorded; i += 2)
{
if (record)
{
myQ.Add(BitConverter.ToInt16(buffer, i) * int.Parse(label3.Text));
myQ.RemoveAt(0);
}
else
{
myQ.Add(1);
myQ.RemoveAt(0);
}
noise.Add(BitConverter.ToInt16(buffer, i) * int.Parse(label3.Text));
noise.RemoveAt(0);
}
progressBar1.Value = (int)(noise.FindAll(a => a > 0).Average(b => b));
label5.Text = myQ.FindAll(a => a > 0).Average(b => b).ToString();
}
//Stopwatch _stopwatch = new Stopwatch();
private void _waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
// if(_stopwatch.ElapsedMilliseconds > 22)
//Console.WriteLine($"Time: {_stopwatch.ElapsedMilliseconds} - Bytes: {e.BytesRecorded}");
// _stopwatch.Restart();
short[] pcmShort = null;
if ((e.BytesRecorded / 2 == SEGMENT_FRAMES) && (_micInputQueue.Count == 0))
{
//perfect!
pcmShort = new short[SEGMENT_FRAMES];
Buffer.BlockCopy(e.Buffer, 0, pcmShort, 0, e.BytesRecorded);
}
else
{
for (var i = 0; i < e.BytesRecorded; i++)
{
_micInputQueue.Enqueue(e.Buffer[i]);
}
}
//read out the queue
while ((pcmShort != null) || (_micInputQueue.Count >= AudioManager.SEGMENT_FRAMES))
{
//null sound buffer so read from the queue
if (pcmShort == null)
{
pcmShort = new short[AudioManager.SEGMENT_FRAMES];
for (var i = 0; i < AudioManager.SEGMENT_FRAMES; i++)
{
pcmShort[i] = _micInputQueue.Dequeue();
}
}
//null sound buffer so read from the queue
if (pcmShort == null)
{
pcmShort = new short[AudioManager.SEGMENT_FRAMES];
for (var i = 0; i < AudioManager.SEGMENT_FRAMES; i++)
{
pcmShort[i] = _micInputQueue.Dequeue();
}
}
try
{
//volume boost pre
for (var i = 0; i < pcmShort.Length; i++)
{
// n.b. no clipping test going on here
pcmShort[i] = (short)(pcmShort[i] * MicBoost);
}
//process with Speex
_speex.Process(new ArraySegment <short>(pcmShort));
float max = 0;
for (var i = 0; i < pcmShort.Length; i++)
{
//determine peak
if (pcmShort[i] > max)
{
max = pcmShort[i];
}
}
//convert to dB
MicMax = (float)VolumeConversionHelper.ConvertFloatToDB(max / 32768F);
var pcmBytes = new byte[pcmShort.Length * 2];
Buffer.BlockCopy(pcmShort, 0, pcmBytes, 0, pcmBytes.Length);
//encode as opus bytes
int len;
var buff = _encoder.Encode(pcmBytes, pcmBytes.Length, out len);
if ((_udpVoiceHandler != null) && (buff != null) && (len > 0))
{
//create copy with small buffer
var encoded = new byte[len];
Buffer.BlockCopy(buff, 0, encoded, 0, len);
// Console.WriteLine("Sending: " + e.BytesRecorded);
if (_udpVoiceHandler.Send(encoded, len))
{
//send audio so play over local too
_micWaveOutBuffer?.AddSamples(pcmBytes, 0, pcmBytes.Length);
}
}
else
{
Logger.Error($"Invalid Bytes for Encoding - {e.BytesRecorded} should be {SEGMENT_FRAMES} ");
}
_errorCount = 0;
}
catch (Exception ex)
{
_errorCount++;
if (_errorCount < 10)
{
Logger.Error(ex, "Error encoding Opus! " + ex.Message);
}
else if (_errorCount == 10)
{
Logger.Error(ex, "Final Log of Error encoding Opus! " + ex.Message);
}
}
pcmShort = null;
}
}
private void RcRecorder_DataAvailable(object sender, WaveInEventArgs e)
{
writer.Write(e.Buffer, 0, e.BytesRecorded);
}
private static void Input_DataAvailable(object sender, WaveInEventArgs e)
{
stream.Write(e.Buffer, 0, e.BytesRecorded);
}
private void OnAudioDataAvailable(object sender, WaveInEventArgs waveInEventArgs)
{
audio.WriteMessage(waveInEventArgs.Buffer);
}
//++++
void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
byte[] encoded = selectedCodec.Encode(e.Buffer, 0, e.BytesRecorded);
udpSender.Send(encoded, encoded.Length);
}
void OnAudioCaptured(object sender, WaveInEventArgs e)
{
byte[] encoded = codec.Encode(e.Buffer, 0, e.BytesRecorded);
audioSender.Send(encoded);
}
private void wi_DataAvailable(object sender, WaveInEventArgs e)
{
bwp.AddSamples(e.Buffer, 0, e.BytesRecorded);
}
// private WaveFileWriter _beforeWaveFile;
// private WaveFileWriter _afterFileWriter;
private void WasapiCaptureOnDataAvailable(object sender, WaveInEventArgs e)
{
if (_resampler == null)
{
//create and use in the same thread or COM issues
_resampler = new EventDrivenResampler(windowsN, _wasapiCapture.WaveFormat, new WaveFormat(AudioManager.MIC_SAMPLE_RATE, 16, 1));
// _beforeWaveFile = new WaveFileWriter(@"C:\Temp\Test-Preview-Before.wav", new WaveFormat(AudioManager.MIC_SAMPLE_RATE, 16, 1));
// _afterFileWriter = new WaveFileWriter(@"C:\Temp\Test-Preview-after.wav", new WaveFormat(AudioManager.OUTPUT_SAMPLE_RATE, 16, 1));
}
if (e.BytesRecorded > 0)
{
//Logger.Info($"Time: {_stopwatch.ElapsedMilliseconds} - Bytes: {e.BytesRecorded}");
short[] resampledPCM16Bit = _resampler.Resample(e.Buffer, e.BytesRecorded);
// Logger.Info($"Time: {_stopwatch.ElapsedMilliseconds} - Bytes: {resampledPCM16Bit.Length}");
//fill sound buffer
for (var i = 0; i < resampledPCM16Bit.Length; i++)
{
_micInputQueue.Enqueue(resampledPCM16Bit[i]);
}
//read out the queue
while (_micInputQueue.Count >= AudioManager.MIC_SEGMENT_FRAMES)
{
short[] pcmShort = new short[AudioManager.MIC_SEGMENT_FRAMES];
for (var i = 0; i < AudioManager.MIC_SEGMENT_FRAMES; i++)
{
pcmShort[i] = _micInputQueue.Dequeue();
}
try
{
//volume boost pre
for (var i = 0; i < pcmShort.Length; i++)
{
// n.b. no clipping test going on here
pcmShort[i] = (short)(pcmShort[i] * MicBoost);
}
//process with Speex
_speex.Process(new ArraySegment <short>(pcmShort));
float max = 0;
for (var i = 0; i < pcmShort.Length; i++)
{
//determine peak
if (pcmShort[i] > max)
{
max = pcmShort[i];
}
}
//convert to dB
MicMax = (float)VolumeConversionHelper.ConvertFloatToDB(max / 32768F);
var pcmBytes = new byte[pcmShort.Length * 2];
Buffer.BlockCopy(pcmShort, 0, pcmBytes, 0, pcmBytes.Length);
//encode as opus bytes
int len;
var buff = _encoder.Encode(pcmBytes, pcmBytes.Length, out len);
if ((_udpVoiceHandler != null) && (buff != null) && (len > 0))
{
//create copy with small buffer
var encoded = new byte[len];
Buffer.BlockCopy(buff, 0, encoded, 0, len);
// Console.WriteLine("Sending: " + e.BytesRecorded);
var clientAudio = _udpVoiceHandler.Send(encoded, len);
// _beforeWaveFile.Write(pcmBytes, 0, pcmBytes.Length);
if (clientAudio != null && _micWaveOutBuffer != null)
{
//todo see if we can fix the resample / opus decode
//send audio so play over local too
var processedAudioBytes = _passThroughAudioProvider?.AddClientAudioSamples(clientAudio);
//process bytes and add effects
if (processedAudioBytes?.Length > 0)
{
// _afterFileWriter.Write(processedAudioBytes, 0, processedAudioBytes.Length);
_micWaveOutBuffer?.AddSamples(processedAudioBytes, 0, processedAudioBytes.Length);
}
}
}
else
{
Logger.Error($"Invalid Bytes for Encoding - {pcmShort.Length} should be {MIC_SEGMENT_FRAMES} ");
}
_errorCount = 0;
}
catch (Exception ex)
{
_errorCount++;
if (_errorCount < 10)
{
Logger.Error(ex, "Error encoding Opus! " + ex.Message);
}
else if (_errorCount == 10)
{
Logger.Error(ex, "Final Log of Error encoding Opus! " + ex.Message);
}
}
}
}
}
private void sourceStream_DataAvailable(object sender, WaveInEventArgs e)
{
//inputStream.Write(e.Buffer, 0, e.Buffer.Length);
}
public override void OnData(WaveInEventArgs a)
{
this.sampleAggregator.Add(a.Buffer);
}
private void OnAudioDataAvailable(object sender, WaveInEventArgs e)
{
throw new NotImplementedException();
}
private void Capture_DataAvailable(object sender, WaveInEventArgs e)
{
sharer.PushData(e.Buffer, e.BytesRecorded, capture.WaveFormat);
}
private void OnDataAvailable(object sender, WaveInEventArgs e)
{
Debug.WriteLine(e.BytesRecorded);
UdpService.Instance.SendMessage(e.Buffer, e.BytesRecorded);
}
private void WaveIn_DataAvailable(object sender,
WaveInEventArgs e)
{
byte[] buffer = e.Buffer;
int bytesGrabados = e.BytesRecorded;
int numMuestras = bytesGrabados / 2;
int exponente = 0;
int numeroBits = 0;
do
{
exponente++;
numeroBits = (int)
Math.Pow(2, exponente);
} while (numeroBits < numMuestras);
exponente -= 1;
numeroBits = (int)
Math.Pow(2, exponente);
Complex[] muestrasComplejas =
new Complex[numeroBits];
for (int i = 0; i < bytesGrabados; i += 2)
{
short muestra =
(short)(buffer[i + 1] << 8 | buffer[i]);
float muestra32bits =
(float)muestra / 32768.0f;
if (i / 2 < numeroBits)
{
muestrasComplejas[i / 2].X = muestra32bits;
}
}
FastFourierTransform.FFT(true,
exponente, muestrasComplejas);
float[] valoresAbsolutos =
new float[muestrasComplejas.Length];
for (int i = 0; i < muestrasComplejas.Length;
i++)
{
valoresAbsolutos[i] = (float)
Math.Sqrt(
(muestrasComplejas[i].X * muestrasComplejas[i].X) +
(muestrasComplejas[i].Y * muestrasComplejas[i].Y));
}
var mitadValoresAbsolutos =
valoresAbsolutos.Take(valoresAbsolutos.Length / 2).ToList();
int indiceValorMaximo =
mitadValoresAbsolutos.IndexOf(
mitadValoresAbsolutos.Max());
float frecuenciaFundamental =
(float)(indiceValorMaximo * formato.SampleRate)
/ (float)valoresAbsolutos.Length;
lblHertz.Text =
frecuenciaFundamental.ToString("n") +
" Hz";
}
private void Capture_DataAvailable(object sender, WaveInEventArgs e)
{
ReadOnlySpan <float> data = MemoryMarshal.Cast <byte, float>(e.Buffer.AsSpan(0, e.BytesRecorded));
streamObserver.Write(data);
}
public void OnDataAvailable(object sender, WaveInEventArgs e)
{
_waitingForData = false;
var outPos = 0;
var floatIndex = 0;
try
{
CheckBuffers(e.BytesRecorded);
// Note: Data ratio of stereo 32-bit 48KHz to mono 16-bit 8KHz is 24:1
//var bytesReceived = e.BytesRecorded;
//var outputSize = bytesReceived / 24;
//var outArray = new byte[(int)Math.Ceiling(outputSize / 2d) * 2];
// Note: Data ratio of stereo 32-bit 48KHz to mono 8-bit 8KHz is 48:1
var bytesReceived = e.BytesRecorded;
var outputSize = bytesReceived / 48;
var outArray = new byte[(int)Math.Ceiling(outputSize / 2d) * 2];
// 48KHz
// 32Kbps
//var i = 0;
//var j = 0;
//var k = 0;
//var o = new float[e.BytesRecorded / 8];
//while (i < e.BytesRecorded)
//{
// var left = BitConverter.ToSingle(e.Buffer, i);
// var right = BitConverter.ToSingle(e.Buffer, i + 4);
// var mono = (left + right) * 0.5F;
// o[j] = mono;
// i = i + 8;
// j = j + 1;
//}
//var result = Downsample(o);
//for (k = 0; k < result.Length; k++)
//{
// outArray[k] = MuLawEncoder.LinearToMuLawSample((short) (result[k] * MaxValue));
//}
// #1 Resample to 8KHz
var waveBuffer = Downsample(e);
while (floatIndex < waveBuffer.FloatBufferCount)
{
// #2 Convert to Mono
var leftSample = waveBuffer.FloatBuffer[floatIndex++];
var rightSample = waveBuffer.FloatBuffer[floatIndex++];
var monoSample = ConvertToMono(leftSample, rightSample);
// #3 Convert to short and then mu-law
outArray[outPos++] = MuLawEncoder.LinearToMuLawSample((short)(monoSample * MaxValue));
}
if (DataAvailable != null)
{
foreach (var delDelegate in DataAvailable.GetInvocationList())
{
delDelegate.DynamicInvoke(this, new DataEventArgs(outArray, outPos)); //24));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.WriteLine($"{nameof(outPos)}: {outPos}, {nameof(floatIndex)}: {floatIndex}");
throw;
}
_waitingForData = true;
}
void OnDaraAvailable(object sender, WaveInEventArgs e)
{
byte[] buffer = e.Buffer;
int bytesGrabados = e.BytesRecorded;
double acumulador = 0;
double nummuestras = bytesGrabados / 2;
int exponente = 1;
int numeroMuestrasComplejas = 0;
int bitsMaximos = 0;
do //1,200
{
bitsMaximos = (int)Math.Pow(2, exponente);
exponente++;
} while (bitsMaximos < nummuestras);
//bitsMaximos = 2048
//exponente = 12
//numeroMuestrasComplejas = 1024
//exponente = 10
exponente -= 2;
numeroMuestrasComplejas = bitsMaximos / 2;
Complex[] muestrasComplejas =
new Complex[numeroMuestrasComplejas];
for (int i = 0; i < bytesGrabados; i += 2)
{
short muestra = (short)(buffer[i + 1] << 8 | buffer[i]);
//lblmuestras.TextInput = muestra.ToString();
//slbvolumen.Value = muestra;
float muestra32bits = (float)muestra / 32768.0f;
slbvolumen.Value = Math.Abs(muestra32bits);
if (1 / 2 < numeroMuestrasComplejas)
{
muestrasComplejas[i / 2].X = muestra32bits;
}
/*acumulador += muestra;
* nummuestras++;*/
}
// double promedio = acumulador / nummuestras;
// slbvolumen.Value = promedio;
//writer.Write(buffer, 0, bytesGrabados);
FastFourierTransform.FFT(true, exponente, muestrasComplejas);
float[] valoresAbsolutos =
new float[muestrasComplejas.Length];
for (int i = 0; i < muestrasComplejas.Length; i++)
{
valoresAbsolutos[i] = (float)
Math.Sqrt((muestrasComplejas[i].X * muestrasComplejas[i].X) +
(muestrasComplejas[i].Y * muestrasComplejas[i].Y));
}
int indiceMaximo =
valoresAbsolutos.ToList().IndexOf(
valoresAbsolutos.Max());
}
private void RecorderOnDataAvailable(object sender, WaveInEventArgs waveInEventArgs)
{
client.sendBytes(IPAddress.Parse(udpAddress), waveInEventArgs.Buffer, sendport);
Console.WriteLine("Sending data");
}
private void WaveSourceOnDataAvailable(object sender, WaveInEventArgs e)
{
// Do important calculation work here
// To get data, e.Buffer and e.BytesRecorded must be used
waveProvider?.AddSamples(e.Buffer, 0, e.BytesRecorded);
}
public void DataAvailableHandler(object sender, WaveInEventArgs e)
{
Console.WriteLine(e.BytesRecorded);
}
void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
sendr.Send(e.Buffer, e.Buffer.Length, Global.remoteAddress, Global.remotePort);
}
//Stopwatch _stopwatch = new Stopwatch();
private void _waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
// if(_stopwatch.ElapsedMilliseconds > 22)
//Console.WriteLine($"Time: {_stopwatch.ElapsedMilliseconds} - Bytes: {e.BytesRecorded}");
// _stopwatch.Restart();
byte[] soundBuffer = null;
if ((e.BytesRecorded == SEGMENT_FRAMES) && (_micInputQueue.Count == 0))
{
//perfect!
soundBuffer = new byte[e.BytesRecorded];
Buffer.BlockCopy(e.Buffer, 0, soundBuffer, 0, e.BytesRecorded);
}
else
{
for (var i = 0; i < e.BytesRecorded; i++)
{
_micInputQueue.Enqueue(e.Buffer[i]);
}
}
//read out the queue
while ((soundBuffer != null) || (_micInputQueue.Count >= SEGMENT_FRAMES))
{
//null sound buffer so read from the queue
if (soundBuffer == null)
{
soundBuffer = new byte[SEGMENT_FRAMES];
for (var i = 0; i < SEGMENT_FRAMES; i++)
{
soundBuffer[i] = _micInputQueue.Dequeue();
}
}
short max = 0;
for (var n = 0; n < soundBuffer.Length; n += 2)
{
var sample = (short)((soundBuffer[n + 1] << 8) | soundBuffer[n + 0]);
// n.b. no clipping test going on here // FROM NAUDIO SOURCE !
sample = (short)(sample * MicBoost);
//determine peak
if (sample > max)
{
max = sample;
}
//convert back
soundBuffer[n] = (byte)(sample & 0xFF);
soundBuffer[n + 1] = (byte)(sample >> 8);
}
MicMax = max;
try
{
//encode as opus bytes
int len;
var buff = _encoder.Encode(soundBuffer, soundBuffer.Length, out len);
if ((_tcpVoiceHandler != null) && (buff != null) && (len > 0))
{
//create copy with small buffer
var encoded = new byte[len];
Buffer.BlockCopy(buff, 0, encoded, 0, len);
// Console.WriteLine("Sending: " + e.BytesRecorded);
if (_tcpVoiceHandler.Send(encoded, len))
{
//send audio so play over local too
if (_micWaveOutBuffer != null)
{
_micWaveOutBuffer.AddSamples(soundBuffer, 0, soundBuffer.Length);
}
}
}
else
{
Logger.Error($"Invalid Bytes for Encoding - {e.BytesRecorded} should be {SEGMENT_FRAMES} ");
}
}
catch (Exception ex)
{
Logger.Error(ex, "Error encoding Opus! " + ex.Message);
}
soundBuffer = null;
}
}
private void Audio_DataAvailable(object sender, WaveInEventArgs e)
{
if (e.BytesRecorded == 0)
{
return;
}
var buffer = e.Buffer;
if (!recording)
{
return;
}
sourceProvider.AddSamples(e.Buffer, 0, e.BytesRecorded);
//using (var str = new RawSourceWaveStream(buffer, 0, e.BytesRecorded, audio.WaveFormat))//need to preserve this?
//{
//var six = new WaveFloatTo16Provider(sourceProvider);
byte[] output = new byte[e.BytesRecorded / 2];
//var volout = new StereoToMonoProvider16(six);
monovolumeprovider.LeftVolume = (1f - videorecordingsettings.audioBalance) * videorecordingsettings.leftVolume * 2;
monovolumeprovider.RightVolume = (videorecordingsettings.audioBalance) * videorecordingsettings.rightVolume * 2;
//var formatconv = new WaveFormatConversionProvider(new WaveFormat(24000, 16, 1), volout);
//byte[] output = new byte[bytesread / 2];
var bytesread = formatconv.Read(output, 0, e.BytesRecorded);
int control = 0;
if (audioframe == 0)
{
control = 1;
}
audioframe++;
if (isConnected)
{
AudioStream.Write(BitConverter.GetBytes(control), 0, sizeof(int));
AudioStream.Write(BitConverter.GetBytes(bytesread), 0, sizeof(int));
AudioStream.Write(BitConverter.GetBytes(formatconv.WaveFormat.SampleRate), 0, sizeof(int)); //volout
AudioStream.Write(BitConverter.GetBytes(formatconv.WaveFormat.AverageBytesPerSecond), 0, sizeof(int));
AudioStream.Write(output, 0, bytesread);
AudioStream.Flush();
AudioStream.WaitForPipeDrain();
}
if (enableWriteToFile && binaryAudioWriter != null)
{
binaryAudioWriter.Write(BitConverter.GetBytes(control), 0, sizeof(int));
binaryAudioWriter.Write(BitConverter.GetBytes(bytesread), 0, sizeof(int));
binaryAudioWriter.Write(BitConverter.GetBytes(formatconv.WaveFormat.SampleRate), 0, sizeof(int));
binaryAudioWriter.Write(BitConverter.GetBytes(formatconv.WaveFormat.AverageBytesPerSecond), 0, sizeof(int));
//AudioStream.Write(BitConverter.GetBytes(volout.WaveFormat.SampleRate), 0, sizeof(int));
//AudioStream.Write(BitConverter.GetBytes(volout.WaveFormat.AverageBytesPerSecond), 0, sizeof(int));
binaryAudioWriter.Write(output, 0, bytesread);
binaryAudioWriter.Flush();
}
audiolengthmonitor = bytesread;
//}
}
} // end void OnRecordingStopped
/// <summary>
/// Event handled when data becomes available. The data will be written out to disk at this point.
/// </summary>
void OnDataAvailable(object sender, WaveInEventArgs e)
{
_writer.Write(e.Buffer, 0, e.BytesRecorded);
//int secondsRecorded = (int)(_writer.Length / _writer.WaveFormat.AverageBytesPerSecond);
}
static void waveSource_DataAvailable(object sender, WaveInEventArgs e)
{
_waveFile.Write(e.Buffer, 0, e.BytesRecorded);
}
private void DataAvailable(object sender, WaveInEventArgs e)
{
try
{
// Convert byte[] to float[].
float[] data = ConvertByteToFloat(e.Buffer, e.BytesRecorded);
if (data.Length < 1)
{
return;
}
Complex[] channelClone = new Complex[(int)FftDataSize.FFT4096];
for (int i = 0; i < channelClone.Length; i++)
{
channelClone[i].X = data[i];
channelClone[i].Y = 0;
}
int binaryExponentitaion = (int)Math.Log((int)FftDataSize.FFT4096, 2);
FastFourierTransform.FFT(true, binaryExponentitaion, channelClone);
for (int i = 0; i < channelClone.Length / 2; i++)
{
data[i] = (float)Math.Sqrt(channelClone[i].X * channelClone[i].X + channelClone[i].Y * channelClone[i].Y);
}
int x, y;
int b0 = 0;
//computes the spectrum data, the code is taken from a bass_wasapi sample.
for (x = 0; x < 16; x++)
{
float peak = 0;
int b1 = (int)Math.Pow(2, x * 10.0 / (16 - 1));
if (b1 > 1023)
{
b1 = 2047;
}
if (b1 <= b0)
{
b1 = b0 + 1;
}
for (; b0 < b1; b0++)
{
if (peak < data[1 + b0])
{
peak = data[1 + b0];
}
}
y = (int)(Math.Sqrt(peak) * 3 * 255 - 4);
if (y > 255)
{
y = 255;
}
if (y < 0)
{
y = 0;
}
_spectrumData.Add((byte)y);
}
SpectrumDataReceived?.Invoke(this, new SpectrumDataEventArgs(_spectrumData));
if (_spectrumData.Equals(_lastSpectrumData))
{
_sameDataCounter++;
}
else
{
_sameDataCounter = 0;
}
_spectrumData.Clear();
_lastSpectrumData = _spectrumData;
}
catch (Exception)
{
// do nothing
}
}
void WaveInDataAvailable(object sender, WaveInEventArgs e)
{
writer.WriteData(e.Buffer, 0, e.BytesRecorded);
}
private void RecorderOnDataAvailable(object sender, WaveInEventArgs e)
{
waveWriter.Write(e.Buffer, 0, e.BytesRecorded);
waveWriter.Flush();
}
