public MainForm()
{
waveOutDevice = null;
mainOutputStream = null;
volumeStream = null;
InitializeComponent();
}
public AudioSample(string fileName)
{
_fileName = fileName;
WaveFileReader reader = new WaveFileReader(fileName);
//offsetStream = new WaveOffsetStream(reader);
//channelStream = new WaveChannel32(offsetStream);
channelStream = new WaveChannel32(reader);
muted = false;
volume = 1.0f;
#region ReverseStuff
//Code to reverse
NAudioBufferReverse nbr = new NAudioBufferReverse();
reversedSample = new byte[(int)channelStream.Length];
channelStream.Read(reversedSample, 0, (int)channelStream.Length);
bytesPerSample = (channelStream.WaveFormat.BitsPerSample / 8) * channelStream.WaveFormat.Channels;
reversedSample = nbr.reverseSample(reversedSample, (int)channelStream.Length, bytesPerSample);
#endregion
}
public static void PlayFromFile(string filename, int frequency)
{
using (
FileStream stream = new FileStream(filename, FileMode.Open))
{
var waveFormat = WaveFormat.CreateMuLawFormat(frequency * 2, 1);
var reader = new NAudio.Wave.RawSourceWaveStream(stream, waveFormat);
using (WaveStream convertedStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
convertedStream.Seek(0, 0);
WaveOutEvent player = new WaveOutEvent();
WaveChannel32 volumeStream = new WaveChannel32(convertedStream);
player.Init(volumeStream);
player.Play();
while (player.PlaybackState == PlaybackState.Playing)
{
System.Threading.Thread.Sleep(100);
var input = Console.ReadKey();
if (input.KeyChar > 1) ;
{
player.Stop();
}
}
}
}
}
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 PianoSynth()
{
mixer = new WaveMixerStream32();
mixer.AutoStop = false;
int i = 0;
foreach (var note in noteFiles)
{
reader[i] = new WaveFileReader(note);
offsetStream[i] = new WaveOffsetStream(reader[i]);
channelSteam[i] = new WaveChannel32(offsetStream[i]);
channelSteam[i].Position = channelSteam[i].Length;
mixer.AddInputStream(channelSteam[i]);
i++;
}
if (waveOutDevice == null)
{
waveOutDevice = new WaveOut {DeviceNumber = 0};
waveOutDevice.Init(mixer);
waveOutDevice.Volume = 0;
waveOutDevice.Play();
waveOutDevice.Volume = 100;
}
}
public SoundResource(ResourceManager mgr, string fullName, Stream stream, Format fmt)
{
_manager = mgr;
FullName = fullName;
switch (fmt)
{
case Format.MP3:
{
Mp3FileReader mp3 = new Mp3FileReader(stream);
_reader = mp3;
break;
}
case Format.WAV:
{
WaveFileReader wav = new WaveFileReader(stream);
_reader = wav;
break;
}
default:
throw new InvalidOperationException("Unsupported extension.");
}
_stream = new WaveChannel32(_reader);
_stream.PadWithZeroes = false;
_wavDevice.PlaybackStopped += _wavDevice_PlaybackStopped;
}
public void LoadFile()
{
var wave = new WaveChannel32(new Mp3FileReader(@"file.mp3"));
var buffer = new byte[16384*2];
var read = 0;
var i = 0;
while (wave.Position < wave.Length)
{
read = wave.Read(buffer, 0, 16384*2);
var max = 0f;
var absMax = 0f;
for (int j = 0; j < read / 4; j++)
{
var s = BitConverter.ToSingle(buffer, j*4);
var abs = Math.Abs(s);
if (abs > absMax)
{
absMax = abs;
max = s;
}
}
Samples.Add(new TLSample(i += 2, max));
}
}
public void playbackFile(string filename)
{
WaveFileReader reader = new WaveFileReader(filename);
WaveChannel32 channelStream = new WaveChannel32(reader);
mixer.AddInputStream(channelStream);
channelStream.Position = 0;
}
private void DisposeInputWave() {
if (wavStream != null) {
this.wavStream.Dispose();
this.wavStream = null;
}
this.wavFileReader = null;
}
// set everything up
public BonIverStemPlayer(Engine.Engine engine) {
mixer.AutoStop = false;
waveOutDevice.Init(mixer);
Engine = engine;
// load in each of our files
reader[0] = new WaveFileReader(@"C:\\Users\\Badger\\repos\\balloon\\SkeletalTracking\\boniver\\bangorkook.wav");
reader[1] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\chippewa_falls.wav");
reader[2] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\eleva.wav");
reader[3] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\gilman.wav");
reader[4] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\grand_rapids.wav");
reader[5] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\heigh_on.wav");
reader[6] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\lake_hallie.wav");
reader[7] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\le_grange_wi.wav");
reader[8] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\long_plain.wav");
reader[9] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\mandolin_wa.wav");
reader[10] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\virginia.wav");
// set the starting positions
// and load into the mixer
for (int i = 0; i < 11; i++) {
channelStream[i] = new WaveChannel32(reader[i]);
channelStream[i].Position = 0;
mixer.AddInputStream(channelStream[i]);
}
}
public Form1()
{
_serialPort.PortName = "COM6";
_serialPort.BaudRate = 9600;
_serialPort.Parity = Parity.None;
_serialPort.DataBits = 8;
_serialPort.StopBits = StopBits.Two;
_serialPort.Handshake = Handshake.None;
_serialPort.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);
_serialPort.Open();
//Set up audio outputs
jaws[0] = new WaveOut();
jaws[1] = new WaveOut();
jaws[2] = new WaveOut();
var jawsAudio1 = new WaveChannel32(new WaveFileReader("Sounds/Jaws3.wav"));
jaws[0].Init(jawsAudio1);
var jawsAudio2 = new LoopStream(new WaveFileReader("Sounds/Jaws2.wav"));
jaws[1].Init(jawsAudio2);
var jawsAudio3 = new LoopStream(new WaveFileReader("Sounds/Jaws1.wav"));
jaws[2].Init(jawsAudio3);
//Set the shark to a random position
resetShark();
InitializeComponent();
}
private void CloseFile()
{
if (inputStream != null)
{
inputStream.Dispose();
inputStream = null;
}
}
public Key(string name, string sampleFile)
{
this.notePitch = name;
WaveFileReader reader = new WaveFileReader(sampleFile);
offsetStream = new WaveOffsetStream(reader);
channelStream = new WaveChannel32(offsetStream);
channelStream.Position = channelStream.Length;
}
public MixDiffStream(string fileName)
{
WaveFileReader reader = new WaveFileReader(fileName);
offsetStream = new WaveOffsetStream(reader);
channelSteam = new WaveChannel32(offsetStream);
muted = false;
volume = 1.0f;
}
public MixerForm(WaveChannel32 channel)
{
InitializeComponent();
waveChannel = channel;
tbPan.Value = 50+(int)(channel.Pan*50.0f);
tbVolume.Value = (int)(channel.Volume*100.0f);
}
public void SetInputWave(string waveInputFilePath, float volume) {
// 4 bytes per sample (32 bit)
this.wavFileReader = new WaveFileReader(waveInputFilePath);
this.wavStream = new WaveChannel32(this.wavFileReader);
// Leave headroom for plugin processing (0.20 seems OK, any higher causes digital clipping)
this.wavStream.Volume = volume;
}
private static WaveStream CreateInputStream(byte[] mediacontent)
{
var memoryStream = new MemoryStream(mediacontent);
var mp3Reader = new Mp3FileReader(memoryStream);
var inputStream = new WaveChannel32(mp3Reader);
return inputStream;
}
private static WaveChannel32 OpenMp3Stream(string fileName)
{
WaveChannel32 inputStream;
WaveStream mp3Reader = new Mp3FileReader(fileName);
WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(mp3Reader);
WaveStream blockAlignedStream = new BlockAlignReductionStream(pcmStream);
inputStream = new WaveChannel32(blockAlignedStream);
return inputStream;
}
private static void AddIntroOutro(string SermonFileName = "",
string IntroFileName = "",
string OutroFileName = "",
double StartSermonTime = 0,
double StartOutroTime = 0,
string ResultingFile = "")
{
if (String.IsNullOrWhiteSpace(SermonFileName)) throw new ArgumentException("SermonFileName must reference a valid file.");
if (String.IsNullOrWhiteSpace(IntroFileName)) throw new ArgumentException("IntroFileName must reference a valid file.");
if (String.IsNullOrWhiteSpace(OutroFileName)) throw new ArgumentException("OutroFileName must reference a valid file.");
if (String.IsNullOrWhiteSpace(ResultingFile)) ResultingFile = Settings.Default.IntroOutroDirectory;
WaveFileReader intro = new WaveFileReader(IntroFileName);
WaveFileReader outro = new WaveFileReader(OutroFileName);
WaveFileReader audio = new WaveFileReader(SermonFileName);
WaveMixerStream32 mixer = new WaveMixerStream32();
//mixer.AutoStop;
WaveOffsetStream audioOffsetted = new WaveOffsetStream(
audio,
TimeSpan.FromSeconds(StartSermonTime), //N seconds after start of intro.
TimeSpan.Zero,
audio.TotalTime);
TimeSpan outroOffset = TimeSpan.FromSeconds(StartSermonTime) + audio.TotalTime - TimeSpan.FromSeconds(StartOutroTime);
WaveOffsetStream outroOffsetted = new WaveOffsetStream(
outro,
outroOffset,
TimeSpan.Zero,
outro.TotalTime);
WaveChannel32 intro32 = new WaveChannel32(intro);
intro32.PadWithZeroes = false;
mixer.AddInputStream(intro32);
WaveChannel32 outro32 = new WaveChannel32(outroOffsetted);
outro32.PadWithZeroes = false;
mixer.AddInputStream(outro32);
WaveChannel32 audio32 = new WaveChannel32(audioOffsetted);
audio32.PadWithZeroes = false;
mixer.AddInputStream(audio32);
FileInfo file = new FileInfo(SermonFileName);
if (!Directory.Exists(ResultingFile)) Directory.CreateDirectory(ResultingFile);
string FileOut = String.Format(@"{0}\{1}", ResultingFile, file.Name);
WaveFileWriter.CreateWaveFile(FileOut, new Wave32To16Stream(mixer));
}
public void Dispose()
{
if (chan != null) {
chan.Dispose();
chan = null;
}
if (algo != null) {
algo.Dispose();
algo = null;
}
}
public void CanCreateWavFileFromWaveChannel32()
{
string inFile = @"F:\Recording\wav\pcm\16bit mono 8kHz.wav";
string outFile = @"F:\Recording\wav\pcm\32bit stereo 8kHz.wav";
if (!File.Exists(inFile))
{
Assert.Ignore("Input test file not found");
}
var audio32 = new WaveChannel32(new WaveFileReader(inFile));
audio32.PadWithZeroes = false;
WaveFileWriter.CreateWaveFile(outFile, audio32);
}
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 WaveStream CreateInputStream(string fileName)
{
WaveChannel32 inputstream;
if (fileName.EndsWith(".mp3"))
{
WaveStream mp3Reader = new Mp3FileReader(fileName);
inputstream = new WaveChannel32(mp3Reader);
}
else
{
throw new InvalidOperationException("Unsupported extension");
}
volumeStream = inputstream;
return volumeStream;
}
public MyItemControl(Word word)
{
InitializeComponent();
_word = word;
Picture = null;// con.ByteToWPFImage(word.Picture);
waveReader = new WaveFileReader(con.byteArrayToStream(_word.Sound));
SoundLength = waveReader.TotalTime;
wc = new WaveChannel32(waveReader);
audioOutput = new DirectSoundOut();
audioOutput.Init(wc);
track.ValueChangedManually += track_PositionChangedManually;
myTrack.ValueChangedManually += track_PositionChangedManually;
myTrack.MouseLeftButtonDown += track_MouseLeftButtonDown;
myTrack.Loaded += track_Loaded;
}
public void SoundOutput(string header, bool IsWin8)
{
/**
*
* 출력할 소리가 wav인지 mp3인지 비프음인지 채크합니다.
* windows8 이상의 경우에는 비프음보다 윈도우8 기본 알림음이 더 알맞다고 생각하기에 IsWin8이 True면 아무 소리도 내보내지 않습니다.
*
**/
DisposeWave();//알림이 동시에 여러개가 울릴 경우 소리가 겹치는 문제를 방지
try
{
var Audiofile = GetRandomSound(header);
if (!IsWin8 && Audiofile == null)
{
SystemSounds.Beep.Play(); //FileCheck에서 음소거 채크를 하고 음소거상태이거나 파일이 없는경우 비프음 출력
return;
}
else if (IsWin8 && Audiofile == null)
return; //위와 동일한 조건이지만 윈도우8인경우는 이 소스에서는 아무 소리도 내보내지않음.
float Volume = Settings.Current.CustomSoundVolume > 0 ? (float)Settings.Current.CustomSoundVolume / 100 : 0;
if (Path.GetExtension(Audiofile).ToLower() == ".wav")
{
WaveStream pcm = new WaveChannel32(new WaveFileReader(Audiofile), Volume, 0);
BlockStream = new BlockAlignReductionStream(pcm);
}
else if (Path.GetExtension(Audiofile).ToLower() == ".mp3")
{
WaveStream pcm = new WaveChannel32(new Mp3FileReader(Audiofile), Volume, 0);
BlockStream = new BlockAlignReductionStream(pcm);
}
else
return;
SoundOut = new DirectSoundOut();
SoundOut.Init(BlockStream);
SoundOut.Play();
}
catch (Exception ex)
{
StatusService.Current.Notify("Unable to play sound notification: " + ex.Message);
}
}
private void CreateInputStream(string fileName)
{
if (fileName.EndsWith(".wav"))
{
inputStream = OpenWavStream(fileName);
}
else if (fileName.EndsWith(".mp3"))
{
inputStream = OpenMp3Stream(fileName);
}
else
{
throw new InvalidOperationException("Unsupported extension");
}
inputStream.Sample += new EventHandler<SampleEventArgs>(inputStream_Sample);
}
public static void PlayGameSound(GameSound sound)
{
var isSubscribed = SubscriptionModule.Get().IsSubscribed ?? false;
if (isSubscribed && Prefs.EnableGameSound)
{
Log.InfoFormat("Playing game sound {0}", sound.Name);
if (!sound.Src.ToLowerInvariant().EndsWith(".mp3"))
{
Log.InfoFormat("Playing game sound {0} as wav", sound.Name);
PlaySound(sound.Src);
return;
}
Task.Factory.StartNew(() =>
{
try
{
Log.InfoFormat("Playing game sound {0} as mp3", sound.Name);
using (var mp3Reader = new Mp3FileReader(sound.Src))
using (var stream = new WaveChannel32(mp3Reader) { PadWithZeroes = false })
using (var wo = new WaveOutEvent())
{
Log.InfoFormat("Initializing game sound {0} as mp3", sound.Name);
wo.Init(stream);
wo.Play();
Log.InfoFormat("Waiting for game sound {0} to complete", sound.Name);
var ttime = mp3Reader.TotalTime.Add(new TimeSpan(0,0,10));
var etime = DateTime.Now.Add(ttime.Add(new TimeSpan(0, 0, 10)));
while (wo.PlaybackState == PlaybackState.Playing)
{
Thread.Sleep(100);
if (DateTime.Now > etime)
{
break;
}
}
Log.InfoFormat("Game sound {0} completed", sound.Name);
}
}
catch (Exception e)
{
Log.Warn("PlayGameSound Error", e);
}
});
}
}
public void Dispose()
{
if (this.waveOutDevice != null)
waveOutDevice.Stop();
if (this.mainOutputStream != null)
{
this.volumeStream.Close();
this.volumeStream = null;
this.mainOutputStream.Close();
this.mainOutputStream = null;
}
if (this.waveOutDevice != null)
{
this.waveOutDevice.Dispose();
this.waveOutDevice = null;
}
}
private void StopAndCloseStream()
{
if (waveOutDevice != null)
{
waveOutDevice.Stop();
}
if (activeStream != null)
{
inputStream.Close();
inputStream = null;
ActiveStream.Close();
ActiveStream = null;
}
if (waveOutDevice != null)
{
waveOutDevice.Dispose();
waveOutDevice = null;
}
}
public Player Load(MediaFile song)
{
if (this.mp3 != null)
{
this.mp3.Close();
}
this.CurrentMediaFile = song;
this.FindAlbumArt();
this.mp3 = new Mp3FileReader(song.Path);
this.TotalTime = this.mp3.TotalTime;
var volumeStream = new WaveChannel32(mp3);
this.player = new WaveOutEvent();
this.player.PlaybackStopped += OnPlaybackStopped;
this.player.Init(volumeStream);
return this;
}
//otwieranie pliku wav
private void openBtn_Click(object sender, EventArgs e)
{
OpenFileDialog open = new OpenFileDialog();
open.Filter = " Wave File (*.wav)|*.wav;";
if (open.ShowDialog() != DialogResult.OK)
{
return;
}
DisposeWave();
NAudio.Wave.WaveChannel32 wave = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(open.FileName));
output = new NAudio.Wave.DirectSoundOut();
output.Init(wave);
output.Play();
pauseBtn.Enabled = true;
}
public void SoundOutput(string header, bool IsWin8)
{
try
{
DisposeWave();//알림이 동시에 여러개가 울릴 경우 소리가 겹치는 문제를 방지
if (!Directory.Exists(Path.Combine(Main_folder, "Sounds")))
Directory.CreateDirectory(Path.Combine(Main_folder, "Sounds"));
List<string> FileList = Directory.GetFiles(Path.Combine(Main_folder, "Sounds"), "*.wav", SearchOption.AllDirectories)
.Concat(Directory.GetFiles(Path.Combine(Main_folder, "Sounds"), "*.mp3", SearchOption.AllDirectories)).ToList();//mp3와 wav를 검색하여 추가
string Audiofile = string.Empty;
if (FileList.Count > 0)
{
Random Rnd = new Random();
Audiofile = FileList[Rnd.Next(0, FileList.Count)];
float Volume = AppSettings.Default.CustomSoundVolume > 0 ? (float)AppSettings.Default.CustomSoundVolume / 100 : 0;
if (Path.GetExtension(Audiofile).ToLower() == ".wav")//wav인지 채크
{
WaveStream pcm = new WaveChannel32(new WaveFileReader(Audiofile), Volume, 0);
BlockStream = new BlockAlignReductionStream(pcm);
}
else if (Path.GetExtension(Audiofile).ToLower() == ".mp3")//mp3인 경우
{
WaveStream pcm = new WaveChannel32(new Mp3FileReader(Audiofile), Volume, 0);
BlockStream = new BlockAlignReductionStream(pcm);
}
SoundOut = new DirectSoundOut();
SoundOut.Init(BlockStream);
SoundOut.Play();
}
else
{
System.Media.SystemSounds.Beep.Play();
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
System.Media.SystemSounds.Beep.Play();
}
}
public static String playSound(int deviceNumber, String audioPatch, EventHandler Stopped_Event = null)
{
disposeWave();
try
{
if (audioPatch.EndsWith(".mp3"))
{
NAudio.Wave.WaveStream pcm = NAudio.Wave.WaveFormatConversionStream.CreatePcmStream(new NAudio.Wave.Mp3FileReader(audioPatch));
stream = new NAudio.Wave.BlockAlignReductionStream(pcm);
}
else if (audioPatch.EndsWith(".wav"))
{
NAudio.Wave.WaveChannel32 pcm = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(audioPatch));
stream = new NAudio.Wave.BlockAlignReductionStream(pcm);
pcm.PadWithZeroes = false;
}
else
{
return("Not a valid audio file");
}
output = new NAudio.Wave.WaveOut();
output.DeviceNumber = deviceNumber;
output.Init(stream);
output.Play();
if (Stopped_Event != null)
{
output.PlaybackStopped += new EventHandler <StoppedEventArgs>(Stopped_Event);
}
}
catch (Exception ex)
{
return(ex.Message);
}
return("true");
}
private void toolStripMenuItem2_Click(object sender, EventArgs e)
{
OpenFileDialog open = new OpenFileDialog();
open.Filter = "Wave File (*.wav)|*.wav";
if (open.ShowDialog() != DialogResult.OK)
{
return;
}
customWaveViewer1.WaveStream = new NAudio.Wave.WaveFileReader(open.FileName);
customWaveViewer1.FitToScreen();
NAudio.Wave.WaveChannel32 wave = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(open.FileName));
byte[] buffer = new byte[16384];
int read = 0;
double point = 0;
double x = 0;
while (wave.Position < wave.Length)
{
read = wave.Read(buffer, 0, 16384);
for (int i = 0; i < read / 4; i++)
{
point = BitConverter.ToSingle(buffer, (i * 4));
x = x + (0.00002267573 / 2);
chart2.Series["wave"].Points.AddXY(x, point);
}
}
WaveFileReader file = new WaveFileReader(open.FileName);
ComputeGraph(file);
}
public void OpenFile(string path)
{
Stop();
if (ActiveStream != null)
{
SelectionBegin = TimeSpan.Zero;
SelectionEnd = TimeSpan.Zero;
ChannelPosition = 0;
}
StopAndCloseStream();
if (System.IO.File.Exists(path))
{
try
{
waveOutDevice = new WaveOut()
{
DesiredLatency = 100
};
ActiveStream = new Mp3FileReader(path);
inputStream = new WaveChannel32(ActiveStream);
sampleAggregator = new SampleAggregator(fftDataSize);
inputStream.Sample += inputStream_Sample;
waveOutDevice.Init(inputStream);
ChannelLength = inputStream.TotalTime.TotalSeconds;
FileTag = TagLib.File.Create(path);
GenerateWaveformData(path);
CanPlay = true;
}
catch
{
ActiveStream = null;
CanPlay = false;
}
}
}
public void MP3PlayFile(string fileName)
{
this.fileName = fileName;
if (fileName.EndsWith(".mp3"))
{
NAudio.Wave.WaveStream pcm = NAudio.Wave.WaveFormatConversionStream.CreatePcmStream(new NAudio.Wave.Mp3FileReader(fileName));
stream = new NAudio.Wave.BlockAlignReductionStream(pcm);
}
else if (fileName.EndsWith(".wav"))
{
NAudio.Wave.WaveStream pcm = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(fileName));
stream = new NAudio.Wave.BlockAlignReductionStream(pcm);
}
else
{
throw new InvalidOperationException("Not a correct audio file type.");
}
output = new NAudio.Wave.DirectSoundOut();
//output = new WaveOut();
output.Init(stream);
output.Play();
//output.Volume = 1.0f;
}
internal bool ContainsInputStream(WaveChannel32 waveChannel)
{
return(inputStreams.Contains(waveChannel));
}
private void button4_Click(object sender, EventArgs e)
{
createSeries();
manager = new Manager();
saveFileName = "";
NAudio.Wave.WaveChannel32 wave = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(readFile.FileName));
byte[] buffer = new byte[44100];
int read = 0;
while (wave.Position < wave.Length)
{
read = wave.Read(buffer, 0, 44100);
for (int i = 0; i < read / 4; i++)
{
samples.Add(BitConverter.ToSingle(buffer, i * 4));
}
}
for (int i = 0; i < samples.Count; ++i)
{
chart3.Series["wave"].Points.Add(samples[i]);
}
N = M + L - 1;
//time:
DateTime startTime = DateTime.Now;
manager.CreateWindows(samples, M, N, R, selectedWindow);
manager.LowPassFIlter(L, fc, N, selectedWindow);
for (int i = 0; i < manager.listOfWindows.Count; ++i)
{
manager.listOfWindows[i] = manager.Time(manager.listOfWindows[i], L);
}
manager.AddTime(R, samples.Count);
for (int i = 0; i < manager.result.Count; ++i)
{
chart4.Series["wave"].Points.Add(manager.result[i]);
}
DateTime stopTime = DateTime.Now;
TimeSpan diff = stopTime - startTime;
label5.Text = "Time domain duration: " + diff.TotalMilliseconds.ToString() + "ms";
//frequency:
DateTime startTime2 = DateTime.Now;
manager = new Manager();
manager.CreateWindows(samples, M, N, R, selectedWindow);
manager.LowPassFIlter(L, fc, N, selectedWindow);
manager.CreateComplexWindows();
manager.CreateComplexCoefficient();
manager.Fill0Coefficients();
List <Complex> wCoefficients = CalculateWCoefficients(manager.listOfComplexCoefficients.Count, false);
List <Complex> wCoefficientsWindows = CalculateWCoefficients(manager.listOfComplexWindows[0].Count, false);
manager.listOfComplexCoefficients = CalculateFastTransform(manager.listOfComplexCoefficients, wCoefficients, 0);
for (int i = 0; i < manager.listOfComplexWindows.Count; ++i)
{
manager.listOfComplexWindows[i] = CalculateFastTransform(manager.listOfComplexWindows[i], wCoefficientsWindows, 0);
}
manager.MultiplySpectrum();
List <Complex> wReverseCoefficients = CalculateWCoefficients(manager.resultComplexWindows[0].Count, true);
for (int i = 0; i < manager.resultComplexWindows.Count; ++i)
{
manager.listOfComplexWindows[i] = CalculateFastTransform(manager.resultComplexWindows[i], wReverseCoefficients, 0);
}
manager.AddReal(M, R, samples.Count);
for (int i = 0; i < manager.result.Count; ++i)
{
chart5.Series["wave"].Points.Add(manager.result[i]);
//generatedSound.Add(new SoundFragment((int)(44100 / i * 2), (2048f / 44100f) * 0.5f));
}
/*saveFile.Filter = "Wave File (*.wav)|*.wav;";
* if (saveFile.ShowDialog() != DialogResult.OK) return;
* SoundGenerator waveGenerator = new SoundGenerator(generatedSound);
* waveGenerator.Save(saveFile.FileName);
* saveFileName = saveFile.FileName;
* button2.Enabled = true;
* generatedSound = new List<SoundFragment>();*/
DateTime stopTime2 = DateTime.Now;
TimeSpan diff2 = stopTime2 - startTime2;
label6.Text = "Time domain duration: " + diff2.TotalMilliseconds.ToString() + "ms";
}
private void F2()
{
saveFileName = "";
NAudio.Wave.WaveChannel32 wave = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(readFile.FileName));
byte[] buffer = new byte[16384];
int read = 0;
List <Complex> samplesComplex = new List <Complex>();
List <int> zeroFrequency = new List <int>();
while (wave.Position < wave.Length)
{
read = wave.Read(buffer, 0, 16384);
for (int i = 0; i < read / 4; i++)
{
samples.Add(BitConverter.ToSingle(buffer, i * 4));
samplesComplex.Add(new Complex(samples[i], 0));
}
}
samplesComplex = CutSignalSamplesToPowerOfTwo(samplesComplex);
List <List <Complex> > listOfFragments = new List <List <Complex> >();
List <Complex> fragment = new List <Complex>();
double totalValue = 0.0;
double average = 0.0;
for (int i = 0; i < (samplesComplex.Count); ++i)
{
totalValue += samples[i];
}
average = Math.Abs(totalValue / samplesComplex.Count);
for (int i = 0; i < samplesComplex.Count; i++)
{
if (Math.Abs(samples[i]) < average * 10)
{
fragment.Add(new Complex(0.000000000001 * 0.5 * (1 - Math.Cos((2 * Math.PI * i) / (2048 - 1))), 0));
}
else
{
fragment.Add(new Complex(samples[i] * 0.5 * (1 - Math.Cos((2 * Math.PI * i) / (2048 - 1))), 0));
}
chart3.Series["wave"].Points.Add(samples[i]);
if (fragment.Count == 2048)
{
listOfFragments.Add(fragment);
fragment = new List <Complex>();
}
}
List <Complex> wCoefficients = CalculateWCoefficients(2048, false);
for (int i = 0; i < listOfFragments.Count; ++i)
{
listOfFragments[i] = CalculateFastTransform(listOfFragments[i], wCoefficients, 0);
}
List <List <double> > amplitudeSpectrum = new List <List <double> >();
for (int i = 0; i < listOfFragments.Count; ++i)
{
List <double> amplitude = new List <double>();
for (int j = 0; j < listOfFragments[i].Count / 2; ++j)
{
amplitude.Add(Math.Sqrt(listOfFragments[i][j].Real * listOfFragments[i][j].Real + listOfFragments[i][j].Imaginary * listOfFragments[i][j].Imaginary));
}
amplitudeSpectrum.Add(amplitude);
}
List <List <Complex> > spectrumComplex = new List <List <Complex> >();
for (int i = 0; i < listOfFragments.Count; ++i)
{
List <Complex> spectrum = new List <Complex>();
for (int j = 0; j < amplitudeSpectrum[i].Count; ++j)
{
amplitudeSpectrum[i][j] = Math.Log(amplitudeSpectrum[i][j]);
spectrum.Add(new Complex(amplitudeSpectrum[i][j], 0));
}
spectrumComplex.Add(spectrum);
}
wCoefficients = CalculateWCoefficients(spectrumComplex[0].Count, false);
for (int i = 0; i < listOfFragments.Count; ++i)
{
listOfFragments[i] = CalculateFastTransform(spectrumComplex[i], wCoefficients, 0);
}
List <List <double> > amplitudeSpectrum2 = new List <List <double> >();
for (int i = 0; i < listOfFragments.Count; ++i)
{
List <double> spectrum = new List <double>();
for (int j = 0; j < listOfFragments[i].Count / 2; ++j)
{
spectrum.Add(Math.Sqrt(listOfFragments[i][j].Real * listOfFragments[i][j].Real + listOfFragments[i][j].Imaginary * listOfFragments[i][j].Imaginary));
}
amplitudeSpectrum2.Add(spectrum);
}
for (int i = 0; i < listOfFragments.Count; ++i)
{
double maxValue = amplitudeSpectrum2[i][treshhold - 1];
int maxIndex = treshhold - 1;
for (int j = treshhold; j < amplitudeSpectrum2[i].Count; ++j)
{
if (amplitudeSpectrum2[i][j] > maxValue)
{
maxValue = amplitudeSpectrum2[i][j];
maxIndex = j;
}
}
for (int k = 0; k < amplitudeSpectrum2[i].Count; ++k)
{
chart4.Series["wave"].Points.Add(amplitudeSpectrum2[i][k]);
}
if (maxIndex == treshhold - 1)
{
chart5.Series["wave"].Points.Add(0);
generatedSound.Add(new SoundFragment((int)(0), (2048f / 44100f) * 0.5f));
}
else
{
chart5.Series["wave"].Points.Add(44100 / maxIndex);
generatedSound.Add(new SoundFragment((int)(44100 / maxIndex), (2048f / 44100f) * 0.5f));
}
}
saveFile.Filter = "Wave File (*.wav)|*.wav;";
if (saveFile.ShowDialog() != DialogResult.OK)
{
return;
}
SoundGenerator waveGenerator = new SoundGenerator(generatedSound);
waveGenerator.Save(saveFile.FileName);
saveFileName = saveFile.FileName;
button2.Enabled = true;
generatedSound = new List <SoundFragment>();
}
private void T4()
{
saveFileName = "";
NAudio.Wave.WaveChannel32 wave = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(readFile.FileName));
byte[] buffer = new byte[44100];
int read = 0;
while (wave.Position < wave.Length)
{
read = wave.Read(buffer, 0, 44100);
for (int i = 0; i < read / 4; i++)
{
samples.Add(BitConverter.ToSingle(buffer, i * 4));
}
}
List <List <double> > listOfFragments = new List <List <double> >();
List <double> fragment = new List <double>();
double totalValue = 0.0;
double average = 0.0;
for (int i = 0; i < (samples.Count - samples.Count % 2048); ++i)
{
totalValue += samples[i];
}
average = Math.Abs(totalValue / samples.Count);
for (int i = 0; i < (samples.Count - samples.Count % 2048); ++i)
{
if (Math.Abs(samples[i]) < average * 10)
{
fragment.Add(0.00000001);
}
else
{
fragment.Add(samples[i]);
}
chart3.Series["wave"].Points.Add(samples[i]);
if (fragment.Count == 2048)
{
listOfFragments.Add(fragment);
fragment = new List <double>();
}
chart3.Series["wave"].Points.Add(samples[i]);
}
List <List <double> > delayedSamples = new List <List <double> >();
double previusValue;
double actualValue;
double nextValue;
for (int i = 0; i < listOfFragments.Count; ++i)
{
List <double> delayed = new List <double>();
for (int j = 0; j < listOfFragments[i].Count; ++j)
{
double result = 0.0;
for (int k = 0; k < listOfFragments[i].Count; ++k)
{
if ((k + j) > (listOfFragments[i].Count - 1))
{
result += Math.Abs(listOfFragments[i][k]);
}
else
{
result += Math.Abs(listOfFragments[i][k] - listOfFragments[i][k + j]);
}
}
delayed.Add(result);
chart4.Series["wave"].Points.Add(delayed[j]);
}
delayedSamples.Add(delayed);
}
for (int i = 0; i < delayedSamples.Count; ++i)
{
int sampleNumber = 1;
for (int j = 2; j < delayedSamples[i].Count; ++j)
{
previusValue = delayedSamples[i][j - 2];
actualValue = delayedSamples[i][j - 1];
nextValue = delayedSamples[i][j];
if (actualValue < previusValue && actualValue < nextValue)
{
sampleNumber = j;
break;
}
}
for (int j = 0; j < delayedSamples[i].Count; ++j)
{
if (sampleNumber == 1)
{
chart5.Series["wave"].Points.Add(0);
}
else
{
chart5.Series["wave"].Points.Add(44100 / sampleNumber * 2);
}
//chart5.Series["wave"].Points.Add(44100/sampleNumber * 2);
}
if (sampleNumber == 1)
{
generatedSound.Add(new SoundFragment((int)(0), (2048f / 44100f) * 0.5f));
}
else
{
generatedSound.Add(new SoundFragment((int)(44100 / sampleNumber * 2), (2048f / 44100f) * 0.5f));
}
}
saveFile.Filter = "Wave File (*.wav)|*.wav;";
if (saveFile.ShowDialog() != DialogResult.OK)
{
return;
}
SoundGenerator waveGenerator = new SoundGenerator(generatedSound);
waveGenerator.Save(saveFile.FileName);
saveFileName = saveFile.FileName;
button2.Enabled = true;
generatedSound = new List <SoundFragment>();
}
private void WriteToFile(string SongID, string strPath, byte[] Buffer)
{
try
{
int samplesPerPixel = 128;
long startPosition = 0;
//FileStream newFile = new FileStream(GeneralUtils.Get_SongFilePath() + "/" + strPath, FileMode.Create);
float[] data = FloatArrayFromByteArray(Buffer);
Bitmap bmp = new Bitmap(1170, 200);
int BORDER_WIDTH = 5;
int width = bmp.Width - (2 * BORDER_WIDTH);
int height = bmp.Height - (2 * BORDER_WIDTH);
NAudio.Wave.Mp3FileReader reader = new NAudio.Wave.Mp3FileReader(strPath, wf => new NAudio.FileFormats.Mp3.DmoMp3FrameDecompressor(wf));
NAudio.Wave.WaveChannel32 channelStream = new NAudio.Wave.WaveChannel32(reader);
int bytesPerSample = (reader.WaveFormat.BitsPerSample / 8) * channelStream.WaveFormat.Channels;
using (Graphics g = Graphics.FromImage(bmp))
{
g.Clear(Color.White);
Pen pen1 = new Pen(Color.Gray);
int size = data.Length;
string hexValue1 = "#009adf";
Color colour1 = System.Drawing.ColorTranslator.FromHtml(hexValue1);
pen1.Color = colour1;
Stream wavestream = new NAudio.Wave.Mp3FileReader(strPath, wf => new NAudio.FileFormats.Mp3.DmoMp3FrameDecompressor(wf));
wavestream.Position = 0;
int bytesRead1;
byte[] waveData1 = new byte[samplesPerPixel * bytesPerSample];
wavestream.Position = startPosition + (width * bytesPerSample * samplesPerPixel);
for (float x = 0; x < width; x++)
{
short low = 0;
short high = 0;
bytesRead1 = wavestream.Read(waveData1, 0, samplesPerPixel * bytesPerSample);
if (bytesRead1 == 0)
{
break;
}
for (int n = 0; n < bytesRead1; n += 2)
{
short sample = BitConverter.ToInt16(waveData1, n);
if (sample < low)
{
low = sample;
}
if (sample > high)
{
high = sample;
}
}
float lowPercent = ((((float)low) - short.MinValue) / ushort.MaxValue);
float highPercent = ((((float)high) - short.MinValue) / ushort.MaxValue);
float lowValue = height * lowPercent;
float highValue = height * highPercent;
g.DrawLine(pen1, x, lowValue, x, highValue);
}
}
string filename = Server.MapPath("image/060.png");
bmp.Save(filename);
bmp.Dispose();
}
catch (Exception e)
{
}
}
public void LoadFile(string filePath)
{
DisposeWave();
pausePlay = true;
if (filePath.EndsWith(".mp3"))
{
NAudio.Wave.WaveStream pcm = NAudio.Wave.WaveFormatConversionStream.CreatePcmStream(new NAudio.Wave.Mp3FileReader(filePath));
stream = new NAudio.Wave.BlockAlignReductionStream(pcm);
}
else if (filePath.EndsWith(".wav"))
{
NAudio.Wave.WaveStream pcm = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(filePath));
stream = new NAudio.Wave.BlockAlignReductionStream(pcm);
}
else
{
throw new InvalidOperationException("oh my god just put in the right file type you twat");
}
output = new NAudio.Wave.WaveOut();
output.DeviceNumber = comboBox2.SelectedIndex;
textBox2.Text = comboBox2.GetItemText(comboBox2.SelectedItem);
var audioFileReader = new AudioFileReader(filePath);
string min = Convert.ToInt32(audioFileReader.TotalTime.TotalMinutes).ToString();
string sec = Convert.ToInt32(audioFileReader.TotalTime.TotalSeconds % 60).ToString();
string mil = Convert.ToInt32(audioFileReader.TotalTime.TotalMilliseconds % 1000).ToString();
if (min.Length < 2)
{
min = "0" + min;
}
if (sec.Length < 2)
{
sec = "0" + sec;
}
if (mil.Length < 2)
{
mil = "00" + mil;
}
else if (mil.Length < 3)
{
mil = "0" + mil;
}
textBox9.Text = "Total " + min + ":" + sec + ":" + mil;
audioFileReader.Volume = vol2.Volume;
output.Init(audioFileReader);
Stopwatch time = new Stopwatch();
time.Start();
stopwatches.Add(time, "time");
totalMil = Convert.ToInt64(audioFileReader.TotalTime.TotalMilliseconds);
output.Play();
if (comboBox1.SelectedIndex != comboBox2.SelectedIndex)
{
if (filePath.EndsWith(".mp3"))
{
NAudio.Wave.WaveStream pcm2 = NAudio.Wave.WaveFormatConversionStream.CreatePcmStream(new NAudio.Wave.Mp3FileReader(filePath));
stream2 = new NAudio.Wave.BlockAlignReductionStream(pcm2);
}
else if (filePath.EndsWith(".wav"))
{
NAudio.Wave.WaveStream pcm2 = new NAudio.Wave.WaveChannel32(new NAudio.Wave.WaveFileReader(filePath));
stream2 = new NAudio.Wave.BlockAlignReductionStream(pcm2);
}
else
{
throw new InvalidOperationException("Not a compatabible audio file type.");
}
outputLocal = new NAudio.Wave.WaveOut();
outputLocal.DeviceNumber = comboBox1.SelectedIndex;
textBox4.Text = comboBox1.GetItemText(comboBox1.SelectedItem);
var audioFileReader2 = new AudioFileReader(filePath);
audioFileReader2.Volume = volumeSlider1.Volume;
outputLocal.Init(audioFileReader2);
outputLocal.Play();
//float a = volumeSlider1.Volume;
//outputLocal.Volume = a;
//outputLocal.Init(stream2);
//outputLocal.Play();
}
}
public void CreateCurrentSongImage(AudioFile audioFile)
{
try
{
int bytesPerSample = 0;
WaveStream reader;
switch (audioFile.Format.ToLower())
{
case ".mp3":
reader = new Mp3FileReader(audioFile.Path);
break;
case ".wav":
reader = new WaveFileReader(audioFile.Path);
break;
case ".aiff":
reader = new AiffFileReader(audioFile.Path);
break;
default:
reader = new AudioFileReader(audioFile.Path);
break;
}
using (NAudio.Wave.WaveChannel32 channelStream = new NAudio.Wave.WaveChannel32(reader))
{
//initialize the progress bar, once the audio stream has been created
_progBar.Maximum = (int)reader.TotalTime.TotalMilliseconds / _visEventTimer.Interval;
bytesPerSample = (reader.WaveFormat.BitsPerSample / 8) * channelStream.WaveFormat.Channels;
//Give a size to the bitmap; either a fixed size, or something based on the length of the audio
using (Bitmap bitmap = new Bitmap((int)Math.Round(reader.TotalTime.TotalSeconds * 80), 300))
{
int width = bitmap.Width;
int height = bitmap.Height;
using (Graphics graphics = Graphics.FromImage(bitmap))
{
graphics.Clear(Color.White);
Pen bluePen = new Pen(Color.Blue);
int samplesPerPixel = (int)(reader.Length / (double)(width * bytesPerSample));
int bytesPerPixel = bytesPerSample * samplesPerPixel;
int bytesRead;
byte[] waveData = new byte[bytesPerPixel];
for (float x = 0; x < width; x++)
{
bytesRead = reader.Read(waveData, 0, bytesPerPixel);
if (bytesRead == 0)
{
break;
}
short low = 0;
short high = 0;
for (int n = 0; n < bytesRead; n += 2)
{
short sample = BitConverter.ToInt16(waveData, n);
if (sample < low)
{
low = sample;
}
if (sample > high)
{
high = sample;
}
}
float lowPercent = ((((float)low) - short.MinValue) / ushort.MaxValue);
float highPercent = ((((float)high) - short.MinValue) / ushort.MaxValue);
float lowValue = height * lowPercent;
float highValue = height * highPercent;
graphics.DrawLine(bluePen, x, lowValue, x, highValue);
}
}
_currentSongImage = new System.Drawing.Bitmap(bitmap);
bitmap.Dispose();
}
}
reader.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
