private void recordDevice_RecordingStopped(object sender, StoppedEventArgs e)
{
try
{
Logger.WriteDebug(MethodBase.GetCurrentMethod(), "recordDevice -> Stopped");
if (_einsatz != null)
{
//Raise Event
EinsatzFinished.RaiseEvent(this, new EinsatzFinishedEventArgs(_einsatz));
//Reset Einsatz
_einsatz = null;
Logger.WriteDebug(MethodBase.GetCurrentMethod(), "Reset einsatz -> finish");
}
_recordMp3Writer?.Dispose();
_recordWaveStream?.Dispose();
}
catch (Exception ex)
{
ExceptionOccured.RaiseEvent(this, new ExceptionEventArgs
{
Methode = MethodBase.GetCurrentMethod(),
Error = ex
});
}
finally
{
_recordState = RecordState.Stopped;
_recordWaveStream = null;
_recordMp3Writer = null;
}
}
public static Stream Convert(Stream inputStream)
{
using (var fileReader = new WaveFileReader(inputStream))
{
Pcm8BitToSampleProvider sampleProvider = new Pcm8BitToSampleProvider(fileReader);
SampleToWaveProvider waveProvider = new SampleToWaveProvider(sampleProvider);
var outStream = new MemoryStream();
using (var fileWriter = new LameMP3FileWriter(outStream, waveProvider.WaveFormat, 24))
{
int buff_length = 1024 * 1024;
var buff = new byte[buff_length];
int position = 0;
int length = waveProvider.Read(buff, position, buff_length);
while (length > 0)
{
position += length;
fileWriter.Write(buff, (int)fileWriter.Position, length);
length = waveProvider.Read(buff, position, buff_length);
}
fileWriter.Flush();
return(outStream);
}
}
}
static void Main(string[] args)
{
outputFilename = String.Format("CaptingAudio_{0:yyy-MM-dd HH-mm-ss}.mp3", DateTime.Now);
string outputFolder;
Console.WriteLine("This program is record in computer. Same loopback record. ");
Console.WriteLine("Save : " + Path.GetTempPath() + "\\CaptingAudio");
Console.WriteLine("0: StartRecording, 1: StopRecord");
outputFolder = Path.Combine(Path.GetTempPath(), "CaptingAudio");
Directory.CreateDirectory(outputFolder);
if (int.Parse(Console.ReadLine()) == 0)
{
if (waveIn == null)
{
waveIn = new WasapiLoopbackCapture();
writer = new LameMP3FileWriter(Path.Combine(outputFolder, outputFilename), waveIn.WaveFormat, 128);
waveIn.DataAvailable += OnDataAvailable;
waveIn.RecordingStopped += OnRecordingStopped;
waveIn.StartRecording();
}
}
if (int.Parse(Console.ReadLine()) == 1)
{
StopRecording();
}
}
public void TC02_Formats()
{
bool TestFormat(WaveFormat format)
{
using (var mp3data = new MemoryStream())
{
using (var writer = new LameMP3FileWriter(mp3data, format, LAMEPreset.STANDARD))
{
var bfr = new byte[format.AverageBytesPerSecond];
writer.Write(bfr, 0, bfr.Length);
}
mp3data.Position = 0;
using (var reader = new Mp3FileReader(mp3data))
{
var encodedFormat = format;
return
((encodedFormat.SampleRate == format.SampleRate) &&
(encodedFormat.Channels == format.Channels));
}
}
}
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(44100, 2)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(44100, 1)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(22050, 2)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(22050, 1)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(16000, 2)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(16000, 1)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(11028, 2)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(11025, 1)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(8000, 2)));
Assert.IsTrue(TestFormat(WaveFormat.CreateIeeeFloatWaveFormat(8000, 1)));
}
private void recording() //record function
{
if (System.Convert.ToInt32(dateStart.ToString("mm")) <= 30)
{
this.delay = (29 - System.Convert.ToInt32(this.dateStart.ToString("mm"))) * 60 + (60 - System.Convert.ToInt32(this.dateStart.ToString("ss")));
}
else
{
this.delay = (59 - System.Convert.ToInt32(this.dateStart.ToString("mm"))) * 60 + (60 - System.Convert.ToInt32(this.dateStart.ToString("ss")));
}
this.message += "initial: voicemail recording started...\r\n";
this.waveSource = new WaveInEvent();
this.waveSource.WaveFormat = new WaveFormat(44100, 1); //hz,kbps,channels of record
this.waveSource.DataAvailable += waveIn_DataAvailable;
this.waveSource.RecordingStopped += waveIn_RecordingStopped;
this.dirInfo = new DirectoryInfo(this.tempDrive.Name[0] + @":\VoiceTracker\" + this.dateStart.ToShortDateString());
if (!this.dirInfo.Exists)
{
this.dirInfo.Create();
}
this.tempFile = (this.tempDrive.Name[0] + @":\VoiceTracker\" + this.dateStart.ToShortDateString() + @"\" + this.dateStart.ToShortDateString() + "-" + this.dateStart.ToString("HH.mm.ss") + @".mp3");
lameWriter = new LameMP3FileWriter(this.tempFile, this.waveSource.WaveFormat, 128);
this.waveSource.StartRecording();
stopped = false;
this.timer = new Timer(_ => cicleRecording(), null, this.delay * 1000, 1800 * 1000); // this.delay, 1800 <- interval ms
}
static void Main(string[] args)
{
// Setup MP3 writer to output at 32kbit/sec (~2 minutes per MB)
wri = new LameMP3FileWriter(@"C:\temp\test_output.mp3", waveIn.WaveFormat, 32);
// Start recording from loopback
IWaveIn waveIn = new WasapiLoopbackCapture();
waveIn.DataAvailable += waveIn_DataAvailable;
waveIn.RecordingStopped += waveIn_RecordingStopped;
waveIn.StartRecording();
stopped = false;
// Keep recording until Escape key pressed
while (!stopped)
{
if (Console.KeyAvailable)
{
var key = Console.ReadKey(true);
if (key != null && key.Key == ConsoleKey.Escape)
{
waveIn.StopRecording();
}
}
else
{
System.Threading.Thread.Sleep(50);
}
}
// flush output to finish MP3 file correctly
wri.Flush();
// Dispose of objects
waveIn.Dispose();
wri.Dispose();
}
public static Stream ConvertWavToMp3(Stream wavStream)
{
_uniqueTempFileCounter += 1;
var tempFile = Path.GetTempFileName();
using (var rdr = new WaveFileReader(wavStream))
{
if (rdr.WaveFormat.BitsPerSample == 24) //Can't go from 24 bits wav to mp3 directly, create temporary 16 bit wav
{
ISampleProvider sampleprovider = new Pcm24BitToSampleProvider(rdr); //24 bit to sample
var resampler = new WdlResamplingSampleProvider(sampleprovider, SampleRate); //sample to new sample rate
WaveFileWriter.CreateWaveFile16(tempFile, resampler); //sample to actual wave file
return(ConvertWavFileToMp3MemoryStream(tempFile, true)); //file to mp3 bytes
}
else if (!SupportedMPEGSampleRates.Contains(rdr.WaveFormat.SampleRate)) //Can't go from unsupported Sample Rate wav to mp3 directly
{
var resampler = new WdlResamplingSampleProvider(rdr.ToSampleProvider(), SampleRate); //sample to new sample rate
WaveFileWriter.CreateWaveFile16(tempFile, resampler); //sample to actual wave file
return(ConvertWavFileToMp3MemoryStream(tempFile, true)); //file to mp3 bytes
}
else
{
var retMs = FilesystemUtils.recyclableMemoryStreamManager.GetStream();
using (var wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, BitRate))
{
rdr.CopyTo(wtr);
return(retMs);
}
}
}
}
//public static void WavToMp3File(ref MemoryStream ms, string savetofilename)
public static void WavToMp3File(string inputWavFile)
{
var outputFile = Path.Combine(
Path.GetDirectoryName(inputWavFile),
Path.GetFileNameWithoutExtension(inputWavFile) + ".mp3");
using (var rdr = new WaveFileReader(inputWavFile))
using (var wtr = new LameMP3FileWriter(outputFile, rdr.WaveFormat, LAMEPreset.STANDARD))
{
//rdr.CopyTo(wtr);
int size = 128;
while (rdr.Position < rdr.Length)
{
if (rdr.Length - rdr.Position < size)
{
size = (int)rdr.Length - (int)rdr.Position;
}
byte[] buffer = new byte[size];
var r = rdr.Read(buffer, 0, size);
wtr.Write(buffer, 0, size);
}
wtr.Flush();
}
}
public static void Concatenate(string outfile, params string[] mp3filenames)
{
if (File.Exists(outfile))
{
File.Delete(outfile);
}
LameMP3FileWriter writer = null;
foreach (string filename in mp3filenames)
{
using (var reader = new Mp3FileReader(filename))
{
//Console.WriteLine("doing ");
if (writer == null)
{
writer = new LameMP3FileWriter(outfile, reader.WaveFormat, LAMEPreset.ABR_320);
}
reader.CopyTo(writer);
//Console.WriteLine("something ");
}
}
if (writer != null)
{
writer.Dispose();
}
}
public void convert(string filepath)
{
Mime mime = new Mime();
string mimeType = mime.Lookup(filepath);
string mp3path = filepath.Replace(".wav", ".mp3");
Debug.WriteLine(mp3path);
try {
byte[] wavFile = File.ReadAllBytes(filepath);
using (MemoryStream memoryStream = new MemoryStream())
using (MemoryStream WaveMemoryStream = new MemoryStream(wavFile))
using (WaveFileReader WaveFileReader = new WaveFileReader(WaveMemoryStream))
using (LameMP3FileWriter mp3Writer = new LameMP3FileWriter(memoryStream, WaveFileReader.WaveFormat, 128)) {
WaveFileReader.CopyTo(mp3Writer);
try {
File.WriteAllBytes(mp3path, memoryStream.ToArray());
} catch (Exception e) {
// error writing file
Debug.WriteLine(e);
}
}
} catch (Exception e) {
Debug.WriteLine(e);
}
}
public async Task Write(Stream fileStream)
{
string wavIntermediate = Path.Combine(outputDirectoryProvider.GetOutputDirectory(), Guid.NewGuid() + ".wav");
try
{
{
await waveStream.Write(wavIntermediate);
await progressReporter.ReportProgress(0.97, JobProgressStatus.InProgress, "Converting WAV to MP3");
await using var audioFileReader = new AudioFileReader(wavIntermediate);
await using var writer = new LameMP3FileWriter(fileStream, audioFileReader.WaveFormat, LAMEPreset.ABR_320);
await audioFileReader.CopyToAsync(writer);
} // dispose it before reporting complete
await progressReporter.ReportProgress(1, JobProgressStatus.Complete, "File created successfully");
}
finally
{
if (File.Exists(wavIntermediate))
{
try { File.Delete(wavIntermediate); } catch (Exception) { }
}
}
}
public void StopRecording()
{
if (waveOut != null)
{
waveOut.StopRecording();
waveOut.Dispose();
waveOut = null;
}
if (waveIn != null)
{
waveOneOut.Stop();
waveIn.StopRecording();
waveIn.Dispose();
}
if (this.waveWriter_in != null)
{
this.waveWriter_in.Flush();
this.waveWriter_in.Dispose();
this.waveWriter_in = null;
}
if (this.waveWriter_out != null)
{
this.waveWriter_out.Flush();
this.waveWriter_out.Dispose();
this.waveWriter_out = null;
}
MixFile();
Startded = false;
}
public void Encode(WaveStream waveData, Stream outputStream)
{
using (LameMP3FileWriter mp3 = new LameMP3FileWriter(outputStream, waveData.WaveFormat, 128))
{
waveData.CopyTo(mp3);
}
}
/// <summary>
/// Create mp3 from file name
/// </summary>
/// <param name="fileName">The output mp3 file name</param>
/// <param name="fileFull">Full image path</param>
public void createMp3(string fileName, string fileFull)
{
model.bmpName = fileName.Replace(".bmp", "");
using (var bmpTemp = new Bitmap(fileFull))
{
Bitmap bitmap = new Bitmap(bmpTemp);
_myWavCreator.NegativeImageMode = model.negative;
// if (!File.Exists(OutDirectory + "\\" + fileName + ".mp3") || !File.Exists(model.realpath))
if (!File.Exists(OutDirectory + "\\" + fileName + ".mp3"))
{
MemoryStream ms = _myWavCreator.createWavMemory(bitmap, fileName, true, true);
ms.Position = 0;
using (var retMs = File.OpenWrite(OutDirectory + "\\" + fileName + ".mp3"))
using (var rdr = new WaveFileReader(ms))
using (var wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, 128))
{
rdr.CopyTo(wtr);
}
}
}
}
public void TC01_EncodeStream()
{
Assert.IsTrue(File.Exists(SourceFilename));
using (var mp3data = new MemoryStream())
{
// Convert source wave to MP3
using (var source = new AudioFileReader(SourceFilename))
using (var mp3writer = new LameMP3FileWriter(mp3data, source.WaveFormat, LAMEPreset.STANDARD))
{
TimeSpan source_time = source.TotalTime;
source.CopyTo(mp3writer);
Assert.AreEqual(source.Length, source.Position);
}
// Open MP3 file and test content
mp3data.Position = 0;
using (var encoded = new Mp3FileReader(mp3data))
{
// encoding did not supply an ID3 tag, ensure none was present in file
Assert.IsNull(encoded.Id3v1Tag);
Assert.IsNull(encoded.Id3v2Tag);
// the STANDARD lame preset produces a Xing header. Check it.
Assert.IsNotNull(encoded.XingHeader);
Assert.AreEqual(mp3data.Length, encoded.XingHeader.Bytes);
// confirm that length is a multiple of the block size
int blkSize = (encoded.XingHeader.Mp3Frame.SampleCount * encoded.WaveFormat.BitsPerSample * encoded.WaveFormat.Channels) / 8;
int calcLength = blkSize * encoded.XingHeader.Frames;
Assert.AreEqual(calcLength, encoded.Length);
}
}
}
private bool DownloadAndSave(string title)
{
try
{
var videoID = mDownloadList.Find(x => x.Item1 == title)?.Item2;
if (String.IsNullOrEmpty(videoID))
{
return(false);
}
var streamManifest = youtube.Videos.Streams.GetManifestAsync(videoID).GetAwaiter().GetResult();
var streamInfo = streamManifest.GetAudioOnly().FirstOrDefault();
var kekwaitstream = youtube.Videos.Streams.GetAsync(streamInfo).GetAwaiter().GetResult();
var filename = string.Join("_", title.Split(Path.GetInvalidFileNameChars()));
using (var reader = new AudioFileReader(streamInfo.Url))
using (var writer = new LameMP3FileWriter($"{AppDomain.CurrentDomain.BaseDirectory}Output\\{filename}.mp3", reader.WaveFormat, 128))
reader.CopyTo(writer);
return(true);
}
catch
{
Thread.Sleep(300);
return(DownloadAndSave(title));
}
}
/// <summary>
/// Starts recording
/// </summary>
/// <param name="recordingConfig">Recording configuration</param>
public void Start(RecordingConfig recordingConfig)
{
if (_recordingStatus == RecordingStatus.NotRecording)
{
InitAggregator(recordingConfig.SampleRate);
CheckRecordingDevice(recordingConfig);
InitFader(recordingConfig.SampleRate);
_waveSource = new WaveIn
{
WaveFormat = new WaveFormat(recordingConfig.SampleRate, recordingConfig.ChannelCount),
DeviceNumber = recordingConfig.RecordingDevice,
};
_waveSource.DataAvailable += WaveSourceDataAvailableHandler;
_waveSource.RecordingStopped += WaveSourceRecordingStoppedHandler;
_mp3Writer = new LameMP3FileWriter(
recordingConfig.DestFilePath,
_waveSource.WaveFormat,
recordingConfig.Mp3BitRate,
CreateTag(recordingConfig));
_waveSource.StartRecording();
OnRecordingStatusChangeEvent(new RecordingStatusChangeEventArgs(RecordingStatus.Recording));
}
}
//Окончание записи
private void waveIn_RecordingStopped(object sender, EventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new EventHandler(waveIn_RecordingStopped), sender, e);
}
else
{
_www.Dispose();
_www = null;
_writer.Close();
_writer.Dispose();
try
{
using (var reader = new AudioFileReader(_writer.Filename))
{
using (var write = new LameMP3FileWriter(@"D:\MP3\gg.mp3", reader.WaveFormat, 128))
{
reader.CopyTo(write);
write.Flush();
}
reader.Flush();
}
}
catch (Exception ev)
{
MessageBox.Show(ev.Message);
}
}
}
public static Stream ConvertAiffToMp3(Stream aiffStream, string directory)
{
_uniqueTempFileCounter += 1;
var tempFile = Path.GetTempFileName();
using (var rdr = new AiffFileReader(aiffStream))
{
//can't go from 24 bits aif to mp3 directly, create temporary 16 bit wav
if (rdr.WaveFormat.BitsPerSample == 24)
{
ISampleProvider sampleprovider = new Pcm24BitToSampleProvider(rdr); //24 bit to sample
var resampler = new WdlResamplingSampleProvider(sampleprovider, SampleRate); //sample to new sample rate
WaveFileWriter.CreateWaveFile16(tempFile, resampler); //sample to actual wave file
return(ConvertWavFileToMp3MemoryStream(tempFile, true)); //file to mp3 bytes
}
else
{
var retMs = FilesystemUtils.recyclableMemoryStreamManager.GetStream();
using (var wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, BitRate))
{
rdr.CopyTo(wtr);
return(retMs);
}
}
}
}
/// <summary>
/// Send buffer to disk
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Data contaning the buffer values</param>
private void DataAvailable(object sender, WaveInEventArgs e)
{
#if DEBUG
Console.WriteLine("Bytes recorded: {0}", e.BytesRecorded);
#endif
string fileName = string.Format("{0}.mp3", DateTime.Now.Ticks);
if (options.WorkingDirectory != null)
{
fileName = Path.Combine(options.WorkingDirectory, fileName);
}
var writter = new LameMP3FileWriter(fileName, waveFormat, (int)RecordingBitRate.BITRATE_128);
//Create a new task/thread separately to save this buffer to disk, avoid thread blockage at all cost
Task.Factory.StartNew(() => {
writter.WriteAsync(e.Buffer, 0, e.BytesRecorded)
.ContinueWith(x => {
writter.Flush();
writter.Dispose();
writter = null;
#if DEBUG
Console.WriteLine("File written: {0}", fileName);
#endif
//TODO: report back to the cloud server that this service is running, index the fileChunk, upload to cloud storage
});
}, TaskCreationOptions.LongRunning);
}
/*async*/ void button3_Click(object sender, EventArgs e)
{
try
{
cap = new WasapiLoopbackCapture();
cap.DataAvailable += InputBufferToFileCallback;
cap.RecordingStopped += stoppedrecordingCallback;
var outputFilePath = "C:\\Users\\Smail\\Desktop\\output-sound-card.mp3";
writer = new WaveFileWriter(outputFilePath, cap.WaveFormat);
file_base64 = new StreamWriter(@"C:\\Users\\Smail\\Desktop\\output-sound-Base64.txt");
var outputFilePath2 = "C:\\Users\\Smail\\Desktop\\output-sound-card2.mp3";
ms = new MemoryStream();
wtr = new LameMP3FileWriter(ms, cap.WaveFormat, (cap.WaveFormat.BitsPerSample * cap.WaveFormat.SampleRate * cap.WaveFormat.Channels) / 1000);
//retMs = new MemoryStream();
//rdr = new RawSourceWaveStream(ms, cap.WaveFormat);
//wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, 128);
cap.StartRecording();
}
catch (Exception ex)
{
MessageBox.Show("error while listening :" + ex.Message);
}
}
private static void CompressToMP3()
{
var bitRate = 128;
using (var reader = new AudioFileReader(_waveFileName))
using (var writer = new LameMP3FileWriter(_targetFileName, reader.WaveFormat, bitRate)) reader.CopyTo(writer);
}
public static void WriteSong(string waveFileName, string mp3FileName, SongInfo info)
{
using (AudioFileReader reader = new AudioFileReader(waveFileName)) {
//Console.WriteLine(reader.WaveFormat.BitsPerSample);
WaveFormat format = WaveFormat.CreateIeeeFloatWaveFormat(reader.WaveFormat.SampleRate, reader.WaveFormat.Channels); //new WaveFormat(reader.WaveFormat.SampleRate, 16, 2)
using (var resampler = new MediaFoundationResampler(reader, format)) {
// resampler.ResamplerQuality = 60;
WaveFileWriter.CreateWaveFile(Path.GetFileNameWithoutExtension(mp3FileName) + ".wav", resampler);
}
}
using (WaveFileReader reader = new WaveFileReader(Path.GetFileNameWithoutExtension(mp3FileName) + ".wav")) {
using (LameMP3FileWriter writer = new LameMP3FileWriter(mp3FileName, reader.WaveFormat, 705)) {
//Console.WriteLine(reader.WaveFormat.BitsPerSample);
reader.CopyTo(writer);
}
}
File.Delete(Path.GetFileNameWithoutExtension(mp3FileName) + ".wav");
TagLib.File f = TagLib.File.Create(mp3FileName);
f.Tag.Album = info.Album;
f.Tag.Artists = new string[] { info.Artist };
f.Tag.AlbumArtists = new string[] { info.Artist };
f.Tag.Title = info.Title;
f.Tag.Genres = new string[] { "Soundtrack" };
f.Tag.Track = (uint)info.TrackNumber;
f.Save();
}
public override void StopRecording()
{
base.StopRecording();
_captureStream.DataAvailable -= CaptureStream_DataAvailable;
_outWriter.Dispose();
_outWriter = null;
}
private void cicleRecording() // record cicle function
{
this.waveSource.StopRecording();
lameWriter.Flush();
this.waveSource.Dispose();
lameWriter.Dispose();
this.fastCheck();
this.dateStart = DateTime.Now;
if (this.dateStart > this.dateEnd)
{
this.terminte("completion of the application: The current day is over.");
}
this.waveSource = new WaveInEvent();
this.waveSource.WaveFormat = new WaveFormat(44100, 1); //hz,kbps,chanels of record
this.waveSource.DataAvailable += waveIn_DataAvailable;
this.waveSource.RecordingStopped += waveIn_RecordingStopped;
this.dirInfo = new DirectoryInfo(this.tempDrive.Name[0] + @":\VoiceTracker\" + dateStart.ToShortDateString());
if (!this.dirInfo.Exists)
{
this.dirInfo.Create();
}
this.tempFile = (this.tempDrive.Name[0] + @":\VoiceTracker\" + dateStart.ToShortDateString() + @"\" + dateStart.ToShortDateString() + "-" + dateStart.ToString("HH.mm.ss") + @".mp3");
lameWriter = new LameMP3FileWriter(this.tempFile, this.waveSource.WaveFormat, 128);
this.waveSource.StartRecording();
}
/// <summary>
/// Converts the recorded WAV file to MP3. The WAV file will be converted
/// ONLY if the recording was finished successfully (using StopRecording).
/// </summary>
public void ConvertToMP3()
{
if (!_isRecording)
{
// Convert WAV to MP3 using libmp3lame library
try
{
_state = RecorderState.ConvertingInProgress;
using (var reader = new AudioFileReader(_tempWavFilePath))
using (var writer = new LameMP3FileWriter(_mp3FilePath, reader.WaveFormat, _mp3Preset))
reader.CopyTo(writer);
}
catch (Exception)
{
_state = RecorderState.ConvertError;
return;
}
}
else
{
_state = RecorderState.ConvertError;
return;
}
_state = RecorderState.ConvertingFinsihed;
}
private void button4_Click(object sender, EventArgs e)
{
synth.SelectVoice(ddlVoices.SelectedItem.ToString());
if (audioFile != null)
{
audioFile.Close();
}
synth.SpeakAsyncCancelAll();
Thread.Sleep(1000);
Console.WriteLine("Redirecting output");
synth.SetOutputToWaveFile("temp.wav");
Console.WriteLine("Speaking text...");
synth.Speak(rtfText.Text);
Console.WriteLine("Done speaking text");
synth.SetOutputToNull();
Console.WriteLine("Done setting output to null");
SaveFileDialog ofd = new SaveFileDialog();
ofd.Filter = "Text files (*.mp3)|*.mp3|All files (*.*)|*.*";
ofd.ShowDialog();
using (var reader = new AudioFileReader("temp.wav"))
using (var writer = new LameMP3FileWriter(ofd.FileName, reader.WaveFormat, LAMEPreset.ABR_128))
reader.CopyTo(writer);
LastSavedFile = ofd.FileName;
}
/// <summary>
/// Applies changes based on the state of this instance, and saves to the specified path.
/// </summary>
/// <param name="path">The file path.</param>
public void Save(string path)
{
// applies peak normalization to the reader
if (this.Settings.NormalizeVolume)
{
this.NormalizationProvider.ApplyPeakNormalization(this.Reader);
}
// determine the output type
if (this.Settings.EncodeToMP3 &&
this.Reader.Length > 0)
{
using (var writer = new LameMP3FileWriter(path, this.Reader.WaveFormat, MP3_BIT_RATE))
{
var buffer = new byte[1024 * 4];
var read = 0;
while ((read = this.Reader.Read(buffer, 0, buffer.Length)) > 0)
{
writer.Write(buffer, 0, read);
}
}
}
else
{
WaveFileWriter.CreateWaveFile(path, this.Reader);
}
}
private static Task <byte[]> CompressWav(this byte[] wav)
{
var task = Task.Run(() =>
{
try
{
using (var ms = new MemoryStream(wav))
{
using (var reader = new WaveFileReader(ms))
{
var newFormat = new WaveFormat(8000, 16, 1);
using (var conversionStream = new WaveFormatConversionStream(newFormat, reader))
{
using (var outms = new MemoryStream())
{
using (var writer = new LameMP3FileWriter(outms, conversionStream.WaveFormat, 24, null))
{
conversionStream.CopyTo(writer);
return(outms.ToArray());
}
}
}
}
}
}
catch (Exception ex)
{
throw;
}
});
return(task);
}
private void startRecording()
{
try
{
if (_einsatz == null)
{
return;
}
//Record Device
_recordWaveStream = new WaveInEvent
{
DeviceNumber = 0,
WaveFormat = new WaveFormat(44100, 16, 2)
};
_recordWaveStream.DataAvailable += recordDevice_DataAvailable;
_recordWaveStream.RecordingStopped += recordDevice_RecordingStopped;
_recordWaveStream.StartRecording();
_recordMp3Writer = new LameMP3FileWriter(_einsatz.RecordPath, _recordWaveStream.WaveFormat, 32);
_recordState = RecordState.Recording;
Logger.WriteDebug(MethodBase.GetCurrentMethod(), $"recordDevice -> Started({_einsatz.RecordPath})");
}
catch (Exception)
{
ExceptionOccured.RaiseEvent(this, new ExceptionEventArgs
{
Methode = MethodBase.GetCurrentMethod(),
Message = "recordDevice -> error on start"
});
}
}