protected override void OnOpen()
{
_validated = Context.QueryString["token"] == _token;
if (!_validated)
{
Context.WebSocket.Close(4000);
}
_capture = new WasapiLoopbackCapture(0, new WaveFormat());
_capture.Initialize();
_capture.Start();
var wsStream = new WebSocketStream(this);
Console.WriteLine($"Captured audio format: {_capture.WaveFormat}");
IWriteable encoder = null;
switch (_format)
{
case AudioFormat.AAC:
encoder = new AacEncoder(_capture.WaveFormat, wsStream, 128000,
TranscodeContainerTypes.MFTranscodeContainerType_ADTS);
break;
case AudioFormat.MP3:
encoder = MediaFoundationEncoder.CreateMP3Encoder(_capture.WaveFormat, wsStream, 320000);
break;
}
_capture.DataAvailable += (sender, e) => { encoder?.Write(e.Data, e.Offset, e.ByteCount); };
}
/// <summary>
/// Create a new file based on the given filename and start recording to it.
/// Filename must include its full path.
/// </summary>
/// <param name="fileName">The name of a file to be created. Include its full path</param>
/// <param name="codec">The codec to record in</param>
/// <param name="bitRate">The bitrate of the file</param>
/// <param name="channels">The channels to record</param>
public void StartCapture(string fileName, AvailableCodecs codec, int bitRate, Channels channels)
{
if (!ReadyToRecord())
{
throw new NullReferenceException("There is no SoundInSource configured for the recorder.");
}
fileName = $"{fileName}.{codec.ToString().ToLower()}";
WaveFormat waveSource;
switch (channels)
{
case Channels.Mono:
waveSource = _soundInSource.ToMono().WaveFormat;
break;
case Channels.Stereo:
waveSource = _soundInSource.ToStereo().WaveFormat;
break;
default:
throw new ArgumentException("The selected channel option could not be found.");
}
switch (codec)
{
case AvailableCodecs.MP3:
_writer = MediaFoundationEncoder.CreateMP3Encoder(waveSource, fileName, bitRate);
break;
case AvailableCodecs.AAC:
_writer = MediaFoundationEncoder.CreateAACEncoder(waveSource, fileName, bitRate);
break;
case AvailableCodecs.WMA:
_writer = MediaFoundationEncoder.CreateWMAEncoder(waveSource, fileName, bitRate);
break;
case AvailableCodecs.WAV:
_writer = new WaveWriter(fileName, waveSource);
break;
default:
throw new ArgumentException("The specified codec was not found.");
}
byte[] buffer = new byte[waveSource.BytesPerSecond];
_soundInSource.DataAvailable += (s, e) =>
{
int read = _waveStream.Read(buffer, 0, buffer.Length);
_writer.Write(buffer, 0, read);
};
// Start recording
_soundInSource.SoundIn.Start();
_state = RecordingState.Recording;
}
public HttpResponseMessage MakeCoolTrack([FromForm] KaraokeElems value)
{
string name = value.TrackName;
// Getting Image
var image = value.VoiceFile;
try
{
var voiceFile = "Assets/Yours/" + image.FileName.Substring(0, image.FileName.Length - 4) +
"-your-voice.mp3";
var instFile = "Assets/Nirvana Smells Like Teen Spirit Inst.mp3";
var trackFile = "Assets/Yours/" + image.FileName.Substring(0, image.FileName.Length - 4) +
"-your-track.mp3";
// Saving Image on Server
if (image.Length > 0)
{
using (var fileStream = new FileStream(voiceFile, FileMode.Create))
{
image.CopyTo(fileStream);
}
}
var voiceWaveSource = CodecFactory.Instance.GetCodec(voiceFile);
var instWaveSource = CodecFactory.Instance.GetCodec(instFile);
using (var cAurio = new AudioControler())
{
VolumeSource vol1, vol2;
var yourTrack = cAurio.MixAudioAndVoice(instWaveSource, out vol1, voiceWaveSource, out vol2);
vol1.Volume = 0.5f;
vol2.Volume = 0.5f;
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(yourTrack.WaveFormat, trackFile))
{
byte[] buffer = new byte[yourTrack.WaveFormat.BytesPerSecond];
int read;
while ((read = yourTrack.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
//Console.CursorLeft = 0;
//Console.Write("{0:P}/{1:P}", (double) yourTrack.Position / yourTrack.Length, 1);
}
}
}
}
catch (Exception e)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public static void ToAudioAgain(string base64Chunks, string outputFile, WaveFormat wav)
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(wav, outputFile))
{
foreach (var element in base64Chunks.GetByteChunks())
{
encoder.Write(element, 0, element.Length);
}
}
}
public void CanEncodeToMP3()
{
using (var source = GlobalTestConfig.TestWav2S())
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat, _targetfilename))
{
MediaFoundationEncoder.EncodeWholeSource(encoder, source);
}
}
}
async Task ISonosRequestHandler.HandleRequest(HttpListenerContext ctx)
{
// stream out the audio content to Sonos
ctx.Response.ContentType = "audio/mp3";
await ctx.Response.OutputStream.WriteAsync(new byte[1] {
0
}, 0, 1);
var cancellationToken = new CancellationTokenSource();
var memoryOffset = 0;
using (var memoryStream = new MemoryStream())
{
using (var audioEncoder = MediaFoundationEncoder.CreateMP3Encoder(_audioListener.WaveFormat, memoryStream))
{
async void OnAudioAvailable(object sender, DataAvailableEventArgs e)
{
audioEncoder.Write(e.Data, e.Offset, e.ByteCount);
try
{
if (memoryStream.TryGetBuffer(out ArraySegment <byte> buffer))
{
var newOffset = (int)memoryStream.Position;
var length = (int)newOffset - memoryOffset;
await ctx.Response.OutputStream.WriteAsync(buffer.Array, (int)memoryOffset, length);
memoryOffset = newOffset;
}
await ctx.Response.OutputStream.FlushAsync();
}
catch
{
cancellationToken.Cancel();
}
}
try
{
_audioListener.AudioAvailable += OnAudioAvailable;
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(1000);
}
}
finally
{
_audioListener.AudioAvailable -= OnAudioAvailable;
}
}
}
}
protected override void OnOpen()
{
_validated = Context.QueryString["token"] == _token;
var capture = new WasapiLoopbackCapture();
capture.Initialize();
capture.Start();
var wsStream = new WebSocketStream(this);
var encoder = MediaFoundationEncoder.CreateMP3Encoder(capture.WaveFormat, wsStream);
capture.DataAvailable += (sender, e) => encoder.Write(e.Data, e.Offset, e.ByteCount);
}
public static void StartRecording(String fileName, int bitRate = 192000)
{
capture = new WasapiLoopbackCapture();
capture.Initialize();
wasapiCaptureSource = new SoundInSource(capture);
stereoSource = wasapiCaptureSource.ToStereo();
switch (System.IO.Path.GetExtension(fileName))
{
case ".mp3":
encoderWriter = MediaFoundationEncoder.CreateMP3Encoder(stereoSource.WaveFormat, fileName, bitRate);
writerType = WriterType.EncoderWriter;
break;
case ".wma":
encoderWriter = MediaFoundationEncoder.CreateWMAEncoder(stereoSource.WaveFormat, fileName, bitRate);
writerType = WriterType.EncoderWriter;
break;
case ".aac":
encoderWriter = MediaFoundationEncoder.CreateAACEncoder(stereoSource.WaveFormat, fileName, bitRate);
writerType = WriterType.EncoderWriter;
break;
case ".wav":
waveWriter = new WaveWriter(fileName, capture.WaveFormat);
writerType = WriterType.WaveWriter;
break;
}
switch (writerType)
{
case WriterType.EncoderWriter:
capture.DataAvailable += (s, e) =>
{
encoderWriter.Write(e.Data, e.Offset, e.ByteCount);
};
break;
case WriterType.WaveWriter:
capture.DataAvailable += (s, e) =>
{
waveWriter.Write(e.Data, e.Offset, e.ByteCount);
};
break;
}
// Start recording
capture.Start();
}
public void CanEncodeToMP3()
{
string targetfilename = Path.ChangeExtension(testfile, "test.mp3");
if (File.Exists(targetfilename))
{
File.Delete(targetfilename);
}
using (var source = Codecs.CodecFactory.Instance.GetCodec(testfile))
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat, targetfilename))
{
MediaFoundationEncoder.EncodeWholeSource(encoder, source);
//Thread.Sleep(5000);
}
}
}
public void ConvertFromWave(string waveFileName, string mp3FileName)
{
var mediaTypes = MediaFoundationEncoder.GetEncoderMediaTypes(AudioSubTypes.MpegLayer3);
if (!mediaTypes.Any())
{
ColorConsole.WriteLine("The current platform does not support mp3 encoding.", ConsoleColor.DarkRed);
return;
}
IWaveSource source;
try
{
source = CodecFactory.Instance.GetCodec(waveFileName);
if (mediaTypes.All(x => x.SampleRate != source.WaveFormat.SampleRate && x.Channels == source.WaveFormat.Channels))
{
int sampleRate = mediaTypes.OrderBy(x => Math.Abs(source.WaveFormat.SampleRate - x.SampleRate)).First(x => x.Channels == source.WaveFormat.Channels).SampleRate;
ColorConsole.WriteLine("Samplerate {0} -> {1}", ConsoleColor.DarkRed, source.WaveFormat.SampleRate, sampleRate);
ColorConsole.WriteLine("Channels {0} -> {1}", ConsoleColor.DarkRed, source.WaveFormat.Channels, 2);
source = source.ChangeSampleRate(sampleRate);
}
}
catch (Exception)
{
ColorConsole.WriteLine("Mp3 Format Not Supported", ConsoleColor.DarkRed);
return;
}
using (source)
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat, mp3FileName))
{
byte[] buffer = new byte[source.WaveFormat.BytesPerSecond];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
ColorConsole.WriteLine("Wav -> Mp3 Progress: {0:P}/{1:P}", ConsoleColor.DarkGreen, (double)source.Position / source.Length, 1);
}
}
}
}
private void StartRecordBtn_Clicked(object sender, RoutedEventArgs ev)
{
capture = new WasapiLoopbackCapture();
capture.Initialize();
DateTime date = DateTime.Now;
string filename = string.Format(@"F:\Share\DailyMeetingRecord\{0:yyyy_MM_dd}.mp3", date);
//create a wavewriter to write the data to
writer = MediaFoundationEncoder.CreateMP3Encoder(capture.WaveFormat, filename);
byte[] buffer = new byte[capture.WaveFormat.BytesPerSecond];
//setup an eventhandler to receive the recorded data
capture.DataAvailable += (s, e) =>
{
//save the recorded audio
writer.Write(e.Data, e.Offset, e.ByteCount);
};
//start recording
capture.Start();
this.StartRecordBtn.IsEnabled = false;
this.StopRecordBtn.IsEnabled = true;
}
/// <summary>
/// Method Converts IWaveSource .Mp4 to .Mp3 with 192kbs Sample Rate and Saves it to Path Using the videoTitle
/// </summary>
/// <param name="source">Takes a IWaveSource videoSource = CSCore.Codecs.CodecFactory.Instance.GetCodec(new Uri(video.Uri))</param>
/// <param name="videoTitle"> Takes the Video Title</param>
/// <returns></returns>
private static bool ConvertToMp3(IWaveSource source, string videoTitle)
{
var supportedFormats = MediaFoundationEncoder.GetEncoderMediaTypes(AudioSubTypes.MpegLayer3);
if (!supportedFormats.Any())
{
Console.WriteLine("The current platform does not support mp3 encoding.");
return(true);
}
if (supportedFormats.All(
x => x.SampleRate != source.WaveFormat.SampleRate && x.Channels == source.WaveFormat.Channels))
{
int sampleRate =
supportedFormats.OrderBy(x => Math.Abs(source.WaveFormat.SampleRate - x.SampleRate))
.First(x => x.Channels == source.WaveFormat.Channels)
.SampleRate;
Console.WriteLine("Samplerate {0} -> {1}", source.WaveFormat.SampleRate, sampleRate);
Console.WriteLine("Channels {0} -> {1}", source.WaveFormat.Channels, 2);
source = source.ChangeSampleRate(sampleRate);
}
using (source)
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat, PATH + videoTitle + ".mp3"))
{
byte[] buffer = new byte[source.WaveFormat.BytesPerSecond];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
//Console.CursorLeft = 0;
//Console.Write("{0:P}/{1:P}", (double)source.Position / source.Length, 1);
}
}
}
File.Delete(PATH + videoTitle + ".mp4");
return(false);
}
public void startRecording(MMDevice micDevice, MMDevice speakDevice)
{
isRecording = true;
window.LockUI();
playSilence();
makeFileNames();
micCapture = new WasapiCapture();
micCapture.Device = micDevice;
micCapture.Initialize();
speakCapture = new WasapiLoopbackCapture();
speakCapture.Device = speakDevice;
speakCapture.Initialize();
micSource = new SoundInSource(micCapture);
micWriter = MediaFoundationEncoder.CreateMP3Encoder(micSource.WaveFormat, micFileName);
byte[] micBuffer = new byte[micSource.WaveFormat.BytesPerSecond];
micSource.DataAvailable += (s, e) =>
{
int read = micSource.Read(micBuffer, 0, micBuffer.Length);
micWriter.Write(micBuffer, 0, read);
};
micCapture.Start();
speakSource = new SoundInSource(speakCapture);
speakWriter = MediaFoundationEncoder.CreateMP3Encoder(speakSource.WaveFormat, speakFileName);
byte[] speakBuffer = new byte[speakSource.WaveFormat.BytesPerSecond];
speakSource.DataAvailable += (s, e) =>
{
int read = speakSource.Read(speakBuffer, 0, speakBuffer.Length);
speakWriter.Write(speakBuffer, 0, read);
};
speakCapture.Start();
}
public MP3Recorder(string filename)
{
if (File.Exists(filename))
{
File.Delete(filename);
}
wasapiCapture_ = new WasapiCapture();
wasapiCapture_.Initialize();
var
wasapiCaptureSource = new SoundInSource(wasapiCapture_);
stereoSource_ = wasapiCaptureSource.ToStereo();
writer_ = MediaFoundationEncoder.CreateMP3Encoder(stereoSource_.WaveFormat, filename);
byte []
buffer = new byte[stereoSource_.WaveFormat.BytesPerSecond];
wasapiCaptureSource.DataAvailable += (s, e) =>
{
int
read = stereoSource_.Read(buffer, 0, buffer.Length);
writer_.Write(buffer, 0, read);
};
wasapiCapture_.Start();
}
private static async void OnImportSoundCommand(bool forceMono)
{
var asset = _currentEditor.Asset;
var soundWave = (SoundWaveAsset)asset.RootObject;
byte chunkIndex = 0;
if (soundWave.Localization != null && soundWave.Localization.Count > 0)
{
var english = soundWave.Localization[0];
chunkIndex = soundWave.RuntimeVariations[english.FirstVariationIndex].ChunkIndex;
}
var chunk = soundWave.Chunks[chunkIndex];
var chunkEntry = App.AssetManager.GetChunkEntry(chunk.ChunkId);
var ofd = new OpenFileDialog();
ofd.Filter = "All Media Files|*.wav;*.mp3";
ofd.Title = "Open Audio";
ofd.Multiselect = true;
if (ofd.ShowDialog(_mainWindow) != true)
{
return;
}
FrostyTask2.Begin("Importing Chunk", "");
await Task.Run(() =>
{
var imports = new List <SoundImport>();
var totalChunkSize = 0u;
foreach (var fileName in ofd.FileNames)
{
var tempFile = Path.GetTempFileName();
#if DEBUG
var tempFile2 = Path.GetTempFileName();
var decoder = new CSCore.Ffmpeg.FfmpegDecoder(fileName);
var source = decoder.ChangeSampleRate(48000);
if (forceMono)
{
decoder.ToMono();
}
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat,
tempFile2))
{
var buffer = new byte[source.WaveFormat.BytesPerSecond];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
}
}
#else
var tempFile2 = fileName;
#endif
try
{
var fileNameEncoded = EncodeParameterArgument(tempFile2);
App.Logger.Log($"- \"{fileNameEncoded}\"");
var result = Primrose.Utility.ExternalTool.Run(@"dandev-el3.exe", $"{fileNameEncoded} -o {tempFile}",
out var stdout, out var stderr);
if (!string.IsNullOrEmpty(stderr))
{
App.Logger.LogError(stderr);
}
if (result == 0)
{
using (var nativeReader =
new NativeReader(
new FileStream(tempFile, FileMode.Open, FileAccess.Read)))
{
var end = nativeReader.ReadToEnd();
if (end.Length > 0 && end[0] == 0x48)
{
var lines = stdout.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var line in lines)
{
App.Logger.Log("> " + line);
}
var chunkSize =
uint.Parse(lines.First(l => l.StartsWith("ChunkSize:")).Substring(10));
var segmentLength =
float.Parse(lines.First(l => l.StartsWith("SegmentLength:")).Substring(15));
imports.Add(new SoundImport
{
SourceFile = fileName,
Chunk = end,
ChunkOffset = totalChunkSize,
ChunkSize = chunkSize,
SegmentLength = segmentLength
});
totalChunkSize += chunkSize;
}
}
}
}
catch (Exception e)
{
App.Logger.LogError(e.Message);
App.Logger.LogError(e.StackTrace);
}
finally
{
try { File.Delete(tempFile); } catch (Exception) { /* ignored */ }
try { File.Delete(tempFile2); } catch (Exception) { /* ignored */ }
}
}
if (soundWave.Localization.Count > 0)
{
var english = soundWave.Localization[0];
if (soundWave.Localization.Count > 1)
{
soundWave.Localization.RemoveRange(1, soundWave.Localization.Count - 1);
}
english.FirstVariationIndex = 0;
english.VariationCount = (ushort)imports.Count;
}
soundWave.Segments.Clear();
soundWave.RuntimeVariations.Clear();
var combinedChunk = new byte[totalChunkSize];
for (var i = 0; i < imports.Count; i++)
{
var import = imports[i];
App.Logger.Log($"Import[{i}] - SampleOffset: {import.ChunkOffset} - SegmentLength: {import.SegmentLength} - SourceFile: {import.SourceFile}");
soundWave.Segments.Add(new SoundWaveVariationSegment
{
SamplesOffset = import.ChunkOffset,
SeekTableOffset = uint.MaxValue,
SegmentLength = import.SegmentLength,
});
soundWave.RuntimeVariations.Add(new SoundWaveRuntimeVariation
{
ChunkIndex = chunkIndex,
FirstLoopSegmentIndex = 0,
FirstSegmentIndex = (ushort)i,
LastLoopSegmentIndex = 0,
PersistentDataSize = 0,
SegmentCount = 1,
Weight = 100,
});
Debug.Assert(import.ChunkSize == import.Chunk.Length);
Array.Copy(import.Chunk, 0, combinedChunk, (int)import.ChunkOffset, import.ChunkSize);
}
App.AssetManager.ModifyChunk(chunkEntry.Id, combinedChunk);
chunk.ChunkSize = totalChunkSize;
asset.Update();
_app.Dispatcher.InvokeAsync(() =>
{
App.AssetManager.ModifyEbx(_currentEditor.AssetEntry.Name, asset);
});
});
FrostyTask2.End();
}
static void Main(string[] args)
{
if (args.Length < 1 || !File.Exists(args[0]) ||
// ReSharper disable once PossibleNullReferenceException
!Path.GetExtension(args[0]).Equals(".wav", StringComparison.InvariantCultureIgnoreCase))
{
Console.WriteLine("Invalid input.");
return;
}
var supportedFormats = MediaFoundationEncoder.GetEncoderMediaTypes(AudioSubTypes.MpegLayer3);
if (!supportedFormats.Any())
{
Console.WriteLine("The current platform does not support mp3 encoding.");
return;
}
IWaveSource source;
try
{
source = CodecFactory.Instance.GetCodec(args[0]);
if (
supportedFormats.All(
x => x.SampleRate != source.WaveFormat.SampleRate && x.Channels == source.WaveFormat.Channels))
{
//the encoder does not support the input sample rate -> convert it to any supported samplerate
//choose the best sample rate with stereo (in order to make simple, we always use stereo in this sample)
int sampleRate =
supportedFormats.OrderBy(x => Math.Abs(source.WaveFormat.SampleRate - x.SampleRate))
.First(x => x.Channels == source.WaveFormat.Channels)
.SampleRate;
Console.WriteLine("Samplerate {0} -> {1}", source.WaveFormat.SampleRate, sampleRate);
Console.WriteLine("Channels {0} -> {1}", source.WaveFormat.Channels, 2);
source = source.ChangeSampleRate(sampleRate);
}
}
catch (Exception)
{
Console.WriteLine("Format not supported.");
return;
}
using (source)
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat, "output.mp3"))
{
byte[] buffer = new byte[source.WaveFormat.BytesPerSecond];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
Console.CursorLeft = 0;
Console.Write("{0:P}/{1:P}", (double)source.Position / source.Length, 1);
}
}
}
}
static void Main(string[] args)
{
args = new string[] { "C:\\fam.wav" };
if (args.Length < 1 || !File.Exists(args[0]) ||
// ReSharper disable once PossibleNullReferenceException
!Path.GetExtension(args[0]).Equals(".wav", StringComparison.InvariantCultureIgnoreCase))
{
Console.WriteLine("Invalid input.");
return;
}
var supportedFormats = MediaFoundationEncoder.GetEncoderMediaTypes(AudioSubTypes.MpegLayer3);
if (!supportedFormats.Any())
{
Console.WriteLine("The current platform does not support mp3 encoding.");
return;
}
IWaveSource source;
try
{
Console.WriteLine("getting source");
source = CodecFactory.Instance.GetCodec(args[0]);
Console.WriteLine("Source retreived");
Console.WriteLine(source.ToString());
if (
supportedFormats.All(
x => x.SampleRate != source.WaveFormat.SampleRate && x.Channels == source.WaveFormat.Channels))
{
//the encoder does not support the input sample rate -> convert it to any supported samplerate
//choose the best sample rate with stereo (in order to make simple, we always use stereo in this sample)
int sampleRate =
supportedFormats.OrderBy(x => Math.Abs(source.WaveFormat.SampleRate - x.SampleRate))
.First(x => x.Channels == source.WaveFormat.Channels)
.SampleRate;
Console.WriteLine("Samplerate {0} -> {1}", source.WaveFormat.SampleRate, sampleRate);
Console.WriteLine("Channels {0} -> {1}", source.WaveFormat.Channels, 2);
source = source.ChangeSampleRate(sampleRate);
}
}
catch (Exception)
{
Console.WriteLine("Format not supported.");
return;
}
//use memstream to write to instead of file
var memStream = new MemoryStream();
using (source)
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat, memStream))
{
byte[] buffer = new byte[source.WaveFormat.BytesPerSecond];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
Console.CursorLeft = 0;
Console.Write("{0:P}/{1:P}", (double)source.Position / source.Length, 1);
}
//write memstream contents to file
var fileStream = File.Open("d:\\output.mp3", FileMode.Create);
memStream.Seek(0, SeekOrigin.Begin);
memStream.CopyTo(fileStream);
fileStream.Close();
memStream.Close();
}
}
Console.WriteLine("done");
while (true)
{
}
}
private bool ConvertWavToMp3(string wavFilePath, string mp3FileName)
{
if (!File.Exists(wavFilePath))
{
Log.Error($"Unable to find wav file {wavFilePath}");
return(false);
}
var supportedFormats = MediaFoundationEncoder.GetEncoderMediaTypes(AudioSubTypes.MpegLayer3);
if (!supportedFormats.Any())
{
Log.Error("The current platform does not support mp3 encoding.");
return(false);
}
IWaveSource source;
try
{
source = CodecFactory.Instance.GetCodec(wavFilePath);
if (
supportedFormats.All(
x => x.SampleRate != source.WaveFormat.SampleRate && x.Channels == source.WaveFormat.Channels))
{
//the encoder does not support the input sample rate -> convert it to any supported samplerate
//choose the best sample rate with stereo (in order to make simple, we always use stereo in this sample)
int sampleRate =
supportedFormats.OrderBy(x => Math.Abs(source.WaveFormat.SampleRate - x.SampleRate))
.First(x => x.Channels == source.WaveFormat.Channels)
.SampleRate;
Log.Info($"Samplerate {source.WaveFormat.SampleRate} -> {sampleRate}");
Log.Info($"Channels {source.WaveFormat.Channels} -> {2}");
source = source.ChangeSampleRate(sampleRate);
}
}
catch (Exception ex)
{
Log.Error("Format not supported.", ex);
return(false);
}
using (source)
{
using (var encoder = MediaFoundationEncoder.CreateMP3Encoder(source.WaveFormat, mp3FileName))
{
Log.Info($"\nWriting {mp3FileName}. . .");
byte[] buffer = new byte[source.WaveFormat.BytesPerSecond];
int read;
double logMessageThreshold = .10;
double logMessageIncrement = .10;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
Console.CursorLeft = 0;
var writePercentage = (double)source.Position / source.Length;
if (writePercentage >= logMessageThreshold)
{
string writePercentageLogMessage = string.Format("{0:P}/{1:P}", writePercentage, 1);
Log.Info(writePercentageLogMessage);
logMessageThreshold += logMessageIncrement;
}
}
}
}
return(true);
}