private void RenderWaveform()
{
if (reader != null)
{
reader.Close();
reader.Dispose();
}
GenerateWindow();
waveRender.SamplesPerPixel = 2;
waveRender.AutoScaleDimensions = new SizeF();
reader = new WaveFileReader(tempOutputFilePath);
waveRender.WaveStream = reader;
}
public List <List <double> > MF(string location)
{
frame = (int)(waveFormat.SampleRate * ((float)BufferMilliseconds / 1000));
Ini();
List <List <double> > mfcc = new List <List <double> >();
WaveFileReader waveReader = new WaveFileReader(location);
byte[] buffer = new byte[frame * 2];
while ((waveReader.Length - waveReader.Position) > (frame * 2))
{
waveReader.Read(buffer, 0, buffer.Length);
Int16[] aux = Int16Convertor(buffer);
double[,] dsp = Dsp(aux);
double medie = MedieFrame(dsp);
if (medie > 120)
{
mfcc.Add(MFcc(buffer));
}
}
waveReader.Close();
return(mfcc);
}
private bool ProcessPairWaveForm(WaveformGenerationParams argument)
{
bool isCancel = false;
WaveFileReader forwardStream = new WaveFileReader(new MemoryStream(argument.Path));
WaveFileReader backStream = new WaveFileReader(new MemoryStream(argument.BackPath));
WaveChannel32 forwardChannel = new WaveChannel32(forwardStream);
WaveChannel32 backChannel = new WaveChannel32(backStream);
backChannel.Sample += waveStream_Sample;
forwardChannel.Sample += waveStream_Sample;
long frameLength = 2 * backChannel.Length / argument.Points;
frameLength = frameLength - frameLength % backChannel.WaveFormat.BlockAlign;
waveformAggregator = new SampleAggregator((int)(frameLength / backChannel.WaveFormat.BlockAlign));
float[] numArray = new float[argument.Points];
byte[] buffer = new byte[frameLength];
int factPointsCount = argument.Points / 2;
for (int i = 0; i < factPointsCount; i++)
{
backChannel.Read(buffer, 0, buffer.Length);
numArray[i * 2] = waveformAggregator.LeftMaxVolume * verticalScale;
forwardChannel.Read(buffer, 0, buffer.Length);
numArray[i * 2 + 1] = waveformAggregator.LeftMaxVolume * verticalScale;
if (this.waveformGenerateWorker.CancellationPending)
{
isCancel = true;
break;
}
}
float[] finalClonedData = (float[])numArray.Clone();
Application.Current.Dispatcher.Invoke(new Action(() => this.WaveformData = finalClonedData));
forwardChannel.Close();
forwardChannel.Dispose();
forwardChannel = null;
backChannel.Close();
backChannel.Dispose();
backChannel = null;
forwardStream.Close();
forwardStream.Dispose();
forwardStream = null;
backStream.Close();
backStream.Dispose();
backStream = null;
return(isCancel);
}
private void PrepareClip(String song, int[] times)
{
Mp3ToWav(song, song + "wav");
WaveFileReader reader = new WaveFileReader(song + "wav");
WaveFileWriter writer = new WaveFileWriter(song + "mix", reader.WaveFormat);
TimeSpan TotalTime = reader.TotalTime;
int audlen = (int)TotalTime.TotalSeconds;
for (int i = 0; i < times.Length; i += 2)
{
if (i == 0 && times[i] > 0)
{
double silence = times[i] * 1000;
InsertSilence(writer, silence);
}
TrimWavFile(reader, writer, new TimeSpan(0, 0, times[i]), new TimeSpan(0, 0, audlen - times[i + 1]));
if (i + 2 < times.Length)
{
double silence = (times[i + 2] - times[i + 1]) * 1000;
InsertSilence(writer, silence);
}
}
writer.Close();
reader.Close();
toMix.Add(new WaveFileReader(song + "mix"));
}
private void Button_Click_3(object sender, RoutedEventArgs e)
{
var file = new AutoDisposeFileReader(new AudioFileReader(FileName));
var trimmed = new OffsetSampleProvider(file);
int totrim = pwfc.WaveFormDisplay.Values.First(n => n.Value.Item1 > NAudio.Utils.Decibels.DecibelsToLinear(SilenceThreshold) && n.Value.Item2 < NAudio.Utils.Decibels.DecibelsToLinear(SilenceThreshold)).Key;
pwfc.SelectionStart = pwfc.XLocationToTimeSpan(pwfc.WaveFormDisplay.Values.First(n => n.Value.Item1 > NAudio.Utils.Decibels.DecibelsToLinear(SilenceThreshold) && n.Value.Item2 < NAudio.Utils.Decibels.DecibelsToLinear(SilenceThreshold)).Key);
pwfc.SelectionEnd = pwfc.XLocationToTimeSpan(pwfc.WaveFormDisplay.Values.Reverse().First(n => n.Value.Item1 > NAudio.Utils.Decibels.DecibelsToLinear(SilenceThreshold) && n.Value.Item2 < NAudio.Utils.Decibels.DecibelsToLinear(SilenceThreshold)).Key);
pwfc.DrawSelectionRect();
trimmed.SkipOver = TimeSpan.Zero;
trimmed.Take = pwfc.SelectionEnd;
WaveFileWriter.CreateWaveFile(@"c:\temp\trimmed.wav", new SampleToWaveProvider(trimmed));
pwfc.ClearWaveForm();
pwfc.AddNewWaveForm(Color.FromRgb(67, 217, 150), SampleRate, BitsPerSample, Channels);
FileName = @"c:\temp\trimmed.wav";
MemoryStream ms = new MemoryStream(File.ReadAllBytes(FileName));
var file2 = new WaveFileReader(ms);
new Task(() =>
{
var player = new WaveOutEvent();
player.Init(file2);
player.Play();
while (player.PlaybackState != PlaybackState.Stopped)
{
System.Threading.Thread.Sleep(100);
}
file2.Close();
}).Start();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var file = new AudioFileReader(FileName);
var trimmed = new OffsetSampleProvider(file);
trimmed.SkipOver = pwfc.SelectionStart;
trimmed.Take = pwfc.SelectionEnd - pwfc.SelectionStart;
WaveFileWriter.CreateWaveFile(@"c:\temp\trimmed.wav", new SampleToWaveProvider(trimmed));
pwfc.ClearWaveForm();
pwfc.AddNewWaveForm(Color.FromRgb(67, 217, 150), SampleRate, BitsPerSample, Channels);
FileName = @"c:\temp\trimmed.wav";
MemoryStream ms = new MemoryStream(File.ReadAllBytes(FileName));
var file2 = new WaveFileReader(ms);
new Task(() =>
{
var player = new WaveOutEvent();
player.Init(file2);
player.Play();
while (player.PlaybackState != PlaybackState.Stopped)
{
System.Threading.Thread.Sleep(100);
}
file2.Close();
}).Start();
}
//Метод для извлечения массива байтов из указанного файла WAV
public static byte[] Load24bitWaveFormFromFile(String filePath)
{
WaveFileReader waveFileReader = null; //Из библиотеки NAudio
try
{
waveFileReader = new WaveFileReader(filePath); //Пробуем открыть файл
if (waveFileReader.WaveFormat.BitsPerSample == 24) //Проверяем разрядность
{
byte[] byteBuffer = new byte[waveFileReader.Length]; //Создаём массив
waveFileReader.Read(byteBuffer, 0, byteBuffer.Length); //Считываем туда файл
return(byteBuffer); //Передаём готовый массив наружу
}
else
{
throw new Exception("Параметры данного звукового файла не подходят");
}
}
catch (IOException)
{
throw new Exception("Программа не может открыть данный файл");
}
finally
{
if (waveFileReader != null)
{
waveFileReader.Close();
}
}
}
/// <summary>
/// Mixes two wav files to a single wav file. (Unused).
/// </summary>
public void mix()
{
window.lockForMixing();
WaveFileReader reader1 = new WaveFileReader(file1);
WaveFileReader reader2 = new WaveFileReader(file2);
int maxSampleRate = Math.Max(reader1.WaveFormat.SampleRate, reader2.WaveFormat.SampleRate);
WaveFormat format = new WaveFormat(maxSampleRate, 1);
MediaFoundationResampler resampler1 = new MediaFoundationResampler(reader1, format);
var input1 = resampler1.ToSampleProvider();
MediaFoundationResampler resampler2 = new MediaFoundationResampler(reader2, format);
var input2 = resampler2.ToSampleProvider();
ISampleProvider[] provider = { input1, input2 };
MixingSampleProvider mixer = new MixingSampleProvider(provider);
WaveFileWriter.CreateWaveFile16(mixfile, mixer);
resampler1.Dispose();
resampler2.Dispose();
reader1.Close();
reader2.Close();
reader1.Dispose();
reader2.Dispose();
window.unlock();
}
private void HandleFile(string filename)
{
try
{
FileInfo file = new FileInfo(filename);
string path = System.IO.Path.Combine(file.Directory.FullName, "output");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
AudioFileReader waveFileReader = new AudioFileReader(filename);
int bytesPerMillisecond = waveFileReader.WaveFormat.AverageBytesPerSecond / 1000;
int startPos = GetSilenceTime(waveFileReader, SilenceLocation.Start, config.Config.SilenceThreshold);
int endPos2 = GetSilenceTime(waveFileReader, SilenceLocation.End, config.Config.SilenceThreshold);
endPos2 -= endPos2 % 4;
WaveFileWriter waveFileWriter = new WaveFileWriter(filename + ".temp.wav", waveFileReader.WaveFormat);
TrimSound(waveFileReader, waveFileWriter, startPos, endPos2);
byte[] temp = new byte[bytesPerMillisecond * 500];
waveFileWriter.Write(temp, 0, temp.Length);
waveFileWriter.Close();
waveFileReader.Close();
WaveFileReader filereader = new WaveFileReader(filename + ".temp.wav");
WaveFormat format = new WaveFormat(8000, 16, 1);
MediaFoundationResampler resample = new MediaFoundationResampler(filereader, format);
WaveFileWriter.CreateWaveFile(System.IO.Path.Combine(path, file.Name.Replace(file.Extension, ".wav")), resample);
resample.Dispose();
filereader.Close();
File.Delete(filename + ".temp.wav");
}
catch (Exception)
{
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// The input file must be audio. If it is not or the format cannot be determined,
/// null is returned.
/// </summary>
/// ------------------------------------------------------------------------------------
public static WaveFormat GetNAudioWaveFormat(string audioFilePath)
{
WaveFileReader reader = null;
try
{
if (!GetDoesFileSeemToBeWave(audioFilePath))
{
return(null);
}
reader = new WaveFileReader(audioFilePath);
return(reader.WaveFormat);
}
catch { }
finally
{
if (reader != null)
{
reader.Close();
reader.Dispose();
}
}
return(null);
}
/// <summary>
/// Convert a WAV into MP3 file
/// </summary>
/// <param name="inputFile">Input WAV files path</param>
/// <param name="outputFile">Output MP3 file path</param>
/// <param name="id3Tag">MP3 tags</param>
public static void WavToMp3(string inputFile, string outputFile, ID3TagData id3Tag)
{
var reader = new WaveFileReader(inputFile);
var writer = new LameMP3FileWriter(outputFile, reader.WaveFormat, ExportQuality, id3Tag);
reader.CopyTo(writer);
writer.Close();
reader.Close();
}
public byte[] GenerateRadioMessageWavBytesFromFile(string fileName)
{
WaveFileReader voiceReader = new WaveFileReader(fileName);
ISampleProvider voiceProvider = voiceReader.ToSampleProvider();
byte[] bytes = DoRadioMix(voiceProvider, voiceReader.TotalTime);
voiceReader.Close(); voiceReader.Dispose();
return(bytes);
}
public static void Stop()
{
if (_waveIn == null)
{
return;
}
_waveOut.Stop();
_waveIn.Close();
_waveIn = null;
OnMusicStop?.Invoke(sender, null);
}
private void waveOut_PlaybackStopped(object sender, StoppedEventArgs e)
{
try
{
waveOut.Stop();
reader.Close();
reader = null;
}
catch
{
}
}
public static bool ConvertWavToMP3(string wavFile, string mp3file, Action <object, long, long, bool> handler)
{
using (WaveFileReader rdr = new WaveFileReader(wavFile))
using (LameMP3FileWriter wtr = new LameMP3FileWriter(mp3file, Helper.Audio.GetWavFormat(wavFile), LAMEPreset.VBR_90))
{
wtr.OnProgress += new NAudio.Lame.ProgressHandler(handler);
rdr.CopyTo(wtr);
rdr.Close();
wtr.Close();
}
return(true);
}
private void bPlay_Click(object sender, EventArgs e)
{
if (File.Exists(PathToFile))
{
var player = new WaveOutEvent();
var waveFile = new WaveFileReader(PathToFile);
_operation.PlayWaveFile(player, waveFile);
Thread.Sleep(2000);
waveFile.Flush();
waveFile.Close();
}
}
public Wave(string filename)
{
using (var reader = new WaveFileReader(filename))
{
mData = new byte[reader.Length];
var read = reader.Read(mData, 0, mData.Length);
mBitsPerSample = reader.WaveFormat.BitsPerSample;
mChannels = reader.WaveFormat.Channels;
mSampleRate = reader.WaveFormat.SampleRate;
reader.Close();
}
}
/// <summary>
/// Concat a list of WAV in a MP3 file
/// </summary>
/// <param name="inputFiles">List of input WAV files paths</param>
/// <param name="outputFile">Output MP3 file path</param>
/// <param name="id3Tag">MP3 tags</param>
public static void WavToMp3(List <string> inputFiles, string outputFile, ID3TagData id3Tag)
{
var writer = new LameMP3FileWriter(outputFile, TempWaveFormat, ExportQuality, id3Tag);
foreach (var inputFile in inputFiles)
{
var reader = new WaveFileReader(inputFile);
reader.CopyTo(writer);
reader.Close();
}
writer.Flush();
writer.Close();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// The input media file may be audio or video. If the waitMessage is null, then no
/// "progress" dialog box will be displayed during the conversion process.
/// </summary>
/// ------------------------------------------------------------------------------------
public static Exception ConvertToStandardPCM(string inputMediaFile,
string outputMediaFile, Control parent, string waitMessage)
{
Program.SuspendBackgroundProcesses();
Exception error = null;
WaveFileReader outputReader = null;
WaitCursor.Show();
var dlg = (waitMessage == null ? null : new LoadingDlg(waitMessage));
if (dlg != null)
{
dlg.Show(parent ?? Application.OpenForms[0]);
}
try
{
outputReader = ConvertToStandardPcmStream(inputMediaFile, outputMediaFile, null, out error);
return(error);
}
finally
{
if (outputReader != null)
{
outputReader.Close();
outputReader.Dispose();
}
if (error != null && File.Exists(outputMediaFile))
{
try
{
File.Delete(outputMediaFile);
}
catch (Exception e)
{
ErrorReport.ReportNonFatalException(e);
}
}
if (dlg != null)
{
dlg.Close();
dlg.Dispose();
}
Program.ResumeBackgroundProcesses(true);
WaitCursor.Hide();
}
}
/// <summary>
/// Converts a single wav file to a single mp3 file.
/// </summary>
public void startConvert()
{
if (File.Exists(infile))
{
WaveFileReader reader = new WaveFileReader(infile);
MediaType mediaType = MediaFoundationEncoder.SelectMediaType(AudioSubtypes.MFAudioFormat_MP3, reader.WaveFormat, 256000);
using (MediaFoundationEncoder encoder = new MediaFoundationEncoder(mediaType))
{
encoder.Encode(outfile, reader);
}
reader.Close();
reader.Dispose();
}
}
public virtual void PlayAudioFilePaused()
{
var wavFile = GetPathToWav();
WaveFileReader reader = new WaveFileReader(wavFile);
Wave16ToFloatProvider converter = new Wave16ToFloatProvider(reader);
_jackOut.Init(converter);
_jackOut.Play();
_jackOut.Pause();
Thread.Sleep(100);
_jackOut.Stop();
Assert.AreEqual(0, reader.Position);
reader.Close();
}
public static WaveFormat GetWavFormat(string file)
{
if (!File.Exists(file))
{
return(null);
}
using (WaveFileReader reader = new WaveFileReader(file))
{
WaveFormat wavForamt = reader.WaveFormat;
reader.Close();
return(wavForamt);
}
}
private void waveOut_PlayingStopped(object sender, EventArgs e)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new EventHandler(waveOut_PlayingStopped), sender, e);
}
else
{
_waveOut.Dispose();
_waveOut = null;
_reader.Close();
_reader = null;
}
}
public virtual void PlayAudioFile()
{
string wavFile = GetPathToWav();
WaveFileReader reader = new WaveFileReader(wavFile);
Wave16ToFloatProvider converter = new Wave16ToFloatProvider(reader);
Analyser analyser = new Analyser();
_client.ProcessFunc += analyser.AnalyseOutAction;
_jackOut.Init(converter);
_jackOut.Play();
Thread.Sleep(100);
_jackOut.Stop();
reader.Close();
Assert.AreNotEqual(0, analyser.NotEmptySamples);
}
public byte[] ReadSong(string path)
{
WaveStream stream = new WaveFileReader(path);
var buffer = new byte[1024];
using (var ms = new MemoryStream())
{
int bytesRead;
while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, bytesRead);
}
stream.Close();
return(ms.ToArray());
}
}
private void readRecordedFile()
{
WaveStream stream = new WaveFileReader(path);
byte[] buffer = new byte[1024];
int bytesRead;
MemoryStream ms = new MemoryStream();
while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, bytesRead);
}
recordedSong = ms.ToArray();
stream.Close();
//File.Delete(@"C:\Users\admin\Documents\Visual Studio 2015\Projects\AudioRecognitionService\AudioRecognitionService\temp.wav");
}
/// ------------------------------------------------------------------------------------
protected virtual byte[] GetAudioBufferToAppendTo(string waveFileName)
{
using (var stream = new WaveFileReader(waveFileName))
{
var buffer = new byte[stream.Length];
var count = (int)Math.Min(stream.Length, int.MaxValue);
int offset = 0;
while (stream.Read(buffer, offset, count) > 0)
{
offset += count;
}
stream.Close();
return(buffer);
}
}
private static void CreateSCD(string wavFilePath, string outputFile)
{
var streamName = Path.GetFileNameWithoutExtension(wavFilePath).Replace("-adpcm", "");
var wavData = StripWavHeader(File.ReadAllBytes(wavFilePath));
var waveFile = new WaveFileReader(wavFilePath);
var dummyScd = File.ReadAllBytes(SCD_HEADER_FILE);
using (var writer = new BinaryWriter(new MemoryStream(dummyScd)))
{
var totalFileSize = dummyScd.Length + wavData.Length;
// Total file size
writer.BaseStream.Position = 0x10;
writer.Write(totalFileSize);
// Stream name
writer.BaseStream.Position = 0x150;
writer.Write(Encoding.UTF8.GetBytes(streamName));
// Audio data size
writer.BaseStream.Position = 0x250;
writer.Write(wavData.Length);
// Channel count
writer.BaseStream.Position = 0x254;
writer.Write((uint)waveFile.WaveFormat.Channels);
// Sample rate
writer.BaseStream.Position = 0x258;
writer.Write((uint)waveFile.WaveFormat.SampleRate);
// Frame size / Block align
writer.BaseStream.Position = 0x27C;
writer.Write((short)waveFile.WaveFormat.BlockAlign);
}
waveFile.Close();
var finalScd = new byte[dummyScd.Length + wavData.Length];
Array.Copy(dummyScd, finalScd, dummyScd.Length);
Array.Copy(wavData, 0, finalScd, dummyScd.Length, wavData.Length);
File.WriteAllBytes(outputFile, finalScd);
}
private static string TrimAudioLength(string File)
{
TimeSpan TargetDuration = new TimeSpan(0, 29, 0); // 29 minutes
WaveFileReader reader = new WaveFileReader(File);
//Calculate Tempo
float PercentChange = CalculateTempo(reader.TotalTime, TargetDuration);
string FileOut = File.Replace(Settings.Default.SpeechCleanedDirectory, Settings.Default.TrimmedDirectory);
processWave(File, FileOut, 1 + PercentChange * 0.01f, 1.0f, 1.0f);
//AddIntroOutro(FileOut);
reader.Close();
return(FileOut);
}
public void TestNAudio()
{
using (var reader = new WaveFileReader("Sound\\CAU1.wav"))
{
//WaveFormatConversionStream conv = new WaveFormatConversionStream(WaveFormat.CreateCustomFormat(WaveFormatEncoding.Pcm, 8000, 1, 8000, 1, 8), reader);
var sp = new VolumeSampleProvider(reader.ToSampleProvider());
sp.Volume = 0.5f;
using (var writer = new WaveFileWriter("dv.wav", WaveFormat.CreateALawFormat(8000, 1)))
{
int sampleCount = (int)reader.SampleCount;
var buff = new float[sampleCount];
sp.Read(buff, 0, sampleCount);
writer.WriteSamples(buff, 0, sampleCount);
writer.Close();
}
reader.Close();
}
}
