private IEnumerator Recognise(AudioClip clip)
{
var wavData = new WavData(clip);
var queryString = String.Format(BingSpeechAPIStrings.QUERY_STRING_SPEECH_API_FORMAT, Guid.NewGuid(), BingSpeechAPIStrings.PARAMETER_APP_ID, Guid.NewGuid());
var speechRecognitionUri = BingSpeechAPIStrings.URI_SPEECH_RECOGNISE + queryString;
var headers = CreateRecogniseHeaders(clip);
// Request
var w = new WWW(speechRecognitionUri, wavData.FullRawBytes, headers);
yield return(w);
// Response
if (string.IsNullOrEmpty(w.error))
{
if (OnRecognise != null)
{
var args = new RecogniseEventArgs(true, w.text);
OnRecognise(this, args);
}
}
else
{
Debug.Log("Error: " + w.text);
}
}
private void ReadDataWave()
{
System.Windows.Forms.OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "All Supported Files (*.wav)|*.wav";
if (openFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
FileName = openFileDialog.FileName;
WavFile file = new WavFile(FileName); //входной файл
WavData orig = file.ReadData();
Processed = new WavData(orig.Header, orig.Data.Length);
SelectedData.Clear();
Line.Points.Clear();
using (orig)
{
int c = orig.GetSamplesCount();
int x = 0;
for (int i = 0; i < c; i++)
{
float y = orig.ReadNextSample(); //читаем следующий семпл
Line.Points.Add(new DataPoint(x++, y));
}
Model.InvalidatePlot(true);
}
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
this.Cursor = Cursors.WaitCursor;
for (int j = 0; j < audioFiles.Length; j++)
{
try
{
WavData.ReadWavDataChunk(audioFiles[j]);
}
catch (WavException ex)
{
MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
setProgressBarSpeed(1);
rawdata = WavData.NornalizeData;
mfcc = MFCC.Transform(ref rawdata, 0, WavData.SampleNumber, Constants.mfccSize, Constants.sampleRate, Constants.mfccFreqMin, Constants.mfccFreqMax);
string mfccString = "";
for (int i = 0; i < mfcc.Length; i++)
{
mfccString += mfcc[i] + "/";
}
mfccString = mfccString.Substring(0, mfccString.Length - 1);
using (StreamWriter streamwriter = new StreamWriter(pathToTempBase, true, Encoding.UTF8))
{
streamwriter.WriteLine(String.Format("{0};{1}", word, mfccString));
}
}
}
public void WriteData(WavData input)
{
var header = input.Header;
byte[] data = input.Data;
using (var fs = new FileStream(FilePath, FileMode.Create, FileAccess.Write))
{
using (var writer = new BinaryWriter(fs))
{
//пишем заголовок
writer.Write((int)header.ChunkId);
writer.Write((int)header.ChunkSize);
writer.Write((int)header.Format);
writer.Write((int)header.Subchunk1Id);
writer.Write((int)header.Subchunk1Size);
writer.Write((short)header.AudioFormat);
writer.Write((short)header.NumChannels);
writer.Write((int)header.SampleRate);
writer.Write((int)header.ByteRate);
writer.Write((short)header.BlockAlign);
writer.Write((short)header.BitsPerSample);
if (header.Subchunk1Size == 18)
{
writer.Write((short)0);
}
//пишем данные
writer.Write((int)header.Subchunk2Id);
writer.Write((int)header.Subchunk2Size);
writer.Write(data);
}
}
}
public void AddSound(string name, WavData wavData)
{
var sound = new WavViewModel(name, wavData);
Sounds.Add(sound);
sound.RemoveSoundCommand = new RelayCommand(() => Sounds.Remove(sound));
}
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!");
}
}
public static void WriteData(string fileName, WavData data)
{
using (var fs = File.Create(fileName))
using (var writer = new BinaryWriter(fs))
{
writer.Write(data.DescriptorChunk.ChunkId);
writer.Write(data.DescriptorChunk.ChunkSize);
writer.Write(data.DescriptorChunk.Format);
writer.Write(data.FormatChunk.ChunkId);
writer.Write(data.FormatChunk.ChunkSize);
writer.Write(data.FormatChunk.AudioFormat);
writer.Write(data.FormatChunk.NumChannels);
writer.Write(data.FormatChunk.SampleRate);
writer.Write(data.FormatChunk.ByteRate);
writer.Write(data.FormatChunk.BlockAlign);
writer.Write(data.FormatChunk.BitsPerSample);
if (data.FormatChunk.ChunkSize == 18)
{
writer.Write(data.FormatChunk.ExtraData);
}
writer.Write(data.DataChunk.ChunkId);
writer.Write(data.DataChunk.ChunkSize);
writer.Write(data.DataChunk.RawData);
}
}
private WavData ReadWavFile(string path)
{
WavData wavData = new WavData();
Console.WriteLine(rm.GetString("ReadFileStarted"), path);
using (BinaryReader br1 = new BinaryReader(File.Open(path, FileMode.Open))) {
if (!wavData.Read(br1))
{
textBoxConsole.Text += string.Format(rm.GetString("ReadFileFailFormat"), path) + "\r\n";
return(null);
}
if (16 != wavData.BitsPerSample)
{
textBoxConsole.Text += string.Format(rm.GetString("BitsPerSampleFailFormat"), path, wavData.BitsPerSample) + "\r\n";
return(null);
}
if (wavData.NumSamples < wavData.SampleRate * (double)numericStartDelayTorelance.Value + (double)numericAccumulateSeconds.Value)
{
textBoxConsole.Text += string.Format(rm.GetString("WavFileTooShort"), path, (double)numericStartDelayTorelance.Value + (double)numericAccumulateSeconds.Value) + "\r\n";
return(null);
}
}
return(wavData);
}
private IEnumerator RecognizeCoroutine(AudioClip clip)
{
var wavData = new WavData(clip);
var client = UnityWebRequest.Put(sttUrl + "?language=" + sttLanguage, wavData.FullRawBytes);
client.SetRequestHeader("Ocp-Apim-Subscription-Key", subscriptionKey);
client.SetRequestHeader("Authorization", _storedTokenValue);
client.SetRequestHeader("Content-type", "audio/wav; codec=audio/pcm; samplerate=16000");
client.method = "POST";
yield return(client.SendWebRequest());
if (client.isNetworkError || client.isHttpError)
{
Debug.Log(client.error);
}
else
{
string resultContent = client.downloadHandler.text;
Debug.Log(resultContent);
//OnTextReceived(resultContent);
Debug.Log("Recognizing...DONE");
Debug.Log(resultContent.ToString());
var result = JsonUtility.FromJson <RecognitionResult>(resultContent.ToString());
OnTextReceived(result);
}
}
public List <Sound> Calculate(WavData wavData)
{
var frequencies = new List <Sound>();
for (int i = 0; i < wavData.ChunkedSamples.Length; i++)
{
var samples = wavData.ChunkedSamples[i];
var localMin = (Index : 0, Value : double.MaxValue);
var lastValue = double.MinValue;
var monotonicityChanged = 0;
var isGrowing = true;
var found = false;
var result = new double[samples.Length - 1];
for (int j = 1; j < samples.Length; j++)
{
var correlated = 0.0;
for (int k = 0; k < samples.Length - j; k++)
{
correlated += Math.Abs(samples[k] - samples[k + j]);
}
result[j - 1] = correlated;
if (!found && isGrowing != lastValue < correlated)
{
isGrowing = lastValue < correlated;
monotonicityChanged++;
if (monotonicityChanged == 2)
{
localMin = (j - 1, lastValue);
found = true;
}
}
lastValue = correlated;
}
var frequency = wavData.FormatChunk.SampleRate / localMin.Index;
if (frequencies.Any() && frequencies.Last().Frequency == frequency)
{
frequencies.Last().EndTime += 50;
}
else
{
frequencies.Add(new Sound
{
StartTime = i * 50,
EndTime = i * 50 + 50,
Frequency = frequency,
Result = result
});
}
}
return(frequencies);
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
int startPos = (int)numericStartPos.Value;
int outputSamples = (int)numericOutputSamples.Value;
string path = textBoxReadWavFile.Text;
WavData wavData = new WavData();
Console.WriteLine(rm.GetString("ReadFileStarted"), path);
using (BinaryReader br1 = new BinaryReader(File.Open(path, FileMode.Open))) {
if (!wavData.Read(br1))
{
resultString = string.Format(rm.GetString("ReadFileFailFormat"), path) + "\r\n";
e.Result = false;
return;
}
if (wavData.NumSamples < startPos + outputSamples)
{
resultString = string.Format(rm.GetString("WavFileTooShort"), startPos + outputSamples, wavData.NumSamples, path) + "\r\n";
e.Result = false;
return;
}
}
Console.WriteLine(rm.GetString("WavFileSummary"), wavData.NumSamples);
resultString += string.Format(rm.GetString("WavFileSummary"), wavData.NumSamples);
double offset = (double)numericUpDownSubSampleOffset.Value;
if (checkBoxCh0.Checked && !checkBoxCh1.Checked)
{
using (StreamWriter sw = new StreamWriter(textBoxWriteFile.Text)) {
for (int i = startPos; i < startPos + outputSamples; ++i)
{
sw.WriteLine("{0} {1}", i + offset, wavData.Sample16Get(0, i));
}
}
}
else if (!checkBoxCh0.Checked && checkBoxCh1.Checked)
{
using (StreamWriter sw = new StreamWriter(textBoxWriteFile.Text)) {
for (int i = startPos; i < startPos + outputSamples; ++i)
{
sw.WriteLine("{0} {1}", i + offset, wavData.Sample16Get(1, i));
}
}
}
else if (checkBoxCh0.Checked && checkBoxCh1.Checked)
{
using (StreamWriter sw = new StreamWriter(textBoxWriteFile.Text)) {
for (int i = startPos; i < startPos + outputSamples; ++i)
{
sw.WriteLine("{0} {1} {2}", i + offset, wavData.Sample16Get(0, i), wavData.Sample16Get(1, i));
}
}
}
e.Result = true;
}
public WavViewModel(string name, WavData wavData)
{
Name = name;
Duration = wavData.NumberOfChunks * 50;
WavData = wavData;
WavByteData = wavData.GetByteData();
PlaySoundCommand = new RelayCommand(PlaySound);
SaveSoundCommand = new RelayCommand(SaveSound);
}
public double[] Equalize(double[] gains, WavData wavData)
{
var n = FourierHelper.GetExpandedPow2(_windowLength + _filterLength - 1);
var size = wavData.Samples.Length + n - _windowLength;
var result = new double[size];
var windows = new double[size / _windowHopSize][];
var windowsComplex = new Complex[size / _windowHopSize][];
for (int i = 0; i < windows.Length; i++)
{
windows[i] = new double[n];
windowsComplex[i] = new Complex[n];
}
var windowFactors = _window.WindowFactors(_windowLength);
var gainsComplex = GenerateGains(gains, wavData.FormatChunk.SampleRate, n);
for (int i = 0; i < windows.Length; i++)
{
for (int j = 0; j < _windowLength; j++)
{
if (i * _windowHopSize + j < wavData.Samples.Length)
{
windows[i][j] = windowFactors[j] * wavData.Samples[i * _windowHopSize + j];
}
else
{
windows[i][j] = 0;
}
}
for (int j = _windowLength; j < n; j++)
{
windows[i][j] = 0;
}
windowsComplex[i] = FourierTransform.FFT(windows[i]);
windowsComplex[i] = AdjustGain(gainsComplex, windowsComplex[i]);
windows[i] = FourierTransform.IFFT(windowsComplex[i]);
}
for (int i = 0; i < windows.Length; i++)
{
for (int j = 0; j < windows[i].Length; j++)
{
if (i * _windowHopSize + j < wavData.Samples.Length)
{
result[i * _windowHopSize + j] += windows[i][j];
}
}
}
return(result);
}
static WavData ReadWavFromFile(string path)
{
WavData wavData = new WavData();
using (BinaryReader br = new BinaryReader(File.Open(path, FileMode.Open))) {
if (!wavData.Read(br))
{
Console.WriteLine("E: Read failed. unknown format. {0}", path);
PrintUsageAndExit();
}
}
return(wavData);
}
public WavData ReadData()
{
var header = new WavHeader();
byte[] data;
using (var fs = new FileStream(FilePath, FileMode.Open, FileAccess.Read))
{
using (var reader = new BinaryReader(fs))
{
//считываем заголовок
header.ChunkId = reader.ReadInt32();
header.ChunkSize = reader.ReadInt32();
header.Format = reader.ReadInt32();
header.Subchunk1Id = reader.ReadInt32();
header.Subchunk1Size = reader.ReadInt32();
header.AudioFormat = reader.ReadInt16();
header.NumChannels = reader.ReadInt16();
header.SampleRate = reader.ReadInt32();
header.ByteRate = reader.ReadInt32();
header.BlockAlign = reader.ReadInt16();
header.BitsPerSample = reader.ReadInt16();
if (header.Subchunk1Size == 18)
{
header.FmtExtraSize = reader.ReadInt16();
reader.ReadBytes(header.FmtExtraSize);
}
//пытаемся считать данные
header.Subchunk2Id = reader.ReadInt32();
header.Subchunk2Size = reader.ReadInt32();
while (true)
{
data = reader.ReadBytes(header.Subchunk2Size);
if (header.Subchunk2Id == 0x61746164)
{
break;
} //данные найдены
//если Subchunk2Id нет тот, что ожидался, пропускаем и пробуем снова
header.Subchunk2Id = reader.ReadInt32();
header.Subchunk2Size = reader.ReadInt32();
}
}
}
var result = new WavData(header, data);
return(result);
}
private bool WriteWavFile(WavData wavData, string path)
{
bool rv = true;
try {
using (BinaryWriter bw1 = new BinaryWriter(File.Open(path, FileMode.Create))) {
wavData.Write(bw1);
}
} catch (System.Exception ex) {
Console.WriteLine(ex.ToString());
rv = false;
}
return(rv);
}
////////////////////////////////////////////////////////
public SignalGeneratorResult GenerateSignal(SignalGenerateParams s, out WavData wavData)
{
List <PcmSamples1Channel> samples = new List <PcmSamples1Channel>();
int nSample = s.seconds * s.sampleRate;
PcmSamples1Channel ch = new PcmSamples1Channel(nSample, s.bitsPerSample);
samples.Add(ch);
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
SignalGeneratorResult result = SignalGeneratorResult.Success;
double truncFreq = (s.sampleRate / 2) * s.truncationRatio;
switch (s.ss)
{
case SignalShape.SineWave:
result = GenerateSineWave(ch, s.sampleRate, s.freq, s.amplitude);
break;
case SignalShape.SquareWave:
result = GenerateSquareWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq);
break;
case SignalShape.SawToothWaveDesc:
result = GenerateSawToothWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq, false);
break;
case SignalShape.SawToothWaveAsc:
result = GenerateSawToothWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq, true);
break;
case SignalShape.TriangleWave:
result = GenerateTriangleWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq);
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
sw.Stop();
Console.WriteLine("{0} ms", sw.ElapsedMilliseconds);
wavData = new WavData();
wavData.Create(s.sampleRate, s.bitsPerSample, samples);
return(result);
}
private void SaveRecordedData()
{
var bytes = wasapi.GetCapturedData(mCapturedPcmData);
var nFrames = bytes / WasapiCS.SampleFormatTypeToUseBytesPerSample(mSampleFormat) / mNumChannels;
if (nFrames == 0)
{
return;
}
textBoxLog.Text += string.Format("captured frames={0} ({1:F1} seconds) glichCount={2}\r\n",
nFrames, (double)nFrames / mSamplingFrequency, wasapi.GetCaptureGlitchCount());
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.DefaultExt = ".wav";
dlg.Filter = "WAVEファイル|*.wav";
Nullable <bool> result = dlg.ShowDialog();
if (result != true)
{
return;
}
// あとで本のサイズに戻す。
var originalSize = mCapturedPcmData.Length;
Array.Resize(ref mCapturedPcmData, (int)bytes);
mWavData = new WavData();
mWavData.Set(mNumChannels, WasapiCS.SampleFormatTypeToUseBytesPerSample(mSampleFormat) * 8, WasapiCS.SampleFormatTypeToValidBitsPerSample(mSampleFormat),
mSamplingFrequency, SampleFormatToVRT(mSampleFormat), nFrames, mCapturedPcmData);
try {
using (BinaryWriter w = new BinaryWriter(File.Open(dlg.FileName, FileMode.Create))) {
mWavData.Write(w);
textBoxLog.Text += string.Format("ファイル保存成功: {0}\r\n", dlg.FileName);
}
} catch (Exception ex) {
string s = string.Format("E: ファイル保存失敗: {0}\r\n{1}\r\n", dlg.FileName, ex);
textBoxLog.Text += s;
MessageBox.Show(s);
}
slider1.Value = 0;
label1.Content = "0/0";
Array.Resize(ref mCapturedPcmData, originalSize);
}
private void Effect(WavData wavData)
{
if (checkBoxInvert.Checked) {
for (int ch=0; ch < wavData.NumChannels; ++ch) {
for (int pos=0; pos < wavData.NumSamples; ++pos) {
short val = wavData.Sample16Get(ch, pos);
// Invert! we want to do this effect
val = (short)-val;
wavData.Sample16Set(ch, pos, val);
}
}
}
}
public List <Sound> Calculate(WavData wavData)
{
var frequencies = new List <Sound>();
for (int i = 0; i < wavData.ChunkedSamples.Length; i++)
{
var samples = wavData.ChunkedSamples[i];
var reducedSamples = FourierHelper.ReduceToPow2(samples);
reducedSamples = FourierHelper.PreEmphasis(reducedSamples);
reducedSamples = _fourierWindow.Windowing(reducedSamples);
var complexSamples = FourierTransform.FFT(reducedSamples);
complexSamples = complexSamples.Take(complexSamples.Length / 2).ToArray();
var threshold = complexSamples.Max(c => c.Magnitude) / 10;
var localMax = 0;
for (int j = 1; j < complexSamples.Length; j++)
{
if (complexSamples[j].Magnitude > threshold && complexSamples[j].Magnitude > complexSamples[j - 1].Magnitude && complexSamples[j].Magnitude > complexSamples[j + 1].Magnitude)
{
localMax = j;
break;
}
}
var frequency = (wavData.FormatChunk.SampleRate / (complexSamples.Length * 2)) * localMax;
if (frequencies.Any() && frequencies.Last().Frequency == frequency)
{
frequencies.Last().EndTime += 50;
}
else
{
frequencies.Add(new Sound
{
StartTime = i * 50,
EndTime = i * 50 + 50,
Frequency = frequency,
Result = complexSamples.Select(c => c.Magnitude).ToArray()
});
}
}
return(frequencies);
}
private bool SaveWav(int sampleRate, int bitsPerSample, List <PcmSamples1Channel> samples, string path)
{
bool ret = true;
WavData wav = new WavData();
wav.Create(sampleRate, bitsPerSample, samples);
try {
using (BinaryWriter bw = new BinaryWriter(File.Open(path, FileMode.CreateNew))) {
wav.Write(bw);
}
} catch (Exception ex) {
resultString = ex.ToString();
ret = false;
}
return(ret);
}
private void Effect(WavData wavData)
{
if (checkBoxInvert.Checked)
{
for (int ch = 0; ch < wavData.NumChannels; ++ch)
{
for (int pos = 0; pos < wavData.NumSamples; ++pos)
{
short val = wavData.Sample16Get(ch, pos);
// Invert! we want to do this effect
val = (short)-val;
wavData.Sample16Set(ch, pos, val);
}
}
}
}
static void Main(string[] args)
{
OptionInfo optionInfo = new OptionInfo(2);
ParseOptions(ref optionInfo, args);
WavData ch0Wav = ReadWavFromFile(optionInfo.channels[0].chFileName);
WavData ch1Wav = ReadWavFromFile(optionInfo.channels[1].chFileName);
if (ch0Wav.NumSamples != ch1Wav.NumSamples)
{
Console.WriteLine("E: NumSamples mismatch. ch0.numSamples={0}, ch1.numSamples={1}",
ch0Wav.NumSamples, ch1Wav.NumSamples);
PrintUsageAndExit();
}
WavData writeWav = new WavData();
List <PcmSamples1Channel> channels = new List <PcmSamples1Channel>();
for (int i = 0; i < 2; ++i)
{
channels.Add(new PcmSamples1Channel(ch0Wav.NumSamples, ch0Wav.BitsPerSample));
}
int ch0UseCh = optionInfo.channels[0].chFileUseCh;
int ch1UseCh = optionInfo.channels[1].chFileUseCh;
for (int i = 0; i < ch0Wav.NumSamples; ++i)
{
channels[0].Set16(i, ch0Wav.Sample16Get(ch0UseCh, i));
channels[1].Set16(i, ch1Wav.Sample16Get(ch1UseCh, i));
}
writeWav.Create(ch0Wav.SampleRate, ch0Wav.BitsPerSample, channels);
try {
using (BinaryWriter bw = new BinaryWriter(File.Open(optionInfo.outputWavFileName, FileMode.CreateNew))) {
writeWav.Write(bw);
}
} catch (Exception ex) {
Console.WriteLine("E: {0}", ex);
PrintUsageAndExit();
}
}
private void UnixPlayThread(object state)
{
if (_unixPlayStopEvent.WaitOne(0))
{
return;
}
Stream stream = null;
AudioDevice dev = null;
try
{
lock (s_playSync)
{
dev = AudioDevice.CreateAlsaDevice(_latency);
stream = ReadFile((string)state);
_unixWavData = new WavData(_logger, stream, _unixPlayStopEvent);
}
_unixWavData.Setup(dev);
_unixWavData.Play(dev);
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
_logger.LogError(Message.SoundPlayError, ex, (string)state);
}
finally
{
if (dev != null)
{
dev.Dispose();
}
if (stream != null)
{
stream.Close();
}
if (_unixWavData == null || !_unixWavData.IsStopped)
{
PlayingStopped.RaiseEvent(this);
}
}
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
WavData wavData = ReadWavFile(textBoxInput.Text);
if (null == wavData)
{
e.Result = string.Format(rm.GetString("ReadWavFileFailed"), textBoxInput.Text) + "\r\n";
return;
}
Effect(wavData);
if (!WriteWavFile(wavData, textBoxOutput.Text))
{
e.Result = string.Format(rm.GetString("WriteWavFileFailed"), textBoxOutput.Text) + "\r\n";
return;
}
e.Result = string.Format(rm.GetString("WriteWavFileSucceeded"), textBoxOutput.Text) + "\r\n";
}
private WavData ReadWavFile(string path)
{
WavData wavData = new WavData();
Console.WriteLine(rm.GetString("ReadWavFileStarted"), path);
using (BinaryReader br1 = new BinaryReader(File.Open(path, FileMode.Open))) {
if (!wavData.Read(br1))
{
return(null);
}
if (16 != wavData.BitsPerSample)
{
return(null);
}
}
return(wavData);
}
////////////////////////////////////////////////////////
public SignalGeneratorResult GenerateSignal(SignalGenerateParams s, out WavData wavData)
{
List<PcmSamples1Channel> samples = new List<PcmSamples1Channel>();
int nSample = s.seconds * s.sampleRate;
PcmSamples1Channel ch = new PcmSamples1Channel(nSample, s.bitsPerSample);
samples.Add(ch);
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
SignalGeneratorResult result = SignalGeneratorResult.Success;
double truncFreq = (s.sampleRate / 2) * s.truncationRatio;
switch (s.ss) {
case SignalShape.SineWave:
result = GenerateSineWave(ch, s.sampleRate, s.freq, s.amplitude);
break;
case SignalShape.SquareWave:
result = GenerateSquareWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq);
break;
case SignalShape.SawToothWaveDesc:
result = GenerateSawToothWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq, false);
break;
case SignalShape.SawToothWaveAsc:
result = GenerateSawToothWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq, true);
break;
case SignalShape.TriangleWave:
result = GenerateTriangleWave(ch, s.sampleRate, s.freq, s.amplitude, truncFreq);
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
sw.Stop();
Console.WriteLine("{0} ms", sw.ElapsedMilliseconds);
wavData = new WavData();
wavData.Create(s.sampleRate, s.bitsPerSample, samples);
return result;
}
public double[] FilterData(WavData wavData)
{
var result = new double[wavData.Samples.Length + _filterLength - 1];
var filterFactors = BasicFilter.LowPassFilterFactors(_cutFreq, wavData.FormatChunk.SampleRate, _filterLength);
var filtered = _window.Windowing(filterFactors);
var data = wavData.Samples.ToList();
var zeros = new double[_filterLength - 1];
data.InsertRange(0, zeros);
data.AddRange(zeros);
for (int i = _filterLength - 1; i < data.Count; i++)
{
for (int j = 0; j < filtered.Length; j++)
{
result[i - _filterLength + 1] += data[i - j] * filtered[j];
}
}
return(result);
}
private void buttonStart_Click(object sender, EventArgs e)
{
textBoxConsole.Clear();
textBoxConsole.Text += string.Format(rm.GetString("ProcessStarted"),
textBoxWavFile1.Text, ReadFilePathToWriteFilePath(textBoxWavFile1.Text),
textBoxWavFile2.Text, ReadFilePathToWriteFilePath(textBoxWavFile2.Text)) + "\r\n";
wavRead1 = ReadWavFile(textBoxWavFile1.Text);
if (null == wavRead1)
{
textBoxConsole.Text += string.Format(rm.GetString("ReadWavFileFailed"), textBoxWavFile1.Text) + "\r\n";
return;
}
wavRead2 = ReadWavFile(textBoxWavFile2.Text);
if (null == wavRead2)
{
textBoxConsole.Text += string.Format(rm.GetString("ReadWavFileFailed"), textBoxWavFile2.Text) + "\r\n";
return;
}
if (wavRead1.SampleRate != wavRead2.SampleRate)
{
textBoxConsole.Text += string.Format(rm.GetString("SampleRateIsDifferent")) + "\r\n";
return;
}
if (wavRead1.NumChannels != wavRead2.NumChannels)
{
textBoxConsole.Text += string.Format(rm.GetString("NumChannelsIsDifferent")) + "\r\n";
return;
}
backgroundWorker1.RunWorkerAsync();
buttonStart.Enabled = false;
}
public void AddLR(WavData wd, int sampleNum, double start, double end)
{
double startTime = wd.RatioToTime(start);
double endTime = wd.RatioToTime(end);
double dt = (endTime - startTime) / sampleNum;
short[] left = wd.GetLeft(sampleNum, start, end);
short[] right = wd.GetRight(sampleNum, start, end);
chart.Series.Clear();
chart.Series.Add("L");
chart.Series["L"].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Line;
for (int i = 0; i < left.Length; i++)
{
double x = startTime + dt * i;
chart.Series["L"].Points.AddXY(x, left[i]);
}
chart.Series.Add("R");
chart.Series["R"].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Line;
for (int i = 0; i < right.Length; i++)
{
double x = startTime + dt * i;
chart.Series["R"].Points.AddXY(x, right[i]);
}
setXlim(startTime, endTime);
setYlim(Int16.MinValue+1, Int16.MaxValue - 1);
}
public void GenerateTime()
{
var wavData = new WavData(44100, Time);
SoundPlayerViewModel.AddSound("TimeFiltered", wavData);
}
public void GenerateOriginal()
{
var wavData = new WavData(44100, Original);
SoundPlayerViewModel.AddSound("Original", wavData);
}
public void GenerateFrequency()
{
var wavData = new WavData(44100, Frequency);
SoundPlayerViewModel.AddSound("FrequencyFiltered", wavData);
}
private void DoWork(object o, DoWorkEventArgs args)
{
Console.WriteLine("DoWork started\n");
int count = 0;
while (!asio.Run()) {
++count;
Console.WriteLine("\nForm1.DoWork() count={0} m_seconds={1}", count, m_seconds);
int percent = 100 * count / m_seconds;
if (100 < percent) {
percent = 100;
}
}
int[] recordedData = asio.RecordedDataGet(m_inputChannelNum, m_seconds * SAMPLE_RATE);
PcmSamples1Channel ch0 = new PcmSamples1Channel(m_seconds * SAMPLE_RATE, 16);
int max = 0;
int min = 0;
for (int i = 0; i < recordedData.Length; ++i) {
if (max < recordedData[i]) {
max = recordedData[i];
}
if (recordedData[i] < min) {
min = recordedData[i];
}
}
Console.WriteLine("max={0} min={1}", max, min);
if (max < -min) {
max = -min;
}
double mag = 32767.0 / max;
Console.WriteLine("mag={0}", mag);
for (int i = 0; i < recordedData.Length; ++i) {
ch0.Set16(i, (short)(recordedData[i] * mag));
}
List<PcmSamples1Channel> chList = new List<PcmSamples1Channel>();
chList.Add(ch0);
WavData wd = new WavData();
wd.Create(SAMPLE_RATE, 16, chList);
using (BinaryWriter bw = new BinaryWriter(File.Open(m_writeFilePath, FileMode.Create))) {
wd.Write(bw);
}
args.Result = 0;
Console.WriteLine("DoWork end\n");
}
static void Main(string[] args)
{
{
byte[] rawData16 = new byte[65536 * 2];
for (int i = 0; i < 65536; ++i) {
rawData16[i * 2] = (byte)(i & 0xff);
rawData16[i * 2 + 1] = (byte)(i >> 8);
}
WavData wdOrigI16 = new WavData();
wdOrigI16.CreateHeader(1, 44100, 16, 65536);
wdOrigI16.SetRawData(rawData16);
{
System.Console.WriteLine("I16 ==> I24 ==> I16 test");
WavData wdI24 = wdOrigI16.BitsPerSampleConvertTo(24, ValueRepresentationType.SInt);
WavData wdNew = wdI24.BitsPerSampleConvertTo(16, ValueRepresentationType.SInt);
byte[] b16to24 = wdI24.SampleRawGet();
byte[] bNew = wdNew.SampleRawGet();
int iMin = Int32.MaxValue;
int iMax = Int32.MinValue;
for (int i = 0; i < 65536; ++i) {
short vOrig = (short)((int)rawData16[i * 2] + (rawData16[i * 2 + 1] << 8));
int v16to24 =
((int)b16to24[i * 3] << 8)
+ (b16to24[i * 3 + 1] << 16)
+ (b16to24[i * 3 + 2] << 24);
int vNew24 = v16to24 / 256;
if (vNew24 < iMin) {
iMin = vNew24;
}
if (iMax < vNew24) {
iMax = vNew24;
}
short vNew = (short)((int)bNew[i * 2] + (bNew[i * 2 + 1] << 8));
if (0 != (vNew - vOrig)) {
System.Console.WriteLine("{0} ==> {1} via {2} diff={3} DIFFERENT! ################",
vOrig, vNew, vNew24, vNew - vOrig);
}
}
System.Console.WriteLine(" i24 min={0} max={1}",
iMin, iMax);
}
{
System.Console.WriteLine("I16 ==> I32 ==> I16 test");
WavData wdI32 = wdOrigI16.BitsPerSampleConvertTo(32, ValueRepresentationType.SInt);
WavData wdNew = wdI32.BitsPerSampleConvertTo(16, ValueRepresentationType.SInt);
byte[] b16toI32 = wdI32.SampleRawGet();
byte[] bNew = wdNew.SampleRawGet();
int iMin = Int32.MaxValue;
int iMax = Int32.MinValue;
for (int i = 0; i < 65536; ++i) {
short vOrig = (short)((int)rawData16[i * 2] + (rawData16[i * 2 + 1] << 8));
int vI32 = BitConverter.ToInt32(b16toI32, i * 4);
if (vI32 < iMin) {
iMin = vI32;
}
if (iMax < vI32) {
iMax = vI32;
}
short vNew = (short)((int)bNew[i * 2] + (bNew[i * 2 + 1] << 8));
if (0 != (vNew - vOrig)) {
System.Console.WriteLine("{0} ==> {1} via {2} diff={3} DIFFERENT!",
vOrig, vNew, vI32, vNew - vOrig);
}
}
System.Console.WriteLine(" i32 min={0} max={1}",
iMin, iMax);
}
{
System.Console.WriteLine("I16 ==> F32 ==> I16 test");
WavData wdF32 = wdOrigI16.BitsPerSampleConvertTo(32, ValueRepresentationType.SFloat);
WavData wdNew = wdF32.BitsPerSampleConvertTo(16, ValueRepresentationType.SInt);
byte[] b16toF32 = wdF32.SampleRawGet();
byte[] bNew = wdNew.SampleRawGet();
float fMin = float.MaxValue;
float fMax = float.MinValue;
for (int i = 0; i < 65536; ++i) {
short vOrig = (short)((int)rawData16[i * 2] + (rawData16[i * 2 + 1] << 8));
float vF32 = BitConverter.ToSingle(b16toF32, i * 4);
if (vF32 < fMin) {
fMin = vF32;
}
if (fMax < vF32) {
fMax = vF32;
}
short vNew = (short)((int)bNew[i * 2] + (bNew[i * 2 + 1] << 8));
if (0 != (vNew - vOrig)) {
System.Console.WriteLine("{0} ==> {1} via {2} diff={3} DIFFERENT!",
vOrig, vNew, vF32, vNew - vOrig);
}
}
System.Console.WriteLine(" fMin={0} fMax={1}", fMin, fMax);
}
}
{
byte[] rawData24 = new byte[16777216 * 3];
for (int i = 0; i < 16777216; ++i) {
rawData24[i * 3] = (byte)(i & 0xff);
rawData24[i * 3 + 1] = (byte)(i >> 8);
rawData24[i * 3 + 2] = (byte)(i >> 16);
}
WavData wdOrigI24 = new WavData();
wdOrigI24.CreateHeader(1, 44100, 24, 16777216);
wdOrigI24.SetRawData(rawData24);
{
System.Console.WriteLine("I24 ==> I32 ==> I24 test");
WavData wdI32 = wdOrigI24.BitsPerSampleConvertTo(32, ValueRepresentationType.SInt);
WavData wdNew = wdI32.BitsPerSampleConvertTo(24, ValueRepresentationType.SInt);
byte[] b24to32 = wdI32.SampleRawGet();
byte[] bNew = wdNew.SampleRawGet();
int iMin = Int32.MaxValue;
int iMax = Int32.MinValue;
for (int i = 0; i < 16777216; ++i) {
int vOrig32 = ((int)rawData24[i * 3]<<8)
+ (rawData24[i * 3 + 1] << 16)
+ (rawData24[i * 3 + 2] << 24);
int vOrig24 = vOrig32 / 256;
int v24to32 = BitConverter.ToInt32(b24to32, i * 4);
if (v24to32 < iMin) {
iMin = v24to32;
}
if (iMax < v24to32) {
iMax = v24to32;
}
int vNew32 = ((int)bNew[i * 3] << 8)
+ (bNew[i * 3 + 1] << 16)
+ (bNew[i * 3 + 2] << 24);
int vNew24 = vNew32 / 256;
if (0 != (vNew24 - vOrig24)) {
System.Console.WriteLine("{0} ==> {1} via {2} diff={3} DIFFERENT! ################",
vOrig24, vNew24, v24to32, vNew24 - vOrig24);
}
}
System.Console.WriteLine(" i32 min={0} max={1}",
iMin, iMax);
}
{
System.Console.WriteLine("I24 ==> F32 ==> I24 test");
WavData wdF32 = wdOrigI24.BitsPerSampleConvertTo(32, ValueRepresentationType.SFloat);
WavData wdNew = wdF32.BitsPerSampleConvertTo(24, ValueRepresentationType.SInt);
byte[] b24toF32 = wdF32.SampleRawGet();
byte[] bNew = wdNew.SampleRawGet();
float fMin = float.MaxValue;
float fMax = float.MinValue;
for (int i = 0; i < 16777216; ++i) {
int vOrig32 = ((int)rawData24[i * 3] << 8)
+ (rawData24[i * 3 + 1] << 16)
+ (rawData24[i * 3 + 2] << 24);
int vOrig24 = vOrig32 / 256;
float vF32 = BitConverter.ToSingle(b24toF32, i * 4);
if (vF32 < fMin) {
fMin = vF32;
}
if (fMax < vF32) {
fMax = vF32;
}
int vNew32 = ((int)bNew[i * 3] << 8)
+ (bNew[i * 3 + 1] << 16)
+ (bNew[i * 3 + 2] << 24);
int vNew24 = vNew32 / 256;
if (0 != (vNew24 - vOrig24)) {
System.Console.WriteLine("{0} ==> {1} via {2} diff={3} DIFFERENT! ################",
vOrig24, vNew24, vF32, vNew24 - vOrig24);
}
}
System.Console.WriteLine(" fMin={0} fMax={1}", fMin, fMax);
}
}
System.Console.WriteLine("done.");
}
private void SaveRecordedData()
{
var bytes = wasapi.GetCapturedData(mCapturedPcmData);
var nFrames = bytes / WasapiCS.SampleFormatTypeToUseBytesPerSample(mSampleFormat) / mNumChannels;
if (nFrames == 0) {
return;
}
textBoxLog.Text += string.Format("captured frames={0} ({1:F1} seconds) glichCount={2}\r\n",
nFrames, (double)nFrames / mSamplingFrequency, wasapi.GetCaptureGlitchCount());
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.DefaultExt = ".wav";
dlg.Filter = "WAVEファイル|*.wav";
Nullable<bool> result = dlg.ShowDialog();
if (result != true) {
return;
}
// あとで本のサイズに戻す。
var originalSize = mCapturedPcmData.Length;
Array.Resize(ref mCapturedPcmData, (int)bytes);
mWavData = new WavData();
mWavData.Set(mNumChannels, WasapiCS.SampleFormatTypeToUseBytesPerSample(mSampleFormat) * 8, WasapiCS.SampleFormatTypeToValidBitsPerSample(mSampleFormat),
mSamplingFrequency, SampleFormatToVRT(mSampleFormat), nFrames, mCapturedPcmData);
try {
using (BinaryWriter w = new BinaryWriter(File.Open(dlg.FileName, FileMode.Create))) {
mWavData.Write(w);
textBoxLog.Text += string.Format("ファイル保存成功: {0}\r\n", dlg.FileName);
}
} catch (Exception ex) {
string s = string.Format("E: ファイル保存失敗: {0}\r\n{1}\r\n", dlg.FileName, ex);
textBoxLog.Text += s;
MessageBox.Show(s);
}
slider1.Value = 0;
label1.Content = "0/0";
Array.Resize(ref mCapturedPcmData, originalSize);
}
private bool WriteWavFile(WavData wavData, string path)
{
Console.WriteLine(rm.GetString("WriteWavFileStarted"), path);
bool rv = true;
try {
using (BinaryWriter bw1 = new BinaryWriter(File.Open(path, FileMode.Create))) {
wavData.Write(bw1);
}
} catch (System.Exception ex) {
Console.WriteLine(ex.ToString());
rv = false;
}
return rv;
}
private WavData ReadWavFile(string path)
{
WavData wavData = new WavData();
Console.WriteLine(rm.GetString("ReadWavFileStarted"), path);
using (BinaryReader br1 = new BinaryReader(File.Open(path, FileMode.Open))) {
if (!wavData.Read(br1)) {
return null;
}
if (16 != wavData.BitsPerSample) {
return null;
}
}
return wavData;
}
