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); }