public static byte[] EncodeCwav(byte[] wavData)
{
if (!ThirdPartyTools.CtrWaveConveter.Present)
{
return(EmptyData);
}
using (var sourceStream = new MemoryStream(wavData))
//
using (var tempBcwav = new TempFile("bcwav"))
using (var tempWav = new TempFile("wav"))
//
{
using (var tempWavStream = File.Open(tempWav.FilePath, FileMode.Create))
{
if (Settings.Default.EXP_ResampleWav)
{
var nwf = new WaveFormat(22050, 8, 1); //22Khz Mono PCM8
var wr = new WaveFileReader(sourceStream);
var conv = new WaveFormatConversionStream(nwf, wr);
conv.CopyTo(tempWavStream);
}
else
{
sourceStream.CopyTo(tempWavStream);
}
tempWavStream.Flush(true);
}
try
{
var psi = new ProcessStartInfo
{
UseShellExecute = false,
CreateNoWindow = true,
WindowStyle = ProcessWindowStyle.Hidden,
FileName = ThirdPartyTools.CtrWaveConveter.Path,
Arguments = $"-o \"{tempBcwav.FilePath}\" \"{tempWav.FilePath}\""
};
var process = Process.Start(psi);
process.WaitForExit();
using (var tempBcwavStream
= File.Open(tempBcwav.FilePath, FileMode.Open))
{
byte[] converted = new byte[tempBcwavStream.Length];
tempBcwavStream.Read(converted, 0, converted.Length);
return(converted);
}
}
catch
{
return(EmptyData);
}
}
}
// Method to convert audio files
private void ConvertAudio_button_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.DefaultExt = ".wav"; // Default file extension
dlg.Filter = "Audio documents (.wav)|*.wav"; // Filter files by extension
dlg.InitialDirectory = TransformFilePath.GetParentDirectoryPath() + @"\Audio";
dlg.Title = "Load audio to convert";
string noiseToConvertFilePath;
// Show save file dialog box
bool?result = dlg.ShowDialog();
// Process save file dialog box results
if (result == true)
{
noiseToConvertFilePath = dlg.FileName;
}
else
{
return;
}
// ask for destination
SaveFileDialog sfd = new SaveFileDialog();
sfd.DefaultExt = ".wav";
sfd.InitialDirectory = TransformFilePath.GetParentDirectoryPath() + @"\Audio";
sfd.Title = "Save new audio";
string newNoise;
// Show save file dialog box
result = sfd.ShowDialog();
// Process save file dialog box results
if (result == true)
{
newNoise = sfd.FileName;
}
else
{
return;
}
// convert existing file into a new one with 'desired' Hz
using (var reader = new WaveFileReader(noiseToConvertFilePath))
{
var newFormat = new WaveFormat(desiredHz, 16, 1);
using (var conversionStream = new WaveFormatConversionStream(newFormat, reader))
{
WaveFileWriter.CreateWaveFile(newNoise, conversionStream);
}
}
}
private void processToolStripMenuItem_Click(object sender, EventArgs e)
{
if (Wave == null)
{
Stream audioStream = Recorder.GetRecordingStream();
audioStream.Position = 0;
Wave = new WaveFormatConversionStream(WaveFormat, new Wave32To16Stream(new WaveFileReader(audioStream)));
}
ProcessAudio();
}
private static byte[] LoadMp3(Stream stream, out int channels, out int bits, out int rate)
{
using (var mp3 = new Mp3FileReader(stream))
{
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
return(LoadWave(pcm, out channels, out bits, out rate));
}
}
}
public void CanEncodeGsm()
{
using (var reader = CreatePcmTestStream())
{
using (var gsm = new WaveFormatConversionStream(new Gsm610WaveFormat(), reader))
{
WaveFileWriter.CreateWaveFile(@"C:\Users\Mark\Code\CodePlex\gsm.wav", gsm);
}
}
}
public void Graph()
{
if (inputpath.EndsWith(".mp3"))
{
WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(inputpath));
stream = new BlockAlignReductionStream(pcm);
}
graphWave.WaveStream = stream;
graphWave.FitToScreen();
}
public void Mp3ToWavConvert(string pathIn, string pathOut)
{
using (Mp3FileReader mp3 = new Mp3FileReader(pathIn))
{
using (WaveStream wave = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.CreateWaveFile(pathOut, wave);
}
}
}
private static MemoryStream Mp3ToWav(Stream mp3File)
{
using Mp3FileReader reader = new Mp3FileReader(mp3File);
using WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader);
MemoryStream ms = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(ms, pcmStream);
ms.Position = 0;
return(ms);
}
//uses nAudio to do magic with sounds
public void ConvertMp3ToWav(string sourceFile, string outputFile)
{
using (Mp3FileReader mp3 = new Mp3FileReader(sourceFile))
{
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.CreateWaveFile(outputFile, pcm);
}
}
}
public static void ConvertMp3ToWav(string mp3, string wav)
{
using (var mp3_ = new Mp3FileReader(mp3))
{
using (var pcm = WaveFormatConversionStream.CreatePcmStream(mp3_))
{
WaveFileWriter.CreateWaveFile(wav, pcm);
}
}
}
BinaryReader startMP3()
{
var read = new Mp3FileReader(stream);
WaveStream convertedStream = WaveFormatConversionStream.CreatePcmStream(read);
channels = (ushort)convertedStream.WaveFormat.Channels;
sampleRate = (uint)convertedStream.WaveFormat.SampleRate;
bitrate = (ushort)convertedStream.WaveFormat.BitsPerSample;
return(new BinaryReader(convertedStream));
}
public static void PlayMP3(string path)
{
WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(path));
BlockAlignReductionStream stream = new BlockAlignReductionStream(pcm);
DirectSoundOut output = new DirectSoundOut();
output.Init(stream);
output.Play();
}
public static void MP3toWAV(string mp3Path, string wavPath)
{
using (Mp3FileReader mp3 = new Mp3FileReader(mp3Path))
{
using (WaveStream wave = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.CreateWaveFile(wavPath, wave);
}
}
}
private byte[] ConvertMp3ToWav(byte[] data)
{
using (var ms = new MemoryStream())
using (var mp3 = new Mp3FileReader(new MemoryStream(data)))
using (var pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.WriteWavFileToStream(ms, pcm);
return(ms.ToArray());
}
}
public static void Mp3ToWav(string path, string outputFile)
{
Mp3FileReader reader = new Mp3FileReader(path);
{
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
WaveFileWriter.CreateWaveFile(outputFile, pcmStream);
}
}
}
public static void ConvertMp3ToWav(string _inPath_, string _outPath_)
{
using (var mp3 = new Mp3FileReader(_inPath_))
{
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.CreateWaveFile(_outPath_, pcm);
}
}
}
private static WaveChannel32 OpenMp3Stream(string fileName)
{
WaveChannel32 inputStream;
WaveStream mp3Reader = new Mp3FileReader(fileName);
WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(mp3Reader);
WaveStream blockAlignedStream = new BlockAlignReductionStream(pcmStream);
inputStream = new WaveChannel32(blockAlignedStream);
return(inputStream);
}
public static void NAudioMp3ToWav(string mp3File, string outwavFile)
{
using (Mp3FileReader reader = new Mp3FileReader(mp3File))
{
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
WaveFileWriter.CreateWaveFile(outwavFile, pcmStream);
}
}
}
public static VorbisWaveReader Mp3ToOgg(string path)
{
using (var mp3 = new Mp3FileReader(path))
{
using (var pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
return(WavToOgg(pcm));
}
}
}
public static byte[] Mp3ToWav(byte[] MP3)
{
using (MemoryStream INPUT = new MemoryStream(MP3))
using (Mp3FileReader mp3 = new Mp3FileReader(INPUT))
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
using (MemoryStream OUTPUT = new MemoryStream()) {
WaveFileWriter.WriteWavFileToStream(OUTPUT, pcm);
return(OUTPUT.ToArray());
}
}
//mp3 converter to wav file
private void Mp3ToWav(string mp3File, string output)
{
using (Mp3FileReader reader = new Mp3FileReader(mp3File))
{
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
WaveFileWriter.CreateWaveFile(output, pcmStream);
}
}
}
private static void ConvertMp3ToWav(Stream sourceStream, string _outPath_)
{
using (Mp3FileReader mp3 = new Mp3FileReader(sourceStream))
{
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.CreateWaveFile(_outPath_, pcm);
}
}
}
private static void MP3ToWav(string mp3file, string wavfile)
{
using (MediaFoundationReader reader = new MediaFoundationReader(mp3file))
{
using (WaveStream convertedStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
WaveFileWriter.CreateWaveFile(wavfile, convertedStream);
}
}
}
/// <summary>
/// Resample wavefile to new waveformat and save output file
/// </summary>
/// <param name="wavInFilePath">input audiofile</param>
/// <param name="wavOutFilePath">output wavefile</param>
/// <param name="waveFormat">waveformat</param>
public static void ResampleWav(string wavInFilePath, string wavOutFilePath, WaveFormat waveFormat)
{
using (var reader = new WaveFileReader(wavInFilePath))
{
using (var conversionStream = new WaveFormatConversionStream(waveFormat, reader))
{
WaveFileWriter.CreateWaveFile(wavOutFilePath, conversionStream);
}
}
}
public void mp3ToWav(string mp3FilePath)
{
using (Mp3FileReader reader = new Mp3FileReader(mp3FilePath))
{
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
WaveFileWriter.CreateWaveFile(mp3Path, pcmStream);
}
}
}
public void CanEncodeGsm()
{
using (var reader = CreatePcmTestStream())
{
using (var gsm = new WaveFormatConversionStream(new Gsm610WaveFormat(), reader))
{
WaveFileWriter.CreateWaveFile(Path.Combine(tempFolder, "gsm.wav"), gsm);
}
}
}
public void ConvertMp3ToWav(string _inPath_)
{
using (Mp3FileReader mp3 = new Mp3FileReader(_inPath_))
{
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.CreateWaveFile("Audio.wav", pcm);
}
}
}
// Resample
private void saveWavButton_Click(object sender, EventArgs e)
{
int sampleRate, bitDepth, channels;
try {
if (this.currentAudio == null)
{
throw new Exception("Вы не выбрали файл для ресэмплинга.");
}
sampleRate = int.Parse(audioSampleRateInfo.Text);
} catch (Exception ex) {
MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
bitDepth = int.Parse(audioBitDepthInfo.Text);
channels = (audioChannelsInfo.SelectedIndex == 0) ? 1 : 2;
SaveFileDialog save = new SaveFileDialog();
save.Filter = "Wave File (*.wav)|*.wav;";
if (save.ShowDialog() != DialogResult.OK)
{
return;
}
WaveFormat format = new WaveFormat(sampleRate, bitDepth, 1);
WaveFormatConversionStream convertedStream = null;
try {
if (this.currentAudio.Format == AudioFormats.MP3)
{
MP3File afile = this.currentAudio as MP3File;
convertedStream = new WaveFormatConversionStream(format, afile.Reader);
}
else
{
WaveFile afile = this.currentAudio as WaveFile;
convertedStream = new WaveFormatConversionStream(format, afile.Reader);
}
} catch (Exception) {
MessageBox.Show("Невозможно сконвертировать в данный формат.", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
WaveFileWriter.CreateWaveFile(save.FileName, convertedStream);
DialogResult dres = MessageBox.Show("Аудиофайл успешно сохранен. Открыть файл?", "Файл сохранен", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dres == DialogResult.Yes)
{
WaveFileReader reader = new WaveFileReader(save.FileName);
WaveStream pcm = new WaveChannel32(reader);
BlockAlignReductionStream stream = new BlockAlignReductionStream(pcm);
AudioFile file = new WaveFile(reader, stream, save.FileName);
this.files.Add(file);
this.addFileToListView(file);
this.initAudio(file);
}
}
public void WavPcm8ToPcm16(string outPutPath_pcm16, string outPutPath)
{
using (WaveFileReader reader = new WaveFileReader(outPutPath_pcm16))
{
var newFormat = new WaveFormat(8000, 16, 1);
using (var conversionStream = new WaveFormatConversionStream(newFormat, reader))
{
WaveFileWriter.CreateWaveFile(outPutPath, conversionStream);
}
}
}
private void loadButton_Click(object sender, EventArgs e)
{
progressBar1.Value = 0;
if (openFileDialog1.ShowDialog() != DialogResult.OK)
{
return;
}
output?.Stop();
output?.Dispose();
timer?.Stop();
var fname = openFileDialog1.FileName;
if (fname.EndsWith(".mp3"))
{
mp3FileReader = new Mp3FileReader(fname);
pcm = WaveFormatConversionStream.CreatePcmStream(mp3FileReader);
}
else
{
MessageBox.Show("File is not mp3!");
return;
}
granularity = (int)numericUpDown1.Value;
textBoxMp3.Text = fname;
stream = new BlockAlignReductionStream(pcm);
output = new WaveOut();
output.DesiredLatency = 500;
output.Init(stream);
waveViewer1.WaveStream = stream;
trackBar1.Maximum = (int)(stream.TotalTime.TotalSeconds * (1000.0 / granularity));
trackBar1.Value = 0;
trackBar2.Maximum = (int)(stream.TotalTime.TotalSeconds * (1000.0 / granularity));
trackBar2.Value = 0;
trackBar3.Maximum = (int)(stream.TotalTime.TotalSeconds * (1000.0 / granularity));
trackBar3.Value = trackBar3.Maximum;
timer = new Timer();
timer.Interval = (int)(granularity / 2 - 10);
timer.Tick += new EventHandler(timer_Tick);
textBox1.Text = TimeSpan.FromMilliseconds(0).ToShortForm();
textBox2.Text = TimeSpan.FromMilliseconds(stream.TotalTime.TotalMilliseconds).ToShortForm();
}
