public void StopCapture() { _capture.Stop(); if (!_writer.IsDisposed) { _writer.Dispose(); } _capture.Dispose(); }
public void Cleanup() { channelMemoryA?.Clear(); channelMemoryB?.Clear(); channelWriterA?.Dispose(); channelWriterB?.Dispose(); channelStreamA?.Dispose(); channelStreamB?.Dispose(); channelCapture?.Dispose(); fileTimer?.Stop(); fileTimer?.Dispose(); }
/// <summary> /// Stop Recording /// </summary> /// <returns>Successful</returns> public bool Stop() { if (!isRecording) { return(false); } // Stop Capturing Audio if (recordAudio) { audioSource.Stop(); if (audioSource != null) { audioSource.Dispose(); audioSource = null; } if (audioFile != null) { audioFile.Dispose(); audioFile = null; } } // Kill Timers StopTimers(); status = "Idle"; isRecording = false; return(isRecording); }
//########################################################################################################################################################################################################## /// <summary> /// Save all samples to a new WAV file /// </summary> /// <param name="filepath">filepath of the new WAV file</param> public void SaveFile(string filepath) { if (Samples == null || format == null) { return; } if (!File.Exists(filepath)) { FileStream stream = File.Create(filepath); stream.Close(); } else { File.Delete(filepath); } WaveWriter writer = new WaveWriter(filepath, format); foreach (AudioSample s in Samples) { writer.WriteSample(s.Value); } writer.Dispose(); }
public void Dispose() { if (_waveWriter != null) { _waveWriter.Dispose(); _waveWriter = null; } if (_notificationSource != null) { _notificationSource.Dispose(); _notificationSource = null; } if (_waveSource != null) { _waveSource.Dispose(); _waveSource = null; } if (_soundInSource != null) { _soundInSource.Dispose(); _soundInSource = null; } if (_capture != null) { _capture.Dispose(); _capture = null; } }
private void StopRecording() { m_capture.Stop(); m_capture.Dispose(); m_ww.Dispose(); }
public bool stopRecording() { bool isStopped = false; if (System.Web.HttpContext.Current.Session[ww] != null && System.Web.HttpContext.Current.Session[wc] != null) { capture = (WasapiCapture)System.Web.HttpContext.Current.Session[wc]; w = (WaveWriter)System.Web.HttpContext.Current.Session[ww]; //stop recording capture.Stop(); w.Dispose(); w = null; capture.Dispose(); capture = null; System.Web.HttpContext.Current.Session[ww] = null; System.Web.HttpContext.Current.Session[wc] = null; //Label1.Text = "Stopped"; } else { isStopped = true; } return(isStopped); }
private void Stop() { if (!recording) { return; } outputCapture.Stop(); inputCapture.Stop(); process.StandardInput.Write('q'); process.WaitForExit(1000); process.Close(); groupBox1.Enabled = true; groupBox2.Enabled = true; groupBox3.Enabled = true; groupBox4.Enabled = true; if (outputWaveWriter != null) { outputWaveWriter.Dispose(); } if (inputWaveWriter != null) { inputWaveWriter.Dispose(); } outputCapture.Dispose(); inputCapture.Dispose(); recording = false; }
private void btnStartStop_Click(object sender, EventArgs e) { if (!recording) { btnStartStop.Text = "Stop"; writer = new WaveWriter(textOutputFile.Text, capture.WaveFormat); capture.Start(); recording = true; recordTime = new TimeSpan(); recordTimer.Enabled = true; btnSelectDevice.Enabled = false; Console.WriteLine("Started recording"); } else { btnStartStop.Text = "Start!"; capture.Stop(); writer.Dispose(); recording = false; recordTimer.Enabled = false; btnSelectDevice.Enabled = true; Console.WriteLine("Stopped recording"); } }
/// <summary> /// Decode File /// </summary> /// <param name="file"></param> /// <returns></returns> public bool DecodeFile() { try { if (!string.IsNullOrEmpty(CurrentFile)) { _chunkSize = 4096; // Set Default Chunk Size if (CurrentFile.ToLower().Contains(".mp3")) // Check Mp3 { if (System.IO.File.Exists(CurrentFile)) // Check File Exists { CurrentFileName = System.IO.Path.GetFileName(CurrentFile); using (var mp3Stream = new Mp3Sharp.Mp3Stream(CurrentFile)) { // Create Mp3 Stream _mp3Stream = mp3Stream; // Set Mp3 Stream _bytes = new byte[mp3Stream.Length]; // Set Bytes _totalBytes = mp3Stream.Length; // Set Total Bytes _numBytesToRead = _totalBytes; // Set Num Bytes to Read _numBytesRead = 0; // Set Num Bytes Read to 0 using (var writer = new WaveWriter(CurrentFile.Replace(".mp3", ".wav"))) { // Create Writer _writer = writer; // Set Writer while (_numBytesToRead > 0) // Loop through Chunks { if (_chunkSize > _numBytesToRead) // Check Progress isn't greater than remaining bytes { _chunkSize = 1; // Check a chunk at a time } var t = new Thread(ReadDecodeChunk); t.Start(); if (!t.Join(1500)) { t.Abort(); // Oops! We read 1 too many bytes! Lets stop trying, we got everything. _numBytesToRead = 0; // This should take us out of the loop soon } if (_readDecodeResult == 0) { break; } _numBytesRead += _readDecodeResult; _numBytesToRead -= _readDecodeResult; _percent = ((int)_numBytesRead * 100 / _totalBytes); if (PercentChanged != null) { PercentChanged(_percent); } } _writer = null; writer.Close(); writer.Dispose(); } _numBytesToRead = _bytes.Length; _mp3Stream = null; } } } } return(true); } catch { throw; } }
public void StopRecording() { WaveIn?.StopRecording(); WaveIn?.Dispose(); WaveIn = null; WaveWriter?.Dispose(); WaveWriter = null; }
private void stopRecording() { if (writer != null && capture != null) { capture.Stop(); writer.Dispose(); capture.Dispose(); } }
public void StopRecording() { areRecording = false; outputCapture.DataAvailable -= WriteOutputData; inputCapture.DataAvailable -= WriteInputData; outputWave.Dispose(); inputWave.Dispose(); }
public void Stop() { if (_isStarted) { _waveWriter.Dispose(); _waveWriter = null; } _isStarted = false; }
private void OnTimedEvent(object sender, ElapsedEventArgs e) { //stop recording capture.Stop(); aTimer.Enabled = false; writer.Dispose(); capture.Dispose(); Console.WriteLine("Zakończono nagrywanie."); }
public void Stop() { if (_soundIn.RecordingState == RecordingState.Stopped) { return; } _soundIn.Stop(); _waveWriter.Dispose(); _waveWriter = null; }
private void OnFinishedRecordingEvent(object sender, ElapsedEventArgs e) { _capture.Stop(); //stop recording _recordFileTimer.Enabled = false; //timer disabled _writer.Dispose(); _capture.Dispose(); Console.WriteLine("now really finished"); }
public static async Task RecordSample() { //create a new soundIn instance var soundIn = new WasapiCapture(); //optional: set some properties //soundIn.Device = ... //... soundIn.Device = new DeviceService().InputDevices().First(); soundIn.Initialize(); var waveWriter = new WaveWriter(@"C:\Users\Cedric Lampron\Desktop\Test Record\dump.wav", soundIn.WaveFormat);; await Task.Run(() => { //create a SoundSource around the the soundIn instance //this SoundSource will provide data, captured by the soundIn instance var soundInSource = new SoundInSource(soundIn) { FillWithZeros = false }; //create a source, that converts the data provided by the //soundInSource to any other format //in this case the "Fluent"-extension methods are being used IWaveSource convertedSource = soundInSource .ToStereo() //2 channels (for example) .ChangeSampleRate(8000) // 8kHz sample rate .ToSampleSource() .ToWaveSource(16); //16 bit pcm //register an event handler for the DataAvailable event of //the soundInSource //Important: use the DataAvailable of the SoundInSource //If you use the DataAvailable event of the ISoundIn itself //the data recorded by that event might won't be available at the //soundInSource yet soundInSource.DataAvailable += (s, e) => { waveWriter.Write(e.Data, e.Offset, e.ByteCount); }; //we've set everything we need -> start capturing data soundIn.Start(); }); await Task.Delay(5000); soundIn.Stop(); waveWriter.Dispose(); waveWriter = null; soundIn.Dispose(); soundIn = null; }
/// <summary> /// ran after recording timer finishes, stops WasapiLoopbackCapture capturing, disposes audio writer, disables record timer /// </summary> private void OnFinishedRecordingEvent(object sender, ElapsedEventArgs e) { _log.Called(sender.ToString(), string.Empty); try { _capture.Stop(); //stop recording _recordFileTimer.Enabled = false; //timer disabled _writer.Dispose(); } catch { _log.Error("Problems when finishing recording."); } }
public virtual void RecordAudioFile() { string currentDirectory = AppDomain.CurrentDomain.BaseDirectory; string wavFile = Path.Combine(currentDirectory, "recording.wav"); _jackIn.Initialize(); WaveWriter writer = new WaveWriter(wavFile, _jackIn.WaveFormat); _jackIn.DataAvailable += (sender, args) => { writer.Write(args.Data, 0, args.ByteCount); }; _jackIn.Stopped += (sender, e) => { writer.Dispose(); long fileSize = new FileInfo(wavFile).Length; Assert.AreNotEqual(0, fileSize); }; _jackIn.Start(); Thread.Sleep(100); _jackIn.Stop(); }
private void btnStartStop_Click(object sender, EventArgs e) { if (!recording) { btnStartStop.Text = "Stop"; /* clear the existing file */ sw = new StreamWriter(textOutputFile.Text); sw.Dispose(); writer = new WaveWriter(textOutputFile.Text, capture.WaveFormat); //writer = new WaveWriter(streamBuffer, capture.WaveFormat); //sw = new StreamWriter(textOutputFile.Text); capture.Start(); recording = true; recordTime = new TimeSpan(); recordTimer.Enabled = true; btnSelectDevice.Enabled = false; Console.WriteLine("Started recording"); } else { btnStartStop.Text = "Start!"; capture.Stop(); writer.Dispose(); //sw.Dispose(); recording = false; recordTimer.Enabled = false; btnSelectDevice.Enabled = true; output_to_file(); Console.WriteLine("Stopped recording"); } }
private void OnRemoteVoiceAdded(RemoteVoiceLink remoteVoiceLink) { int bitsPerSample = 32; string filePath = this.GetFilePath(remoteVoiceLink); if (this.Logger.IsInfoEnabled) { this.Logger.LogInfo("Incoming stream, output file path: {0}", filePath); } WaveWriter waveWriter = new WaveWriter(filePath, new WaveFormat(remoteVoiceLink.Info.SamplingRate, bitsPerSample, remoteVoiceLink.Info.Channels)); remoteVoiceLink.FloatFrameDecoded += f => { waveWriter.WriteSamples(f.Buf, 0, f.Buf.Length); }; remoteVoiceLink.RemoteVoiceRemoved += () => { if (this.Logger.IsInfoEnabled) { this.Logger.LogInfo("Remote voice stream removed: Saving wav file."); } waveWriter.Dispose(); }; }
public static void StopRecording() { // Stop recording capture.Stop(); // Dispose respective writers (for WAV, Dispose() writes header) switch (writerType) { case WriterType.EncoderWriter: encoderWriter.Dispose(); break; case WriterType.WaveWriter: waveWriter.Dispose(); break; } // Dispose of other objects stereoSource.Dispose(); wasapiCaptureSource.Dispose(); capture.Dispose(); }
public void RecSoundStop(bool isDeleteWav) { if (w != null && capture != null) { capture.Stop(); w.Dispose(); w = null; capture.Dispose(); capture = null; LogIt("began converting to mp3"); Task task1 = Task.Factory.StartNew(() => ConvertToMP3(_outputWaveName)); task1.Wait(); LogIt(string.Format("converting finished to {0}", _outputMp3Name)); if (isDeleteWav) { File.Delete(_outputWaveName); LogIt(string.Format("File {0} deleted", _outputWaveName)); } LogIt(string.Format("recording {0} stopped", _outputWaveName)); } }
/// <summary> /// Decode File /// </summary> /// <param name="file"></param> /// <returns></returns> public bool DecodeFile() { try { if (!string.IsNullOrEmpty(CurrentFile)) { _chunkSize = 4096; // Set Default Chunk Size if (CurrentFile.ToLower().Contains(".mp3")) { // Check Mp3 if (System.IO.File.Exists(CurrentFile)) { // Check File Exists CurrentFileName = System.IO.Path.GetFileName(CurrentFile); using (var mp3Stream = new Mp3Sharp.Mp3Stream(CurrentFile)) { // Create Mp3 Stream _mp3Stream = mp3Stream; // Set Mp3 Stream _bytes = new byte[mp3Stream.Length]; // Set Bytes _totalBytes = mp3Stream.Length; // Set Total Bytes _numBytesToRead = _totalBytes; // Set Num Bytes to Read _numBytesRead = 0; // Set Num Bytes Read to 0 using (var writer = new WaveWriter(CurrentFile.Replace(".mp3", ".wav"))) { // Create Writer _writer = writer; // Set Writer while (_numBytesToRead > 0) { // Loop through Chunks if (_chunkSize > _numBytesToRead) { // Check Progress isn't greater than remaining bytes _chunkSize = 1; // Check a chunk at a time } var t = new Thread(ReadDecodeChunk); t.Start(); if (!t.Join(1500)) { t.Abort(); // Oops! We read 1 too many bytes! Lets stop trying, we got everything. _numBytesToRead = 0; // This should take us out of the loop soon } if (_readDecodeResult == 0) { break; } _numBytesRead += _readDecodeResult; _numBytesToRead -= _readDecodeResult; _percent = ((int)_numBytesRead * 100 / _totalBytes); if (PercentChanged != null) { PercentChanged(_percent); } } _writer = null; writer.Close(); writer.Dispose(); } _numBytesToRead = _bytes.Length; _mp3Stream = null; } } } } return true; } catch { throw; } }
public void Dispose() { _waveWriter?.Dispose(); }
public void Dispose() { _waveWriter?.Dispose(); _isStarted = false; _waveWriter = null; }
public void Record(string deviceName, string audioFilePath = @"C:\Temp\output.wav") { _timer = new Stopwatch(); _timer.Start(); // choose the capture mod CaptureMode captureMode = CaptureMode.LoopbackCapture; DataFlow dataFlow = captureMode == CaptureMode.Capture ? DataFlow.Capture : DataFlow.Render; //select the device: var devices = MMDeviceEnumerator.EnumerateDevices(dataFlow, DeviceState.Active); if (!devices.Any()) { Console.WriteLine("### No devices found."); return; } Console.WriteLine($"### Using device {deviceName}"); var device = devices.First(d => d.FriendlyName.Equals(deviceName)); //start recording //create a new soundIn instance _soundIn = captureMode == CaptureMode.Capture ? new WasapiCapture() : new WasapiLoopbackCapture(); //optional: set some properties _soundIn.Device = device; //initialize the soundIn instance _soundIn.Initialize(); //create a SoundSource around the the soundIn instance //this SoundSource will provide data, captured by the soundIn instance SoundInSource soundInSource = new SoundInSource(_soundIn) { FillWithZeros = false }; //create a source, that converts the data provided by the //soundInSource to any other format //in this case the "Fluent"-extension methods are being used _convertedSource = soundInSource .ChangeSampleRate(SampleRate) // sample rate .ToSampleSource() .ToWaveSource(BitsPerSample); //bits per sample //channels... _convertedSource = _convertedSource.ToMono(); //create a new wavefile _waveWriter = new WaveWriter(audioFilePath, _convertedSource.WaveFormat); //register an event handler for the DataAvailable event of //the soundInSource //Important: use the DataAvailable of the SoundInSource //If you use the DataAvailable event of the ISoundIn itself //the data recorded by that event might won't be available at the //soundInSource yet soundInSource.DataAvailable += (s, e) => { //read data from the converedSource //important: don't use the e.Data here //the e.Data contains the raw data provided by the //soundInSource which won't have your target format byte[] buffer = new byte[_convertedSource.WaveFormat.BytesPerSecond / 2]; int read; //keep reading as long as we still get some data //if you're using such a loop, make sure that soundInSource.FillWithZeros is set to false while ((read = _convertedSource.Read(buffer, 0, buffer.Length)) > 0) { //write the read data to a file // ReSharper disable once AccessToDisposedClosure _waveWriter.Write(buffer, 0, read); } }; //we've set everything we need -> start capturing data _soundIn.Start(); Console.WriteLine($"### RECORDING {audioFilePath}"); while (_timer.ElapsedMilliseconds / 1000 < 15 && _timer.IsRunning) { Thread.Sleep(500); } Console.WriteLine("### STOP RECORDING"); _soundIn.Stop(); _timer.Stop(); _waveWriter.Dispose(); _convertedSource.Dispose(); _soundIn.Dispose(); AudioFileCaptured?.Invoke(this, new AudioRecorderEventArgs() { AudioFilePath = audioFilePath }); }
//*********************************************************************************************************************************************************************************************************** /// <summary> /// Stop a record /// </summary> public async void StopRecord() { try { if (RecordState == RecordStates.STOPPED) { return; } if (_capture != null) { try { _capture.Stop(); _capture.Dispose(); } catch (Exception ex) { _logHandle.Report(new LogEventError("Error while stopping record: " + ex.Message)); } _silenceOut.Stop(); } if (_silenceOut != null) { _silenceOut.Stop(); _silenceOut.Dispose(); } if (_wavWriter != null) { _wavWriter.Dispose(); } _logHandle.Report(new LogEventInfo("Record (\"" + TrackInfo?.TrackName + "\") stopped.")); if (System.IO.File.Exists(FileStrWAV)) //Delete too short records { if (WasRecordPaused && RecorderRecSettings.DeletePausedRecords) { System.IO.File.Delete(FileStrWAV); DirectoryManager.DeleteEmptyFolders(RecorderRecSettings.BasePath); _logHandle.Report(new LogEventWarning("Record (\"" + TrackInfo?.TrackName + "\") deleted, because it was paused during record and DeletePausedRecords setting is enabled.")); RecordState = RecordStates.STOPPED; return; } TimeSpan wavLength = TimeSpan.Zero; try { FileInfo fileInfo = new FileInfo(FileStrWAV); if (fileInfo.Length > 44) //"Empty" files are 44 bytes big { IWaveSource wavSource = new WaveFileReader(FileStrWAV); wavLength = wavSource.GetLength(); wavSource?.Dispose(); } } catch (Exception ex) { wavLength = TimeSpan.Zero; _logHandle.Report(new LogEventError("Error while stopping record: " + ex.Message)); } if (TrackInfo?.Duration > TimeSpan.Zero && (wavLength < (TrackInfo?.Duration - AllowedDifferenceToTrackDuration) || wavLength > (TrackInfo?.Duration + AllowedDifferenceToTrackDuration))) { System.IO.File.Delete(FileStrWAV); DirectoryManager.DeleteEmptyFolders(RecorderRecSettings.BasePath); _logHandle.Report(new LogEventWarning("Record (\"" + TrackInfo?.TrackName + "\") deleted, because of wrong length (Length = " + wavLength.ToString(@"hh\:mm\:ss\.fff") + " s, Expected Range = [" + (TrackInfo?.Duration - AllowedDifferenceToTrackDuration).Value.ToString(@"hh\:mm\:ss\.fff") + ", " + (TrackInfo?.Duration + AllowedDifferenceToTrackDuration).Value.ToString(@"hh\:mm\:ss\.fff") + "]).")); RecordState = RecordStates.STOPPED; return; } } if (!System.IO.File.Exists(FileStrWAV)) { RecordState = RecordStates.STOPPED; return; } await Task.Run(() => { if (NormalizeWAVFile(FileStrWAV) == false) { RecordState = RecordStates.STOPPED; return; } _logHandle.Report(new LogEventInfo("Record (\"" + TrackInfo?.TrackName + "\") normalized.")); RecorderPostSteps?.Invoke(this, new EventArgs()); if (RecorderRecSettings.RecordFormat == RecordFormats.WAV_AND_MP3) { if (ConvertWAVToMP3(FileStrWAV, FileStrMP3) == false) { RecordState = RecordStates.STOPPED; return; } _logHandle.Report(new LogEventInfo("Record (\"" + TrackInfo?.TrackName + "\") converted to MP3.")); } else if (RecorderRecSettings.RecordFormat == RecordFormats.MP3) { if (ConvertWAVToMP3(FileStrWAV, FileStrMP3) == false) { RecordState = RecordStates.STOPPED; return; } if (System.IO.File.Exists(FileStrWAV)) { System.IO.File.Delete(FileStrWAV); } _logHandle.Report(new LogEventInfo("Record (\"" + TrackInfo?.TrackName + "\") converted to MP3 and WAV deleted.")); } AddTrackTags(FileStrWAV, TrackInfo); AddTrackTags(FileStrMP3, TrackInfo); _logHandle.Report(new LogEventInfo("Record (\"" + TrackInfo?.TrackName + "\") tagged.")); RecordState = RecordStates.STOPPED; OnRecorderPostStepsFinished?.Invoke(this, new EventArgs()); }); } catch (Exception ex) { _logHandle.Report(new LogEventError("Error while stopping record: " + ex.Message)); RecordState = RecordStates.STOPPED; } }
private void MIDIConversionTbT(Control Form, Panel ThreadsPanel, String OPath) { try { Status = "prep"; Int32 MT = Properties.Settings.Default.MultiThreadedMode ? Properties.Settings.Default.MultiThreadedLimitV : 1; WaveFormat WF = new WaveFormat(Properties.Settings.Default.Frequency, 32, 2, AudioEncoding.IeeeFloat); // Initialize BASS Debug.PrintToConsole("ok", "Initializing BASS..."); if (!Bass.BASS_Init(0, WF.SampleRate, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero)) { throw new Exception("Unable to initialize BASS!"); } LoadSoundFonts(); foreach (MIDI MFile in Program.MIDIList) { MultiStreamMerger MSM = new MultiStreamMerger(WF); if (StopRequested) { Debug.PrintToConsole("ok", "Stop requested. Stopping foreach loop..."); break; } MDV.SetTotalTracks(MFile.Tracks); MDV.ResetCurrentTrack(); // Begin conversion Status = "mconv"; try { CTS = new CancellationTokenSource(); Debug.PrintToConsole("ok", String.Format("Preparing loop... MaxDegreeOfParallelism = {0}", MT)); ParallelFor(0, MFile.Tracks, MT, CTS.Token, T => { if (StopRequested) { Debug.PrintToConsole("ok", "Stop requested. Stopping Parallel.For..."); //LS.Stop(); return; } if (MFile.NoteCount > 0) { TrackThreadStatus Trck = new TrackThreadStatus(T); Trck.Dock = DockStyle.Top; ThreadsPanel.Invoke((MethodInvoker) delegate { Debug.PrintToConsole("ok", "Added TrackThreadStatus control for MIDI."); ThreadsPanel.Controls.Add(Trck); }); ConvertWorker Worker = new ConvertWorker(MFile.GetSingleTrackTimeBased(T), MFile.TimeLength.TotalSeconds); ISampleWriter Writer; WaveWriter SDestination = null; FileStream SFOpen = null; if (Properties.Settings.Default.PerTrackSeparateFiles) { // Check if we need to export each track to a file String Folder = OPath; if (Properties.Settings.Default.PerTrackSeparateFiles) { // We do, create folder Folder += String.Format("\\{0}\\", Path.GetFileNameWithoutExtension(MFile.Name)); if (!Directory.Exists(Folder)) { Directory.CreateDirectory(Folder); } } else { Folder += " "; } // Prepare the filename String SOutputDir = String.Format("{0}Track {1}.{2}", Folder, T, Properties.Settings.Default.Codec); // Check if file already exists if (File.Exists(SOutputDir)) { SOutputDir = String.Format("{0}Track {1} - {2}.{3}", Folder, T, DateTime.Now.ToString("dd-MM-yyyy HHmmsstt"), Properties.Settings.Default.Codec); } Debug.PrintToConsole("ok", String.Format("{0} - Output file: {1}", T, SOutputDir)); SFOpen = File.Open(SOutputDir, FileMode.Create); SDestination = new WaveWriter(SFOpen, WF); Writer = new WaveSampleWriter(SDestination); } else { Writer = MSM.GetWriter(); } Task ConvThread = Task.Run(() => { Worker.Convert(Writer, WF, false, CTS.Token); }); while (!ConvThread.IsCompleted) { if (StopRequested) { break; } Trck.Invoke((MethodInvoker) delegate { Trck.UpdatePB(Convert.ToInt32(Math.Round(Worker.Progress * 100))); }); Thread.Sleep(10); } ConvThread.Wait(); if (SDestination != null) { SDestination.Dispose(); } if (SFOpen != null) { SFOpen.Dispose(); } ThreadsPanel.Invoke((MethodInvoker) delegate { Debug.PrintToConsole("ok", String.Format("{0} - Removed TrackThreadStatus control for MIDI.", T)); ThreadsPanel.Controls.Remove(Trck); }); if (!StopRequested) { MDV.AddTrack(); } } }); } catch (OperationCanceledException) { } finally { CTS.Dispose(); CTS = null; } if (StopRequested) { break; } else { MDV.AddValidMIDI(); } // Time to save the file String OutputDir = String.Format("{0}\\{1}.{2}", OPath, Path.GetFileNameWithoutExtension(MFile.Name), Properties.Settings.Default.Codec); // Check if file already exists if (File.Exists(OutputDir)) { OutputDir = String.Format("{0}\\{1} - {2}.{3}", OPath, Path.GetFileNameWithoutExtension(MFile.Name), DateTime.Now.ToString("dd-MM-yyyy HHmmsstt"), Properties.Settings.Default.Codec); } Debug.PrintToConsole("ok", String.Format("Output file: {0}", OutputDir)); // Reset MSM position MSM.Position = 0; // Prepare wave source IWaveSource MStream; if (Properties.Settings.Default.LoudMax) { Debug.PrintToConsole("ok", "LoudMax enabled."); AntiClipping BAC = new AntiClipping(MSM, 0.1); MStream = BAC.ToWaveSource(32); } else { MStream = MSM.ToWaveSource(32); } FileStream FOpen = File.Open(OutputDir, FileMode.Create); WaveWriter Destination = new WaveWriter(FOpen, WF); Debug.PrintToConsole("ok", "Output file is open."); Int32 FRead = 0; byte[] FBuffer = new byte[1024 * 16]; Status = "aout"; Debug.PrintToConsole("ok", String.Format("Writing data for {0} to disk...", OutputDir)); while ((FRead = MStream.Read(FBuffer, 0, FBuffer.Length)) != 0) { Destination.Write(FBuffer, 0, FRead); } Debug.PrintToConsole("ok", String.Format("Done writing {0}.", OutputDir)); Destination.Dispose(); FOpen.Dispose(); } FreeSoundFonts(); Debug.PrintToConsole("ok", "BASS freed."); Bass.BASS_Free(); } catch (Exception ex) { Status = "crsh"; StError = String.Format("The converter encountered an error during the conversion process.\nError: {0}", ex.Message.ToString()); IsCrash = true; Debug.PrintToConsole("err", String.Format("{0} - {1}", ex.InnerException.ToString(), ex.Message.ToString())); } if (!StopRequested && !IsCrash) { Form.Invoke((MethodInvoker) delegate { ((Form)Form).Close(); }); } }
void Record(int channel) { state[channel].Disposable = Disposable.Empty; //create a new soundIn instance ISoundIn soundIn = new WasapiCapture(); //optional: set some properties //soundIn.Device = ... //... //initialize the soundIn instance soundIn.Initialize(); //create a SoundSource around the the soundIn instance //this SoundSource will provide data, captured by the soundIn instance var soundInSource = new SoundInSource(soundIn) { FillWithZeros = false }; //create a source, that converts the data provided by the //soundInSource to any other format //in this case the "Fluent"-extension methods are being used var convertedSource = soundInSource .ToStereo() //2 channels (for example) .ChangeSampleRate(8000) // 8kHz sample rate .ToSampleSource() .ToWaveSource(16); //16 bit pcm //register an event handler for the DataAvailable event of //the soundInSource //Important: use the DataAvailable of the SoundInSource //If you use the DataAvailable event of the ISoundIn itself //the data recorded by that event might won't be available at the //soundInSource yet var waveWriter = new WaveWriter(channelFile(channel), convertedSource.WaveFormat); soundInSource.DataAvailable += (s, e) => { //read data from the converedSource //important: don't use the e.Data here //the e.Data contains the raw data provided by the //soundInSource which won't have your target format var buffer = new byte[convertedSource.WaveFormat.BytesPerSecond / 2]; int read; //keep reading as long as we still get some data //if you're using such a loop, make sure that soundInSource.FillWithZeros is set to false while ((read = convertedSource.Read(buffer, 0, buffer.Length)) > 0) { //your logic follows here //for example: stream.Write(buffer, 0, read); waveWriter.Write(buffer, 0, read); } }; //we've set everything we need -> start capturing data soundIn.Start(); state[channel].Disposable = Disposable.Create(() => { soundIn.Stop(); waveWriter.Dispose(); }); }