/// <summary>
/// Пункт конвертации в стерео
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void конвертацияВСтереоToolStripMenuItem_Click(object sender, EventArgs e)
{
StopAud();
SaveFileDialog save = new SaveFileDialog();
save.InitialDirectory = "C:\\";
save.Filter = "wav files (*.wav)|*.wav";
save.FilterIndex = 1;
save.Title = "Сохранить файл";
if (save.ShowDialog() == DialogResult.Cancel)
{
return;
}
string filename = save.FileName;
if (filename != null)
{
using (var inputReader = new AudioFileReader(rfname))
{
var stereo = new MonoToStereoSampleProvider(inputReader);
WaveFileWriter.CreateWaveFile16(filename, stereo);
}
MessageBox.Show("Файл сохранен!");
}
else
{
System.Windows.Forms.MessageBox.Show("Не выбран путь сохранения!", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void AddSource(ISampleProvider source, TimeSpan delayBy)
{
ISampleProvider _source;
if (source == null || source.WaveFormat == null)
{
return;
}
if (source.WaveFormat.Channels == 1)
{
_source = new MonoToStereoSampleProvider(source);
}
else if (source.WaveFormat.Channels == 2)
{
_source = source;
}
else
{
return;
}
mix.AddMixerInput(new OffsetSampleProvider(_source)
{
DelayBy = delayBy
});
}
string micAdd()
{
string ret = "";
ISampleProvider micProv;
if (micVol != null && micVol.OK())
{
return("");
}
if (settings.devMic != null && settings.devMic.mm != null)
{
Logger.mix.a("create mic");
micCap = new WasapiCapture(settings.devMic.mm);
micCap.DataAvailable += micDev_DataAvailable_03;
micIn = new BufferedWaveProvider(micCap.WaveFormat);
if (micCap.WaveFormat.SampleRate != settings.samplerate)
{
Logger.mix.a("create mic resampler");
micRe = new MediaFoundationResampler(micIn, settings.samplerate);
micRe.ResamplerQuality = 60;
ret += "Incorrect samplerate on microphone device, resampling\n" +
settings.devMic.mm.DeviceFriendlyName + "\n" +
settings.devMic.mm.FriendlyName + "\n" +
settings.devMic.id + "\n" +
LSDevice.stringer(settings.devMic.wf) + "\n" +
LSDevice.stringer(micCap.WaveFormat) + "\n\n";
}
micProv = new WaveToSampleProvider((IWaveProvider)micRe ?? (IWaveProvider)micIn);
if (micCap.WaveFormat.Channels == 1)
{
Logger.mix.a("mic mono2stereo");
micProv = new MonoToStereoSampleProvider(micProv);
}
else if (settings.micLeft != settings.micRight)
{
Logger.mix.a("mic chanselector");
micProv = new NPatch.ChannelSelector(micProv, settings.micLeft ? 0 : 1);
}
if (settings.reverbP > 0)
{
micProv = new NPatch.Reverb(micProv);
}
micVol.SetSource(micProv);
mixa.AddMixerInput(micVol);
Logger.mix.a("mic done");
}
else
{
Logger.mix.a("mic skipped");
}
return(ret);
}
/// <summary>
/// Initialises a new instance of SampleChannel
/// </summary>
/// <param name="waveProvider">Source wave provider, must be PCM or IEEE</param>
/// <param name="forceStereo">force mono inputs to become stereo</param>
public SampleChannel(IWaveProvider waveProvider, bool forceStereo)
{
ISampleProvider sampleProvider = SampleProviderConverters.ConvertWaveProviderIntoSampleProvider(waveProvider);
if (sampleProvider.WaveFormat.Channels == 1 && forceStereo)
{
sampleProvider = new MonoToStereoSampleProvider(sampleProvider);
}
this.waveFormat = sampleProvider.WaveFormat;
// let's put the meter before the volume (useful for drawing waveforms)
this.preVolumeMeter = new MeteringSampleProvider(sampleProvider);
this.volumeProvider = new VolumeSampleProvider(preVolumeMeter);
}
/// <summary>
/// Converts to stereo.
/// </summary>
/// <param name="monoFilePath">The mono file path.</param>
/// <returns>System.String.</returns>
public static string ConvertToStereo(string monoFilePath)
{
var outputFilePath = monoFilePath.Substring(0, monoFilePath.Length - 4) + monoFilePath.Substring(monoFilePath.Length - 4).Replace(".wav", $"-{STEREO}.wav");
using (var inputReader = new AudioFileReader(monoFilePath))
{
// convert our mono ISampleProvider to stereo
var stereo = new MonoToStereoSampleProvider(inputReader);
// write the stereo audio out to a WAV file
WaveFileWriter.CreateWaveFile16(outputFilePath, stereo);
}
return(outputFilePath);
}
private void btn_stop_Click(object sender, EventArgs e)
{
if (output != null)
{
btn_stop.Enabled = false;
btn_pause.Enabled = false;
vsb_volumeL.Enabled = false;
vsb_volumeR.Enabled = false;
vsb_volumeM.Enabled = false;
trb_progress.Enabled = false;
cb_controle.Enabled = false;
progressBar1.Value = 0;
progressBar2.Value = 0;
progressBar3.Value = 0;
progressBar4.Value = 0;
progressBar6.Value = 0;
progressBar7.Value = 0;
progressBar8.Value = 0;
btn_pause.Text = "Play";
lb_name.Text = "";
lb_length.Text = "";
trb_progress.Value = 0;
lb_decTime.Text = "";
if (output != null)
{
if (output.PlaybackState == NAudio.Wave.PlaybackState.Playing)
{
output.Stop();
}
output.Dispose();
output = null;
}
if (stream != null)
{
stream.Dispose();
stream = null;
}
if (pitch != null)
{
pitch = null;
}
if (stereo != null)
{
stereo = null;
}
}
}
public SmartSample(MasterVolume volume, Sound sound, AudioFileReader reader)
{
_volume = volume;
_sound = sound;
_reader = reader;
var sampleProvider = ConvertWaveProviderIntoSampleProvider(_reader);
if (sampleProvider.WaveFormat.Channels == 1)
{
sampleProvider = new MonoToStereoSampleProvider(sampleProvider);
}
WaveFormat = sampleProvider.WaveFormat;
_preVolumeMeter = new MeteringSampleProvider(sampleProvider);
_volumeProvider = new VolumeSampleProvider(_preVolumeMeter);
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
if (output != null)
{
if (output.PlaybackState == NAudio.Wave.PlaybackState.Playing)
{
output.Stop();
}
output.Dispose();
output = null;
}
if (stream != null)
{
stream.Dispose();
stream = null;
}
if (pitch != null)
{
pitch = null;
}
if (stereo != null)
{
stereo = null;
}
closing = true;
if (capture != null && capture.CaptureState == NAudio.CoreAudioApi.CaptureState.Capturing)
{
capture.StopRecording();
}
if (wo != null)
{
if (wo.PlaybackState == PlaybackState.Playing)
{
wo.Stop();
}
wo.Dispose();
}
waveIn.StopRecording();
writer?.Dispose();
wo = null;
waveIn = null;
capture = null;
writer = null;
}
public EStimAudioDevice(DirectSoundDeviceInfo device, EstimParameters parameters)
{
Name = device.Description;
_parameters = parameters;
_generator = new SineWaveProvider();
_generator.Frequency = 600;
_stereo = new MonoToStereoSampleProvider(_generator);
_stereo.LeftVolume = 0f;
_stereo.RightVolume = 0f;
_soundOut = new DirectSoundOut(device.Guid);
_soundOut.Init(_stereo);
_soundOut.Play();
MinDelayBetweenCommands = TimeSpan.Zero;
}
/// <summary>
/// Converts between Stereo and Mono SampleProviders for 32 bit sampled audio
/// </summary>
/// <param name="input">The input 32 bit SampleProvider</param>
/// <param name="toMono">True for mono audio, falses for stereo</param>
/// <returns></returns>
public ISampleProvider MonoStereoConvert32(ISampleProvider input, bool toMono)
{
if (toMono && input.WaveFormat.Channels != 1)
{
var stmp = new StereoToMonoSampleProvider(input);
return(stmp);
}
else if (!toMono && input.WaveFormat.Channels != 2)
{
var mtsp = new MonoToStereoSampleProvider(input);
mtsp.LeftVolume = 0.7f;
mtsp.RightVolume = 0.7f; //0.7 on each to avoid double loud
return(mtsp);
}
else
{
return(input);
}
}
static void Convert(
string inputPath, out string intermediateChannelFormatPath, ChannelFormat?channelFormat,
string outputDirectory, string outputFileName)
{
if (!channelFormat.HasValue)
{
intermediateChannelFormatPath = inputPath;
return;
}
using (var reader = new AudioFileReader(inputPath))
{
var intermediateChannelFormatFileName = $"{outputFileName}-intermediate-channelformat.wav";
intermediateChannelFormatPath = Path.Combine(outputDirectory, intermediateChannelFormatFileName);
if (reader.WaveFormat.Channels == 2 && channelFormat.Value == ChannelFormat.Mono)
{
var resampler = new StereoToMonoSampleProvider(reader)
{
LeftVolume = 0,
RightVolume = 1
};
WaveFileWriter.CreateWaveFile16(intermediateChannelFormatPath, resampler);
}
else if (reader.WaveFormat.Channels == 1 && channelFormat.Value == ChannelFormat.Stereo)
{
var resampler = new MonoToStereoSampleProvider(reader)
{
LeftVolume = 0.5f,
RightVolume = 0.5f
};
WaveFileWriter.CreateWaveFile16(intermediateChannelFormatPath, resampler);
}
else
{
// Do nothing, already same channel format
File.Copy(inputPath, intermediateChannelFormatPath, true);
}
}
}
private void btn_open_Click(object sender, EventArgs e)
{
OpenFileDialog open = new OpenFileDialog();
open.Filter = "MP3 File (*.mp3)|*.mp3|WAV File (*.wav)|*.wav";
if (open.ShowDialog() != DialogResult.OK)
{
return;
}
output = new WaveOutEvent();
stream = new AudioFileReader(open.FileName);
pitch = new SmbPitchShiftingSampleProvider(stream.ToSampleProvider());
pitch.PitchFactor = 1;
stereo = new MonoToStereoSampleProvider(pitch.ToMono());
output.Init(stereo);
stereo.RightVolume = 0.5f;
stereo.LeftVolume = 0.5f;
stream.Volume = 0.5f;
lb_name.Text = open.SafeFileName;
lb_length.Text = stream.TotalTime.ToString().Remove(8);
lb_length.Text += " sec.";
lb_decTime.Text = stream.CurrentTime.ToString();
btn_pause.Enabled = true;
btn_stop.Enabled = true;
vsb_volumeL.Enabled = true;
vsb_volumeM.Enabled = true;
vsb_volumeR.Enabled = true;
trb_progress.Enabled = true;
cb_controle.Enabled = true;
trb_progress.Maximum = (int)stream.TotalTime.TotalSeconds;
}
static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("There is nothing to process...");
Console.ReadLine();
}
else if (args.Length == 1 && (args[0] == "--create-equalizer"))
{
CreateEqualizerJson(equalizerFilename);
Console.WriteLine("Done.");
Console.ReadLine();
}
else
{
MediaFoundationApi.Startup();
Directory.CreateDirectory(Path.Combine(Environment.CurrentDirectory, outputDir));
ReadEqParams(equalizerFilename);
CalcAdjustVolumeFromEq(eqParams);
GetDelayValues();
GetChannelsVolume();
foreach (var arg in args)
{
try
{
Console.WriteLine($"Loading file {Path.GetFileName(arg)}.");
var loadedAudio = LoadFile(arg);
var stereo = loadedAudio;
if (loadedAudio.WaveFormat.Channels != 2)
{
stereo = new MonoToStereoSampleProvider(loadedAudio);
}
if (volumeAdjustDB < 0)
{
stereo = new ChannelsVolumeSampleProvider(stereo)
{
LeftChannelVolumeInDB = volumeAdjustDB,
RightChannelVolumeInDB = volumeAdjustDB
};
}
var resampled = stereo;
if (stereo.WaveFormat.SampleRate != 44100)
{
resampled = new WdlResamplingSampleProvider(stereo, 44100);
}
var processedAudio = ChannelsDelay(resampled, leftDelay, rightDelay);
processedAudio = eqParams == null ? processedAudio : EqualizeChannels(processedAudio);
processedAudio = leftVolumeDB == 0 && rightVolumeDB == 0 ? processedAudio : AdjustChannelsVolume(processedAudio);
SaveToMp3(Path.Combine(Environment.CurrentDirectory, outputDir, $"{Path.GetFileNameWithoutExtension(arg)}.mp3"),
processedAudio);
Console.WriteLine("Success.");
Console.WriteLine("");
}
catch (Exception ex)
{
Console.WriteLine($"Error on file: {Path.GetFileName(arg)}. {ex.Message}");
}
}
Console.WriteLine("Done.");
Console.ReadLine();
}
}
