public void OpenWAV()
{
OutputLogs logs = OutputLogs.Instance();
OpenFileDialogService.Filter = "Wav Files (.wav)|*.wav|All Files (*.*)|*.*";
OpenFileDialogService.FilterIndex = 1;
OpenFileDialogService.Title = "Open target audio";
if (OpenFileDialogService.ShowDialog())
{
IFileInfo file = OpenFileDialogService.Files.First();
WavReader reader = null;
try
{
reader = new WavReader(File.Open(file.GetFullName(), FileMode.Open, FileAccess.Read, FileShare.None));
Audio = reader.ReadAudio();
AudioFileName = file.Name;
string msg = string.Concat("Succesfully loaded file - ", file.GetFullName());
logs.AddLog(new Message(MessageType.Info, msg, "WavReader"));
}
catch (ApplicationException ex)
{
logs.AddLog(new Message(MessageType.Error, ex.Message, ex.Source));
}
finally
{
if (reader != null)
{
reader.Dispose();
}
}
}
}
private void CExportElement(object sender, ExecutedRoutedEventArgs e)
{
TranscriptionParagraph par = VirtualizingListBox.ActiveTransctiption as TranscriptionParagraph;
var data = _WavReader.LoadaudioDataBuffer(par.Begin, par.End);
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.DefaultExt = ".wav";
dlg.Filter = "wav soubory (.wav)|*.wav";
if (dlg.ShowDialog() == true)
{
WavReader.SaveToWav(dlg.FileName, data);
string ext = System.IO.Path.GetExtension(dlg.FileName);
dlg.FileName = dlg.FileName.Substring(0, dlg.FileName.Length - ext.Length);
string textf = dlg.FileName + ".txt";
File.WriteAllBytes(textf, win1250.GetBytes(par.Text));
if (!string.IsNullOrEmpty(par.Phonetics))
{
textf = dlg.FileName + ".phn";
File.WriteAllBytes(textf, win1250.GetBytes(par.Phonetics));
}
}
}
public static void SeparateChannels(
Arguments args,
FileInfo ipFile,
out double[] samplesL,
out double[] samplesR,
out double epsilon)
{
//you'd then use wavreader on the resulting preparedFile
//the channel select functionality does not currently exist in AnalyzeLongRecording. I need to add it.
var request = new AudioUtilityRequest
{
OffsetStart = args.StartOffset,
OffsetEnd = args.EndOffset,
TargetSampleRate = args.SamplingRate,
Channels = new[] { 1, 2 },
MixDownToMono = false,
};
var audioFile = AudioFilePreparer.PrepareFile(args.OpDir, ipFile, args.OutputMediaType, request, args.OpDir).TargetInfo.SourceFile;
var wavReader = new WavReader(audioFile);
var recording = new AudioRecording(wavReader);
samplesL = recording.WavReader.GetChannel(0);
samplesR = recording.WavReader.GetChannel(1);
epsilon = Math.Pow(0.5, recording.BitsPerSample - 1);
}
public void WavReaderMakeMultiChannelWav()
{
const double Tau = 2 * Math.PI;
var a = new double[22050].Select((v, i) => Math.Sin(Tau * i * 500 / 22050)).ToArray();
var b = new double[22050].Select((v, i) => Math.Sin(Tau * i * 1500 / 22050)).ToArray();
var c = new double[22050].Select((v, i) => Math.Sin(Tau * i * 2500 / 22050)).ToArray();
var d = new double[22050].Select((v, i) => Math.Sin(Tau * i * 3500 / 22050)).ToArray();
var multiplexed = new double[22050 * 4].Select(
(v, i) =>
{
switch (i % 4)
{
case 0: return(a[i / 4]);
case 1: return(b[i / 4]);
case 2: return(c[i / 4]);
case 3: return(d[i / 4]);
}
return(double.NaN);
});
var reader = new WavReader(multiplexed.ToArray(), 4, 16, 22050);
CollectionAssert.AreEqual(a, reader.GetChannel(0));
CollectionAssert.AreEqual(b, reader.GetChannel(1));
CollectionAssert.AreEqual(c, reader.GetChannel(2));
CollectionAssert.AreEqual(d, reader.GetChannel(3));
}
public void WavReaderReadsSamplesAccurately24bit()
{
// 11025Hz fake array
var a = new double[44100 * 5].Select((v, i) => i % 4 == 3 ? -1 : i % 2).ToArray();
var source = PathHelper.GetTestAudioFile("11025Hz-24bit.wav");
var info = this.audioUtility.Info(source);
var reader = new WavReader(source);
TestHelper.WavReaderAssertions(reader, info);
Assert.AreEqual(5.0M, reader.ExactDurationSeconds);
var mono = reader.GetChannel(0);
Assert.AreEqual(a.Length, reader.Samples.Length);
Assert.AreEqual(a.Length, mono.Length);
for (int i = 0; i < a.Length; i++)
{
Assert.AreEqual(a[i], reader.Samples[i], double.Epsilon);
Assert.AreEqual(a[i], mono[i], double.Epsilon);
}
}
static void Main(string[] args)
{
var files = Directory.GetFiles("../testfiles/", "*.wav", SearchOption.AllDirectories);
foreach (var file in files)
{
_lameEnc = new Mp3Encoder();
var audioFile = new WavReader();
audioFile.OpenFile(file);
var srcFormat = audioFile.GetFormat();
_lameEnc.SetFormat(srcFormat, srcFormat);
var inBuffer = audioFile.readWav();
var outBuffer = new byte[inBuffer.Length];
var timer = new System.Diagnostics.Stopwatch();
timer.Start();
var len = _lameEnc.EncodeBuffer(inBuffer, 0, inBuffer.Length, outBuffer);
timer.Stop();
_lameEnc.Close();
// _lameDec = new LameDecoder();
var outFile = File.Create(file + ".mp3");
outFile.Write(outBuffer, 0, len);
outFile.Close();
Console.WriteLine($"Converted {file} to MP3 in {timer.ElapsedMilliseconds / 1000}s");
}
}
public static decimal GetLoudness(string fileName, Action <double, double> updateProgress = null)
{
if (Path.GetExtension(fileName) != ".wav")
{
return(defaultLoadness);
}
try {
WavReader wavReader;
using (FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
wavReader = new WavReader(fileStream, Encoding.Default);
}
WavReader.FmtChunk fmt = (WavReader.FmtChunk)wavReader.Riff.Chunks["fmt "];
double[][] buffer = wavReader.GetSampleData();
R128LufsMeter r128LufsMeter = new R128LufsMeter();
r128LufsMeter.Prepare(fmt.SampleRate, buffer.Length);
r128LufsMeter.StartIntegrated();
r128LufsMeter.ProcessBuffer(buffer,
(double current, double total) => { updateProgress?.Invoke(current, total); });
r128LufsMeter.StopIntegrated();
// Report input loudness
return(-16 - Convert.ToDecimal(r128LufsMeter.IntegratedLoudness));
}
catch (Exception ex) {
return(defaultLoadness);
}
}
public byte[] Extract(DigitalAudio stegoAudio)
{
int[] primeSignal;
using (WavReader reader = new WavReader(File.OpenRead(PrimeSignalFilePath)))
primeSignal = reader.ReadAudio().GetSignal();
var stegoSignal = stegoAudio.GetSignal();
int samplesPerSegment = (int)Math.Floor((double)stegoSignal.Length / (MessageLength * 8));
var rnd = new Random(RandomSeed); int lseg, rseg;
int[] pseudoRandomSignal = new int[samplesPerSegment];
var difference = new double[samplesPerSegment];
List <bool> message = new List <bool>();
double primeMean = 0, difMean = 0;
for (int i = 0; (i + 1) * samplesPerSegment <= stegoSignal.Length; i++)
{
lseg = i * samplesPerSegment;
rseg = samplesPerSegment * (i + 1);
RndSignal(rnd, pseudoRandomSignal);
for (int j = lseg, k = 0; j < rseg; j++, k++)
{
primeSignal[j] = (int)(primeSignal[j] * 0.95);
difference[k] = (stegoSignal[j] - primeSignal[j]) * pseudoRandomSignal[k];
primeMean += primeSignal[j];
difMean += stegoSignal[j];
}
message.Add(Math.Sign(primeMean) == Math.Sign(difMean));
primeMean = 0; difMean = 0;
}
return(BitArrayToByteArray(new BitArray(message.ToArray())));
}
private void LoadFile(object o)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Title = "Browse WAV Files";
openFileDialog.DefaultExt = "wav";
openFileDialog.Filter = "WAV files (*.wav)|*.wav";
if (openFileDialog.ShowDialog() == true)
{
WavData data = WavReader.ReadData(openFileDialog.FileName);
this.Channel = data.Samples;
this.FileName = openFileDialog.FileName;
this.SampleRate = data.FormatChunk.SampleRate;
List <DataPoint> signal = new List <DataPoint>();
for (int i = 0; i < this.Channel.Length; i++)
{
signal.Add(new DataPoint(i, this.Channel[i]));
}
this.Signal = signal;
this.AutocorrelationFreq = null;
this.FourierFreq = null;
this.AutocorrelationData = null;
Notify.Info("WAV file loaded sucessfully!");
}
}
private WavHeader GetHeader()
{
using (var input = Helper.GetAudioStream())
{
var reader = new WavReader(input);
return(reader.Header);
}
}
public void WavReaderSampleOutOfBoundsFails()
{
var source = PathHelper.GetTestAudioFile("different_channels_tone.wav");
var reader = new WavReader(source);
Assert.ThrowsException <IndexOutOfRangeException>(() => { reader[-1, 0].ToString(); });
Assert.ThrowsException <IndexOutOfRangeException>(() => { reader[reader.BlockCount + 1, 0].ToString(); });
}
public WavFormat(Stream stream)
{
sourceStream = stream;
if (!WavReader.LoadSound(stream, out wavStreamFactory, out channels, out sampleBits, out sampleRate))
{
throw new InvalidDataException();
}
}
public static AudioRecording GenerateTestRecording(int sampleRate, double duration, int[] harmonics, WaveType waveType)
{
var signal = GenerateTestSignal(sampleRate, duration, harmonics, waveType);
var wr = new WavReader(signal, 1, 16, sampleRate);
var recording = new AudioRecording(wr);
return(recording);
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioRecording"/> class.
/// Wrapper for the wav reader.
/// Audio must be in wav format.
/// Use MasterAudioUtility to convert or segment the audio first.
/// </summary>
public AudioRecording(byte[] bytes)
{
this.FilePath = "UNKNOWN";
this.Bytes = bytes;
if (this.Bytes != null)
{
this.wavReader = new WavReader(bytes);
}
}
public void ContentSize()
{
using (var input = Helper.GetAudioStream())
{
var reader = new WavReader(input);
Assert.AreEqual(70026, reader.Header.FileSize, "FileSize");
}
}
public void SoxResamplingShouldBeDeterministic()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(60),
SampleRate = 22050,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 352800,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
TargetSampleRate = 22050,
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("CaneToad_Gympie_44100.wav");
var repeats = new double[5][];
for (int r = 0; r < repeats.Length; r++)
{
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output,
MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
TestHelper.CheckAudioUtilityInfo(expected, actual);
var reader = new WavReader(output);
TestHelper.WavReaderAssertions(reader, actual);
repeats[r] = reader.Samples;
File.Delete(output.FullName);
}
for (int i = 1; i < repeats.Length; i++)
{
Assert.AreEqual(repeats[0].Length, repeats[1].Length);
var totalDifference = 0.0;
for (int j = 0; j < repeats[0].Length; j++)
{
var delta = Math.Abs(repeats[i][j] - repeats[0][j]);
totalDifference += delta;
}
CollectionAssert.AreEqual(repeats[0], repeats[i], $"Repeat {i} was not identical to repeat 0. Total delta: {totalDifference}");
}
}
/// <summary>
/// WAVファイルのヘッダ部分を読み込む。
/// </summary>
/// <returns>読めたらtrue</returns>
private bool ReadWavFileHeader(string path)
{
bool result = false;
var pd = new PcmData();
var wavR = new WavReader();
using (BinaryReader br = new BinaryReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))) {
if (wavR.ReadHeader(br))
{
// WAVヘッダ読み込み成功。PcmDataを作って再生リストに足す。
pd.SetFormat(wavR.NumChannels, wavR.BitsPerSample, wavR.ValidBitsPerSample,
(int)wavR.SampleRate, wavR.SampleValueRepresentationType, wavR.NumFrames);
if (wavR.SampleDataType == WavReader.DataType.DoP)
{
pd.SampleDataType = PcmData.DataType.DoP;
}
if ("RIFFINFO_INAM".Equals(wavR.Title) &&
"RIFFINFO_IART".Equals(wavR.ArtistName))
{
// Issue 79 workaround
}
else
{
if (wavR.Title != null)
{
pd.DisplayName = wavR.Title;
}
if (wavR.AlbumName != null)
{
pd.AlbumTitle = wavR.AlbumName;
}
if (wavR.ArtistName != null)
{
pd.ArtistName = wavR.ArtistName;
}
if (wavR.ComposerName != null)
{
pd.ComposerName = wavR.ComposerName;
}
}
pd.SetPicture(wavR.PictureBytes, wavR.PictureData);
result = CheckAddPcmData(path, pd, true);
}
else
{
LoadErrorMessageAdd(string.Format(CultureInfo.InvariantCulture, Properties.Resources.ReadFileFailed + ": {1} : {2}{3}",
"WAV", path, wavR.ErrorReason, Environment.NewLine));
}
}
return(result);
}
public void HeaderSize()
{
using (var input = Helper.GetAudioStream())
{
var reader = new WavReader(input);
reader.ToString(); // we don't need the reader, but we need it's initialization operation
Assert.AreEqual(WavHeader.Size, input.Position);
}
}
/// <summary>
/// 从Wav文件读取波形数据
/// </summary>
/// <param name="path">文件路径</param>
/// <param name="channelCount">通道个数</param>
/// <returns>波形数据</returns>
public static double[] FromWavFile(string path, out int channelCount)
{
WavReader reader = new WavReader();
reader.ReadFile(path);
double[] waveData = new double[reader.GetTotalPoints()];
reader.GetCopyOfData(waveData);
channelCount = reader.GetChannelCounts();
return(waveData);
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioRecording"/> class.
/// Wrapper for the wav reader.
/// Audio must be in wav format.
/// Use MasterAudioUtility to convert or segment the audio first.
/// </summary>
public AudioRecording(byte[] bytes, string name)
{
this.FilePath = name;
this.BaseName = Path.GetFileNameWithoutExtension(name);
this.Bytes = bytes;
if (this.Bytes != null)
{
this.wavReader = new WavReader(bytes);
}
}
public void DataChunkHeader()
{
using (var input = Helper.GetAudioStream())
{
var reader = new WavReader(input);
var chunkHeader = reader.ReadChunkHeader();
Assert.AreEqual(WavConst.Data, chunkHeader.ChunkId, "ChunkID");
Assert.AreEqual(65938, chunkHeader.ChunkLength, "ChunkLength");
}
}
public void WavReaderChannelOutOfBoundsFails()
{
var source = PathHelper.GetTestAudioFile("different_channels_tone.wav");
var reader = new WavReader(source);
Assert.ThrowsException <IndexOutOfRangeException>(() => { reader.GetChannel(-1); });
Assert.ThrowsException <IndexOutOfRangeException>(() => { reader.GetChannel(5); });
Assert.ThrowsException <IndexOutOfRangeException>(() => { reader[0, -1].ToString(); });
Assert.ThrowsException <IndexOutOfRangeException>(() => { reader[0, 5].ToString(); });
}
public void FllrChunkHeader()
{
using (var input = Helper.GetAudioStream())
{
var reader = new WavReader(input);
var chunkHeader = reader.ReadChunkHeader(skipFllr: false);
Assert.AreEqual(WavConst.Fllr, chunkHeader.ChunkId, "ChunkID");
Assert.AreEqual(4044, chunkHeader.ChunkLength, "ChunkLength");
}
}
/// <summary>
/// 読み込み処理を終了する。
/// </summary>
/// <returns>Error code</returns>
public int StreamEnd()
{
int rv = 0;
mMD5SumInMetadata = null;
mMD5SumOfPcm = null;
switch (m_format)
{
case Format.FLAC:
rv = mFlacR.ReadEnd();
mMD5SumInMetadata = mFlacR.MD5SumInMetadata;
mMD5SumOfPcm = mFlacR.MD5SumOfPcm;
break;
case Format.AIFF:
mAiffR.ReadStreamEnd();
break;
case Format.WAVE:
mWaveR.ReadStreamEnd();
break;
case Format.DSF:
mDsfR.ReadStreamEnd();
break;
case Format.DSDIFF:
mDsdiffR.ReadStreamEnd();
break;
case Format.MP3:
mMp3Reader.ReadStreamEnd();
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
if (null != mBr)
{
mBr.Close();
mBr = null;
}
mPcmData = null;
mFlacR = null;
mAiffR = null;
mWaveR = null;
mDsfR = null;
return(rv);
}
public static AudioRecording Filter_IIR(AudioRecording audio, string filterName)
{
DSP_IIRFilter filter = new DSP_IIRFilter(filterName);
filter.ApplyIIRFilter(audio.WavReader.Samples, out var output);
int channels = audio.WavReader.Channels;
int bitsPerSample = audio.BitsPerSample;
int sampleRate = audio.SampleRate;
WavReader wr = new WavReader(output, channels, bitsPerSample, sampleRate);
var ar = new AudioRecording(wr);
return(ar);
}
public async Task ReadToEnd()
{
using (var input = Helper.GetAudioStream())
{
var reader = new WavReader(input);
var chunkHeader = reader.ReadChunkHeader();
var buffer = new byte[chunkHeader.ChunkLength];
var count = await reader.ReadDataChunk(buffer);
Assert.AreEqual(count, buffer.Length, "buffer.Length");
Assert.AreEqual(false, reader.HasMore, "reader.HasMore");
}
}
public void WavReaderReadsMono()
{
var source = PathHelper.GetTestAudioFile("curlew.wav");
var info = this.audioUtility.Info(source);
var reader = new WavReader(source);
TestHelper.WavReaderAssertions(reader, info);
Assert.IsTrue(reader.Samples.Length > 0);
var sample = reader.Samples[500];
Assert.IsFalse(double.IsNaN(sample));
}
private void LoadFile(object o)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Title = "Browse WAV Files";
openFileDialog.DefaultExt = "wav";
openFileDialog.Filter = "WAV files (*.wav)|*.wav";
if (openFileDialog.ShowDialog() == true)
{
this.SignalData = WavReader.ReadData(openFileDialog.FileName);
this.FileName = openFileDialog.FileName;
Notify.Info("WAV file loaded sucessfully!");
}
}
public static void WavReaderAssertions(WavReader reader, AudioUtilityInfo info)
{
BaseTest.Assert.AreEqual(info.ChannelCount.Value, reader.Channels);
if (info.BitsPerSample.HasValue)
{
BaseTest.Assert.AreEqual(info.BitsPerSample.Value, reader.BitsPerSample);
}
BaseTest.Assert.AreEqual(info.SampleRate.Value, reader.SampleRate);
BaseTest.Assert.AreEqual(info.Duration.Value.TotalMilliseconds, reader.Time.TotalMilliseconds, 150);
BaseTest.Assert.AreEqual(
(int)(info.Duration.Value.TotalSeconds * info.SampleRate.Value),
reader.BlockCount,
100);
}
private static void DoFrequencyAnalysis(
AudioUtilityInfo expected,
int[][] expectedFrequencies)
{
var reader = new WavReader(expected.SourceFile);
TestHelper.WavReaderAssertions(reader, expected);
for (var channel = 0; channel < expectedFrequencies.Length; channel++)
{
var samples = reader.GetChannel(channel);
TestHelper.AssertFrequencyInSignal(reader, samples, expectedFrequencies[channel]);
}
}
/// <summary>
/// Starts playing specified wave file for the specified number of times.
/// </summary>
/// <param name="stream">Wave stream.</param>
/// <param name="count">Number of times to play.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>stream</b> is null reference.</exception>
public void Play(Stream stream,int count)
{
if(stream == null){
throw new ArgumentNullException("stream");
}
if(m_IsPlaying){
Stop();
}
m_IsPlaying = true;
m_Stop = false;
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object state){
using(BinaryReader waveFile = new BinaryReader(stream)){
WavReader wavReader = new WavReader(waveFile);
if(!string.Equals(wavReader.Read_ChunkID(),"riff",StringComparison.InvariantCultureIgnoreCase)){
throw new ArgumentNullException("Invalid wave file, RIFF header missing.");
}
RIFF_Chunk riff = wavReader.Read_RIFF();
wavReader.Read_ChunkID();
fmt_Chunk fmt = wavReader.Read_fmt();
using(AudioOut player = new AudioOut(m_pOutputDevice,fmt.SampleRate,fmt.BitsPerSample,fmt.NumberOfChannels)){
long audioStartOffset = waveFile.BaseStream.Position;
// Loop audio playing for specified times.
for(int i=0;i<count;i++){
waveFile.BaseStream.Position = audioStartOffset;
// Read wave chunks.
while(true){
string chunkID = wavReader.Read_ChunkID();
// EOS reached.
if(chunkID == null || (waveFile.BaseStream.Length - waveFile.BaseStream.Position) < 4){
break;
}
// Wave data chunk.
else if(string.Equals(chunkID,"data",StringComparison.InvariantCultureIgnoreCase)){
data_Chunk data = wavReader.Read_data();
int totalReaded = 0;
byte[] buffer = new byte[8000];
while(totalReaded < data.ChunkSize){
if(m_Stop){
m_IsPlaying = false;
return;
}
// Read audio block.
int countReaded = waveFile.Read(buffer,0,(int)Math.Min(buffer.Length,data.ChunkSize - totalReaded));
// Queue audio for play.
player.Write(buffer,0,countReaded);
// Don't buffer more than 2x read buffer, just wait some data played out first.
while(m_IsPlaying && player.BytesBuffered >= (buffer.Length * 2)){
Thread.Sleep(10);
}
totalReaded += countReaded;
}
}
// unknown chunk.
else{
wavReader.SkipChunk();
}
}
}
// Wait while audio playing is completed.
while(m_IsPlaying && player.BytesBuffered > 0){
Thread.Sleep(10);
}
}
}
m_IsPlaying = false;
}));
}
