private void Encode()
{
if (String.IsNullOrEmpty(InputFile) || !File.Exists(InputFile))
{
MessageBox.Show("Please select a valid input file to convert");
return;
}
if (SelectedMediaType == null || SelectedMediaType.MediaType == null)
{
MessageBox.Show("Please select a valid output format");
return;
}
using (var reader = new MediaFoundationReader(InputFile))
{
string outputUrl = SelectSaveFile(SelectedOutputFormat.Name, SelectedOutputFormat.Extension);
if (outputUrl == null)
{
return;
}
using (var encoder = new MediaFoundationEncoder(SelectedMediaType.MediaType))
{
encoder.Encode(outputUrl, reader);
}
}
}
public bool OpenFile(string filePath)
{
Close();
try
{
MediaFoundationReader reader = new MediaFoundationReader(filePath);
WaveChannel32 inputStream = new WaveChannel32(reader)
{
PadWithZeroes = false
};
ProcessorStream = new SoundTouchWaveStream(inputStream);
waveOut = new WaveOutEvent()
{
DesiredLatency = 100
};
waveOut.Init(ProcessorStream);
waveOut.PlaybackStopped += OnPlaybackStopped;
return(true);
}
catch (Exception)
{
waveOut = null;
return(false);
}
}
public void Stop()
{
if (waveOut != null)
{
waveOut.Stop();
waveOut.Dispose();
waveOut = null;
}
if (baStream != null)
{
baStream.Dispose();
baStream = null;
}
if (wavStream != null)
{
wavStream.Dispose();
wavStream = null;
}
if (mf != null)
{
mf.Close();
mf.Dispose();
mf = null;
}
}
private void PlayYouTube(PlaylistItem fileInfo)
{
if (wavePlayer == null)
{
wavePlayer = new WaveOutEvent();
var mf = new MediaFoundationReader(fileInfo.filePath);
var memory = new MemoryStream();
audioFile.Volume = localVolume;
LS = new LoopStream(mf, enableLooping);
wavePlayer.Init(LS);
wavePlayer.PlaybackStopped += OnPlaybackStopped;
wavePlayer.Play();
currentItem = fileInfo;
}
else
{
wavePlayer.Stop();
wavePlayer.Dispose();
wavePlayer = null;
}
}
private void sendAudioUsingDiscordHQ(Stream stream)
{
var channelCount = client.GetService <AudioService>().Config.Channels;
var OutFormat = new WaveFormat(48000, 16, channelCount);
stream.Position = 0;
using (var AACReader = new MediaFoundationReader(stream))
using (var resampler = new MediaFoundationResampler(AACReader, OutFormat))
{
resampler.ResamplerQuality = 60;
int blockSize = OutFormat.AverageBytesPerSecond / 50; //50
byte[] buffer = new byte[blockSize];
int byteCount;
while ((byteCount = resampler.Read(buffer, 0, blockSize)) > 0)
{
if (byteCount < blockSize)
{
for (int i = byteCount; i < blockSize; i++)
{
buffer[i] = 0;
}
}
audioClient.Send(buffer, 0, blockSize);
}
}
}
public audio_player_with_effect_class(FFT_class _real_time_fft, Effect_3band_DRC _three_band_drc, effect_EQ _equalizer, BackgroundWorker _bgw_temp, MediaFoundationReader audioreader, int _AudioLength, int _in_total_byte_per_frame, int _Samples_per_frame)
{
// MessageBox.Show("new audio class");
audioreader_temp = audioreader;
initPos = audioreader_temp.Position;
//MessageBox.Show(initPos.ToString());
bgw_temp = _bgw_temp;
sig_conv_temp = new signalconverter(audioreader_temp.WaveFormat.Channels, audioreader_temp.WaveFormat.BitsPerSample / 8);
waveFormatOut = new WaveFormat(audioreader_temp.WaveFormat.SampleRate, audioreader_temp.WaveFormat.BitsPerSample, audioreader_temp.WaveFormat.Channels);
in_total_byte_per_frame = _in_total_byte_per_frame;
out_total_byte_per_frame = in_total_byte_per_frame;
Samples_per_frame = _Samples_per_frame;
bufferlen = _AudioLength;
///effect
///
equalizer_temp = _equalizer;
three_band_drc_temp = _three_band_drc;
real_time_fft_temp = _real_time_fft;
// equalizer = new effect_EQ(audioreader_temp.WaveFormat.SampleRate, Samples_per_frame, audioreader_temp.WaveFormat.Channels);
}
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(TextBox.Text))
{
MessageBox.Show("No text");
return;
}
if (listboxFolder1.SelectedItems.Count > 0)
{
var b = new Task(() =>
{
var selected = Dispatcher.Invoke(() => (Voice)listboxFolder1.SelectedItems[0]);
using (var mf = new MediaFoundationReader(Downloader.Parse(selected, isMale, Dispatcher.Invoke(() => TextBox.Text))))
using (var wo = new WaveOutEvent())
{
wo.Init(mf);
wo.Play();
while (wo.PlaybackState == PlaybackState.Playing)
{
Thread.Sleep(500);
}
}
});
b.Start();
}
}
public async Task LoadPeaksAsync()
{
var episode = currentEpisode;
await Task.Run(() =>
{
var peaks = new List <float>();
using (var reader = new MediaFoundationReader(episode.AudioFile))
{
var sampleProvider = reader.ToSampleProvider();
var sampleBuffer = new float[reader.WaveFormat.SampleRate *reader.WaveFormat.Channels];
int read;
do
{
read = sampleProvider.Read(sampleBuffer, 0, sampleBuffer.Length);
if (read > 0)
{
var max = sampleBuffer.Take(read).Select(Math.Abs).Max();
peaks.Add(max);
}
} while (read > 0);
episode.Peaks = peaks.ToArray();
}
});
EventAggregator.Instance.Publish(new PeaksAvailableMessage(episode));
}
public MusicRecoder(string filePath)
{
audioBuffers[0] = new byte[bufferSize];
audioBuffers[1] = new byte[bufferSize];
string extension = Path.GetExtension(filePath);
Play = PlayFileWave;
switch (extension)
{
case ".mp3": Mp3FileReader mp3 = new Mp3FileReader(filePath);
audioStream = new WaveFormatConversionStream(mp3.WaveFormat, mp3);
break;
case ".wma": MediaFoundationReader wma = new MediaFoundationReader(filePath);
audioStream = new WaveFormatConversionStream(wma.WaveFormat, wma);
break;
case ".m4a": MediaFoundationReader m4a = new MediaFoundationReader(filePath);
audioStream = new WaveFormatConversionStream(m4a.WaveFormat, m4a);;
break;
default: Play = PlaySystemInput;
break;
}
}
private void convertButton_Click(object sender, EventArgs e)
{
MediaFoundationReader foundationReader = new MediaFoundationReader(OFD.FileName);
SaveFileDialog SFD = new SaveFileDialog();
SFD.Title = "Save here your file";
if (mp3RadioButton.Checked)
{
SFD.Filter = "MP3|*.mp3";
SFD.ShowDialog();
MediaFoundationEncoder.EncodeToMp3(foundationReader, SFD.FileName);
}
if (aacRadioButton.Checked)
{
SFD.Filter = "AAC|*.aac";
SFD.ShowDialog();
MediaFoundationEncoder.EncodeToAac(foundationReader, SFD.FileName);
}
if (wmaRadioButton.Checked)
{
SFD.Filter = "WMA|*.wma";
SFD.ShowDialog();
MediaFoundationEncoder.EncodeToWma(foundationReader, SFD.FileName);
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
string fileDir = AppContext.BaseDirectory;
var inPath = SPath.Combine(fileDir, "了解真相快三退.wav");
var semitone = Math.Pow(2, 1.0 / 12);
var upOneTone = semitone * semitone * semitone * semitone * semitone;
var downOneTone = 1.0 / (upOneTone);
var tfile = TagLib.File.Create(inPath);
using (var reader = new MediaFoundationReader(inPath))
{
var pitch = new SmbPitchShiftingSampleProvider(reader.ToSampleProvider());
pitch.PitchFactor = (float)(((double)new Random().Next(60, 115)) / 100);
string tempFileNameGuid = Guid.NewGuid().ToString();
string tempFilePath = SPath.Combine(fileDir, tempFileNameGuid + ".wav");
string outputFileNameGuid = Guid.NewGuid().ToString();
string outWavFilePath = SPath.Combine(fileDir, outputFileNameGuid + ".wav");
string outMp3FilePath = SPath.Combine(fileDir, outputFileNameGuid + ".mp3");
WaveFileWriter.CreateWaveFile(tempFilePath, pitch.ToWaveProvider());
ConvertWavToMp3(tempFilePath, outMp3FilePath, tfile.Properties.AudioBitrate);
//playSampleProvider(pitch);
using (var mp3Reader = new Mp3FileReader(outMp3FilePath))
using (var conversionStream = new WaveFormatConversionStream(reader.WaveFormat, mp3Reader))
WaveFileWriter.CreateWaveFile(outWavFilePath, conversionStream);
if (File.Exists(tempFilePath))
{
File.Delete(tempFilePath);
}
}
}
private void PlayAudio(string audioFile)
{
if (GlobalUser.WavePlayer?.PlaybackState == PlaybackState.Playing)
{
GlobalUser.WavePlayer?.Stop();
GlobalUser.WavePlayer = null;
_dTimer.Stop();
PlayTime = 0;
return;
}
try
{
GlobalUser.WavePlayer = CreateWavePlayer();
var reader = new MediaFoundationReader(audioFile);
GlobalUser.WavePlayer.Init(reader);
GlobalUser.WavePlayer.PlaybackStopped += OnPlaybackStopped;
TotalTime = Convert.ToInt32(reader.TotalTime.TotalSeconds);
PlayTime = 0;
_dTimer.Start();
PlayIcon = "Stop";
GlobalUser.WavePlayer.Play();
}
catch (Exception e)
{
Log4NetHelper.Error(String.Format("Play Error {0}", e.Message));
}
}
private void BeginB_Click(object sender, RoutedEventArgs e)
{
BeginB.IsEnabled = false;
Output = new NullOut();
CurrentComplexes.Clear();
cparam.Take = TakeS.Value;
cparam.Begining = FftBeginS.Value;
cparam.Threshold = ThreshS.Value;
cparam.UsingLowPass = LowPassC.IsChecked ?? false;
mfr = new MediaFoundationReader(Path);
ProgressB.Value = 0;
ProgressB.Maximum = mfr.TotalTime.TotalMilliseconds;
Equalizer eq = new Equalizer(new SampleChannel(mfr));
eq.AddLowPassFilter(500, 0.1f);
eq.Enabled = cparam.UsingLowPass;
fftProv = new FFT.SyncSampleProvider(eq);
Output.Init(fftProv);
fftProv.FftFinished += FftProv_FftFinished;
Output.PlaybackStopped += Output_PlaybackStopped;
Task.Run(() =>
{
Output.Play();
});
}
public static bool ConvertM4AToMp3(byte[] m4AFile, string directory, ref Track song)
//requires windows 8 or higher
{
var tempFile = Path.Combine(directory, "tempdata" + _uniqueTempFileCounter + ".m4a");
//
try
{
_uniqueTempFileCounter += 1;
File.WriteAllBytes(tempFile, m4AFile);
song.LocalPath += ".mp3"; //conversion wil result in an mp3
using (var reader = new MediaFoundationReader(tempFile)) //this reader supports: MP3, AAC and WAV
{
var aaCtype = AudioSubtypes.MFAudioFormat_AAC;
var bitrates = MediaFoundationEncoder.GetEncodeBitrates(aaCtype, reader.WaveFormat.SampleRate,
reader.WaveFormat.Channels);
MediaFoundationEncoder.EncodeToMp3(reader, song.LocalPath, bitrates[bitrates.GetUpperBound(0)]);
}
File.Delete(tempFile);
return(true);
}
catch (Exception)
{
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
return(false);
}
}
public void Play(string filename, float volume)
{
var configuration = configurationManager.LoadConfiguration <AudioConfiguration>();
configuration.InitializeConfiguration();
var pathToFile = Path.Combine(soundPathProvider.Path, filename);
if (!File.Exists(pathToFile))
{
return;
}
if (volume == 0f)
{
logger.Warning($"Die Lautstärke für '{filename}' liegt bei 0 und kann nicht gehört werden.");
return;
}
using var reader = new MediaFoundationReader(pathToFile);
using var volumeStream = new WaveChannel32(reader);
using var outputStream = new WasapiOut(configuration.SelectedSoundCommandDevice, NAudio.CoreAudioApi.AudioClientShareMode.Shared, false, 10);
volumeStream.Volume = NormalizeVolume(volume);
outputStream.Init(volumeStream);
outputStream.Play();
Thread.Sleep(reader.TotalTime.Add(TimeSpan.FromMilliseconds(100)));
outputStream.Stop();
}
private void button3_Click(object sender, EventArgs e)
{
var mf = new MediaFoundationReader(currentFile);
if (playing)
{
wo.Pause();
button3.Text = "Play";
playing = false;
}
else
{
{
try
{
wo.Init(mf);
}
catch
{
}
wo.Play();
if (wo.PlaybackState == PlaybackState.Playing)
{
button3.Text = "Pause";
}
playing = true;
}
}
}
protected override EventResult OnConnectBusy()
{
try {
/* 一度でも開いていないときのみ初期化 */
if ((reader_ == null) ||
(resampler_ == null)
)
{
reader_ = new MediaFoundationReader(devp_.InputFilePath.Value);
resampler_ = new MediaFoundationResampler(
reader_,
new WaveFormat(
(int)devp_.InputSamplingRate.Value,
(int)devp_.InputBitsPerSample.Value,
(int)devp_.InputChannelNum.Value));
sampling_buffer_ = new byte[resampler_.WaveFormat.AverageBytesPerSecond / 10];
}
return(EventResult.Success);
} catch {
return(EventResult.Error);
}
}
public static async Task wavConvert(string mp4Conv, Channel voice)
{
// convert source audio to AAC
// create media foundation reader to read the source (can be any supported format, mp3, wav, ...)
/*using (MediaFoundationReader reader = new MediaFoundationReader(@"d:\source.mp3"))
* {
* MediaFoundationEncoder.EncodeToAac(reader, @"D:\test.mp4");
* }*/
var channelCount = discord.GetService <AudioService>().Config.Channels;
// convert "back" to WAV
// create media foundation reader to read the AAC encoded file
using (MediaFoundationReader reader = new MediaFoundationReader(mp4Conv))
// resample the file to PCM with same sample rate, channels and bits per sample
using (ResamplerDmoStream resampledReader = new ResamplerDmoStream(reader,
new WaveFormat(48000, 16, channelCount)))
// create WAVe file
using (WaveFileWriter waveWriter = new WaveFileWriter(@"C:\music\tempaud.wav", resampledReader.WaveFormat))
{
// copy samples
resampledReader.CopyTo(waveWriter);
}
await SendAudio(@"C:\music\tempaud.wav", voice);
}
public override float GetLengthInSeconds(string pathToSourceFile)
{
using (var mediaFoundationReader = new MediaFoundationReader(pathToSourceFile))
{
return((float)mediaFoundationReader.TotalTime.TotalSeconds);
}
}
private void Init(string url)
{
using (var mf = new MediaFoundationReader(url))
{
player.Init(mf);
}
}
public void Open()
{
if (MediaSource == null)
{
throw new InvalidOperationException("Media Source is not specified.");
}
m_fileReader = new MediaFoundationReader(MediaSource);
InFormat = new Format(
m_fileReader.WaveFormat.SampleRate,
m_fileReader.WaveFormat.BitsPerSample / 8,
m_fileReader.WaveFormat.Channels
);
m_bufferSize =
(m_bufferSizeInMs * InFormat.SampleRate / 1000) *
InFormat.Channels *
InFormat.BytesPerSample
;
m_writtenBufferLength = m_bufferSize;
m_blockLength = InFormat.Channels * InFormat.BytesPerSample;
m_buffer = new byte[m_bufferSize];
m_bufferPos = m_bufferSize;
OutSample = new Sample();
OutSample.SetSampleParams(InFormat);
IsOpen = true;
}
public void Convert(string filePath)
{
using (var reader = new MediaFoundationReader(filePath))
{
MediaFoundationEncoder.EncodeToMp3(reader, GetNextFileName("convert", ".mp3"));
}
}
private void musicListPanelsButton_Click(object sender, EventArgs e)
{
audioPath = fileNames[Convert.ToInt32((sender as System.Windows.Forms.Button).Name)];
if (fileReader == null)
{
fileReader = new MediaFoundationReader(audioPath);
}
else
{
fileReader.Close();
fileReader.Dispose();
fileReader = new MediaFoundationReader(audioPath);
}
if (outputDevice == null)
{
outputDevice = new WaveOutEvent();
}
else
{
outputDevice.Stop();
}
musicTrackBar.Value = 0;
musicIsPlaying = false;
playButton.Text = "";
timerOfPlayback.Enabled = false;
outputDevice.Init(fileReader);
musicTrackBar.Maximum = fileReader.TotalTime.Minutes * 60 + fileReader.TotalTime.Seconds;
maximumDuration.Text = fileReader.TotalTime.Minutes.ToString("00") + ":" + fileReader.TotalTime.Seconds.ToString("00");
playButton_Click(null, null);
}
/// <summary>
/// Validate video file: [0 = sound video] // [1 = silent video] // [-1 = system error]
/// </summary>
/// <param name="file_path"></param>
/// <param name="file_name"></param>
/// <returns></returns>
public static int IsSoundVideoFile(string file_path, string file_name)
{
string code = "0xc00d36b3";
string error = "";
string videofile = System.IO.Path.Combine(file_path, file_name);
string audiofile = System.IO.Path.Combine(file_path, "unknown.wav");
int kq = int.MinValue;
try {
using (var video = new MediaFoundationReader(videofile)) {
WaveFileWriter.CreateWaveFile(audiofile, video);
}
kq = 0;
}
catch (Exception ex) { error = ex.ToString(); }
if (kq == int.MinValue)
{
kq = error.ToLower().Contains(code) ? 1 : -1; //
}
else
{
System.IO.File.Delete(audiofile); //delete file audio
}
return(kq);
}
public Stream GetSampleStream(int sampleRate, int channels)
{
if (channels != 1 && channels != 2)
{
throw new ArgumentOutOfRangeException(nameof(channels), "Only 1 or 2 channels are allowed.");
}
using (var reader = new MediaFoundationReader(_path))
{
ISampleProvider sampler = new WdlResamplingSampleProvider(reader.ToSampleProvider(), sampleRate);
switch (channels)
{
case 1:
sampler = sampler.ToMono();
break;
case 2:
sampler = sampler.ToStereo();
break;
}
return(new SamplerWrapper(sampler));
}
}
public void Play()
{
if (player == null)
{
if (currentEpisode.AudioFile == null)
{
MessageBox.Show("No audio file download provided");
Process.Start(currentEpisode.AudioFile ?? currentEpisode.Link);
return;
}
try
{
player = new WaveOutEvent();
currentReader = new MediaFoundationReader(currentEpisode.AudioFile);
player.Init(currentReader);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error retrieving podcast audio");
player = null;
}
}
if (player != null)
{
player.Play();
}
}
/// <summary>
/// Convert WAV to WMA
/// </summary>
/// <param name="waveFileName"></param>
/// <param name="mp3FileName"></param>
/// <param name="bitRate"></param>
public void WaveToWMA(string waveFileName, string wmaFileName, int bitRate = 44100)
{
using (MediaFoundationReader reader = new MediaFoundationReader(waveFileName))
{
MediaFoundationEncoder.EncodeToWma(reader, wmaFileName, bitRate);
}
}
public static void StartStream()
{
_initialized = false;
_wo = new WaveOut();
_listenMoeThread = new Thread(() =>
{
using (var mf = new MediaFoundationReader(Url))
{
_wo.Init(mf);
_initialized = true;
while (true)
{
Thread.Sleep(1000 * 60 * 60 * 24); // 1 day because this loop literally does nothing
}
}
});
_listenMoeThread.Start();
while (!_initialized)
{
Thread.Sleep(100);
}
_wo.Volume = Properties.Settings.Default.volume;
_wo.Play();
IsPlaying = true;
PlayingStateChanged?.Invoke();
SongDataChanged?.Invoke();
}
public WmaInput(Stream file) : base(file)
{
var reader = new CustomMediaFoundationReader(file);
if (reader.Duration != 0)
{
m_bitrate = (int)(file.Length * 80000000L / reader.Duration);
}
else
{
m_bitrate = reader.WaveFormat.AverageBytesPerSecond * 8;
}
m_reader = reader;
var format = new GameRes.WaveFormat {
FormatTag = (ushort)m_reader.WaveFormat.Encoding,
Channels = (ushort)m_reader.WaveFormat.Channels,
SamplesPerSecond = (uint)m_reader.WaveFormat.SampleRate,
BitsPerSample = (ushort)m_reader.WaveFormat.BitsPerSample,
BlockAlign = (ushort)m_reader.BlockAlign,
AverageBytesPerSecond = (uint)m_reader.WaveFormat.AverageBytesPerSecond,
};
this.Format = format;
this.PcmSize = m_reader.Length;
}
static void Main(string[] args)
{
MediaFoundationReader reader = new MediaFoundationReader(@"C:\Users\Null\Desktop\Disconnected - Pegboard Nerds.mp3");
WaveOut wout = new WaveOut();
wout.Init(reader);
wout.Play();
Console.Write("Input file path: ");
player = new MciPlayer(Console.ReadLine().Trim('"'));
player.Open();
player.Play();
MciSendString($"set {player.AliasName} time format msf", null, 0, IntPtr.Zero);
Console.WriteLine($"Device Alias Name: {player.AliasName}");
Console.WriteLine($"Length: {player.GetLength()}; Position: {player.GetPosition()}");
string rst = new string('\0', 256);
string before = string.Copy(rst);
int err;
while (true)
{
if ((err = MciSendString(Console.ReadLine(), rst, rst.Length, IntPtr.Zero)) != 0)
{
Console.WriteLine($"Execute failed. {new MciException(err)}");
}
if (rst != before)
{
Console.WriteLine($"Return text: {rst.TrimEnd('\0')}");
rst = new string('\0', 256);
before = string.Copy(rst);
}
}
}
public override float[] ReadMonoFromFile(string pathToFile, int sampleRate, int secondsToRead, int startAtSecond)
{
using (var reader = new MediaFoundationReader(pathToFile))
{
int actualSampleRate = reader.WaveFormat.SampleRate;
int bitsPerSample = reader.WaveFormat.BitsPerSample;
reader.Seek(actualSampleRate * bitsPerSample / 8 * startAtSecond, System.IO.SeekOrigin.Begin);
using (var resampler = new MediaFoundationResampler(reader, WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1)))
{
float[] buffer = new float[sampleRate * 20]; // 20 seconds buffer
List<float[]> chunks = new List<float[]>();
int totalFloatsToRead = secondsToRead == 0 ? int.MaxValue : secondsToRead * sampleRate;
int totalFloatsRead = 0;
Pcm32BitToSampleProvider pcmReader = new Pcm32BitToSampleProvider(resampler);
while (totalFloatsRead < totalFloatsToRead)
{
// get re-sampled/mono data
int floatsRead = pcmReader.Read(buffer, 0, buffer.Length);
if (floatsRead == 0)
{
break;
}
totalFloatsRead += floatsRead;
float[] chunk;
if (totalFloatsRead > totalFloatsToRead)
{
chunk = new float[(totalFloatsToRead - (totalFloatsRead - floatsRead))];
Array.Copy(buffer, chunk, totalFloatsToRead - (totalFloatsRead - floatsRead));
}
else
{
chunk = new float[floatsRead]; // each float contains 4 bytes
Array.Copy(buffer, chunk, floatsRead);
}
chunks.Add(chunk);
}
if (totalFloatsRead < (secondsToRead * sampleRate))
{
return null; /*not enough samples to return the requested data*/
}
float[] data = ConcatenateChunksOfSamples(chunks);
return data;
}
}
}
public TagInfo GetTagInfo(string pathToAudioFile)
{
using (var reader = new MediaFoundationReader(pathToAudioFile))
{
return new TagInfo
{
Duration = reader.TotalTime.TotalSeconds,
Album = string.Empty,
AlbumArtist = string.Empty,
Artist = pathToAudioFile,
Composer = string.Empty,
Genre = string.Empty,
IsEmpty = false,
ISRC = string.Empty,
Title = pathToAudioFile,
Year = 0
};
}
}
private float[] ReadMonoFromSource(string pathToSource, int sampleRate, int secondsToRead, int startAtSecond, Func<SampleProviderConverterBase, ISamplesProvider> getSamplesProvider)
{
using (var reader = new MediaFoundationReader(pathToSource))
{
SeekToSecondInCaseIfRequired(startAtSecond, reader);
var ieeeFloatWaveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1);
using (var resampler = new MediaFoundationResampler(reader, ieeeFloatWaveFormat))
{
var waveToSampleProvider = new WaveToSampleProvider(resampler);
return samplesAggregator.ReadSamplesFromSource(getSamplesProvider(waveToSampleProvider), secondsToRead, sampleRate);
}
}
}
public WaveStream CreateNewStreamFromFilename(string fileName)
{
var reader = new MediaFoundationReader(fileName);
return new WaveChannel32(reader);
}
public void RecodeFileToMonoWave(string pathToFile, string pathToRecodedFile, int sampleRate)
{
using (var reader = new MediaFoundationReader(pathToFile))
{
var ieeeFloatWaveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, 1);
using (var resampler = new MediaFoundationResampler(reader, ieeeFloatWaveFormat))
{
WaveFileWriter.CreateWaveFile(pathToRecodedFile, resampler);
}
}
}
