private static byte[] ReadWaveSamples(
string file,
float volume)
{
var samples = default(byte[]);
var vol = volume > 1.0f ? 1.0f : volume;
using (var audio = new AudioFileReader(file)
{
Volume = vol
})
using (var resampler = new MediaFoundationResampler(audio, DefaultOutputFormat))
using (var output = new MemoryStream(51200))
using (var wrap = new WrappingStream(output))
{
WaveFileWriter.WriteWavFileToStream(wrap, resampler);
wrap.Flush();
wrap.Position = 0;
// ヘッダをカットする
var raw = wrap.ToArray();
var headerLength = 0;
using (var wave = new WaveFileReader(wrap))
{
headerLength = (int)(raw.Length - wave.Length);
}
// ヘッダをスキップした波形データを取得する
samples = raw.Skip(headerLength).ToArray();
}
return(samples);
}
public async Task SpeechToText()
{
//var authData = GenerateAuthData(path, AccessKey, SecretKey, ContractId);
//var authString = GenerateAuthString(authData);
//var uri = $"{endpoint}?auth={authString}";
var jwtToken = await HttpUtils.GenerateJwtDataAsync(AccessKey, SecretKey, 3 * 60 /* 3 minutes */, jwtEndpoint);
var uri = $"{sttEndpoint}?token=Bearer {jwtToken}";
var waveIn = new WaveInEvent();
// デフォルト録音デバイスを利用します。
waveIn.DeviceNumber = 0;
// サンプルレート、ビットレート、チャンネル数を16000Hz、16bits、1に指定します。
waveIn.WaveFormat = new WaveFormat(16000, 16, 1);
waveIn.DataAvailable += (object sender, WaveInEventArgs e) =>
{
var inputMemStream = new MemoryStream(e.Buffer);
var rawWaveStream = new RawSourceWaveStream(inputMemStream, waveIn.WaveFormat);
var outputMemStream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(outputMemStream, rawWaveStream);
audioBuffers.Enqueue(outputMemStream.ToArray());
};
waveIn.RecordingStopped += (object sender, StoppedEventArgs e) =>
{
clientAsyncTokenSource.Cancel();
};
var client = new ClientWebSocket();
await client.ConnectAsync(new Uri(uri), CancellationToken.None);
// 日本語の音声を認識します。
_ = await SetLanguageAsync(client, "ja");
_ = await SetSamplingRateAsync(client, 16000);
try
{
waveIn.StartRecording();
Console.WriteLine("（音声認識：認識中です。）");
var sendLoop = this.InitSendLoop(client);
var readLoop = this.InitReadLoop(client);
Console.Read();
waveIn.StopRecording();
Console.WriteLine("（音声認識：完了しました。）");
await sendLoop;
await readLoop;
await client.CloseAsync(WebSocketCloseStatus.NormalClosure, "OK", CancellationToken.None);
}
catch (OperationCanceledException)
{
Console.WriteLine("（音声認識：サーバとの通信を止めました。）");
}
}
private async void SendTempBuffer()
{
if (TempBuffer.Count == 0)
{
return;
}
using (var ms1 = new MemoryStream())
{
using (var wfw = new WaveFileWriter(ms1, Capturer.WaveFormat))
{
wfw.Write(TempBuffer.ToArray(), 0, TempBuffer.Count);
}
TempBuffer.Clear();
// Resample to 16-bit so Firefox will play it.
using (var ms2 = new MemoryStream(ms1.ToArray()))
using (var wfr = new WaveFileReader(ms2))
using (var ms3 = new MemoryStream())
{
using (var resampler = new MediaFoundationResampler(wfr, TargetFormat))
{
WaveFileWriter.WriteWavFileToStream(ms3, resampler);
}
var conductor = ServiceContainer.Instance.GetRequiredService <Conductor>();
await conductor.CasterSocket.SendAudioSample(ms3.ToArray(), Program.Conductor.Viewers.Keys.ToList());
}
}
}
public byte[] adjustSpeed(byte[] data, double speedFactor)
{
MemoryStream msInput = new MemoryStream(data);
MemoryStream msOutput = new MemoryStream();
string tempfilename = $"{DateTime.Now.ToFileTimeUtc()}.wav";
using (var reader = new WaveFileReader(msInput))
{
var stupidIeeeNecessity = WaveFormat.CreateIeeeFloatWaveFormat(reader.WaveFormat.SampleRate, reader.WaveFormat.Channels);
using (var resampler = new MediaFoundationResampler(reader, stupidIeeeNecessity))
{
WaveFileWriter.CreateWaveFile(tempfilename, resampler);
}
}
using (var ieeeReader = new WaveFileReader(tempfilename))
{
var stwp = new SoundTouchWaveProvider(ieeeReader);
stwp.Tempo = speedFactor;
WaveFileWriter.WriteWavFileToStream(msOutput, stwp);
}
File.Delete(tempfilename);
return(msOutput.ToArray());
}
/// <summary>
/// Resample source into 16 bit WAV mono output with the target sampling rate.
/// Output stream includes modified RIFF header.
/// </summary>
/// <param name="sourceStream"></param>
/// <param name="targetSampleRate"></param>
/// <param name="targetChannels"></param>
/// <returns></returns>
public static MemoryStream Resample(MemoryStream sourceStream, int targetSampleRate)
{
/*Read from the wav file's contents using stream */
using (var inputReader = new WaveFileReader(sourceStream))
{
int sourceChannels = inputReader.WaveFormat.Channels;
WdlResamplingSampleProvider resampler;
/*Stereo source. Must convert to mono with StereoToMonoSampleProvider */
if (sourceChannels == 2)
{
var monoSampleProvider = new StereoToMonoSampleProvider(inputReader.ToSampleProvider());
resampler = new WdlResamplingSampleProvider(monoSampleProvider, targetSampleRate);
}
else
{
resampler = new WdlResamplingSampleProvider(inputReader.ToSampleProvider(), targetSampleRate);
}
MemoryStream outStream = new MemoryStream();
/*Ensure that header has correct RIFF format with data appended after header.*/
WaveFileWriter.WriteWavFileToStream(outStream, resampler.ToWaveProvider16());
outStream.Position = 0;
return(outStream);
}
}
private void SendTempBuffer()
{
if (TempBuffer.Count == 0)
{
return;
}
using (var ms1 = new MemoryStream())
{
using (var wfw = new WaveFileWriter(ms1, Capturer.WaveFormat))
{
wfw.Write(TempBuffer.ToArray(), 0, TempBuffer.Count);
}
TempBuffer.Clear();
// Resample to 16-bit so Firefox will play it.
using (var ms2 = new MemoryStream(ms1.ToArray()))
using (var wfr = new WaveFileReader(ms2))
using (var ms3 = new MemoryStream())
{
using (var resampler = new MediaFoundationResampler(wfr, TargetFormat))
{
WaveFileWriter.WriteWavFileToStream(ms3, resampler);
}
AudioSampleReady?.Invoke(this, ms3.ToArray());
}
}
}
public async Task <IActionResult> Test()
{
try
{
var file = Request.Form.Files.First();
int outRate = 44000;
var source = new RawSourceWaveStream(file.OpenReadStream(), new WaveFormat(outRate, 2));
using (var wavFileReader = new WaveFileReader(source))
{
var resampler = new WdlResamplingSampleProvider(wavFileReader.ToSampleProvider(), 16000);
var monoSource = resampler.ToMono().ToWaveProvider16();
using (var outputStream = new MemoryStream())
{
WaveFileWriter.WriteWavFileToStream(outputStream, monoSource);
outputStream.Seek(0, SeekOrigin.Begin);
var result = await client.VerifyAsync(outputStream, Guid.Parse("fb786241-9f01-41cc-a585-50b65bd52c38"));
if (result.Result == Result.Accept)
{
// verification successful
}
}
}
}
catch (Exception e)
{
int x = 1;
}
return(Ok());
}
public IWaveProvider Convert()
{
using (Stream stream = new MemoryStream(buffer))
{
using (var rawStream = new RawSourceWaveStream(stream, new WaveFormat(48000, 16, 1)))
using (var downsample = new WaveFormatConversionStream(new WaveFormat(44100, 16, 1), rawStream))
using (var outputStream = new MemoryStream())
{
WaveFileWriter.WriteWavFileToStream(outputStream, downsample.ToSampleProvider().ToWaveProvider16());
var outputData = outputStream.ToArray();
waveBufferSize = outputData.Length;
BufferedWaveProvider bufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(44100, 1));
if (outputData.Length < bufferedWaveProvider.BufferLength)
{
bufferedWaveProvider.AddSamples(outputData, 0, outputData.Length);
}
else
{
bufferedWaveProvider.AddSamples(outputData, 0, bufferedWaveProvider.BufferLength);
}
IWaveProvider finalStream = new Wave16ToFloatProvider(bufferedWaveProvider);
return(finalStream);
}
}
}
public override void WriteToStream(Stream stream)
{
using (Stream source = Source.GetStream())
using (BinaryReader reader = new BinaryReader(source, Encoding.ASCII, true))
{
string magic = Encoding.ASCII.GetString(reader.ReadBytes(3));
if (Magic != magic)
{
throw new InvalidDataException("Supplied file is not an XGG wrapped file.");
}
byte version = reader.ReadByte();
if (version != Version)
{
throw new InvalidDataException("Supplied XGG wrapped file is of an incompatible version.");
}
FrameSize = reader.ReadInt32();
Bitrate = reader.ReadInt32();
uint count = reader.ReadUInt16();
using (OpusWaveProvider wav = new OpusWaveProvider(source, count))
WaveFileWriter.WriteWavFileToStream(stream, wav);
}
}
/// <summary>
/// Convert the mp3 file into wav format and return it
/// </summary>
/// <returns>The wav conversion of the mp3 file</returns>
private byte[] GenerateWav()
{
Mp3FileReader mp3 = new Mp3FileReader(mp3_path);
MemoryStream stream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(stream, mp3);
return(stream.ToArray());
}
public static void ChangeVolume(float volume, Stream source, Stream target)
{
var reader = new WaveFileReader(source);
var vp = new VolumeWaveProvider16(reader);
vp.Volume = volume;
WaveFileWriter.WriteWavFileToStream(target, vp);
}
private MemoryStream GetResolutionNoDO(string doNoteName, ResolutionType resolutionType)
{
double bpm = double.Parse(ConfigurationManager.AppSettings["BPM"]);
double quarterNotemillis = (60 / bpm) * 1000;
TimeSpan quarterNoteDuration = TimeSpan.FromMilliseconds(quarterNotemillis);
TimeSpan halfNoteDuration = quarterNoteDuration.Add(quarterNoteDuration);
TimeSpan wholeNoteDuration = halfNoteDuration.Add(halfNoteDuration);
string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);
doFileName = Path.GetFileName(doFileName);
int doNoteNumber = int.Parse(doFileName.Split('.')[0]);
ISampleProvider note1;
ISampleProvider note2;
switch (resolutionType)
{
case ResolutionType.DoDoReDo:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor2nd, halfNoteDuration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
break;
case ResolutionType.DoDoFaMi:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, halfNoteDuration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, wholeNoteDuration);
break;
case ResolutionType.DoDoLaSo:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor6th, halfNoteDuration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect5th, wholeNoteDuration);
break;
case ResolutionType.DoDoTiHighDo:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, halfNoteDuration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber + 12, wholeNoteDuration);
break;
case ResolutionType.DoDoLowTiDo:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.DownMinor2nd, halfNoteDuration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber, wholeNoteDuration);
break;
default:
throw new NotSupportedException($"ResolutionType '{resolutionType}' is not supported.");
}
ISampleProvider phrase = note1
.FollowedBy(note2);
SampleToWaveProvider stwp = new SampleToWaveProvider(phrase);
MemoryStream wavStream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
wavStream.Position = 0;
return(wavStream);
}
private static async Task ConvertWaveProviderToMp3File(IWaveProvider waveProvider, string outPutFile, LAMEPreset lamePreset, CancellationToken ctx = default)
{
await using var memoryStream = new MemoryStream();
using var reader = new StreamReader(memoryStream);
WaveFileWriter.WriteWavFileToStream(memoryStream, waveProvider);
await using var lameMp3FileWriter = new LameMP3FileWriter(outPutFile, waveProvider.WaveFormat, lamePreset);
await reader.BaseStream.CopyToAsync(lameMp3FileWriter, ctx);
}
public Stream ToWave(Stream stream)
{
var mem = new MemoryStream();
var waveStream = MakeDecodingStream(stream);
WaveFileWriter.WriteWavFileToStream(mem, waveStream);
mem.Flush();
mem.Position = 0;
return(mem);
}
/// <returns>The audio sample content as wave format byte array.</returns>
public byte[] GetBytes()
{
MemoryStream outStream =
new MemoryStream(BlockAlignReductionStream.WaveFormat.AverageBytesPerSecond * 4);
BlockAlignReductionStream.Seek(0, SeekOrigin.Begin);
WaveFileWriter.WriteWavFileToStream(outStream, BlockAlignReductionStream);
BlockAlignReductionStream.Seek(0, SeekOrigin.Begin);
return(outStream.ToArray());
}
public static byte[] Mp3ToWav(byte[] MP3)
{
using (MemoryStream INPUT = new MemoryStream(MP3))
using (Mp3FileReader mp3 = new Mp3FileReader(INPUT))
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
using (MemoryStream OUTPUT = new MemoryStream()) {
WaveFileWriter.WriteWavFileToStream(OUTPUT, pcm);
return(OUTPUT.ToArray());
}
}
private static MemoryStream Mp3ToWav(Stream mp3File)
{
using Mp3FileReader reader = new Mp3FileReader(mp3File);
using WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader);
MemoryStream ms = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(ms, pcmStream);
ms.Position = 0;
return(ms);
}
public static byte[] ToWavData(byte[] bytes)
{
using (var mp3Stream = new MemoryStream(bytes))
using (var outStream = new MemoryStream())
using (var reader = new Mp3FileReader(mp3Stream, wf => new Mp3FrameDecompressor(wf)))
{
WaveFileWriter.WriteWavFileToStream(outStream, new WaveFloatTo16Provider(reader));
return(outStream.ToArray());
}
}
private byte[] ConvertMp3ToWav(byte[] data)
{
using (var ms = new MemoryStream())
using (var mp3 = new Mp3FileReader(new MemoryStream(data)))
using (var pcm = WaveFormatConversionStream.CreatePcmStream(mp3))
{
WaveFileWriter.WriteWavFileToStream(ms, pcm);
return(ms.ToArray());
}
}
public CachedSound(string audioFileName)
{
var newFileName = CachePath;
if (!File.Exists(audioFileName))
{
foreach (var ext in _supportExtensions)
{
var autoAudioFile = audioFileName + ext;
if (!File.Exists(autoAudioFile))
{
continue;
}
audioFileName = autoAudioFile;
break;
}
}
try
{
int outRate = 44100;
int channels = 2;
var outFormat = new WaveFormat(outRate, channels);
using (var audioFileReader = new MyAudioFileReader(audioFileName))
using (var resampler = new MediaFoundationResampler(audioFileReader, outFormat))
using (var stream = new FileStream(newFileName, FileMode.Create))
{
resampler.ResamplerQuality = 60;
WaveFileWriter.WriteWavFileToStream(stream, resampler);
}
}
catch (Exception e)
{
Console.WriteLine(audioFileName);
throw;
}
using (var audioFileReader = new AudioFileReader(newFileName))
{
WaveFormat = audioFileReader.WaveFormat;
var wholeFile = new List <float>((int)(audioFileReader.Length / 4));
var readBuffer = new float[audioFileReader.WaveFormat.SampleRate * audioFileReader.WaveFormat.Channels];
int samplesRead;
while ((samplesRead = audioFileReader.Read(readBuffer, 0, readBuffer.Length)) > 0)
{
wholeFile.AddRange(readBuffer.Take(samplesRead));
}
AudioData = wholeFile.ToArray();
}
}
private MemoryStream GetHarmonicDrill(string doNoteName, L1C7HarmonicDrillType drillType)
{
TimeSpan duration = TimeSpan.FromSeconds(3);
string doFileName = NAudioHelper.GetFileNameFromNoteName(doNoteName);
doFileName = Path.GetFileName(doFileName);
int doNoteNumber = int.Parse(doFileName.Split('.')[0]);
ISampleProvider note1, note2;
switch (drillType)
{
// Minor 2nds.
case L1C7HarmonicDrillType.MiFa2nd:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor3rd, duration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, duration);
break;
case L1C7HarmonicDrillType.TiDo2nd:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfectOctave, duration);
break;
// Major 7ths.
case L1C7HarmonicDrillType.DoTi7th:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber, duration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor7th, duration);
break;
case L1C7HarmonicDrillType.FaMi7th:
note1 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpPerfect4th, duration);
note2 = NAudioHelper.GetSampleProvider(doNoteNumber + Interval.UpMajor10th, duration);
break;
default:
throw new NotSupportedException($"L1C7HarmonicDrillType '{drillType}' is not supported.");
}
MixingSampleProvider msp = new MixingSampleProvider(note1.WaveFormat);
msp.AddMixerInput(note1);
msp.AddMixerInput(note2);
var stwp = new SampleToWaveProvider(msp);
MemoryStream wavStream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
wavStream.Position = 0;
return(wavStream);
}
/// <summary>
/// MP3 to WAV conversion.
/// </summary>
/// <param name="mp3Stream"></param>
/// <returns></returns>
public static byte[] ConvertMP3(this Stream mp3Stream)
{
using var reader = new Mp3FileReader(mp3Stream);
using var resampled = new WaveFormatConversionStream(
new WaveFormat(
rate: audio_sample_rate,
bits: audio_bit_per_sample,
channels: audio_channels),
reader);
using var wavStream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(wavStream, resampled);
return(wavStream.ToArray());
}
private static async Task <Stream> ConvertWaveProviderToMp3Stream(IWaveProvider waveProvider, Stream outStream, LAMEPreset lamePreset, CancellationToken ctx = default)
{
var memoryStream = new MemoryStream();
using var streamReader = new StreamReader(memoryStream);
WaveFileWriter.WriteWavFileToStream(memoryStream, waveProvider);
await using var lameMp3StreamWriter = new LameMP3FileWriter(outStream, waveProvider.WaveFormat, lamePreset);
await streamReader.BaseStream.CopyToAsync(lameMp3StreamWriter, ctx);
return(outStream);
}
private MemoryStream WaveFormatConversion(MemoryStream memoryStream, WaveFormat waveFormat)
{
using (var reader = new WaveFileReader(memoryStream))
{
var newFormat = new WaveFormat(16000, 16, 1);
using (var resampler = new MediaFoundationResampler(reader, newFormat))
{
MemoryStream ConvertStream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(ConvertStream, resampler);
return(ConvertStream);
}
}
}
public override void WriteToStream(Stream stream)
{
using (Stream source = Source.GetStream())
{
//byte[] buffer = new byte[Source.Size];
//source.Read(buffer, 0, (int)Source.Size);
//using (MemoryStream mem = new MemoryStream(buffer))
//using (Mp3FileReader mp3 = new Mp3FileReader(mem))
using (OpusWaveProvider wav = new OpusWaveProvider(source, Source.Size))
{
WaveFileWriter.WriteWavFileToStream(stream, wav);
}
}
}
public byte[] raiseVolume(byte[] data, int decibels)
{
MemoryStream msInput = new MemoryStream(data);
MemoryStream msOutput = new MemoryStream();
double percentage = Math.Pow(10, ((double)decibels) / 10);
using (var reader = new WaveFileReader(msInput))
{
var volumeProvider = new VolumeWaveProvider16(reader);
volumeProvider.Volume = (float)percentage;
WaveFileWriter.WriteWavFileToStream(msOutput, volumeProvider);
return(msOutput.ToArray());
}
}
public ActionResult GetNoteEx(string doNoteName, int type)
{
int doNoteNumber = NoteHelper.NoteNumberFromNoteName(doNoteName);
int thisNoteNumber = doNoteNumber + type;
ISampleProvider note = NAudioHelper.GetSampleProvider(thisNoteNumber, TimeSpan.FromSeconds(3));
var stwp = new SampleToWaveProvider(note);
MemoryStream wavStream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
wavStream.Position = 0;
wavStream.WavToMp3File(out string fileName);
return(Redirect($"~/Temp/{fileName}"));
}
public ActionResult GetDOEx(string doNoteName)
{
_log.Info("Entered. Getting the note...");
ISampleProvider note = NAudioHelper.GetSampleProvider(doNoteName, TimeSpan.FromSeconds(2));
_log.Info("Got the note");
var stwp = new SampleToWaveProvider(note);
MemoryStream wavStream = new MemoryStream();
WaveFileWriter.WriteWavFileToStream(wavStream, stwp);
wavStream.Position = 0;
wavStream.WavToMp3File(out string fileName);
return(Redirect($"~/Temp/{fileName}"));
}
public static byte[] ConvertToAzureWav(byte[] rawAudio)
{
MemoryStream outStream = new MemoryStream();
using (var waveFileReader = new RawSourceWaveStream(new MemoryStream(rawAudio), new WaveFormat()))
{
var outFormat = new WaveFormat(16000, 1);
using (var resampler = new MediaFoundationResampler(waveFileReader, outFormat))
{
WaveFileWriter.WriteWavFileToStream(outStream, resampler);
}
}
return(outStream.ToArray());
}
/// <summary>
/// Once the mp3 music file has been loaded as raw bytes, this function can uncompress them into a WAV clip.
/// </summary>
private static void LoadMp3AsClip()
{
if (RawMusicFile != null && RawMusicFile.Length > 0)
{
MemoryStream waveStream = new MemoryStream();
Mp3FileReader mp3Stream = new Mp3FileReader(new MemoryStream(RawMusicFile));
WaveFileWriter.WriteWavFileToStream(waveStream, mp3Stream);
RawWaveFile = waveStream.ToArray();
LoadSuccess = true;
}
else
{
LoadSuccess = false;
}
}
