public byte[] Encode()
{
int ms = 20;
int channels = 2;
int sampleRate = 48000;
int blockSize = 48 * 2 * channels * ms; //the size per each frame to encode
byte[] buffer = new byte[blockSize]; //a nicely sized pcm buffer to work with.
var outFormat = new WaveFormat(sampleRate, 16, channels);
if(__filename.EndsWith(".mp3"))
{
using (var mp3Reader = new Mp3FileReader(__filename))
{
using (var resampler = new WaveFormatConversionStream(outFormat, mp3Reader))
{
int byteCount;
using (BinaryWriter bw = new BinaryWriter(new MemoryStream()))
{
while ((byteCount = resampler.Read(buffer, 0, blockSize)) > 0)
{
//now to encode
byte[] opusOutput = new byte[buffer.Length]; //extra bytes but that's okay
int opusEncoded = encoder.EncodeFrame(buffer, 0, opusOutput);
bw.Write((ushort)opusEncoded);
bw.Write(opusOutput, 0, opusEncoded);
}
MemoryStream baseStream = bw.BaseStream as MemoryStream;
return baseStream.ToArray();
}
}
}
}
return null;
}
public TestMix()
{
//WaveStream str1 = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\guitar1.mp3");
//WaveStream str2 = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\molecules.mp3");
//WaveMixerStream32 mix = new WaveMixerStream32(new [] {str1, str2}, false);
var background = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\ferriss.mp3");
var message = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\guitar1.mp3");
var mixer = new WaveMixerStream32();
mixer.AutoStop = true;
var messageOffset = background.TotalTime;
var messageOffsetted = new WaveOffsetStream(message, TimeSpan.FromSeconds(1.5), TimeSpan.Zero, message.TotalTime.Subtract(TimeSpan.FromSeconds(1)));
var background32 = new WaveChannel32(background);
background32.PadWithZeroes = false;
background32.Volume = 0.9f;
var message32 = new WaveChannel32(messageOffsetted);
message32.PadWithZeroes = false;
message32.Volume = 0.7f;
var s1 = new RawSourceWaveStream(background32, new WaveFormat(8000, 16, 1));
var s2 = new RawSourceWaveStream(message32, new WaveFormat(8000, 16, 1));
WaveFormat targetFormat = WaveFormat.CreateIeeeFloatWaveFormat(128, 2);
var ss1 = new WaveFormatConversionStream(targetFormat, background32);
//var c = new WaveFormatConversionStream(WaveFormat.CreateALawFormat(8000, 1), background32);
//var stream_background32 = new WaveFormatConversionStream(new WaveFormat(256, 32, 2), background32);
//var stream_message32 = new WaveFormatConversionStream(new WaveFormat(256, 32, 2), message32);
mixer.AddInputStream(s1);
mixer.AddInputStream(s2);
WaveFileWriter.CreateWaveFile("mycomposed.wav", new Wave32To16Stream(mixer));
}
public TestSpeed()
{
//WaveStream str1 = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\guitar1.mp3");
//WaveStream str2 = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\molecules.mp3");
//WaveMixerStream32 mix = new WaveMixerStream32(new [] {str1, str2}, false);
var mp3Filename = @"C:\WS\jmerde\trunk\_VisualStudio\AudioBooker\IlyaFranker\Content\snd\ilyafrank_open.mp3";
WavComposite writer = new WavComposite("../../wawa.wav");
writer.AppendAllOfFile(mp3Filename, null);
writer.AppendAllOfFile(mp3Filename, 2);
writer.AppendAllOfFile(mp3Filename, 0.5);
writer.Close();
//format = readerWave.WaveFormat;
//writer = new WaveFileWriter(destFilename, format);
//var wave = new Mp3FileReader(mp3Filename);
using (var reader = new Mp3FileReader(mp3Filename))
using (var pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
using (var downsampledStream = new WaveFormatConversionStream(new WaveFormat(
(int)(pcmStream.WaveFormat.SampleRate * 1.5),
reader.WaveFormat.BitsPerSample,
reader.WaveFormat.Channels), pcmStream))
{
WaveFileWriter.CreateWaveFile("../../xello.wav", downsampledStream);
}
}
public void CanEncodeGsm()
{
using (var reader = CreatePcmTestStream())
{
using (var gsm = new WaveFormatConversionStream(new Gsm610WaveFormat(), reader))
{
WaveFileWriter.CreateWaveFile(@"C:\Users\Mark\Code\CodePlex\gsm.wav", gsm);
}
}
}
private void changeSampleRate(String fileName)
{
float sampleRateMultiplier;
using (var reader = new WaveFileReader(fileName))
{
var newFormat = new WaveFormat(Convert.ToInt32(8000*getSampleRateMultiplier()), 16, 1); //ex, 8000 is the base sample rate
using (var conversionStream = new WaveFormatConversionStream(newFormat, reader))
{
WaveFileWriter.CreateWaveFile("output.wav", conversionStream);
}
}
}
public PlaywavAction(String file)
{
_file = file;
using (var reader = CreateWavStream(_file))
{
var newFormat = new WaveFormat(48000, 16, 1);
using (var conversionStream = new WaveFormatConversionStream(newFormat, reader))
{
WaveFileWriter.CreateWaveFile(_file + ".sampled", conversionStream);
}
}
}
private static WaveStream CreateInputStream(string fileName)
{
WaveChannel32 inputStream;
WaveStream readerStream = null;
if (fileName.EndsWith(".wav"))
{
readerStream = new WaveFileReader(fileName);
}
//else if (fileName.EndsWith(".wma"))
//{
// // readerStream = new WMAFileReader2(fileName);
// MemoryStream memoryStream = new MemoryStream();
// using (FileStream infile = new FileStream(fileName, FileMode.Open, FileAccess.Read))
// {
// while (infile.Position < infile.Length)
// {
// byte data = (byte)infile.ReadByte();
// memoryStream.WriteByte(data);
// }
// }
// memoryStream.Position = 0;
// readerStream = new WMAFileReader2(memoryStream);
//}
else
{
throw new InvalidOperationException("Unsupported extension");
}
// Provide PCM conversion if needed
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
// Provide conversion to 16 bits if needed
if (readerStream.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(readerStream.WaveFormat.SampleRate,
16, readerStream.WaveFormat.Channels);
readerStream = new WaveFormatConversionStream(format, readerStream);
}
inputStream = new WaveChannel32(readerStream);
return inputStream;
}
private static void SynthToCam(string fileName, CameraWindow cw)
{
using (var waveStream = new MemoryStream())
{
//write some silence to the stream to allow camera to initialise properly
var silence = new byte[1 * 22050];
waveStream.Write(silence, 0, silence.Count());
//read in and convert the wave stream into our format
using (var reader = new WaveFileReader(fileName))
{
var newFormat = new WaveFormat(11025, 16, 1);
byte[] buff = new byte[22050];
using (var conversionStream = new WaveFormatConversionStream(newFormat, reader))
{
do
{
int i = conversionStream.Read(buff, 0, 22050);
waveStream.Write(buff, 0, i);
if (i < 22050)
break;
} while (true);
}
}
//write some silence to the stream to allow camera to end properly
waveStream.Write(silence, 0, silence.Count());
waveStream.Seek(0, SeekOrigin.Begin);
var ds = new DirectStream(waveStream) { RecordingFormat = new WaveFormat(11025, 16, 1) };
var talkTarget = TalkHelper.GetTalkTarget(cw.Camobject, ds);
ds.Start();
talkTarget.Start();
while (ds.IsRunning)
{
Thread.Sleep(100);
}
ds.Stop();
talkTarget.Stop();
talkTarget = null;
ds = null;
waveStream.Close();
}
}
public void CanEncodeGsm()
{
var testFile = @"C:\Users\Mark\Code\CodePlex\AudioTestFiles\WAV\PCM 16 bit\pcm mono 16 bit 8kHz.wav";
if (!File.Exists(testFile))
{
Assert.Ignore("Missing test file");
}
using (var reader = new WaveFileReader(testFile))
{
using (var gsm = new WaveFormatConversionStream(new Gsm610WaveFormat(), reader))
{
WaveFileWriter.CreateWaveFile(@"C:\Users\Mark\Code\CodePlex\gsm.wav", gsm);
}
}
}
private void AudioSourceDataAvailable(object sender, DataAvailableEventArgs e)
{
try
{
lock (_obj)
{
if (_bTalking && _avstream != null)
{
byte[] bSrc = e.RawData;
int totBytes = bSrc.Length;
int j = -1;
if (!_audioSource.RecordingFormat.Equals(_waveFormat))
{
var ws = new TalkHelperStream(bSrc, totBytes, _audioSource.RecordingFormat);
var bDst = new byte[44100];
totBytes = 0;
using (var helpStm = new WaveFormatConversionStream(_waveFormat, ws))
{
while (j != 0)
{
j = helpStm.Read(bDst, totBytes, 10000);
totBytes += j;
}
}
bSrc = bDst;
}
var enc = new byte[totBytes / 2];
ALawEncoder.ALawEncode(bSrc, totBytes, enc);
try
{
_avstream.Write(enc, 0, enc.Length);
}
catch (SocketException)
{
StopTalk();
}
}
}
}
catch (Exception ex)
{
MainForm.LogExceptionToFile(ex,"Talk (Android)");
StopTalk();
}
}
static Task DoVoice(DiscordVoiceClient vc, string file)
{
return Task.Run(() =>
{
try
{
int ms = 20;
int channels = 2;
int sampleRate = 48000;
int blockSize = 48 * 2 * channels * ms; //sample rate * 2 * channels * milliseconds
byte[] buffer = new byte[blockSize];
var outFormat = new WaveFormat(sampleRate, 16, channels);
vc.SetSpeaking(true);
using (var mp3Reader = new Mp3FileReader(file))
{
using (var resampler = new WaveFormatConversionStream(outFormat, mp3Reader))
{
int byteCount;
while ((byteCount = resampler.Read(buffer, 0, blockSize)) > 0)
{
if (vc.Connected)
{
//sequence = await vc.SendSmallOpusAudioPacket(buffer, sampleRate, byteCount, sequence).ConfigureAwait(false);
vc.SendVoice(buffer);
//sequence = vc.SendSmallOpusAudioPacket(buffer, 48000, buffer.Length, sequence);
//Task.Delay(19).Wait();
}
else
break;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Voice finished enqueuing");
Console.ForegroundColor = ConsoleColor.White;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
});
}
/// <summary>
/// Converts a WMA file to a WAV stream
/// </summary>
/// <param name="outputStream">Stream to store the converted wav.</param>
/// <param name="filePath">Path to a .wma file to convert</param>
/// <returns>The WaveFormat object of the converted wav</returns>
private static WaveFormat wmaToWav(string pathToWma, Stream outputStream, int sampleRate, int bitDepth, int numChannels)
{
if (!Path.GetExtension(pathToWma).ToLowerInvariant().Contains("wma"))
throw new ArgumentException("Must be a .wma file!");
using (var reader = new WMAFileReader(pathToWma))
{
var targetFormat = new NAudio.Wave.WaveFormat(sampleRate, bitDepth, numChannels);
var pcmStream = new WaveFormatConversionStream(targetFormat, reader);
var buffer = new byte[pcmStream.Length];
pcmStream.Read(buffer, 0, (int)pcmStream.Length);
outputStream.Write(buffer, 0, buffer.Length);
outputStream.Position = 0;
pcmStream.Close();
return targetFormat;
}
}
public static void ComputeAllFeatures(string wavpath, string resultpath, System.Windows.Forms.TextBox progress)
{
int aa=0;
StreamWriter writer = new StreamWriter("d:\\features.txt");
for (int i = 1; i <= 674; i++)
{
WaveStream readerStream = new WaveFileReader(@"D:\Z projekti\Emocije\code\sustav(pun)\wavs\" + i.ToString()+ ".wav");
WaveFormat format = new WaveFormat(readerStream.WaveFormat.SampleRate, 8, 1);
readerStream = new WaveFormatConversionStream(format, readerStream);
int length = (int)readerStream.Length;
byte[] buffer = new byte[length];
readerStream.Read(buffer, 0, length);
Classifier = new Classifiers.GoodClassifier();
Classifier.SamplingFrequency = 11025;
Classifier.SubWindowLength = 256; // 44100 [samples per second] * 0.025 [25 milisecond interval]
Classifier.SubWindowShift = 165; // 44100 [samples per second] * 0.015 [15 milisecond interval]
Classifier.SuperWindowLength = (int)Math.Floor((double)length / (Classifier.SubWindowShift))-10; // 44100 [samples per second] / 1102 [SubFeatures per second] * 2 [seconds]
Classifier.SuperWindowShift = 5; // 44100 [samples per second] / 1102 [SubFeatures per second] * 1 [seconds]
Classifier.ClassificationComplete += new AbstractClassifier.ClassifComplete(Classifier_ClassificationComplete);
Classifier.SubFeaturesComputed += new AbstractClassifier.SubFeaturesComp(Classifier_SubFeaturesComputed);
Classifier.SuperFeaturesComputed += new AbstractClassifier.SuperFeaturesComp(Classifier_SuperFeaturesComputed);
Classifier.EnqueueData(buffer);
System.Windows.Forms.Application.DoEvents();
string line = "";
foreach (double d in Classifier.AllFeatures.First())
{
line += d.ToString(CultureInfo.InvariantCulture) + ",";
}
line = line.TrimEnd(',');
line += "\r\n";
writer.WriteLine(line);
writer.Flush();
progress.Text = i.ToString();
}
writer.Flush();
}
/// <summary>
/// Creates the reader stream, supporting all filetypes in the core NAudio library,
/// and ensuring we are in PCM format
/// </summary>
/// <param name="fileName">File Name</param>
private void CreateReaderStream(string fileName)
{
if (fileName.EndsWith(".wav", StringComparison.OrdinalIgnoreCase))
{
readerStream = new WaveFileReader(fileName);
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm && readerStream.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
}
else if (fileName.EndsWith(".mp3", StringComparison.OrdinalIgnoreCase))
{
readerStream = new Mp3FileReader(fileName);
}
else if (fileName.EndsWith(".aiff"))
{
readerStream = new AiffFileReader(fileName);
}
}
public void AddSound(string FileName)
{
FileInfo file = new FileInfo (Path.Combine(Environment.CurrentDirectory,
Path.Combine(this.context.Configuration[EngineConfigurationName.SoundsRoot], FileName)));
if(!file.Exists)
return;
WaveStream readerstream = new WaveFileReader (file.FullName);
readerstream = new BlockAlignReductionStream (readerstream);
if(readerstream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
readerstream = WaveFormatConversionStream.CreatePcmStream (readerstream);
}
if(readerstream.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat (readerstream.WaveFormat.SampleRate, 16,
readerstream.WaveFormat.Channels);
readerstream = new WaveFormatConversionStream (format, readerstream);
}
byte[] data = new byte[readerstream.Length];
int position = 0;
while(true)
{
int result = readerstream.ReadByte ();
if(result == -1)
break;
data[position] = Convert.ToByte (result);
position++;
}
this.AddSound (file.Name, new AudioSource(data, (uint)readerstream.WaveFormat.SampleRate, 1.0f, readerstream.WaveFormat.Channels));
}
// TODO: make this shit more presice
private void WritePieceOfSomeFile_stream(WaveStream readerWave, double secondIn, double secondOut, double? speedChange)
{
InitWriterIfNull(readerWave);
speedChange = speedChange ?? 1;
using (var pcmStream = WaveFormatConversionStream.CreatePcmStream(readerWave))
using (var downsampledStream = new WaveFormatConversionStream(new WaveFormat(
(int)(format.SampleRate / speedChange),
format.BitsPerSample,
format.Channels), pcmStream))
{
var sss = pcmStream;
const int readThisManyBytes = 4000; // 16384;
byte[] buffer = new byte[readThisManyBytes];
int bufferL = 0;
while (sss.Position < sss.Length) {
bufferL = sss.Read(buffer, 0, readThisManyBytes);
if (sss.CurrentTime.TotalSeconds >= secondIn) {
writer.Write(buffer, 0, bufferL);
}
if (sss.CurrentTime.TotalSeconds >= secondOut)
break;
}
//while (readerWave.Position < readerWave.Length) {
// bufferL = readerWave.Read(buffer, 0, readThisManyBytes);
// //TODO: volume chart trimming
// //for (int i = 0; i < read / 4; i++) {
// // chart1.Series["wave"].Points.Add(BitConverter.ToSingle(buffer, i * 4));
// //}
// //Console.WriteLine("{0} {1}", readerWave.CurrentTime, (readerWave.CurrentTime.TotalSeconds >= secondIn) ? "xxxxxxxxxx" : "");
// if (readerWave.CurrentTime.TotalSeconds >= secondIn) {
// //writer.Write(frame.RawData, 0, frame.RawData.Length);
// writer.Write(buffer, 0, bufferL);
// }
// if (readerWave.CurrentTime.TotalSeconds >= secondOut)
// break;
//}
}
}
private static WaveStream CreateInputStream(string fileName)
{
WaveChannel32 inputStream;
WaveStream readerStream = null;
if (fileName.EndsWith(".wav"))
{
readerStream = new WaveFileReader(fileName);
}
else if (fileName.EndsWith(".flac"))
{
readerStream = new FLACFileReader(fileName);
}
else
{
throw new InvalidOperationException("Unsupported extension");
}
// Provide PCM conversion if needed
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
// Provide conversion to 16 bits if needed
if (readerStream.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(readerStream.WaveFormat.SampleRate,
16, readerStream.WaveFormat.Channels);
readerStream = new WaveFormatConversionStream(format, readerStream);
}
inputStream = new WaveChannel32(readerStream);
return inputStream;
}
public void StartTalk()
{
string sPost = "POST /axis-cgi/audio/transmit.cgi HTTP/1.0\r\n";
//sPost += "Content-Type: multipart/x-mixed-replace; boundary=--myboundary\r\n";
sPost += "Content-Type: audio/basic\r\n";
sPost += "Content-Length: 9999999\r\n";
sPost += "Connection: Keep-Alive\r\n"; // Have read about problems with .NET keep-alive but this seems to work ok
sPost += "Cache-Control: no-cache\r\n";
string usernamePassword = _username + ":" + _password;
sPost += "Authorization: Basic " + Convert.ToBase64String(new ASCIIEncoding().GetBytes(usernamePassword)) + "\r\n\r\n";
_tcpClient = new TcpClient(_cameraIP, _cameraPort);
_avStream = _tcpClient.GetStream();
byte[] hdr = Encoding.ASCII.GetBytes(sPost);
_avStream.Write(hdr, 0, hdr.Length);
_waveFormat = new NAudio.Wave.WaveFormat(44100, NAudio.Wave.WaveIn.GetCapabilities(_localAudioDevices.GetCurWaveInDeviceNumber()).Channels);
_memStream = new MemoryStream();
_waveStream = new RawSourceWaveInStream(_memStream, _waveFormat);
// Downsampler converts from 44KHz to 8KHz
_downsamplerStream = new WaveFormatConversionStream(new WaveFormat(8000, _waveFormat.BitsPerSample, 1), _waveStream);
// MuLaw coder converts PCM to mulaw
WaveFormat muLaw = WaveFormat.CreateMuLawFormat(8000, 1);
_converterStream = new WaveFormatConversionStream(muLaw, _downsamplerStream);
// Start microphone
OpenWaveInDevice();
logger.Info("Talk Starting");
_localAudioDevices.StartingTalking();
_bTalking = true;
}
private void AudioSourceDataAvailable(object sender, DataAvailableEventArgs e)
{
try
{
lock (_obj)
{
if (_bTalking && _avstream != null)
{
byte[] bSrc = e.RawData;
int totBytes = bSrc.Length;
int j = -1;
if (!_audioSource.RecordingFormat.Equals(_waveFormat))
{
using (var ws = new TalkHelperStream(bSrc, totBytes, _audioSource.RecordingFormat))
{
var bDst = new byte[44100];
totBytes = 0;
using (var helpStm = new WaveFormatConversionStream(_waveFormat, ws))
{
while (j != 0)
{
j = helpStm.Read(bDst, totBytes, 10000);
totBytes += j;
}
helpStm.Close();
}
ws.Close();
bSrc = bDst;
}
}
var enc = _muLawCodec.Encode(bSrc, 0, totBytes);
//ALawEncoder.ALawEncode(bSrc, totBytes, enc);
Buffer.BlockCopy(enc, 0, _talkBuffer, _talkDatalen, enc.Length);
_talkDatalen += enc.Length;
j = 0;
try
{
while (j + 240 < _talkDatalen)
{
//need to write out in 240 byte packets
var pkt = new byte[240];
Buffer.BlockCopy(_talkBuffer, j, pkt, 0, 240);
// _avstream.Write(_hdr, 0, _hdr.Length);
_avstream.Write(pkt, 0, 240);
j += 240;
}
if (j < _talkDatalen)
{
Buffer.BlockCopy(_talkBuffer, j, _talkBuffer, 0, _talkDatalen - j);
_talkDatalen = _talkDatalen - j;
}
}
catch (SocketException)
{
StopTalk();
}
}
}
}
catch (Exception ex)
{
MainForm.LogExceptionToFile(ex);
StopTalk();
}
}
private void GetAudioSamples()
{
////var pcmStream = WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader("whitelight.mp3"));
//var pcmStream = new WaveFileReader("whitelight-ulaw.wav");
//byte[] sampleBuffer = new byte[160];
//int bytesRead = pcmStream.Read(sampleBuffer, 0, 160);
////int bytesRead = m_rawRTPPayloadReader.BaseStream.Read(sampleBuffer, 0, 160);
//while (bytesRead > 0)
//{
// m_rtpChannel.AddSample(sampleBuffer);
// bytesRead = pcmStream.Read(sampleBuffer, 0, 160);
// //bytesRead = m_rawRTPPayloadReader.BaseStream.Read(sampleBuffer, 0, 160);
//}
var pcmFormat = new WaveFormat(8000, 16, 1);
var ulawFormat = WaveFormat.CreateMuLawFormat(8000, 1);
using (WaveFormatConversionStream pcmStm = new WaveFormatConversionStream(pcmFormat, new Mp3FileReader("whitelight.mp3")))
{
using (WaveFormatConversionStream ulawStm = new WaveFormatConversionStream(ulawFormat, pcmStm))
{
byte[] buffer = new byte[160];
int bytesRead = ulawStm.Read(buffer, 0, 160);
while (bytesRead > 0)
{
byte[] sample = new byte[bytesRead];
Array.Copy(buffer, sample, bytesRead);
m_rtpChannel.Send(sample, 20);
bytesRead = ulawStm.Read(buffer, 0, 160);
}
}
}
logger.Debug("Finished adding audio samples.");
}
private static byte[] ReadWavDataIntoMonoPcm(string audioInputFile, int samepleRate)
{
using (var reader = new WaveFileReader(audioInputFile))
{
var newFormat = new WaveFormat(samepleRate, 16, 1);
using (var conversationStream = new WaveFormatConversionStream(newFormat, reader))
using (var pcmStream = WaveFormatConversionStream.CreatePcmStream(conversationStream))
{
var buffer = new byte[pcmStream.Length];
var bytesRead = pcmStream.Read(buffer, 0, buffer.Length);
if (bytesRead != buffer.Length)
{
var outputBuffer = new byte[bytesRead];
Buffer.BlockCopy(buffer, 0, outputBuffer, 0, bytesRead);
return outputBuffer;
}
return buffer;
}
}
}
private void EncodeFile()
{
string inputFileName = GetInputFileName("Select PCM WAV File to Encode");
if (inputFileName == null)
return;
using (var reader = new WaveFileReader(inputFileName))
{
if (reader.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
MessageBox.Show("Please select a PCM WAV file to encode");
return;
}
WaveFormat targetFormat = GetTargetFormat(reader.WaveFormat);
if (targetFormat == null)
{
return;
}
string outputFileName = GetOutputFileName("Select Ouput File Name");
if (outputFileName == null)
{
return;
}
using (WaveStream convertedStream = new WaveFormatConversionStream(targetFormat, reader))
{
WaveFileWriter.CreateWaveFile(outputFileName, convertedStream);
}
if (checkBoxAutoLaunchConvertedFile.Checked)
{
System.Diagnostics.Process.Start(outputFileName);
}
}
}
private void AppendAllOfFile_stream(WaveStream readerWave, double? speedChange)
{
InitWriterIfNull(readerWave);
speedChange = speedChange ?? 1;
using (var pcmStream = WaveFormatConversionStream.CreatePcmStream(readerWave))
using (var downsampledStream = new WaveFormatConversionStream(new WaveFormat(
(int)(format.SampleRate / speedChange),
format.BitsPerSample,
format.Channels), pcmStream))
{
const int readThisManyBytes = 16384;
byte[] buffer = new byte[readThisManyBytes];
int bufferL = 0;
//ByteBufferCompressor bbbb = new ByteBufferCompressor(readThisManyBytes, speedChange);
while (downsampledStream.Position < downsampledStream.Length) {
bufferL = downsampledStream.Read(buffer, 0, readThisManyBytes);
if (bufferL == 0)
break;
writer.Write(buffer, 0, bufferL);
//var buffer2L = bbbb.Transform(buffer, bufferL);
//writer.Write(bbbb.GetNewBuffer(), 0, buffer2L);
}
}
}
public void AudioDeviceDataAvailable(object sender, DataAvailableEventArgs e)
{
if (Levels == null || IsReconnect)
return;
try
{
lock (_lockobject)
{
Helper.FrameAction fa;
if (!Recording)
{
var dt = Helper.Now.AddSeconds(0 - Micobject.settings.buffer);
while (Buffer.Count > 0)
{
if (Buffer.TryPeek(out fa))
{
if (fa.TimeStamp < dt)
{
if (Buffer.TryDequeue(out fa))
fa.Nullify();
}
else
{
break;
}
}
}
}
fa = new Helper.FrameAction(e.RawData, e.BytesRecorded, Levels.Max(), Helper.Now);
Buffer.Enqueue(fa);
}
if (Micobject.settings.needsupdate)
{
Micobject.settings.samples = AudioSource.RecordingFormat.SampleRate;
Micobject.settings.channels = AudioSource.RecordingFormat.Channels;
Micobject.settings.needsupdate = false;
}
OutSockets.RemoveAll(p => p.TcpClient.Client.Connected == false);
if (OutSockets.Count>0)
{
if (_mp3Writer == null)
{
_audioStreamFormat = new WaveFormat(22050, 16, Micobject.settings.channels);
var wf = new WaveFormat(_audioStreamFormat.SampleRate, _audioStreamFormat.BitsPerSample, _audioStreamFormat.Channels);
_mp3Writer = new LameMP3FileWriter(_outStream, wf, LAMEPreset.STANDARD);
}
byte[] bSrc = e.RawData;
int totBytes = bSrc.Length;
var ws = new TalkHelperStream(bSrc, totBytes, AudioSource.RecordingFormat);
var helpStm = new WaveFormatConversionStream(_audioStreamFormat, ws);
totBytes = helpStm.Read(_bResampled, 0, 22050);
ws.Close();
ws.Dispose();
helpStm.Close();
helpStm.Dispose();
_mp3Writer.Write(_bResampled, 0, totBytes);
var bterm = Encoding.ASCII.GetBytes("\r\n");
if (_outStream.Length > 0)
{
var bout = new byte[(int) _outStream.Length];
_outStream.Seek(0, SeekOrigin.Begin);
_outStream.Read(bout, 0, (int) _outStream.Length);
_outStream.SetLength(0);
_outStream.Seek(0, SeekOrigin.Begin);
foreach (var s in OutSockets)
{
var b = Encoding.ASCII.GetBytes(bout.Length.ToString("X") + "\r\n");
try
{
s.Stream.Write(b, 0, b.Length);
s.Stream.Write(bout, 0, bout.Length);
s.Stream.Write(bterm, 0, bterm.Length);
}
catch
{
OutSockets.Remove(s);
break;
}
}
}
}
else
{
if (_mp3Writer != null)
{
_mp3Writer.Close();
_mp3Writer = null;
}
}
if (DataAvailable != null)
{
DataAvailable(this, new NewDataAvailableArgs((byte[])e.RawData.Clone()));
}
if (_reconnectTime != DateTime.MinValue)
{
Micobject.settings.active = true;
_errorTime = _reconnectTime = DateTime.MinValue;
DoAlert("reconnect");
}
_errorTime = DateTime.MinValue;
}
catch (Exception ex)
{
if (ErrorHandler != null)
ErrorHandler(ex.Message);
}
}
public void StopTalk()
{
_localAudioDevices.StoppingTalking();
if (_bTalking)
{
lock (_semaphore)
{
logger.Info("Talk Stopping");
_bTalking = false;
if (_tcpClient != null)
{
_tcpClient.Close();
_tcpClient = null;
}
if (_avStream != null)
{
_avStream.Close();
_avStream.Dispose();
_avStream = null;
}
if (_waveStream != null)
{
_waveStream.Close();
}
if (_converterStream != null)
{
_converterStream.Close();
_converterStream = null;
}
if (_downsamplerStream != null)
{
_downsamplerStream.Close();
_downsamplerStream = null;
}
if (_waveInDevice != null)
{
_waveInDevice.StopRecording();
_waveInDevice = null;
}
}
}
}
private static WaveChannel32 OpenWavStream(Stream stream)
{
WaveStream readerStream = new WaveFileReader(stream);
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
if (readerStream.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(readerStream.WaveFormat.SampleRate, 16, readerStream.WaveFormat.Channels);
readerStream = new WaveFormatConversionStream(format, readerStream);
}
return new WaveChannel32(readerStream);
}
/// <summary>
/// Build all the temp files
/// </summary>
/// <remarks>
/// One of the most hideous functions ever written. Refactoring would be nice.
/// </remarks>
public void CreateTempFiles()
{
/* Dev links:
*
* http://localhost:82/player/epgcbha - clerks mp3 - id46
*
* http://localhost:82/player/dpccbha - beavis wav - id32
*
* http://localhost:82/player/dpbcbha - ace losers mp3 - id31
*
* http://192.168.1.117:82/player/fqavbha - borat wav - id50 - it is nice - won't convert to mp3
*
*/
dynamic theSound = null;
Stream outputStream = new MemoryStream();
if (_requestInfo.IsValid) // Functions.IsNumeric(soundId))
{
int soundId = _requestInfo.SoundId;
//
// First, look in the cache and see if we have a converted mp3 there already
//
string targetMp3File = LocalMp3File; //Functions.CombineElementsWithDelimiter("\\", _targetPath, string.Format("id{0}.mp3", soundId));
string targetWavFile = LocalWavFile; // Functions.CombineElementsWithDelimiter("\\", _targetPath, string.Format("id{0}.wav", soundId));
//if (!NeedToCreateAtLeastOneFile(targetMp3File, targetWavFile))
if (HaveAtLeastOneFile(targetMp3File, targetWavFile))
{
return;
}
else
{
//
// OK, let's grab the sound data from the DB
//
theSound = GetSoundData(Functions.ConvertInt(soundId, -1));
if (theSound != null && theSound.Id >= 0)
{
//
// The DB returns HTML-ready bytes. It would be more efficient to return the binary data. Then we wouldn't have to do 2 conversions.
// Todo!
//
byte[] originalSourceByteArray = System.Convert.FromBase64String(theSound.Data);
if (Functions.IsWav(theSound.FileName))
{
bool successfulWavConversionToMp3 = false;
//
// It's an wav, convert to mp3
//
Mp3Writer outputMp3Writer = null;
// Mp3Writer outputFileMp3Writer = null;
//
// These are WaveLib.WaveStream objects that wrap the LAME thing
//
WaveStream waveDataToConvertToMp3 = null;
WaveStream convertedSourceWaveStream = null;
WaveStream originalSourceWaveStream = new WaveStream(new MemoryStream(originalSourceByteArray));
try
{
outputMp3Writer = new Mp3Writer(outputStream, originalSourceWaveStream.Format);
waveDataToConvertToMp3 = originalSourceWaveStream;
}
catch // (Exception ex)
{
outputMp3Writer = null;
//
// The source WAV isn't compatible with the LAME thingy. Let's try to convert it to something we know is usable with the NAudio thingy.
// Then we'll use the NAudio stuff to try to get the LAME stuff to work.
//
//MemoryStream tempMemStream = new MemoryStream();
int sampleRate = 16000;
int bitDepth = 16;
//
// Note: there appears to be a bug in the LAME thing for files with 1 channel (mono). The file plays at double speed.
//
int channels = 2;
NAudio.Wave.WaveFormat targetFormat = new NAudio.Wave.WaveFormat(sampleRate, bitDepth, channels);
NAudio.Wave.WaveStream stream = new NAudio.Wave.WaveFileReader(new MemoryStream(originalSourceByteArray));
NAudio.Wave.WaveFormatConversionStream str = null;
try
{
str = new NAudio.Wave.WaveFormatConversionStream(targetFormat, stream);
}
catch (Exception ex3)
{
//
// The borat "It is nice" WAV won't convert, has strange exception. Todo: add logging and fix.
//
ErrorMsg = string.Format("Well, naudio can't convert the WAV to the target WAV format either: {0}", ex3.Message);
}
if (str != null)
{
//
// For lack of a better solution to get the bytes from the converted data into a "WaveStream" variable, use these
// available methods to write to a disk file and then open up the disk file. The problem with directly converting
// with memory streams is that the required headers (like "RIFF") aren't written into the converted stream at this point.
//
NAudio.Wave.WaveFileWriter.CreateWaveFile(targetWavFile, str);
convertedSourceWaveStream = new WaveStream(targetWavFile);
//
// Now we have a correct WAV memory stream
//
try
{
WaveFormat format = convertedSourceWaveStream.Format;
outputMp3Writer = new Mp3Writer(outputStream, format);
waveDataToConvertToMp3 = convertedSourceWaveStream;
}
catch (Exception ex2)
{
//
// Crap, I think we're hosed
//
ErrorMsg = string.Format("Oops - second try - can't process this file: {0}", ex2.Message);
}
}
}
if (outputMp3Writer != null)
{
//
// If we're here, we've successfully created the MP3 converter from the WAV file, and our data stream
// is in the variable "waveDataToConvertToMp3"
//
try
{
byte[] buff = new byte[outputMp3Writer.OptimalBufferSize];
int read = 0;
while ((read = waveDataToConvertToMp3.Read(buff, 0, buff.Length)) > 0)
{
outputMp3Writer.Write(buff, 0, read);
}
//
// We have mp3 bytes, write 'em
//
// FileStream outputMp3File = new FileStream(targetMp3File, FileMode.CreateNew);
//outputMp3File.Write(originalSourceByteArray, 0, originalSourceByteArray.Length);
using (Stream outputMp3File = File.OpenWrite(targetMp3File))
{
outputStream.Position = 0;
Functions.CopyStream(outputStream, outputMp3File);
}
successfulWavConversionToMp3 = true;
}
catch (Exception ex)
{
ErrorMsg = string.Format("Oops, fatal error: {0}", ex.Message);
}
finally
{
outputMp3Writer.Close();
waveDataToConvertToMp3.Close();
}
}
if (!successfulWavConversionToMp3)
{
//
// Well, everthing failed. We have a WAV at least, let's go ahead and write that.
//
File.WriteAllBytes(targetWavFile, originalSourceByteArray);
}
//
// Let's clean this stuff up
//
originalSourceWaveStream.Close();
if (convertedSourceWaveStream != null)
{
convertedSourceWaveStream.Close();
}
}
else
{
FileStream outputMp3File = null;
try
{
outputMp3File = new FileStream(targetMp3File, FileMode.CreateNew);
//
// We have mp3 bytes, write 'em
//
outputMp3File.Write(originalSourceByteArray, 0, originalSourceByteArray.Length);
}
catch
{
// Maybe we have the file already by another thread?
ErrorMsg = "Have mp3, can't write to disk.";
}
finally
{
if (outputMp3File != null)
{
outputMp3File.Close();
}
}
/*
* Huge todo: this code works fine on Windows 7, but doesn't work on Windows 2008 Server. The problem is two fold:
*
* a) The two mp3 encoders installed by Win7 (l3codeca.acm and l3codecp.acm) don't exist. I see no way to "install" them.
* This site comes closes to explaining, but these reg keys do NOT exist so the solution doesn't work:
* http://blog.komeil.com/2008/06/enabling-fraunhofer-mp3-codec-vista.html
*
* b) The alternate option explained here:
* http://stackoverflow.com/questions/5652388/naudio-error-nodriver-calling-acmformatsuggest/5659266#5659266
* Also doesn't work since the COM object for the DMO isn't registered on Win2K8. The Windows SDK is supposed to have it,
* but it doesn't install properly on the server. Also Win Media Player won't install with a weird "There is no update to Windows Media Player".
*
* I've googled for a long time, but this is a tricky one. Maybe Microsoft needs to be contacted?
*
* This is required to create WAV files for Firefox to play. Otherwise you have to click on a link. (alt solution: embed?)
*
* NAudio.Wave.Mp3FileReader reader = null;
* try
* {
* //
* // Let's write the WAV bytes
* // http://hintdesk.com/c-mp3wav-converter-with-lamenaudio/
* //
* using (reader = new NAudio.Wave.Mp3FileReader(targetMp3File))
* {
* using (NAudio.Wave.WaveStream pcmStream = NAudio.Wave.WaveFormatConversionStream.CreatePcmStream(reader))
* {
* NAudio.Wave.WaveFileWriter.CreateWaveFile(targetWavFile, pcmStream);
* }
* }
* }
* catch
* {
* ErrorMsg = "Have mp3, can't convert to WAV";
* }
* finally
* {
* if (reader != null)
* {
* reader.Close();
* }
* }
*
*/
}
}
else
{
ErrorMsg = "Cannot get sound id";
}
}
}
else
{
ErrorMsg = string.Format("Invalid request parameter: {0}", _encryptedPlayerRequest);
}
}
private byte[] RealMix(ReceivedRtp item1, ReceivedRtp item2)
{
if (item1 == null || item2 == null) return null;
if (item1.size == 0 || item2.size == 0) return null;
byte[] wavSrc1 = new byte[item1.size - headersize];
byte[] wavSrc2 = new byte[item2.size - headersize];
Array.Copy(item1.buff, headersize, wavSrc1, 0, (item1.size - headersize));
Array.Copy(item2.buff, headersize, wavSrc2, 0, (item2.size - headersize));
WaveMixerStream32 mixer = new WaveMixerStream32();
// mixer.AutoStop = true;
MemoryStream memstrem = new MemoryStream(wavSrc1);
RawSourceWaveStream rawsrcstream = new RawSourceWaveStream(memstrem, this.codec);
WaveFormatConversionStream conversionstream = new WaveFormatConversionStream(pcmFormat16, rawsrcstream);
WaveChannel32 channelstream = new WaveChannel32(conversionstream);
mixer.AddInputStream(channelstream);
memstrem = new MemoryStream(wavSrc2);
rawsrcstream = new RawSourceWaveStream(memstrem, this.codec);
conversionstream = new WaveFormatConversionStream(pcmFormat16, rawsrcstream);
channelstream = new WaveChannel32(conversionstream);
mixer.AddInputStream(channelstream);
mixer.Position = 0;
Wave32To16Stream to16 = new Wave32To16Stream(mixer);
var convStm = new WaveFormatConversionStream(pcmFormat8, to16);
byte[] mixedbytes = new byte[(int)convStm.Length];
int chk = convStm.Read(mixedbytes, 0, (int)convStm.Length);
//Buffer.BlockCopy(tobyte, 0, writingBuffer, 0, tobyte.Length);
memstrem.Close();
rawsrcstream.Close();
conversionstream.Close();
channelstream.Close();
convStm.Close(); convStm.Dispose(); convStm = null;
to16.Close(); to16.Dispose(); to16 = null;
mixer.Close(); mixer.Dispose(); mixer = null;
return mixedbytes;
}
void AudioDeviceDataAvailable(object sender, DataAvailableEventArgs e)
{
if (Levels == null)
return;
try
{
if (WriterBuffer == null)
{
var dt = DateTime.Now.AddSeconds(0 - Micobject.settings.buffer);
AudioBuffer.RemoveAll(p => p.TimeStamp < dt);
AudioBuffer.Add(new AudioAction(e.RawData, Levels.Max(), DateTime.Now));
}
else
{
WriterBuffer.Enqueue(new AudioAction(e.RawData, Levels.Max(), DateTime.Now));
}
if (Micobject.settings.needsupdate)
{
Micobject.settings.samples = AudioSource.RecordingFormat.SampleRate;
Micobject.settings.channels = AudioSource.RecordingFormat.Channels;
Micobject.settings.needsupdate = false;
}
OutSockets.RemoveAll(p => p.Connected == false);
if (OutSockets.Count>0)
{
if (_mp3Writer == null)
{
//_as = new AudioStreamer();
//_as.Open(AudioCodec.AAC, AudioSource.RecordingFormat.BitsPerSample * AudioSource.RecordingFormat.SampleRate * AudioSource.RecordingFormat.Channels, AudioSource.RecordingFormat.SampleRate, AudioSource.RecordingFormat.Channels);
_audioStreamFormat = new WaveFormat(22050, 16, Micobject.settings.channels);
var wf = new MP3Stream.WaveFormat(_audioStreamFormat.SampleRate, _audioStreamFormat.BitsPerSample, _audioStreamFormat.Channels);
_mp3Writer = new Mp3Writer(_outStream, wf, false);
}
//unsafe
//{
// fixed (byte* p = e.RawData)
// {
// int byteLength = 0;
// int* l = &byteLength;
// byte* outStream = _as.WriteAudio(p, e.RawData.Length, l);
// byteLength = *l;
// if (byteLength > 0)
// {
// var toSend = new byte[byteLength];
// for (var i = 0; i < byteLength;i++ )
// {
// if (i==0)
// Debug.Write(toSend[0]);
// toSend[i] = *(outStream + i);
// }
// foreach (Socket s in OutSockets)
// {
// s.Send(Encoding.ASCII.GetBytes(byteLength.ToString("X") + "\r\n"));
// s.Send(toSend);
// s.Send(Encoding.ASCII.GetBytes("\r\n"));
// }
// }
// }
//}
byte[] bSrc = e.RawData;
int totBytes = bSrc.Length;
var ws = new TalkHelperStream(bSrc, totBytes, AudioSource.RecordingFormat);
var helpStm = new WaveFormatConversionStream(_audioStreamFormat, ws);
totBytes = helpStm.Read(_bResampled, 0, 25000);
ws.Close();
ws.Dispose();
helpStm.Close();
helpStm.Dispose();
_mp3Writer.Write(_bResampled, 0, totBytes);
if (_outStream.Length > 0)
{
var bout = new byte[(int) _outStream.Length];
_outStream.Seek(0, SeekOrigin.Begin);
_outStream.Read(bout, 0, (int) _outStream.Length);
_outStream.SetLength(0);
_outStream.Seek(0, SeekOrigin.Begin);
foreach (Socket s in OutSockets)
{
s.Send(Encoding.ASCII.GetBytes(bout.Length.ToString("X") + "\r\n"));
s.Send(bout);
s.Send(Encoding.ASCII.GetBytes("\r\n"));
}
}
}
else
{
if (_mp3Writer != null)
{
_mp3Writer.Close();
_mp3Writer = null;
}
//if (_as!=null)
//{
// _as.Close();
// _as.Dispose();
// _as = null;
//}
}
if (DataAvailable != null)
{
DataAvailable(this, new NewDataAvailableArgs((byte[])e.RawData.Clone()));
}
}
catch (Exception ex)
{
Log.Error("",ex);//MainForm.LogExceptionToFile(ex);
}
}
private void CanCreateConversionStream(WaveFormat inputFormat, WaveFormat outputFormat)
{
using (WaveFormatConversionStream stream = new WaveFormatConversionStream(
inputFormat, new NullWaveStream(outputFormat, 10000)))
{
}
}
/// <summary>
/// Creates a wave stream from the given file.
/// </summary>
/// <param name="fileName">A WAVE or MP3 file.</param>
private WaveChannel32 CreateInputStream(string fileName)
{
WaveChannel32 inputStream;
if (fileName.EndsWith(".wav"))
{
WaveStream readerStream = new WaveFileReader(fileName);
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
if (readerStream.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(readerStream.WaveFormat.SampleRate, 16, readerStream.WaveFormat.Channels);
readerStream = new WaveFormatConversionStream(format, readerStream);
}
inputStream = new WaveChannel32(readerStream);
}
else if (fileName.EndsWith(".mp3"))
{
WaveStream mp3Reader = new Mp3FileReader(fileName);
WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(mp3Reader);
WaveStream blockAlignedStream = new BlockAlignReductionStream(pcmStream);
inputStream = new WaveChannel32(blockAlignedStream);
}
else
{
throw new InvalidOperationException("Unsupported audio extension");
}
return inputStream;
}
/// <summary>
/// 音楽ファイルの音声データへのストリームを生成します。
/// </summary>
/// <param name="fileName">音楽ファイルへのパス。</param>
/// <exception cref="InvalidOperationException">ストリームの生成に失敗した。</exception>
private void InitializeStream( string fileName )
{
_filePath = fileName;
WaveChannel32 stream;
if( fileName.EndsWith( ".wav" ) )
{
WaveStream reader = new WaveFileReader( fileName );
if( reader.WaveFormat.Encoding != WaveFormatEncoding.Pcm )
{
reader = WaveFormatConversionStream.CreatePcmStream( reader );
reader = new BlockAlignReductionStream( reader );
}
if( reader.WaveFormat.BitsPerSample != 16 )
{
var format = new WaveFormat( reader.WaveFormat.SampleRate, 16, reader.WaveFormat.Channels );
reader = new WaveFormatConversionStream( format, reader );
}
stream = new WaveChannel32( reader );
}
else if( fileName.EndsWith( ".mp3" ) )
{
var reader = new Mp3FileReader( fileName );
var pcmStream = WaveFormatConversionStream.CreatePcmStream( reader );
var blockAlignedStream = new BlockAlignReductionStream( pcmStream );
stream = new WaveChannel32( blockAlignedStream );
}
else
{
throw new InvalidOperationException( "Unsupported extension" );
}
this._volumeStream = stream;
this._audioStream = new MeteringStream( stream, stream.WaveFormat.SampleRate / 10 );
this._waveOut = new WaveOut() { DesiredLatency = 200 };
this._waveOut.Init( this._audioStream );
}
