/// <summary>
/// Read audio wavFile.
/// </summary>
/// <param name="wavFile">WAV File in each turn.</param>
public void ReadAudio(string wavFile)
{
lock (this.BotReplyList)
{
this.BotReplyList.Clear();
this.indexActivityWithAudio = 0;
}
if (this.appsettings.PushStreamEnabled)
{
int readBytes;
byte[] dataBuffer = new byte[MaxSizeOfTtsAudioInBytes];
WaveFileReader waveFileReader = new WaveFileReader(Path.Combine(this.appsettings.InputFolder, wavFile));
// Reading header bytes
int headerBytes = waveFileReader.Read(dataBuffer, 0, WavHeaderSizeInBytes);
while ((readBytes = waveFileReader.Read(dataBuffer, 0, BytesToRead)) > 0)
{
this.pushAudioInputStream.Write(dataBuffer, readBytes);
}
// When done, we forcibly write one second (32000 bytes) of silence
// to the stream, forcing the speech recognition service to segment.
Array.Clear(dataBuffer, 0, 32000);
this.pushAudioInputStream.Write(dataBuffer, 32000);
waveFileReader.Dispose();
}
else
{
GlobalPullStream.FilePullStreamCallback.ReadFile(Path.Combine(this.appsettings.InputFolder, wavFile));
}
}
private static void TrimWavFile(WaveFileReader reader, WaveFileWriter writer, int startPos, int endPos)
{
// set blockalign -> 8 pour 24 bit
Int32 blockalign = reader.WaveFormat.BlockAlign;
Int32 bytealign = 0;
// 4 = 1024 pour 16bit, sinon 6 pour 24bit, 384 car c'est divisible par 6 sans faire planter le pc
if (blockalign == 4)
{
bytealign = 1024;
}
else
{
bytealign = 384;
}
reader.Position = startPos;
byte[] buffer = new byte[bytealign];
while (reader.Position < endPos)
{
int bytesRequired = (int)(endPos - reader.Position);
if (bytesRequired > 0)
{
int bytesToRead = Math.Min(bytesRequired, buffer.Length);
int bytesRead = reader.Read(buffer, 0, bytesToRead);
if (bytesRead > 0)
{
// WriteData obsolète
writer.Write(buffer, 0, bytesRead);
}
}
}
}
public CachedAudioEffect(AudioEffectTypes audioEffect)
{
AudioEffectType = audioEffect;
var file = GetFile();
AudioEffectBytes = new byte[0];
if (file != null)
{
using (var reader = new WaveFileReader(file))
{
// Assert.AreEqual(16, reader.WaveFormat.BitsPerSample, "Only works with 16 bit audio");
if (reader.WaveFormat.BitsPerSample == 16 && reader.WaveFormat.Channels == 1)
{
AudioEffectBytes = new byte[reader.Length];
var read = reader.Read(AudioEffectBytes, 0, AudioEffectBytes.Length);
Logger.Info($"Read Effect {audioEffect} from {file} Successfully");
}
else
{
Logger.Info($"Unable to read Effect {audioEffect} from {file} Successfully - not 16 bits!");
}
}
}
else
{
Logger.Info($"Unable to find file for effect {audioEffect} in AudioEffects\\{FileNameLookup[(int) audioEffect]} ");
}
}
private void RenderFile()
{
SampleAggregator.RaiseRestart();
using (WaveFileReader reader = new WaveFileReader(this.voiceRecorderState.ActiveFile))
{
this.samplesPerSecond = reader.WaveFormat.SampleRate;
SampleAggregator.NotificationCount = reader.WaveFormat.SampleRate / 10;
byte[] buffer = new byte[1024];
WaveBuffer waveBuffer = new WaveBuffer(buffer);
waveBuffer.ByteBufferCount = buffer.Length;
int bytesRead;
do
{
bytesRead = reader.Read(waveBuffer, 0, buffer.Length);
int samples = bytesRead / 2;
for (int sample = 0; sample < samples; sample++)
{
if (bytesRead > 0)
{
sampleAggregator.Add(waveBuffer.ShortBuffer[sample] / 32768f);
}
}
} while (bytesRead > 0);
int totalSamples = (int)reader.Length / 2;
TotalWaveFormSamples = totalSamples / sampleAggregator.NotificationCount;
SelectAll();
}
audioPlayer.LoadFile(this.voiceRecorderState.ActiveFile);
}
private static void TrimWavFile(WaveFileReader reader, WaveFileWriter writer, int startPos, int endPos)
{
reader.Position = startPos;
byte[] buffer = new byte[1024];
while (reader.Position < endPos)
{
int bytesRequired = (int)(endPos - reader.Position);
if (bytesRequired > 0)
{
int bytesToRead = Math.Min(bytesRequired, buffer.Length);
int bytesRead = reader.Read(buffer, 0, bytesToRead);
if (bytesRead > 0)
{
writer.Write(buffer, 0, bytesRead);
}
}
}
if (reader != null)
{
reader.Dispose();
}
if (writer != null)
{
writer.Dispose();
}
}
public ActionResult Reverse(string name)
{
var a = name.Split('.');
string newName = a[a.Length - 2];
if (a[a.Length - 1] == "mp3")
{
using (Mp3FileReader reader = new Mp3FileReader(HttpContext.Server.MapPath("~/Content/" + name)))
{
WaveFileWriter.CreateWaveFile(HttpContext.Server.MapPath("~/Content/" + newName + ".wav"), reader);
}
}
using (WaveFileReader reader = new WaveFileReader(HttpContext.Server.MapPath("~/Content/" + newName + ".wav")))
{
int blockAlign = reader.WaveFormat.BlockAlign;
using (WaveFileWriter writer = new WaveFileWriter(HttpContext.Server.MapPath("~/Content/" + newName + "_rev.wav"), reader.WaveFormat))
{
byte[] buffer = new byte[blockAlign];
long samples = reader.Length / blockAlign;
for (long sample = samples - 1; sample >= 0; sample--)
{
reader.Position = sample * blockAlign;
reader.Read(buffer, 0, blockAlign);
writer.WriteData(buffer, 0, blockAlign);
}
}
}
return(Json(new { name1 = newName + "_rev.wav" }, JsonRequestBehavior.AllowGet));
}
private void TestThread()
{
int BufferMilliseconds = 20;
var format = new WaveFormat(8000, 16, WaveIn.GetCapabilities(0).Channels);
int chunksize = BufferMilliseconds * format.AverageBytesPerSecond / 1000;
if (chunksize % format.BlockAlign != 0)
{
chunksize -= chunksize % format.BlockAlign;
}
using (WaveFileReader reader = new WaveFileReader("D:\\dev\\RicoChat\\RicoChat\\sfx\\trumpet.wav"))
{
byte[] bytesBuffer = new byte[reader.Length];
int read = reader.Read(bytesBuffer, 0, bytesBuffer.Length);
int j = 0;
for (int i = 0; i < bytesBuffer.Length - chunksize; i += chunksize)
{
byte[] b2 = new byte[chunksize];
Buffer.BlockCopy(bytesBuffer, i, b2, 0, chunksize);
hand.SendData(b2, chunksize);
Thread.Sleep(BufferMilliseconds);
//j++;
//if (j > 10)
// break;
}
}
}
private static void TrimWavFile(WaveFileReader reader,
WaveFileWriter writer,
int startPos,
int endPos)
{
reader.Position = startPos;
byte[] writeBuffer = new byte[1024];
long position = reader.Position;
while (position < endPos)
{
int bytesRequired = (int)(endPos - position);
if (bytesRequired > 0)
{
int bytesToRead = Math.Min(bytesRequired, writeBuffer.Length);
int bytesRead = reader.Read(writeBuffer, 0, bytesToRead);
if (bytesRead > 0)
{
writer.Write(writeBuffer, 0, bytesRead);
position = reader.Position;
}
else
{
// We have overrun the original audio. Fill remaining duration with silence.
writer.Write(new byte[bytesToRead], 0, bytesToRead);
position += bytesToRead;
}
}
}
}
public void CanLoadAndReadVariousProblemWavFiles()
{
string testDataFolder = @"C:\Users\Mark\Downloads\NAudio";
if (!Directory.Exists(testDataFolder))
{
Assert.Ignore("{0} not found", testDataFolder);
}
foreach (string file in Directory.GetFiles(testDataFolder, "*.wav"))
{
string wavFile = Path.Combine(testDataFolder, file);
Debug.WriteLine(String.Format("Opening {0}", wavFile));
using (var reader = new WaveFileReader(wavFile))
{
byte[] buffer = new byte[reader.WaveFormat.AverageBytesPerSecond];
int bytesRead;
int total = 0;
do
{
bytesRead = reader.Read(buffer, 0, buffer.Length);
total += bytesRead;
} while (bytesRead > 0);
Debug.WriteLine(String.Format("Read {0} bytes", total));
}
}
}
private void ExtractSongToFile(byte[] reusedBuffer, WaveFileReader groupReader, WaveFileWriter songWriter, SongInfo song)
{
DateTime songEndTime = song.EndTime ?? Group.EndTime;
TimeSpan songDuration = songEndTime - song.StartTime;
int bytesPerMillisecond = Group.WaveFormat.AverageBytesPerSecond / 1000;
long songLength = (long)songDuration.TotalMilliseconds * bytesPerMillisecond;
long songStartPos = groupReader.Position;
long songEndPos = songStartPos + songLength;
//Stream variables use longs not ints, so use longs where possible/relevant
//However, Stream.Read() takes ints, so we have to cast back there (with a checked cast)
//_logger.Log($"songEndTime: {songEndTime}, songDuration: {songDuration}, bytesPerMillisecond: {bytesPerMillisecond}, songLength: {songLength}, songStartPos: {songStartPos}, songEndPos {songEndPos}.");
while (true)
{
long songBytesRemaining = songEndPos - groupReader.Position;
long readerBytesRemaining = groupReader.Length - groupReader.Position;
//_logger.Log($"songBytesRemaining: {songBytesRemaining}, readerBytesRemaining: {readerBytesRemaining}");
if (songBytesRemaining <= 0 || readerBytesRemaining <= 0)
{
break;
}
int numRead = groupReader.Read(
reusedBuffer,
offset: 0,
count: checked ((int)Math.Min(Math.Min(songBytesRemaining, readerBytesRemaining), reusedBuffer.Length))
);
songWriter.Write(reusedBuffer, offset: 0, count: numRead);
}
}
//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();
}
}
static public Sound Read(Stream source)
{
BinaryReaderEx reader = new BinaryReaderEx(source);
Sound result = new Sound();
int id = reader.ReadInt32();
if (id == 0x00394453)
{
int headerLength = reader.ReadInt32();
int sampleLength = reader.ReadInt32();
headerLength -= 12;
if (headerLength > 0)
{
reader.ReadBytes(headerLength);
}
byte[] wavData = reader.ReadBytes(sampleLength);
using (MemoryStream wavDataMem = new MemoryStream(wavData))
{
using (WaveStream wavStream = new WaveFileReader(wavDataMem))
{
byte[] rawWaveData = new byte[wavStream.Length];
wavStream.Read(rawWaveData, 0, (int)wavStream.Length);
result.SetSound(rawWaveData, wavStream.WaveFormat);
}
}
}
return(result);
}
private void button1_Click(object sender, EventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Multiselect = false;
dlg.Title = "SELECCIONE SOPLO PARA OBTENER EL DIAGNOSTICO.";
dlg.CheckFileExists = true;
dlg.Filter = "WAV files (*.wav)|*.wav";
dlg.DefaultExt = ".wav";
if (dlg.ShowDialog() == DialogResult.OK)
{
label4.Text = "";
label3.Text = dlg.FileName;
arraydeentradas = new float[1, entradas];
WaveFileReader reader = new WaveFileReader(dlg.FileName);
Assert.AreEqual(16, reader.WaveFormat.BitsPerSample, "Only works with 16 bit audio");
byte[] buffer = new byte[reader.Length];
int read = reader.Read(buffer, 0, buffer.Length);
short[] sampleBuffer = new short[read / 2];
Buffer.BlockCopy(buffer, 0, sampleBuffer, 0, read);
for (int i = 0; i < 100; i++)
{
arraydeentradas[0, i] = float.Parse(sampleBuffer[i].ToString());
}
NormalizarEntradasDeLaRed();
button2.Enabled = true;
}
}
public static IAudio LoadWave(string filePath)
{
if (_disposables.ContainsKey(filePath))
{
return((IAudio)_disposables[filePath]);
}
IntPtr device = Alc.OpenDevice(null);
ContextHandle handle = Alc.CreateContext(device, (int[])null);
Alc.MakeContextCurrent(handle);
int buffer = AL.GenBuffer();
int source = AL.GenSource();
WaveFileReader reader = new WaveFileReader(filePath);
byte[] data = new byte[reader.Length];
reader.Read(data, 0, data.Length);
AL.BufferData(buffer, GetSoundFormat(reader.WaveFormat.Channels, reader.WaveFormat.BitsPerSample), data,
data.Length, reader.WaveFormat.SampleRate);
AL.Source(source, ALSourcei.Buffer, buffer);
IAudio audio = new WaveAudio(filePath, source, buffer, handle);
_disposables.TryAdd(filePath, audio);
return(audio);
}
public WavCharactersProvider(IConfiguration configuration)
{
var speechConfig = configuration.GetSection("SpeechConfig").Get <SpeechConfig>();
charactersWavBytes = new Dictionary <char, byte[]>();
var characters = new[] {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'
};
byte[] readBuffer = new byte[16 * 1024];
foreach (var character in characters)
{
//FileNotFoundException can be thrown
using var waveFileReader = new WaveFileReader(Path.Combine(speechConfig.CharactersPath, $"{character}.wav"));
using var ms = new MemoryStream();
using var waveFileWriter = new WaveFileWriter(ms, waveFileReader.WaveFormat);
int read;
while ((read = waveFileReader.Read(readBuffer, 0, readBuffer.Length)) > 0)
{
waveFileWriter.Write(readBuffer, 0, read);
}
waveFileWriter.Flush();
charactersWavBytes[character] = ms.ToArray();
}
}
private void ConvertWavTo10SecondWavs(FileInfo inputFile)
{
var samplesOutWav = @"..\..\..\samples\wav10seconds\";
using (var inAudio = new WaveFileReader(inputFile.FullName))
{
//Calculate required byte[] buffer.
var buffer = new byte[10 * inAudio.WaveFormat.AverageBytesPerSecond];//Assume average will be constant for WAV format.
int index = 0;
do
{
var outFile = string.Format("{0}{1}.{2:0000}.wav",
samplesOutWav, inputFile.Name.Replace(inputFile.Extension, string.Empty), index);
int bytesRead = 0;
do
{
bytesRead = inAudio.Read(buffer, 0, buffer.Length - bytesRead);
} while (bytesRead > 0 && bytesRead < buffer.Length);
//Write new file
using (var waveWriter = new WaveFileWriter(outFile, inAudio.WaveFormat))
{
waveWriter.Write(buffer, 0, buffer.Length);
}
index++;
} while (inAudio.Position < inAudio.Length);
}
}
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);
}
public void ReaderShouldReadBackSameDataWrittenWithWrite()
{
var ms = new MemoryStream();
var testSequence = new byte[] { 0x1, 0x2, 0xFF, 0xFE };
using (var writer = new WaveFileWriter(new IgnoreDisposeStream(ms), new WaveFormat(16000, 24, 1)))
{
writer.Write(testSequence, 0, testSequence.Length);
}
// check the Reader can read it
ms.Position = 0;
using (var reader = new WaveFileReader(ms))
{
Assert.AreEqual(16000, reader.WaveFormat.SampleRate, "Sample Rate");
Assert.AreEqual(24, reader.WaveFormat.BitsPerSample, "Bits Per Sample");
Assert.AreEqual(1, reader.WaveFormat.Channels, "Channels");
Assert.AreEqual(testSequence.Length, reader.Length, "File Length");
var buffer = new byte[600]; // 24 bit audio, block align is 3
int read = reader.Read(buffer, 0, buffer.Length);
Assert.AreEqual(testSequence.Length, read, "Data Length");
for (int n = 0; n < read; n++)
{
Assert.AreEqual(testSequence[n], buffer[n], "Byte " + n);
}
}
}
public void Load(string path)
{
FourierSounds = new List <Complex[]>();
using (var reader = new WaveFileReader(path))
{
SampleRate = reader.WaveFormat.SampleRate;
Ts = 1.0 / SampleRate;
FftLength = 4096;
//FftLength = 2048;
//FftLength = 1024;
Time = reader.TotalTime.TotalSeconds;
var channels = reader.WaveFormat.Channels;
var m = (int)Math.Log(FftLength, 2.0);
var readBuffer = new byte[reader.Length];
reader.Read(readBuffer, 0, readBuffer.Length);
var data = ConvertByteToFloat(readBuffer, readBuffer.Length);
for (var j = 0; j < data.Length / FftLength; j++)
{
var sampleBuffer = data.Skip(j * FftLength).Take(FftLength).ToList();
var fftBuffer = new Complex[FftLength];
var fftPos = 0;
for (var i = 0; i < FftLength; i++)
{
fftBuffer[fftPos].X = (float)(sampleBuffer[i] * FastFourierTransform.HammingWindow(i, FftLength));
fftBuffer[fftPos].Y = 0;
fftPos++;
}
FastFourierTransform.FFT(true, m, fftBuffer);
FourierSounds.Add(fftBuffer);
}
}
}
public void FlushUpdatesHeaderEvenIfDisposeNotCalled()
{
var ms = new MemoryStream();
var testSequence = new byte[] { 0x1, 0x2, 0xFF, 0xFE };
var testSequence2 = new byte[] { 0x3, 0x4, 0x5 };
var writer = new WaveFileWriter(new IgnoreDisposeStream(ms), new WaveFormat(16000, 24, 1));
writer.Write(testSequence, 0, testSequence.Length);
writer.Flush();
// BUT NOT DISPOSED
// another write that was not flushed
writer.Write(testSequence2, 0, testSequence2.Length);
// check the Reader can read it
ms.Position = 0;
using (var reader = new WaveFileReader(ms))
{
Assert.AreEqual(16000, reader.WaveFormat.SampleRate, "Sample Rate");
Assert.AreEqual(24, reader.WaveFormat.BitsPerSample, "Bits Per Sample");
Assert.AreEqual(1, reader.WaveFormat.Channels, "Channels");
Assert.AreEqual(testSequence.Length, reader.Length, "File Length");
var buffer = new byte[600]; // 24 bit audio, block align is 3
int read = reader.Read(buffer, 0, buffer.Length);
Assert.AreEqual(testSequence.Length, read, "Data Length");
for (int n = 0; n < read; n++)
{
Assert.AreEqual(testSequence[n], buffer[n], "Byte " + n);
}
}
writer.Dispose(); // to stop the finalizer from moaning
}
static void Main(string[] args)
{
const string fileName = "Test.wav";
Console.WriteLine("Hello silence detection!");
// Check it is a valid raw WAVE file
// We will use NAudio for this and just read the header
var fileTest = new FileStream(fileName, FileMode.Open, FileAccess.Read);
WaveFileReader reader = new WaveFileReader(fileTest);
if (reader.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
throw new Exception($"This sample supports only PCM raw WAVE format");
}
Console.WriteLine($"SampleRate: {reader.WaveFormat.SampleRate}, Channels: {reader.WaveFormat.Channels}, BitsPerSample: {reader.WaveFormat.BitsPerSample}");
Console.WriteLine($"Buffer length: {reader.Length}");
// Create a buffer to read everything
Span <byte> toFindSilence = new byte[reader.Length];
reader.Read(toFindSilence);
// Now detect silences
var slicers = toFindSilence.GetAllSilences(reader.WaveFormat.SampleRate, reader.WaveFormat.Channels, reader.WaveFormat.BitsPerSample / 8, new TimeSpan(0, 0, 0, 0, 500), -40);
foreach (var slice in slicers)
{
Console.WriteLine($"Start: {slice.Start.TotalMilliseconds} ms, duration: {slice.Duration.TotalMilliseconds} ms, index start: {slice.IndexStart}, index end: {slice.IndexEnd}");
}
}
private void CopyWaveFile(string destinationFile, string sourceFile)
{
using (var fs = File.Open(sourceFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (var reader = new WaveFileReader(fs))
{
using (var writer = new WaveFileWriter(destinationFile, reader.WaveFormat))
{
reader.Position = 0;
var endPos = (int)reader.Length;
var buffer = new byte[1024];
while (reader.Position < endPos)
{
var bytesRequired = (int)(endPos - reader.Position);
if (bytesRequired <= 0)
{
continue;
}
var bytesToRead = Math.Min(bytesRequired, buffer.Length);
var bytesRead = reader.Read(buffer, 0, bytesToRead);
if (bytesRead > 0)
{
writer.Write(buffer, 0, bytesRead);
}
}
}
}
}
}
public static List <float[]> Separate(WaveFileReader reader)
{
var output = new List <float[]>();
var buffer = new byte[2 * reader.WaveFormat.SampleRate * reader.WaveFormat.Channels];
var writers = new WaveFileWriter[reader.WaveFormat.Channels];
for (int n = 0; n < writers.Length; n++)
{
var format = new WaveFormat(reader.WaveFormat.SampleRate, 16, 1);
writers[n] = new WaveFileWriter(String.Format("channel{0}.wav", n + 1), format);
}
int bytesRead;
while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0)
{
int offset = 0;
while (offset < bytesRead)
{
for (int n = 0; n < writers.Length; n++)
{
// write one sample
writers[n].Write(buffer, offset, 2);
offset += 2;
}
}
}
for (int n = 0; n < writers.Length; n++)
{
writers[n].Dispose();
}
reader.Dispose();
return(output);
}
void Join()
{
src1 = new WaveFileReader(src1_n);
src2 = new WaveFileReader(src2_n);
// Test whether two wave files have the same format
if (!src1.WaveFormat.Equals(src2.WaveFormat))
{
Console.Out.WriteLine("Two waves are not of the same format.");
return;
}
// Read in the wave file and write out to the destination
using (dest = new WaveFileWriter(dest_n, src1.WaveFormat))
{
byte[] buffer = new byte[2048];
int n = 0;
do
{
n = src1.Read(buffer, 0, 2048);
n = Math.Min(2048, n);
dest.Write(buffer, 0, n);
} while (n > 0);
do
{
n = src2.Read(buffer, 0, 2048);
n = Math.Min(2048, n);
dest.Write(buffer, 0, n);
} while (n > 0);
}
}
//Метод для извлечения массива байтов из указанного файла 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>
/// cut the trash time before tts result
/// </summary>
/// <param name="reader">source</param>
/// <param name="writer">destination</param>
/// <param name="cutFromStart">start time</param>
/// <param name="cutFromEnd">end time</param>
public void TrimWave(WaveFileReader reader, WaveFileWriter writer, TimeSpan cutFromStart, TimeSpan cutFromEnd)
{
int bytesPerMillisecond = reader.WaveFormat.AverageBytesPerSecond / 1000;
int startPos = (int)cutFromStart.TotalMilliseconds * bytesPerMillisecond;
startPos = startPos - startPos % reader.WaveFormat.BlockAlign;
int endBytes = (int)cutFromEnd.TotalMilliseconds * bytesPerMillisecond;
endBytes = endBytes - endBytes % reader.WaveFormat.BlockAlign;
int endPos = (int)reader.Length - endBytes;
reader.Position = startPos;
byte[] buffer = new byte[1024];
while (reader.Position < endPos)
{
int bytesRequired = (int)(endPos - reader.Position);
if (bytesRequired > 0)
{
int bytesToRead = Math.Min(bytesRequired, buffer.Length);
int bytesRead = reader.Read(buffer, 0, bytesToRead);
if (bytesRead > 0)
{
writer.Write(buffer, 0, bytesRead);
}
}
}
}
protected void SplitTwoChannel(string FileName)
{
int bytesRead;
var reader = new WaveFileReader(FileName);
var buffer = new byte[2 * reader.WaveFormat.SampleRate * reader.WaveFormat.Channels];
var writers = new WaveFileWriter[reader.WaveFormat.Channels];
for (int n = 0; n < writers.Length; n++)
{
var format = new WaveFormat(reader.WaveFormat.SampleRate, 16, 1);
writers[n] = new WaveFileWriter(GetFullPath(String.Format("channel{0}.wav", n + 1)), format);
}
while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0)
{
int offset = 0;
while (offset < bytesRead)
{
for (int n = 0; n < writers.Length; n++)
{
writers[n].Write(buffer, offset, 2);
offset += 2;
}
}
}
for (int n = 0; n < writers.Length; n++)
{
writers[n].Dispose();
}
reader.Dispose();
}
private int ConcatWavFiles(List <string> waveList, WaveFormat waveFormat, string outputPath)
{
int bytes = 0;
if (waveFormat != null)
{
byte[] buffer = new byte[1024];
int read;
using (WaveFileWriter waveFileWriter = new WaveFileWriter(outputPath, waveFormat))
{
foreach (string sourceFile in waveList)
{
using (WaveFileReader waveFileReader = new WaveFileReader(sourceFile))
{
while ((read = waveFileReader.Read(buffer, 0, buffer.Length)) > 0)
{
waveFileWriter.Write(buffer, 0, read);
bytes += read;
}
}
}
}
}
return(bytes);
}
/// <summary>
/// 來源: https://stackoverflow.com/questions/12075062/saving-each-wav-channel-as-a-mono-channel-wav-file-using-naudio/12149659#12149659
/// </summary>
public static void SplitEachChannelToFiles()
{
var reader = new WaveFileReader(@"E:\Dropbox\WorkGrandsys\W\Workarea\20180511音檔 - 複製\1_8690002555DA7B59370000037\0_00001_0000364_0000837.wav");
var buffer = new byte[2 * reader.WaveFormat.SampleRate * reader.WaveFormat.Channels];
var writers = new WaveFileWriter[reader.WaveFormat.Channels];
for (int n = 0; n < writers.Length; n++)
{
var format = new WaveFormat(reader.WaveFormat.SampleRate, 16, 1);
writers[n] = new WaveFileWriter(String.Format(@"E:\Dropbox\WorkGrandsys\W\Workarea\20180511音檔 - 複製\output\channel{0}.wav", n + 1), format);
}
int bytesRead;
while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0)
{
int offset = 0;
while (offset < bytesRead)
{
for (int n = 0; n < writers.Length; n++)
{
// write one sample
writers[n].Write(buffer, offset, 2);
offset += 2;
}
}
}
for (int n = 0; n < writers.Length; n++)
{
writers[n].Dispose();
}
reader.Dispose();
}
public void OpenWav(string filename)
{
short[] sampleBuffer;
using (WaveFileReader reader = new WaveFileReader(filename))
{
fileName = Path.GetFileName(filename);
sampleRate = reader.WaveFormat.SampleRate;
framesNumber = (int)reader.SampleCount * reader.WaveFormat.Channels;
totalTime = reader.TotalTime;
byte[] buffer = new byte[reader.Length];
int read = reader.Read(buffer, 0, buffer.Length);
sampleBuffer = new short[read / 2];
Buffer.BlockCopy(buffer, 0, sampleBuffer, 0, read);
}
int[] result = new int[sampleBuffer.Length];
float[] resultNormalized = new float[sampleBuffer.Length];
for (int i = 0; i < result.Length; i++)
{
result[i] = sampleBuffer[i];
resultNormalized[i] = sampleBuffer[i] / (float)(short.MaxValue + 1);
}
data = result;
dataNormalized = resultNormalized;
}
