private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
{
if (RecordCallback != null)
{
RecordCallback(e.Buffer);
}
}
void waveSource_DataAvailable(object sender, WaveInEventArgs e)
{
if (File != null)
{
File.Write(e.Buffer, 0, e.BytesRecorded);
File.Flush();
}
}
private void VoiceDataAvailable(object sender, WaveInEventArgs e)
{
if (!_recording)
return;
//At the moment we're sending *from* the local user, this is kinda stupid.
//What we really want is to send *to* other users, or to channels. Something like:
//
// _connection.Users.First().SendVoiceWhisper(e.Buffer);
//
// _connection.Channels.First().SendVoice(e.Buffer, shout: true);
//if (_protocol.LocalUser != null)
// _protocol.LocalUser.SendVoice(new ArraySegment<byte>(e.Buffer, 0, e.BytesRecorded));
//Send to the channel LocalUser is currently in
if (_protocol.LocalUser != null && _protocol.LocalUser.Channel != null)
{
//_protocol.Connection.SendControl<>
_protocol.LocalUser.Channel.SendVoice(new ArraySegment<byte>(e.Buffer, 0, e.BytesRecorded));
}
//if (DateTime.Now.TimeOfDay.TotalMilliseconds - lastPingSendTime > 1000 || DateTime.Now.TimeOfDay.TotalMilliseconds < lastPingSendTime)
//{
// _protocol.Connection.SendVoice
//}
}
private void OnDataAvailable(object sender, WaveInEventArgs e)
{
byte[] buffer = e.Buffer;
byte[] resampled = PcmUtilities.Resample(buffer, _waveIn.WaveFormat.SampleRate, (short)_waveIn.WaveFormat.BitsPerSample, (short)_waveIn.WaveFormat.Channels,
16000, 16, 1);
this.WriteAudio(resampled);
}
private void OnDataAvailable(object sender, WaveInEventArgs e)
{
if (e.BytesRecorded != 0)
{
var buffer = new byte[e.Buffer.Length*2];
int readSize = WaveFloatTo16(e.Buffer, e.BytesRecorded, buffer);
if (outputStream != null)
lock (outputStream)
{
DataPacket.CreateBuilder()
.SetDataPacketType(DataPacket.Types.DataPacketType.Audio)
.SetAudio(
Audio.CreateBuilder()
.SetSound(ByteString.CopyFrom(GZipCompress(buffer, readSize))) //compress
.Build()
).Build()
.WriteDelimitedTo(outputStream);
//outputStream.Flush();
}
else
{
StopRecording();
}
//Console.WriteLine("recording");
}
}
static void wavInStream_DataAvailable(object sender, WaveInEventArgs e)
{
upStream.Write(e.Buffer, 0, e.BytesRecorded);
upStream.Flush();
// shell.Write(e.Buffer, 0, e.BytesRecorded);
//shell.Flush();
}
void OnDataAvailable(object sender, WaveInEventArgs e)
{
if (!IsCapturing)
{
return;
}
// first save the audio
byte[] buffer = e.Buffer;
writer.WriteData(buffer, 0, e.BytesRecorded);
// now report each sample if necessary
for (int index = 0; index < e.BytesRecorded; index += 2)
{
short sample = (short)((buffer[index + 1] << 8) | buffer[index + 0]);
/* short sample2 = BitConverter.ToInt16(buffer, index);
Debug.Assert(sample == sample2, "Oops"); */
float sample32 = sample / 32768f;
if (OnSample != null)
{
OnSample(this, new SampleEventArgs(sample32, 0));
}
}
// close the recording if necessary
if (maxCaptureBytes != 0 && recordedStream.Length >= maxCaptureBytes)
{
CloseRecording();
}
}
private void sourceStreamDataAvailable(object sender, WaveInEventArgs e)
{
string path = outputPath + "wavsam" + nFiles + ".wav";
writer = new WaveFileWriter(path, waveFormat);
writer.Write(e.Buffer, 0, e.Buffer.Length);
writer.Flush();
writer.Close();
nFiles++;
Process process = new Process();
process.StartInfo.CreateNoWindow = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.FileName = "praatcon.exe";
String male;
if (isMale) male = "yes"; else male = "no";
process.StartInfo.Arguments = "extract_measures.praat " + path + " " + male;
// process.StartInfo.RedirectStandardOutput = true;
process.Start();
process.WaitForExit();
ResultEventArgs args = new ResultEventArgs();
// args.text = output;
OnResults(args);
// args.nWords = err.Length;
}
private void StreamDataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
byte[] bytes = new byte[e.Buffer.Length]; //your local byte[]
List <byte> bytelist = new List <byte>();
bytelist.AddRange(bytes);
stream_ms = new MemoryStream(bytelist.ToArray());
waveBuffer.AddSamples(e.Buffer, 0, e.BytesRecorded);
waveBuffer.DiscardOnBufferOverflow = true;
var bytesPerFrame = sourceStream.WaveFormat.BitsPerSample / 8
* sourceStream.WaveFormat.Channels;
var bufferedFrames = waveBuffer.BufferedBytes / bytesPerFrame;
var frames = new float[bufferedFrames];
Console.WriteLine(bufferedFrames);
samples.Read(frames, 0, bufferedFrames);
floatToDouble(frames, algo.originalWavSamples);
algo.preProcessing();
bool[] vad = algo.getVAD(publicTw);
for (int i = 0; i < 8; i++)
{
// if(vad[i])
for (int j = i * 100; j < i * 100 + 100 && j < frames.Length; j++)
{
testStream.Add(frames[j]);
}
if (!vad[i])
{
zeros++;
if (zeros == 24) // magical constant
{
float[] speech = testStream.ToArray();
var algo = new Algorithms(speech);
double[] a = new double[speech.Length];
testStream.Clear();
// insert async recognition here here
zeros = 0;
System.Threading.Tasks.Task.Run(() =>
{
algo.set_fs(16000);
algo.defineStepAndLength();
processWavFile(algo);
});
}
}
else
{
zeros = 0;
}
}
//foreach (var frame in frames)
// testStream.Add(frame);
}
//Event args to check if Data is available
private void wavSource_DataAvail(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (wavFile != null)
{
wavFile.Write(e.Buffer, 0, e.BytesRecorded);
wavFile.Flush();
}
}
private void RecorderOnDataAvailable(object sender, WaveInEventArgs waveInEventArgs)
{
byte[] buffer = new byte[10000];
if (waveInEventArgs.BytesRecorded > 0 && !isWriterDisposed)
writer.Write(waveInEventArgs.Buffer, 0, waveInEventArgs.BytesRecorded);
if (waveInEventArgs.BytesRecorded == 0)
Dispose(); // auto-dispose in case users forget
}
public void InputBufferToFileCallback(object sender, WaveInEventArgs e)
{
writer.Write(e.Buffer,0, e.BytesRecorded);
// Console.WriteLine(e.BytesRecorded);
if (OnAudioData != null)
OnAudioData(e.Buffer, e.BytesRecorded);
}
private void recordInstance_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (recordWriter == null)
{
return;
}
recordWriter.Write(e.Buffer, 0, e.BytesRecorded);
recordWriter.Flush();
}
private void OnDataAvailable(object sender, WaveInEventArgs e)
{
// the float values come in chunks of 4 bytes
// first left channel then right channel
for (int n = 0; n < e.Buffer.Length; n += 8) {
float lb = BitConverter.ToSingle(e.Buffer, n);
float rb = BitConverter.ToSingle(e.Buffer, n + 4);
sampleAggregator.Add(lb, rb);
}
}
static void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
for (int index = 0; index < e.BytesRecorded; index += 2)
{
float sample = (short)((e.Buffer[index + 1] << 8) | e.Buffer[index + 0]);
sample = Math.Max(0, sample / 32768f);
Metrics.Histogram("mic_noise", sample);
}
}
private void sourceStream_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (waveWriter == null)
{
return;
}
waveWriter.Write(e.Buffer, 0, e.BytesRecorded);
waveWriter.Flush();
}
private NAudio.Wave.WaveFileWriter waveWriter = null; // zapisywanie pliku
// WaveInEventArgs - jesli zmienia się pobierany dzwiek to
private void sourceStream_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (waveWriter == null)
{
return;
}
waveWriter.WriteData(e.Buffer, 0, e.BytesRecorded); //buforujemy dane
waveWriter.Flush(); // czyszczenie buforu dla tego strumienia
}
public void ListenerDataAvailable(object sender, WaveInEventArgs e)
{
double sample32 = 0.0;
for (int index = 0; index < e.BytesRecorded; index += 2)
{
short sample = (short)((e.Buffer[index + 1] << 8) |
e.Buffer[index + 0]);
sample32 = Math.Abs(sample / 32768.0);
}
change(sample32);
}
void _wave_DataAvailable(object sender, WaveInEventArgs e)
{
Debug.WriteLine(e.BytesRecorded + " bytes, " + _sw.ElapsedTicks / TimeSpan.TicksPerMillisecond);
_sw.Reset();
_sw.Start();
byte[] clear = e.Buffer;
byte[] nonce;
byte[] cipher = _clientA.Encrypt(e.Buffer, 0, e.BytesRecorded, out nonce);
clear = _clientB.Decrypt(cipher, nonce);
_playback.AddSamples(clear, 0, clear.Length);
}
private void OnDataAvailable(object sender, WaveInEventArgs waveInEventArgs)
{
if (_writer == null)
{
throw new NullReferenceException();
}
_writer.Write(waveInEventArgs.Buffer, 0, waveInEventArgs.BytesRecorded);
//byte[] by = Float32toInt16(waveInEventArgs.Buffer, 0, waveInEventArgs.BytesRecorded);
}
//credit: http://channel9.msdn.com/coding4fun/articles/NET-Voice-Recorder
private void recordingStream_DataAvailable(object sender, WaveInEventArgs e)
{
waveWriter.Write(e.Buffer, 0, e.BytesRecorded);
for (int index = 0; index < e.BytesRecorded; index += 2)
{
short sample = (short)((e.Buffer[index + 1] << 8) |
e.Buffer[index + 0]);
float sample32 = sample / 32768f;
recordingData.Add(sample32);
}
}
private void sourceStream_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (waveWriter == null)
{
return;
}
waveWriter.Write(e.Buffer, 0, e.BytesRecorded);
sampleLocation += e.BytesRecorded / 4;
labelCurrentTime.Text = ((double)sampleLocation / (double)sampleRate).ToString();
waveWriter.Flush();
}
private void update(object sender, WaveInEventArgs e)
{
byte[] buffer = e.Buffer;
double sum = .0;
for (int i = 0; i < buffer.Length; i += 2)
{
double sample = BitConverter.ToInt16(buffer, i) / 32768d;
sum += sample * sample;
}
double rms = Math.Sqrt(sum / buffer.Length / 2d);
lastPressure = 92.8 + 20d * Math.Log10(rms);
}
static void sourceStream_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (waveWriter == null)
{
return;
}
waveWriter.Write(e.Buffer, 0, e.BytesRecorded);
sampleLocation += e.BytesRecorded / 4;
Debug.Print(((double)sampleLocation / (double)sampleRate).ToString());
waveWriter.Flush();
}
void OnDataAvailable(Object sender, WaveInEventArgs e)
{
if (_measuring)
{
if (_measured >= 0)
{
_measurements.Add(e.Buffer.Take(e.BytesRecorded).ToArray());
}
_measured++;
}
}
private void sourcestream_DataAvailable(object notUsed, WaveInEventArgs e)
{
try
{
byte[] buffer = (e.Buffer);
sender.Send(buffer, buffer.Length);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
private void CaptureOnDataAvailable(object sender, WaveInEventArgs waveInEventArgs)
{
if (writer == null)
{
writer = new WaveFileWriter(Path.Combine(RecordingsViewModel.OutputFolder,
currentFileName),
capture.WaveFormat);
}
writer.Write(waveInEventArgs.Buffer, 0, waveInEventArgs.BytesRecorded);
UpdatePeakMeter();
}
private void sourceStream_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (waveWriter == null)
{
return;
}
waveWriter.WriteData(e.Buffer, 0, e.BytesRecorded);
waveWriter.Flush();
int timer = (int)(waveWriter.Length / waveWriter.WaveFormat.AverageBytesPerSecond);
int hora = 0;
int minu = 0;
int seg = 0;
string tSeg = null, tMin = null, tHora = null;
if (timer >= 60)
{
minu = (int)(timer / 60);
if (minu >= 60)
{
hora = (int)(minu / 60);
minu = minu % 60;
}
seg = timer % 60;
tHora = hora < 10 ? "0" + hora.ToString() : tHora = hora.ToString();
tMin = minu < 10 ? "0" + minu.ToString() : tMin = minu.ToString();
tSeg = seg < 10 ? "0" + seg.ToString() : tSeg = seg.ToString();
timerHora.Text = tHora;
timerMinuto.Text = tMin;
timerSec.Text = tSeg;
}
else
{
if (timer < 10)
{
tSeg = "0" + timer.ToString();
}
else
{
tSeg = timer.ToString();
}
timerSec.Text = tSeg;
}
var device = (MMDevice)micList.SelectedItem;
WaveAudioLevel.Value = (int)(Math.Round(device.AudioMeterInformation.MasterPeakValue * 100));
}
private void sourceStream_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
byte[] waveData = e.Buffer;
int globalMax = 0;
int globalMin = 0;
long p;
for (p = 0; p < waveData.Length; p += bytesPerChannel)
{
int val = BitConverter.ToInt16(waveData, (int)p);
if (val < globalMin)
{
globalMin = val;
}
if (val > globalMax)
{
globalMax = val;
}
}
globalMin = -globalMin;
if (globalMin > globalMax)
{
globalMax = globalMin;
}
int l = (int)((globalMax * 100) / (32768 >> level));
if (l > 100)
{
l = 100;
}
if (l < 0)
{
l = 0;
}
audioLevel.Value = l;
if (isRecording)
{
if (!recordingFirstSkip)
{
conductor.StartRecording(waveData.Length * 4);
recordingFirstSkip = true;
}
recordingStream.Write(waveData, 0, waveData.Length);
}
}
private void new_dataAvailable(object sender, WaveInEventArgs e)
{
for (int i = 0; i < e.BytesRecorded; i += 4)
{
short leftSample = (short)((e.Buffer[i + 1] << 8) | e.Buffer[i + 0]);
float leftSample32 = leftSample / 32768f;
short rightSample = (short)((e.Buffer[i + 3] << 8) | e.Buffer[i + 2]);
float rightSample32 = rightSample / 32768f;
_writer.WriteSample(leftSample32);
_writer.WriteSample(rightSample32);
}
}
public void DataReceived(object sender, WaveInEventArgs e)
{
for ( int index = 0; index < e.BytesRecorded; index+=2)
{
short sample = (short)((e.Buffer[index]<<8)|(e.Buffer[index]));
float sample32 = sample/ 32786f;
byte[] floatBytes = BitConverter.GetBytes(sample32);
int currentLength = SampledData.Length -1;
for (int i = 0; i<floatBytes.Length;i++)
{
data.Enqueue(floatBytes[i]);
}
}
}
private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
{
//m_BufferProvider.AddSamples(e.Buffer, 0, e.BytesRecorded);
m_WavSampleList.Clear();
for (int i = 0; i < e.Buffer.Length; i += 2)
{
m_WavSampleList.Add(BitConverter.ToInt16(e.Buffer, i));
}
double[] normalizeArray = Normalize(m_WavSampleList);
if (DataAvailable != null)
{
DataAvailable(normalizeArray);
}
}
private void OnDataAvailable(object sender, NAudio.Wave.WaveInEventArgs args)
{
int bytesPerSample = wvin.WaveFormat.BitsPerSample / 8;
int samplesRecorded = args.BytesRecorded / bytesPerSample;
if (dataPcm == null)
{
dataPcm = new Int16[samplesRecorded];
}
for (int i = 0; i < samplesRecorded; i++)
{
dataPcm[i] = BitConverter.ToInt16(args.Buffer, i * bytesPerSample);
}
}
private void WaveInStreamOnDataAvailable(object sender, WaveInEventArgs waveInEventArgs)
{
if (InvokeRequired)
{
BeginInvoke(new EventHandler<WaveInEventArgs>(WaveInStreamOnDataAvailable), sender, waveInEventArgs);
}
else
{
if (_waveFileWriter != null)
{
_waveFileWriter.Write(waveInEventArgs.Buffer, 0, waveInEventArgs.BytesRecorded);
_currentLength = (int)(_waveFileWriter.Length * 1000 / _waveFileWriter.WaveFormat.AverageBytesPerSecond);
}
}
}
private void SaveSample(object sender, NAudio.Wave.WaveInEventArgs e)
{
Sample sample = new Sample()
{
Id = CurrentTrack,
Value = new Byte[e.BytesRecorded]
};
Array.Copy(e.Buffer, sample.Value, e.BytesRecorded);
this.SilenceDetected = this.IsSilent(sample.Value);
this.SoundDetected = !this.SilenceDetected;
this.Buffer.AddSample(sample);
}
private void Lc_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (e.BytesRecorded == 0)
{
return;
}
byte[] downSampled = new byte[e.BytesRecorded / 2];
for (int i = 0; i < e.BytesRecorded / 2; i++)
{
downSampled[i] = e.Buffer[i * 2 + 0];
}
_reader.ProcessFrame(downSampled, e.BytesRecorded / 2 - (e.BytesRecorded / 2) % 2);
NextEventAt = _reader.Timecode;
//NextEventAt = now.ToString();
}
void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
if (e.BytesRecorded != samplesPerBatch * (BIT_DEPTH / 8))
{
Debug.WriteLine("Data available was not what was expected");
return;
}
// Put bytes into 16-bit samples as floats.
for (int i = 0; i < samplesPerBatch; i++) {
data[i] = (short)(e.Buffer[i * 2] | e.Buffer[i * 2 + 1] << 8);
}
if (AudioAvilable != null) {
AudioAvilable(this, new AudioAvailableHandlerArgs(data));
}
}
public void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
try
{
if (recordingStarted)
{
mainWindow.Server.SendConversationMessage(new ConversationDC()
{
ConversationId = mainWindow.Player.MainRoomId,
NewAudioMessageBuffer = e.Buffer,
NewAudioMessageBytesRecorded = e.BytesRecorded,
NewMessageType = 1,
MessageSenderPlayerId = mainWindow.Player.PlayerId
});
}
}
catch { }
}
private void sourceStream_DataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
if (calibrating)
{
return;
}
byte[] waveData = e.Buffer;
int windowSize = 1000 * bytesPerSample;
int globalMax = 0;
int globalMin = 0;
long n, p, q;
for (n = p = 0; p < waveData.Length; p += bytesPerSample * 500, n++)
{
for (q = p; (q < waveData.Length) && (q < p + (bytesPerSample * 500)); q += bytesPerSample)
{
int val = BitConverter.ToInt16(waveData, (int)q);
if (val < globalMin)
{
globalMin = val;
}
if (val > globalMax)
{
globalMax = val;
}
}
}
globalMin = -globalMin;
if (globalMin > globalMax)
{
globalMax = globalMin;
}
float factor = globalMax / ((float)(32768 >> sensitivity));
if (factor > 1.0f)
{
factor = 1.0f;
}
conductor.SetJaw(factor);
}
private void Update(object sender, NAudio.Wave.WaveInEventArgs args)
{
this.Volume = recordingDevice.AudioMeterInformation.MasterPeakValue;
lock (this.maxAudioDataLevels) {
short[] values = new short[args.Buffer.Length / 2];
for (int i = 0; i < args.BytesRecorded; i += 2)
{
values[i / 2] = (short)((args.Buffer[i + 1] << 8) | args.Buffer[i]);
}
this.unanalyzedValues.AddRange(values);
if (this.unanalyzedValues.Count >= fftSize)
{
this.GenerateAudioData();
this.unanalyzedValues.Clear();
}
foreach (var pair in this.config.levelDriverPresets)
{
if (pair.Value.Source != LevelDriverSource.Audio)
{
continue;
}
AudioLevelDriverPreset preset = (AudioLevelDriverPreset)pair.Value;
double filteredMax = AudioInput.GetFilteredMax(
preset.FilterRangeStart,
preset.FilterRangeEnd,
this.AudioData
);
if (this.maxAudioDataLevels.ContainsKey(preset.Name))
{
this.maxAudioDataLevels[preset.Name] = Math.Max(
this.maxAudioDataLevels[preset.Name],
filteredMax
);
}
else
{
this.maxAudioDataLevels[preset.Name] = filteredMax;
}
}
this.UpdateEnergyHistory();
}
}
private void WaveIn_DataAvailable(object?sender, NAudio.Wave.WaveInEventArgs e)
{
int latestMax = int.MinValue;
for (int index = 0; index < e.BytesRecorded; index += 2)
{
int value = BitConverter.ToInt16(e.Buffer, index);
latestMax = Math.Max(latestMax, value);
}
// report maximum relative to the maximum value previously seen
MaxPcmValue = Math.Max(MaxPcmValue, latestMax);
float fraction = (float)latestMax / MaxPcmValue;
// basic smoothing so the level does not change too quickly
LevelFraction += (fraction - LevelFraction) * .1f;
skglControl1.Invalidate();
}
private void OnDataAvailable(object sender, NAudio.Wave.WaveInEventArgs args)
{
// convert from a 16-bit byte array to a double array
int bytesPerValue = BITRATE / 8;
int valuesInBuffer = args.BytesRecorded / bytesPerValue;
double[] bufferValues = new double[valuesInBuffer];
for (int i = 0; i < valuesInBuffer; i++)
{
bufferValues[i] = BitConverter.ToInt16(args.Buffer, i * bytesPerValue) * signalMultiple;
}
lastAmplitude = bufferValues.Max() - bufferValues.Min();
// create the values buffer if it does not exist
if (values == null)
{
int idealSampleCount = STORESECONDS * SAMPLERATE;
int bufferCount = idealSampleCount / valuesInBuffer;
values = new double[bufferCount * valuesInBuffer];
times = new double[bufferCount * valuesInBuffer];
for (int i = 0; i < times.Length; i++)
{
times[i] = (double)i / SAMPLERATE;
}
}
// copy these data into the correct place of the larger buffer
Array.Copy(bufferValues, 0, values, bufferIndex * valuesInBuffer, bufferValues.Length);
lastPointUpdated = bufferIndex * valuesInBuffer + bufferValues.Length;
// update counts
buffersCaptured += 1;
bufferIndex += 1;
if (bufferIndex * valuesInBuffer > values.Length - 1)
{
bufferIndex = 0;
}
}
private void DataAvailable(object sender, WaveInEventArgs e)
{
var bytesRecorded = e.BytesRecorded;
// Convert to 16 bit
if ( bytesRecorded % 8 > 0 )
{
log.Error("float sample not multiple of 8");
}
byte[] destBuffer = new byte[bytesRecorded / 2];
var readBuffer = e.Buffer;
WaveBuffer sourceWaveBuffer = new WaveBuffer(readBuffer);
WaveBuffer destWaveBuffer = new WaveBuffer(destBuffer);
int sourceSamples = bytesRecorded / 4;
int destOffset = 0;
for (int sample = 0; sample < sourceSamples; sample++)
{
// adjust volume
float sample32 = sourceWaveBuffer.FloatBuffer[sample]*1.0f;
// clip
if ( sample32 > 1.0f )
{
sample32 = 1.0f;
}
if ( sample32 < -1.0f )
{
sample32 = -1.0f;
}
destWaveBuffer.ShortBuffer[destOffset++] = (short) (sample32*32767);
}
if (SampleAvailable != null)
SampleAvailable.BeginInvoke(destWaveBuffer.ByteBuffer, ar =>
{
}, null);
}
private void sourceStream_DataAvailable(object sender, WaveInEventArgs e)
{
var buffer = new byte[3200];
e.Buffer.CopyTo(buffer, 0);
bufl.Add(buffer);
lvlv = GetAudioLevel(bufl.Last());
if(lvlv>555)
{
flag = true;
lvlv2 ++;
resBuf = new byte[3200 * bufl.Count];
for (int i = 0; i < bufl.Count; i++)
bufl[i].CopyTo(resBuf, i * 3200);
if (lvlv2 > 4)
{
shg.post(resBuf);
lvlv2 = 0;
}
}
else
{
if (flag)
{
flag = false;
if (bufl.Count > 1)
shg.post(resBuf);
shg.post(null);
lvlv2 = 0;
}
bufl.Clear();
}
frm.SetTextSafe("" + lvlv);
frm.SetPrbr(lvlv);
lvlv=0;
}
// the callback from naudio
void waveInStream_DataAvailable(object sender, WaveInEventArgs e) {
if (m_shutdown) return;
using (ILScope.Enter()) {
// prepare variables for requesting X values and the index of the maximum value
ILArray<int> maxID = 1;
// convert the recorded samples in computation module:
ILArray<float> Y = Computation.GetMagnitudes(e.Buffer, e.BytesRecorded, m_fftlen, maxID);
// update the line shape
Line.Update(Y);
// update the marker point
ILArray<float> markerPoints = ILMath.zeros<float>(2, maxID.S[0]);
markerPoints[0, ":"] = ILMath.tosingle(maxID);
markerPoints[1, ":"] = Y[maxID];
Marker.Update(markerPoints);
// on the first only run we zoom to content
if (m_startup) {
m_startup = false;
ilPanel1.Scene.First<ILPlotCube>().Reset();
}
// redraw the scene
ilPanel1.Refresh();
}
}
// Functions which writes chunks of samples to the wav file
private void OnDataAvailable(object sender, NAudio.Wave.WaveInEventArgs e)
{
waveWriter.Write(e.Buffer, 0, e.BytesRecorded);
waveWriter.Flush();
}
void device_DataAvailable(object sender, WaveInEventArgs e)
{
var waveIn = sender as WaveIn;
if (waveIn == null)
{
throw new InvalidOperationException("Sender must be a WaveIn instance");
}
//TODO support 16 bit
//var is16Bit = device.Driver.WaveFormat.BitsPerSample == 16;
//var size = is16Bit ? sizeof(short) : sizeof(int);
var size = sizeof(float);
var sampleCount = e.BytesRecorded / device.Channels / size;
for (int i = 0; i < device.Channels; i++)
{
device.Buffers[i] = BufferHelpers.Ensure(device.Buffers[i], sampleCount);
}
copySamplesToManagedMemory(device.Buffers, e.Buffer, sampleCount, device.Channels);
for (int i = 0; i < device.Channels; i++)
{
var input = Sources.ElementAt(i);
if (input.IsMapped)
{
(input as SignalSource).RaiseBufferReady(
new RoutingEventArgs
{
Index = i,
Format = formatPerLine,
Count = sampleCount,
Buffer = device.Buffers[i]
});
}
}
}
private void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
this.bufferedWaveProvider.AddSamples(e.Buffer, 0, e.BytesRecorded);
}
