private void Playbtn_Click(object sender, RoutedEventArgs e)
{
SoundList soundList = (SoundList)MainListbox.SelectedItem;
if (soundList == null)
{
return;
}
string filename = soundList.FileName;
byte[] buffer = soundList.soundData.bytes;
try
{
if (System.IO.Path.GetExtension(filename).ToLower() == ".wav")
{
WaveFileReader waveFileReader = new WaveFileReader(new MemoryStream(buffer));
waveOut.Init(waveFileReader);
waveOut.Play();
}
else if (System.IO.Path.GetExtension(filename).ToLower() == ".ogg")
{
NAudio.Vorbis.VorbisWaveReader vorbisWaveReader = new NAudio.Vorbis.VorbisWaveReader(new MemoryStream(buffer));
waveOut.Init(vorbisWaveReader);
waveOut.Play();
}
}
catch (Exception)
{
System.Media.SystemSounds.Hand.Play();
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (directWaveOut != null)
{
directWaveOut.Stop();
}
if (GenericFileReader != null)
{
GenericFileReader.Dispose();
}
if (VorbisFileReader != null)
{
VorbisFileReader.Dispose();
}
if (directWaveOut != null)
{
directWaveOut.Dispose();
}
Debug.WriteLine("[DISPOSE] Disposed of player for " + fileName + ".");
}
}
GenericFileReader = null;
VorbisFileReader = null;
directWaveOut = null;
//dispose unmanaged resources
disposed = true;
}
private void StopAudio()
{
if (_audio != null)
{
if (_waveReader != null)
{
_waveReader.Dispose();
_waveReader = null;
}
if (_mp3Reader != null)
{
_mp3Reader.Dispose();
_mp3Reader = null;
}
try
{
_audio.PlaybackStopped -= PreviewAudio_PlaybackStopped;
_audio.Stop();
_audio.Dispose();
}
catch (Exception e)
{
Logger.Warn($"Error stopping audio: {e.Message}");
}
_audio = null;
NotifyPropertyChanged(nameof(IsPlayingAudio));
}
}
public NSoundPlayer(Guid SoundDevice, string soundFile, float volume)
{
fullFileName = soundFile;
fileName = soundFile.Split('\\').Last();
if (File.Exists(soundFile))
{
if (soundFile.EndsWith("ogg"))
{
format = PlayerFormat.Vorbis;
}
switch (format)
{
case PlayerFormat.Vorbis:
VorbisFileReader = new NAudio.Vorbis.VorbisWaveReader(soundFile);
directWaveOut = new DirectSoundOut(SoundDevice, 120);
directWaveOut.Init(VorbisFileReader);
directWaveOut.Volume = volume;
directWaveOut.Play();
break;
default:
GenericFileReader = new AudioFileReader(soundFile);
directWaveOut = new DirectSoundOut(SoundDevice, 120);
directWaveOut.Init(GenericFileReader);
GenericFileReader.Volume = volume;
directWaveOut.Play();
break;
}
}
}
static async Task <bool> To_MP3(int File_Number, string To_Dir, bool IsFromFileDelete)
{
if (!File.Exists(From_Files[File_Number]))
{
return(false);
}
try
{
string To_Audio_File = To_Dir + "\\" + Path.GetFileNameWithoutExtension(From_Files[File_Number]) + ".mp3";
await Task.Run(() =>
{
string Ex = Path.GetExtension(From_Files[File_Number]);
if (Ex == ".ogg")
{
using (NAudio.Vorbis.VorbisWaveReader reader = new NAudio.Vorbis.VorbisWaveReader(From_Files[File_Number]))
using (LameMP3FileWriter wtr = new LameMP3FileWriter(To_Audio_File, reader.WaveFormat, 128))
reader.CopyTo(wtr);
}
else if (Ex == ".wav")
{
using (WaveFileReader reader = new WaveFileReader(From_Files[File_Number]))
using (LameMP3FileWriter wtr = new LameMP3FileWriter(To_Audio_File, reader.WaveFormat, 128))
reader.CopyTo(wtr);
}
else if (Ex == ".flac")
{
using (NAudio.Flac.FlacReader reader = new NAudio.Flac.FlacReader(From_Files[File_Number]))
using (LameMP3FileWriter wtr = new LameMP3FileWriter(To_Audio_File, reader.WaveFormat, 128))
reader.CopyTo(wtr);
}
else if (Ex == ".aac" || Ex == ".wma" || Ex == ".mp4" || Ex == ".webm")
{
using (MediaFoundationReader reader = new MediaFoundationReader(From_Files[File_Number]))
using (LameMP3FileWriter wtr = new LameMP3FileWriter(To_Audio_File, reader.WaveFormat, 128))
reader.CopyTo(wtr);
}
else
{
Un4seen.Bass.Misc.EncoderLAME mc = new Un4seen.Bass.Misc.EncoderLAME(0);
mc.EncoderDirectory = Voice_Set.Special_Path + "/Encode_Mp3";
mc.InputFile = From_Files[File_Number];
mc.OutputFile = To_Audio_File;
mc.LAME_Bitrate = (int)Un4seen.Bass.Misc.EncoderLAME.BITRATE.kbps_160;
mc.LAME_Mode = Un4seen.Bass.Misc.EncoderLAME.LAMEMode.Default;
mc.LAME_Quality = Un4seen.Bass.Misc.EncoderLAME.LAMEQuality.Q2;
Un4seen.Bass.Misc.BaseEncoder.EncodeFile(mc, null, true, false, true);
}
if (IsFromFileDelete)
{
File.Delete(From_Files[File_Number]);
}
});
}
catch
{
return(false);
}
return(true);
}
private void MapSoundPlay()
{
SoundListItem soundListItems = (SoundListItem)MainListbox.SelectedItem;
if (soundListItems != null)
{
string soundname = soundListItems.FileName;
SoundData soundData = mapEditor.mapdata.soundDatas.Find((x) => x.path == soundname);
try
{
if (soundData == null)
{
byte[] buffer = data.ReadFile(soundname);
if (buffer.Length == 0)
{
return;
}
if (System.IO.Path.GetExtension(soundname).ToLower() == ".wav")
{
WaveFileReader waveFileReader = new WaveFileReader(new MemoryStream(buffer));
waveOut.Init(waveFileReader);
waveOut.Play();
}
else if (System.IO.Path.GetExtension(soundname).ToLower() == ".ogg")
{
NAudio.Vorbis.VorbisWaveReader vorbisWaveReader = new NAudio.Vorbis.VorbisWaveReader(new MemoryStream(buffer));
waveOut.Init(vorbisWaveReader);
waveOut.Play();
}
}
else
{
if (System.IO.Path.GetExtension(soundname).ToLower() == ".wav")
{
WaveFileReader waveFileReader = new WaveFileReader(new MemoryStream(soundData.bytes));
waveOut.Init(waveFileReader);
waveOut.Play();
}
else if (System.IO.Path.GetExtension(soundname).ToLower() == ".ogg")
{
NAudio.Vorbis.VorbisWaveReader vorbisWaveReader = new NAudio.Vorbis.VorbisWaveReader(new MemoryStream(soundData.bytes));
waveOut.Init(vorbisWaveReader);
waveOut.Play();
}
}
}
catch (Exception)
{
System.Media.SystemSounds.Hand.Play();
}
}
}
public void PlayMusic(string fileName)
{
var vorbisStream = new NAudio.Vorbis.VorbisWaveReader(fileName);
try
{
mixer.AddMixerInput((IWaveProvider)vorbisStream);
}
catch (ArgumentException)
{
}
}
void OnMessageInbound(object sender, Client.MessageInboundEventArgs e)
{
ChatBoxWriteLine(e.username + ": " + e.message);
if (e.message.ToUpper().Contains("CARAMEL"))
{
if (!(waveOut is null))
{
waveOut.Dispose();
}
waveOut = new WaveOutEvent();
NAudio.Vorbis.VorbisWaveReader ogg = new NAudio.Vorbis.VorbisWaveReader(new System.IO.MemoryStream(Properties.Resources.CaramelHeaven));
waveOut.Init(ogg);
waveOut.Play();
}
if (e.message.ToUpper().Contains("MIAU") || e.message.ToUpper().Contains("MEOW"))
{
if (!(waveOut is null))
{
waveOut.Dispose();
}
waveOut = new WaveOutEvent();
NAudio.Vorbis.VorbisWaveReader ogg = new NAudio.Vorbis.VorbisWaveReader(new System.IO.MemoryStream(Properties.Resources.Meow));
waveOut.Init(ogg);
waveOut.Play();
}
if (e.message.ToUpper().Contains("MONOSUGOI"))
{
if (!(waveOut is null))
{
waveOut.Dispose();
}
waveOut = new WaveOutEvent();
NAudio.Vorbis.VorbisWaveReader ogg = new NAudio.Vorbis.VorbisWaveReader(new System.IO.MemoryStream(Properties.Resources.Monosugoi_Space_Shuttle_de_Koishi_ga_Monosugoi_uta));
waveOut.Init(ogg);
waveOut.Play();
}
if (e.message.ToUpper().Contains("STOP"))
{
if (!(waveOut is null))
{
waveOut.Dispose();
}
}
}
private void Play(Stream stream)
{
mStop = false;
Task.Factory.StartNew(() =>
{
using (var vorbisStream = new NAudio.Vorbis.VorbisWaveReader(stream))
using (var waveOut = new NAudio.Wave.WaveOutEvent())
{
try
{
waveOut.Init(vorbisStream);
waveOut.Play();
SpinWait.SpinUntil(() => vorbisStream.Position >= vorbisStream.Length || mStop);
Thread.Sleep(200);
}
catch (NAudio.MmException) { }
}
}).ContinueWith((t) => { if (OnPlayFinished != null) OnPlayFinished(); });
}
private void StarCraftSoundPlay()
{
TreeViewItem titem = (TreeViewItem)MainTreeview.SelectedItem;
if (titem != null)
{
if (titem.Items.Count == 0)
{
ComboBoxItem combo = (ComboBoxItem)SoundLan.SelectedItem;
string lanstr = (string)combo.Tag;
string filename = (string)titem.Tag;
//lanstr = lanstr.ToLower();
//filename = filename.ToLower();
byte[] buffer = data.ReadFile(lanstr + filename);
if (buffer.Length == 0)
{
buffer = data.ReadFile(filename);
}
if (buffer.Length == 0)
{
return;
}
if (System.IO.Path.GetExtension(filename).ToLower() == ".wav")
{
WaveFileReader waveFileReader = new WaveFileReader(new MemoryStream(buffer));
waveOut.Init(waveFileReader);
waveOut.Play();
}
else if (System.IO.Path.GetExtension(filename).ToLower() == ".ogg")
{
NAudio.Vorbis.VorbisWaveReader vorbisWaveReader = new NAudio.Vorbis.VorbisWaveReader(new MemoryStream(buffer));
waveOut.Init(vorbisWaveReader);
waveOut.Play();
}
}
}
}
private void PlaySound(string filepath)
{
if (File.Exists(filepath))
{
Task.Factory.StartNew(() =>
{
if (filepath.EndsWith("ogg"))
{
NAudio.Vorbis.VorbisWaveReader VorbisFileReader = new NAudio.Vorbis.VorbisWaveReader(filepath);
directWaveOut.Init(VorbisFileReader);
}
else
{
AudioFileReader audioFileReader = new AudioFileReader(filepath);
directWaveOut.Init(audioFileReader);
}
directWaveOut.Play();
});
}
}
public static byte[] Ogg_to_wav(string fil_n, byte ch, out byte[] mono)
{
byte[] mono2 = null;
Task a = Task.Run(() =>
{
WaveFormat format = new WaveFormat(48000, 16, 1);
try
{
using (NAudio.Vorbis.VorbisWaveReader reader = new NAudio.Vorbis.VorbisWaveReader(fil_n))
{
using (WaveFormatConversionStream stream = new WaveFormatConversionStream(format, reader))
{
mono2 = new byte[stream.Length];
stream.Read(mono2, 0, mono2.Length);
}
}
}
catch (Exception) { }
});
byte[] buffer = null;
try
{
WaveFormat format = new WaveFormat(48000, 16, ch);
using (NAudio.Vorbis.VorbisWaveReader reader = new NAudio.Vorbis.VorbisWaveReader(fil_n))
{
using (WaveFormatConversionStream stream = new WaveFormatConversionStream(format, reader))
{
buffer = new byte[stream.Length];
stream.Read(buffer, 0, buffer.Length);
}
}
}
catch (Exception) { }
a.Wait();
mono = mono2;
return(buffer);
}
private void ButtonClicked(object sender, RoutedEventArgs e)
{
SoundButton button = sender as SoundButton;
WaveOutEvent waveOut = new WaveOutEvent();
try {
if (button.SoundClip.Contains(".ogg"))
{
FileStream fileStream = new FileStream(button.SoundClip, FileMode.Open, FileAccess.Read);
MemoryStream memoryStream = new MemoryStream();
fileStream.CopyTo(memoryStream);
var vorbisStream = new NAudio.Vorbis.VorbisWaveReader(memoryStream);
vorbisStream.Position = 0;
waveOut.Init(vorbisStream);
}
else if (button.SoundClip.Contains(".mp3"))
{
var reader = new Mp3FileReader(button.SoundClip);
reader.Position = 0;
waveOut.Init(reader);
}
else if (button.SoundClip.Contains(".flac"))
{
var reader = new FlacReader(button.SoundClip);
reader.Position = 0;
waveOut.Init(reader);
}
waveOut.PlaybackStopped += new EventHandler <StoppedEventArgs>(AudioPlaybackStopped);
waveOut.Play();
}
catch (Exception ex) {
Debug.WriteLine(ex);
waveOut.Dispose();
}
}
internal void PlayPreviewAudio()
{
if (_audio == null)
{
try
{
if (_audioFileName.EndsWith(".ogg", StringComparison.InvariantCultureIgnoreCase))
{
if (!string.IsNullOrWhiteSpace(_audioPath))
{
_audio = new NAudio.Wave.WaveOut();
_waveReader = new NAudio.Vorbis.VorbisWaveReader(_audioPath);
_audio.Init(_waveReader);
}
else if (_audioFile != null)
{
_audio = new NAudio.Wave.WaveOut();
_waveReader = new NAudio.Vorbis.VorbisWaveReader(_audioFile);
_audio.Init(_waveReader);
}
}
else if (_audioFileName.EndsWith(".mp3", StringComparison.InvariantCultureIgnoreCase))
{
if (!string.IsNullOrWhiteSpace(_audioPath))
{
_audio = new NAudio.Wave.WaveOut();
_mp3Reader = new NAudio.Wave.Mp3FileReader(_audioPath);
_audio.Init(_mp3Reader);
}
else if (_audioFile != null)
{
_audio = new NAudio.Wave.WaveOut();
_mp3Reader = new NAudio.Wave.Mp3FileReader(_audioFile);
_audio.Init(_mp3Reader);
}
}
else
{
Logger.Warn($"Unsupported audio file: {_audioFileName}");
return;
}
if (_waveReader != null || _mp3Reader != null)
{
_audio.PlaybackStopped += PreviewAudio_PlaybackStopped;
_audio.Play();
}
else
{
Sys.Message(new WMessage($"{ResourceHelper.Get(StringKey.FailedToPlayPreviewAudio)} {_audioFileName}"));
}
NotifyPropertyChanged(nameof(IsPlayingAudio));
}
catch (Exception e)
{
Logger.Error(e);
Sys.Message(new WMessage($"{ResourceHelper.Get(StringKey.FailedToPlayPreviewAudio)} {_audioFileName}: {e.Message}"));
}
}
else
{
StopAudio();
}
}
private void PlaySound(SaveFile.Sound Item)
{
foreach (System.Windows.Forms.TreeNode DeviceNode in this.treeView1.Nodes)
{
if (DeviceNode.Checked && DeviceNode.Tag != null && ((SaveFile.Device)DeviceNode.Tag).CurrentDevice != null)
{
try
{
NAudio.Wave.WaveStream Stream;
if (Item.SndFormat == SoundFormat.OGG)
{
Stream = new NAudio.Vorbis.VorbisWaveReader(Item.FilePath);
}
else if (Item.SndFormat == SoundFormat.WAV)
{
Stream = new NAudio.Wave.WaveFileReader(Item.FilePath);
}
else if (Item.SndFormat == SoundFormat.MP3)
{
Stream = new NAudio.Wave.Mp3FileReader(Item.FilePath);
}
else if (Item.SndFormat == SoundFormat.AIFF)
{
Stream = new NAudio.Wave.AiffFileReader(Item.FilePath);
}
else
{
throw new System.NotSupportedException();
}
if (this.UserData.LoopEnabled)
{
Stream = new LoopStream(Stream);
}
NAudio.Wave.WasapiOut PlayAudio = new NAudio.Wave.WasapiOut((NAudio.CoreAudioApi.MMDevice)((SaveFile.Device)DeviceNode.Tag).CurrentDevice, NAudio.CoreAudioApi.AudioClientShareMode.Shared, true, 100);
this.CurrentlyPlaying.Add(PlayAudio);
{
PlayAudio.Init(Stream);
PlayAudio.Play();
}
PlayAudio.PlaybackStopped += this.WaveOut_PlaybackStopped;
}
catch (System.FormatException Ex)
{
LucasStuff.Message.Show(Ex.Message, "An error occured while playing", LucasStuff.Message.Buttons.OK, LucasStuff.Message.Icon.Error);
return;
}
catch (System.IO.InvalidDataException Ex)
{
LucasStuff.Message.Show(Ex.Message, "An error occured while playing", LucasStuff.Message.Buttons.OK, LucasStuff.Message.Icon.Error);
return;
}
catch (System.IO.FileNotFoundException Ex)
{
System.Windows.Forms.DialogResult Result = LucasStuff.Message.Show(Ex.Message + "\n\nShould this file be removed from your audio listing?", "An error occured while playing", LucasStuff.Message.Buttons.YesNo, LucasStuff.Message.Icon.Error);
if (Result == System.Windows.Forms.DialogResult.Yes)
{
//this.DeleteSounds(); // HACK: fix this before PC 1.0 Update #1
}
return;
}
}
}
}
/// <summary>
/// Plays audio_test_file.ogg based on launch settings for testing audio
/// </summary>
/// <param name="channel"> Where audio will play from: Left,Center,or Right channel</param>
internal void TestAudio(AudioChannel channel)
{
string pathToTestFile = Path.Combine(Sys._7HFolder, "Resources", "audio_test_file.ogg");
if (_audioTest == null)
{
// reference: https://markheath.net/post/handling-multi-channel-audio-in-naudio
// reference: https://stackoverflow.com/questions/22248138/play-sound-on-specific-channel-with-naudio?rq=1
// input 0 - audio test .ogg
// input 1 - silenced wave provider to play silent audio
NAudio.Vorbis.VorbisWaveReader waveReader = new NAudio.Vorbis.VorbisWaveReader(pathToTestFile);
MultiplexingWaveProvider waveProvider = new MultiplexingWaveProvider(new List <IWaveProvider>()
{
waveReader, new SilenceWaveProvider(waveReader.WaveFormat)
}, 2);
int leftChannel = 0;
int rightChannel = 1;
if (IsReverseSpeakersChecked)
{
leftChannel = 1;
rightChannel = 0;
}
if (channel == AudioChannel.Left)
{
// note that the wave reader has 2 input channels so we must route both input channels of the reader to the output channel
waveProvider.ConnectInputToOutput(0, leftChannel);
waveProvider.ConnectInputToOutput(1, leftChannel);
waveProvider.ConnectInputToOutput(2, rightChannel);
waveProvider.ConnectInputToOutput(3, rightChannel);
}
else if (channel == AudioChannel.Right)
{
waveProvider.ConnectInputToOutput(0, rightChannel);
waveProvider.ConnectInputToOutput(1, rightChannel);
waveProvider.ConnectInputToOutput(2, leftChannel);
waveProvider.ConnectInputToOutput(3, leftChannel);
}
else
{
waveProvider.ConnectInputToOutput(0, leftChannel);
waveProvider.ConnectInputToOutput(1, leftChannel);
waveProvider.ConnectInputToOutput(0, rightChannel);
waveProvider.ConnectInputToOutput(1, rightChannel);
}
float outVolume = (float)MusicVolumeValue / (float)100.0;
if (LastVolumeSliderChanged == VolumeSlider.Sfx)
{
outVolume = (float)SfxVolumeValue / (float)100.0;
}
_audioTest = new WaveOut
{
DeviceNumber = GetSelectedSoundDeviceNumber(),
Volume = outVolume
};
_audioTest.Init(waveProvider);
_audioTest.PlaybackStopped += AudioTest_PlaybackStopped;
_audioTest.Play();
NotifyPropertyChanged(nameof(IsAudioPlaying));
NotifyPropertyChanged(nameof(IsAudioNotPlaying));
}
}
static async Task <bool> To_WAV(int File_Number, string To_Dir, bool IsFromFileDelete, bool IsUseFFmpeg, bool IsUseBass)
{
if (!File.Exists(From_Files[File_Number]))
{
return(false);
}
if (IsUseFFmpeg)
{
if (IsUseBass)
{
string To_Audio_File = To_Dir + "\\" + Path.GetFileNameWithoutExtension(From_Files[File_Number]) + ".wav";
Un4seen.Bass.Misc.EncoderWAV w = new Un4seen.Bass.Misc.EncoderWAV(0);
w.InputFile = From_Files[File_Number];
w.OutputFile = To_Audio_File;
w.WAV_BitsPerSample = 24;
w.Start(null, IntPtr.Zero, false);
w.Stop();
if (IsFromFileDelete)
{
File.Delete(From_Files[File_Number]);
}
}
else
{
string Encode_Style = "-y -vn -ac 2 -ar 44100 -acodec pcm_s24le -f wav";
StreamWriter stw = File.CreateText(Voice_Set.Special_Path + "/Encode_Mp3/Audio_Encode" + File_Number + ".bat");
stw.WriteLine("chcp 65001");
stw.Write("\"" + Voice_Set.Special_Path + "/Encode_Mp3/ffmpeg.exe\" -i \"" + From_Files[File_Number] + "\" " + Encode_Style + " \"" + To_Dir + "\\" +
Path.GetFileNameWithoutExtension(From_Files[File_Number]) + ".wav\"");
stw.Close();
ProcessStartInfo processStartInfo = new ProcessStartInfo
{
FileName = Voice_Set.Special_Path + "/Encode_Mp3/Audio_Encode" + File_Number + ".bat",
CreateNoWindow = true,
UseShellExecute = false
};
Process p = Process.Start(processStartInfo);
await Task.Run(() =>
{
p.WaitForExit();
if (IsFromFileDelete)
{
File.Delete(From_Files[File_Number]);
}
File.Delete(Voice_Set.Special_Path + "/Encode_Mp3/Audio_Encode" + File_Number + ".bat");
});
}
}
else if (IsUseBass)
{
string To_Audio_File = To_Dir + "\\" + Path.GetFileNameWithoutExtension(From_Files[File_Number]) + ".wav";
Un4seen.Bass.Misc.EncoderWAV w = new Un4seen.Bass.Misc.EncoderWAV(0);
w.InputFile = From_Files[File_Number];
w.OutputFile = To_Audio_File;
w.WAV_BitsPerSample = 24;
w.Start(null, IntPtr.Zero, false);
w.Stop();
if (IsFromFileDelete)
{
File.Delete(From_Files[File_Number]);
}
}
else
{
int Number = 0;
string To_Audio_File = To_Dir + "\\" + Path.GetFileNameWithoutExtension(From_Files[File_Number]) + ".wav";
await Task.Run(() =>
{
start:
try
{
string Ex = Path.GetExtension(From_Files[File_Number]);
if (Ex == ".ogg")
{
using (NAudio.Vorbis.VorbisWaveReader reader = new NAudio.Vorbis.VorbisWaveReader(From_Files[File_Number]))
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
WaveFileWriter.CreateWaveFile(To_Audio_File, pcmStream);
}
else if (Ex == ".mp3")
{
using (NAudio.Wave.Mp3FileReader reader = new NAudio.Wave.Mp3FileReader(From_Files[File_Number]))
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
WaveFileWriter.CreateWaveFile(To_Audio_File, pcmStream);
}
else if (Ex == ".flac")
{
using (NAudio.Flac.FlacReader reader = new NAudio.Flac.FlacReader(From_Files[File_Number]))
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
WaveFileWriter.CreateWaveFile(To_Audio_File, pcmStream);
}
else if (Ex == ".aac" || Ex == ".wma" || Ex == ".mp4")
{
using (MediaFoundationReader reader = new MediaFoundationReader(From_Files[File_Number]))
WaveFileWriter.CreateWaveFile(To_Audio_File, reader);
}
else if (Ex == ".wav")
{
using (WaveFileReader reader = new WaveFileReader(From_Files[File_Number]))
using (WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(reader))
WaveFileWriter.CreateWaveFile(To_Audio_File, pcmStream);
}
if (IsFromFileDelete)
{
File.Delete(From_Files[File_Number]);
}
}
catch (Exception e)
{
if (Number < 4)
{
Number++;
//goto文...許してください...
goto start;
}
else
{
Sub_Code.Error_Log_Write(e.Message);
}
}
});
}
return(true);
}
public bool StartAsync(string audioFilePath)
{
string fullPath = "";
try
{
if (string.IsNullOrWhiteSpace(audioFilePath))
{
throw new ArgumentNullException(audioFilePath);
}
fullPath = System.IO.Path.GetFullPath(audioFilePath);
if (System.IO.File.Exists(fullPath) == false)
{
throw new System.IO.FileNotFoundException("Could not find the file", audioFilePath);
}
WaveStream newStream = null;
var ext = System.IO.Path.GetExtension(fullPath).ToUpperInvariant();
switch (ext)
{
case ".OGG":
newStream = new NAudio.Vorbis.VorbisWaveReader(fullPath);
break;
case ".WAV":
newStream = new WaveFileReader(fullPath);
break;
default:
throw new ArgumentException("Extension must be .wav or .ogg");
}
if (newStream == null)
{
throw new ArgumentException("Could not open the file", fullPath);
}
Stop();
Stream = newStream;
if (Output == null)
{
Output = new WaveOut();
}
// NOTE: this "true" means "convertTo16Bit", and in some audio devices, it seems to need this convert!!
if (Output != null)
{
Output.Init(Stream.ToSampleProvider(), true);
}
if (Output != null)
{
Output.Play();
}
AudioFileFullPath = fullPath;
return(true);
}
catch (Exception ex)
{
var msg = ex.Message + Environment.NewLine;
msg += "the argument audioFilePath: " + audioFilePath + Environment.NewLine;
msg += "fullPath: " + fullPath + Environment.NewLine;
if (IsToShowMessageBoxOfExceptions)
{
MessageBox.Show(msg);
}
return(false);
}
}
private void AddList(SoundData soundData)
{
if (soundData == null)
{
return;
}
bool isrefresh;
SoundList soundList;
{
SoundList fsoundList = soundLists.Find((x) => x.FileName == soundData.path);
if (fsoundList != null)
{
soundList = fsoundList;
isrefresh = true;
}
else
{
soundList = new SoundList();
isrefresh = false;
}
}
soundList.FileName = soundData.path;
soundList.Size = soundData.bytes.Length / 1024 + "kb";
soundList.soundData = soundData;
WaveFormat waveFormat = null;
long Samplerate = 0;
long Bitrate = 0;
try
{
if (System.IO.Path.GetExtension(soundData.path).ToLower() == ".wav")
{
WaveFileReader waveFileReader = new WaveFileReader(new MemoryStream(soundData.bytes));
waveFormat = waveFileReader.WaveFormat;
soundList.Len = waveFileReader.TotalTime.ToString();
}
else if (System.IO.Path.GetExtension(soundData.path).ToLower() == ".ogg")
{
NAudio.Vorbis.VorbisWaveReader vorbisWaveReader = new NAudio.Vorbis.VorbisWaveReader(new MemoryStream(soundData.bytes));
waveFormat = vorbisWaveReader.WaveFormat;
soundList.Len = vorbisWaveReader.TotalTime.ToString();
}
Samplerate = waveFormat.SampleRate;
Bitrate = Samplerate * waveFormat.BitsPerSample * waveFormat.Channels;
}
catch (Exception)
{
}
soundList.Samplerate = Samplerate + "Hz";
soundList.Bitrate = Bitrate / 1000 + "kb";
if (!isrefresh)
{
soundLists.Add(soundList);
}
MainListbox.ItemsSource = null;
MainListbox.ItemsSource = soundLists;
}
private void SendVoice(string file, DiscordClient client, YouTubeVideo video)
{
DiscordVoiceClient vc = client.GetVoiceClient();
try
{
int ms = vc.VoiceConfig.FrameLengthMs;
int channels = vc.VoiceConfig.Channels;
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);
if(video.AudioFormat == AudioFormat.Mp3)
{
using (var mp3Reader = new Mp3FileReader(video.Stream()))
{
using (var resampler = new MediaFoundationResampler(mp3Reader, outFormat) { ResamplerQuality = 60 })
{
//resampler.ResamplerQuality = 60;
int byteCount;
while ((byteCount = resampler.Read(buffer, 0, blockSize)) > 0)
{
if (vc.Connected)
{
vc.SendVoice(buffer);
}
else
break;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Voice finished enqueuing");
Console.ForegroundColor = ConsoleColor.White;
resampler.Dispose();
mp3Reader.Close();
}
}
}
else if(video.AudioFormat == AudioFormat.Vorbis)
{
using (var vorbis = new NAudio.Vorbis.VorbisWaveReader(video.Stream()))
{
using (var resampler = new MediaFoundationResampler(vorbis, outFormat) { ResamplerQuality = 60 })
{
int byteCount;
while ((byteCount = resampler.Read(buffer, 0, blockSize)) > 0)
{
if (vc.Connected)
{
vc.SendVoice(buffer);
}
else
break;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Voice finished enqueuing");
Console.ForegroundColor = ConsoleColor.White;
resampler.Dispose();
vorbis.Close();
}
}
}
}
catch (Exception ex)
{
try
{
MainEntry.owner.SendMessage("Exception during voice: `" + ex.Message + "`\n\n```" + ex.StackTrace + "\n```");
}
catch { }
}
}