//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 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)));
}
/// <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);
}
}
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 waveIn_DataAvailable(object sender, WaveInEventArgs e) //support function
{
if (lameWriter != null)
{
lameWriter.Write(e.Buffer, 0, e.BytesRecorded);
}
}
void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
{
// write recorded data to MP3 writer
if (wri != null)
{
wri.Write(e.Buffer, 0, e.BytesRecorded);
}
float max = 0;
var buffer = new WaveBuffer(e.Buffer);
// interpret as 32 bit floating point audio
for (int index = 0; index < e.BytesRecorded / 2; index++)
{
var sample = buffer.ShortBuffer[index];
// to floating point
var sample32 = sample / 32768f;
//for fft
sampleAggregator.Add(sample32);
// absolute value
if (sample32 < 0)
{
sample32 = -sample32;
}
// is this the max value?
if (sample32 > max)
{
max = sample32;
}
}
MyDelegate md = new MyDelegate(showResult);
this.BeginInvoke(md, this, max);
}
}
public void WaveToMP3(string filePath)
{
byte[] wavBytes = File.ReadAllBytes(filePath);
FileInfo wavInfo = new FileInfo(filePath);
using (MemoryStream retMs = new MemoryStream())
using (MemoryStream ms = new MemoryStream(wavBytes))
using (WaveFileReader rdr = new WaveFileReader(ms))
using (LameMP3FileWriter wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, 128))
{
byte[] buffer = new byte[16 * 1024];
long size = rdr.Length;
long runningTotal = 0;
int read;
while ((read = rdr.Read(buffer, 0, buffer.Length)) > 0)
{
wtr.Write(buffer, 0, read);
runningTotal += read;
if (ReportingProgress != null)
{
double progress = runningTotal / (double)size * 100;
ConvertorProgressEventArgs args = new ConvertorProgressEventArgs() { Progress = Convert.ToInt32(progress) };
ReportingProgress(this, args);
}
}
string mp3Path = string.Format("{0}.mp3", wavInfo.FullName.Substring(0, wavInfo.FullName.LastIndexOf('.')));
File.WriteAllBytes(mp3Path, retMs.ToArray());
}
}
static void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
// write recorded data to MP3 writer
if (wri != null)
{
wri.Write(e.Buffer, 0, e.BytesRecorded);
}
}
// adds data to the audio recording buffer
void wi_DataAvailable(object sender, WaveInEventArgs e)
{
if (wri != null)
{
wri.Write(e.Buffer, 0, e.BytesRecorded);
}
bwp.AddSamples(e.Buffer, 0, e.BytesRecorded);
}
private void CaptureStream_DataAvailable(object sender, WaveInEventArgs e)
{
if (_outWriter == null)
{
return;
}
_outWriter.Write(e.Buffer, 0, e.BytesRecorded);
}
private void WaveOut_DataAvailable(object sender, WaveInEventArgs e)
{
if (waveWriter_out == null)
{
return;
}
waveWriter_out.Write(e.Buffer, 0, e.BytesRecorded);
//waveWriter_out.Flush();
}
private void readThread()
{
byte[] data;
while (true)
{
// Check if any data in ring buffer
lock (mRingBuffer)
{
if (mRingBuffer.Count < mBlockSize)
{
mDataReady.Reset();
}
}
// Wait untill data is received
int i = WaitHandle.WaitAny(new WaitHandle[] { mDataReady, mExitEvent });
int count = mRingBuffer.Count;
if (i == 1 && count < mBlockSize)
{
// Write remaining data in ringbuffer
if (mRingBuffer.Count > 0)
{
mMp3Writer.Write(mRingBuffer.Get(count), 0, count);
}
mMp3Writer.Close();
mFS.Close();
// Exit!
return;
}
// Copy data
lock (mRingBuffer)
{
// Copy the block data
data = mRingBuffer.Get(mBlockSize);
}
// Handle data
mMp3Writer.Write(data, 0, mBlockSize);
}
}
public MemoryStream ToMp3(byte[] wavbytes, WaveFormat format)
{
using (var retMs = new MemoryStream())
{
using (var wtr = new LameMP3FileWriter(retMs, format, 128))
{
wtr.Write(wavbytes, 0, wavbytes.Length);
return(retMs);
}
}
}
private static Stream EncodeSilence(LameConfig config, WaveFormat format, int seconds = 1)
{
var mp3data = new MemoryStream();
using (var mp3writer = new LameMP3FileWriter(mp3data, format, config))
{
var bfr = new byte[format.AverageBytesPerSecond * seconds];
mp3writer.Write(bfr, 0, bfr.Length);
}
mp3data.Position = 0;
return(mp3data);
}
/// <summary>
/// Internal method for saving one mp3 file chunk.
/// </summary>
/// <param name="samplesStream">1D bytes list containing linearised local samples buffer (all channels)</param>
/// <param name="channels">Number of channels to save in mp3 file</param>
private void saveMp3Chunk(List <byte> samplesStream, short channels)
{
if (!_isSaving)
{
//initiate saving
//resampler is a must here! Sampling rates higher than 48k are rejected automatically; #TODO
_lameWriter = new LameMP3FileWriter(_filePath, new WaveFormat(_openFile.getSampleRate(), 16, channels), LAMEPreset.V0);
_isSaving = true;
}
_lameWriter.Write(samplesStream.ToArray());
}
/// <summary>
/// Stream copied to mp3 encoder
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
private byte[] EncodeToMp3(byte[] data)
{
var positionStart = (int)_lameStream.Position;
_lameWriter.Write(data, 0, data.Length);
var positionStop = (int)_lameStream.Position;
var lenght = positionStop - positionStart;
byte[] encodedBytes = new byte[lenght];
_lameStream.Seek(positionStart, SeekOrigin.Begin);
_lameStream.Read(encodedBytes, 0, lenght);
_lameStream.Seek(positionStop, SeekOrigin.Begin);
return(encodedBytes);
}
public void Test_Issue42()
{
var waveFormat = new WaveFormat();
var tag = new ID3TagData {
Album = "Album"
};
using (var ms = new MemoryStream())
using (var writer = new LameMP3FileWriter(ms, waveFormat, LAMEPreset.STANDARD, tag))
{
byte[] empty = new byte[8192];
writer.Write(empty, 0, 8192);
writer.Flush();
}
}
// Create an in-memory MP3 file with the supplied ID3v2 tag, then read the tag back from the MP3 file
private static ID3TagData GetTagAsWritten(ID3TagData tag)
{
var waveFormat = new WaveFormat();
using (var ms = new MemoryStream())
{
using (var writer = new LameMP3FileWriter(ms, waveFormat, LAMEPreset.STANDARD, tag))
{
byte[] empty = new byte[8192];
writer.Write(empty, 0, 8192);
writer.Flush();
}
ms.Position = 0;
return(ID3Decoder.Decode(ReadID3v2Tag(ms)));
}
}
private static void TrimWavFile(AudioFileReader reader, LameMP3FileWriter writer, int startPos, int endPos)
{
reader.Position = startPos;
var buffer = new byte[1024];
while (reader.Position < endPos)
{
var bytesRequired = (int)(endPos - reader.Position);
if (bytesRequired > 0)
{
var bytesToRead = Math.Min(bytesRequired, buffer.Length);
var bytesRead = reader.Read(buffer, 0, bytesToRead);
if (bytesRead > 0)
{
writer.Write(buffer, 0, bytesRead);
}
}
}
}
private void recordDevice_DataAvailable(object sender, WaveInEventArgs e)
{
try
{
if (_recordWaveStream == null || _recordMp3Writer == null)
{
return;
}
_recordMp3Writer.Write(e.Buffer, 0, e.BytesRecorded);
}
catch (Exception ex)
{
ExceptionOccured.RaiseEvent(this, new ExceptionEventArgs
{
Methode = MethodBase.GetCurrentMethod(),
Error = ex
});
}
}
private void WaveSourceDataAvailableHandler(object?sender, WaveInEventArgs waveInEventArgs)
{
// as audio samples are provided by WaveIn, we hook in here
// and write them to disk, encoding to MP3 on the fly
// using the _mp3Writer.
var buffer = waveInEventArgs.Buffer;
var bytesRecorded = waveInEventArgs.BytesRecorded;
var isFloatingPointAudio = _waveSource?.WaveFormat.BitsPerSample == 32;
if (_fader != null && _fader.Active)
{
// we're fading out...
_fader.FadeBuffer(buffer, bytesRecorded, isFloatingPointAudio);
}
AddToSampleAggregator(buffer, bytesRecorded, isFloatingPointAudio);
_mp3Writer?.Write(buffer, 0, bytesRecorded);
}
private void CropToFile(CropAudioRequest message, string fileName)
{
var reader = _factory.Create(message.Selection.Source);
using (reader as IDisposable)
using (var writer = new LameMP3FileWriter(fileName, reader.WaveFormat, BitRate))
{
var inputLength = (int)(message.Selection.Duration * reader.WaveFormat.AverageBytesPerSecond);
var bytesLeft = inputLength;
var buffer = new byte[reader.WaveFormat.AverageBytesPerSecond];
reader.CurrentTime = TimeSpan.FromSeconds(message.Selection.Start);
while (bytesLeft > 0)
{
var bytesRead = reader.Read(buffer, 0, Math.Min(buffer.Length, bytesLeft));
writer.Write(buffer, 0, bytesRead);
bytesLeft -= bytesRead;
}
}
_events.PublishOnUIThread(new CropAudioResponse(new Uri(fileName)));
}
private void Wavein_DataAvailable(object sender, WaveInEventArgs e)
{
float level = this.GetCurrentPeak();
if (level > voiceLevel)
{
recording = true;
silence = 0;
}
if (recording)
{
if (writer != null)
{
writer.Write(e.Buffer, 0, e.BytesRecorded);
}
else
{
currentFileName = GetNextFileName();
writer = new LameMP3FileWriter(tempFolder + currentFileName, wavein.WaveFormat, LAMEPreset.MEDIUM_FAST);
}
}
}
//============================================================================================================================================================
//file and audio operations
//============================================================================================================================================================
void saveTrimmedAudio()
{
setStatus(FileStatus.WAITING);
deleteFileIfExists(filename_name + filename_ext);
filename_name = textBoxFileName.Text;
byte[] selected_audio_array = getSelectedAsByteArray();
if (comboBoxFileType.SelectedIndex == 0)
{
filename_ext = ".wav";
WaveFileWriter writer = new WaveFileWriter(filename_name + filename_ext, wave_format);
writer.Write(selected_audio_array, 0, selected_audio_array.Length);
writer.Dispose();
}
else
{
int bitrate;
if (comboBoxFileType.SelectedIndex == 1)
{
bitrate = 320;
}
else
{
bitrate = 192;
}
filename_ext = ".mp3";
LameMP3FileWriter writer = new LameMP3FileWriter(filename_name + filename_ext, wave_format, bitrate);
writer.Write(selected_audio_array, 0, selected_audio_array.Length);
writer.Dispose();
}
recorded_audio_seconds = (float)selected_audio_array.Length / wave_format.AverageBytesPerSecond;
double file_mb = new FileInfo(filename_name + filename_ext).Length / 1024.0 / 1024.0;
toolStripStatusLabel_status.Text = "Selected length: " + recorded_audio_seconds.ToString("0.0") + " sec | File size: " + file_mb.ToString("0.00") + " MB";
setStatus(FileStatus.READY);
}
private void WaveSourceDataAvailableHandler(object sender, WaveInEventArgs waveInEventArgs)
{
// as audio samples are provided by WaveIn, we hook in here
// and write them to disk, encoding to MP3 on the fly
// using the _mp3Writer.
byte[] buffer = waveInEventArgs.Buffer;
int bytesRecorded = waveInEventArgs.BytesRecorded;
if (_fader != null && _fader.Active)
{
// we're fading out...
_fader.FadeBuffer(buffer, bytesRecorded);
}
for (int index = 0; index < bytesRecorded; index += 2)
{
short sample = (short)((buffer[index + 1] << 8) | buffer[index + 0]);
float sample32 = sample / 32768F;
_sampleAggregator.Add(sample32);
}
_mp3Writer.Write(buffer, 0, bytesRecorded);
}
/// <summary>
/// NAudio Event to handle recorded data
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void DataAvailableEvent(object sender, WaveInEventArgs e)
{
//Write recorded data to MP3 writer
wri.Write(e.Buffer, 0, e.BytesRecorded);
byte[] buffer = null;
int readCount = 0;
outStream.Position = pos;
// Read buffer
buffer = new byte[BufferSize];
readCount = outStream.Read(buffer, 0, BufferSize);
while (readCount > 0)
{
pos += readCount;
//Stream data to each connected users
activeContexts.ToList().ForEach(context =>
{
if (context.Value.Context.Response.IsClientConnected)
{
try
{
context.Value.Context.Response.OutputStream.Write(buffer, 0, readCount);
context.Value.Context.Response.Flush();
}
catch
{
//Swallow since client can disconnect when flushing and streaming to other clients shouldn't be affected
}
}
});
readCount = outStream.Read(buffer, 0, BufferSize);
}
}
/*
* Record Method
*/
static void OnDataAvailable(object sender, WaveInEventArgs e)
{
writer.Write(e.Buffer, 0, e.BytesRecorded);
}
private void BtnSave_Click(object sender, EventArgs e)
{
if (!_usingCustomPath && File.Exists(saveLocation.Text) &&
MessageBox.Show("A file with the same name exists, overwrite?", "File exists", MessageBoxButtons.YesNo,
MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.No)
{
return;
}
btnSave.Enabled = false;
var tag = new ID3TagData
{
Title = _title.Text.Trim(),
Artist = _speaker.Text.Trim(),
Album = _series.Text.Trim(),
Year = $"{Recorder.StartTime.Year:#0000}{Recorder.StartTime.Month:#00}{Recorder.StartTime.Day:#00}",
Comment = _passage.Text,
AlbumArtist = _service.Text.Trim(),
Genre = "swec.org.au"
};
TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.Normal);
TaskbarManager.Instance.SetProgressValue(0, 1);
using (var inputWave = new WaveFileReader(Recorder.FilePath))
using (var compressor = new SimpleCompressorStream(inputWave)
{
Attack = (float)1.5,
Enabled = true,
Threshold = 10,
Ratio = 4,
MakeUpGain = -3
})
using (var writer = new LameMP3FileWriter(saveLocation.Text + ".compressed.mp3", inputWave.WaveFormat,
LAMEPreset.MEDIUM,
tag))
{
writer.MinProgressTime = 0;
writer.OnProgress += (w, i, o, f) =>
{
if (f)
{
Close();
}
else
{
UpdateProgressBar(i, inputWave.Length);
}
};
var bytesPerMillisecond = inputWave.WaveFormat.AverageBytesPerSecond / 1000;
var startPos = (int)waveform.TimeStart.TotalMilliseconds * bytesPerMillisecond;
var endBytes = (int)waveform.TimeEnd.TotalMilliseconds * bytesPerMillisecond;
endBytes = endBytes - endBytes % inputWave.WaveFormat.BlockAlign;
var endPos = (int)inputWave.Length - endBytes;
inputWave.Position = startPos - startPos % inputWave.WaveFormat.BlockAlign;
var buffer = new byte[1024];
while (inputWave.Position < endPos)
{
var bytesRequired = (int)(endPos - inputWave.Position);
if (bytesRequired > 0)
{
var bytesToRead = Math.Min(bytesRequired, buffer.Length);
var bytesRead = compressor.Read(buffer, 0, bytesToRead);
if (bytesRead > 0)
{
writer.Write(buffer, 0, bytesRead);
}
}
}
}
using (var inputWave = new WaveFileReader(Recorder.FilePath))
using (var writer = new LameMP3FileWriter(saveLocation.Text, inputWave.WaveFormat, LAMEPreset.MEDIUM,
tag))
{
inputWave.CopyTo(writer);
}
}
private void OnDataRead(object sender, DataReadEventArgs args, LameMP3FileWriter writer)
{
writer.Write(args.Data, 0, (int)args.DataSize);
}
//------------------------------------------------------------------------------------------------------------------------
public void Write(byte[] mp3data)
{
lock (this)
lameMp3wr.Write(mp3data, 0, mp3data.Length);
}