/// <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 void CanEncodeToAAC()
{
using (var source = GlobalTestConfig.TestWav2S())
{
using (var encoder = MediaFoundationEncoder.CreateAACEncoder(source.WaveFormat, _targetfilename))
{
MediaFoundationEncoder.EncodeWholeSource(encoder, source);
}
}
}
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 CanEncodeToAAC()
{
string targetfilename = Path.ChangeExtension(testfile, "test.mp4");
if (File.Exists(targetfilename))
{
File.Delete(targetfilename);
}
using (var source = Codecs.CodecFactory.Instance.GetCodec(testfile))
{
using (var encoder = MediaFoundationEncoder.CreateAACEncoder(source.WaveFormat, targetfilename))
{
MediaFoundationEncoder.EncodeWholeSource(encoder, source);
}
}
}
public byte[] FromWav(byte[] audioFile)
{
var supportedFormats = MediaFoundationEncoder.GetEncoderMediaTypes(AudioSubTypes.MPEG_HEAAC);
_logger.Verbose("Checking for support of AAC encoding.");
if (!supportedFormats.Any())
{
_logger.Verbose("The current platform does not support AAC encoding.");
throw new ApplicationException("Current platform does not support AAC encoding.");
}
MemoryStream inStream = null;
MemoryStream outStream = null;
IWaveSource source = null;
bool sourceDisposed = false;
try
{
_logger.Verbose("Creating input stream and decoder.");
inStream = new MemoryStream(audioFile);
source = new CSCore.MediaFoundation.MediaFoundationDecoder(inStream);
//in case the encoder does not support the input sample rate -> convert it to any supported samplerate
//choose the best sample rate
_logger.Verbose("Searching for the optimal sample rate.");
_logger.Verbose($"Input wave format: {source.WaveFormat.ToString()}");
int sampleRate =
supportedFormats.OrderBy(x => Math.Abs(source.WaveFormat.SampleRate - x.SampleRate))
.First(x => x.Channels == source.WaveFormat.Channels)
.SampleRate;
if (source.WaveFormat.SampleRate != sampleRate)
{
_logger.Verbose($"Changing sample rate of the source: {source.WaveFormat.SampleRate} -> {sampleRate}.");
source = source.ChangeSampleRate(sampleRate);
}
_logger.Verbose("Encoding WAV to AAC");
outStream = new MemoryStream();
using (source)
{
using (var encoder = MediaFoundationEncoder.CreateAACEncoder(source.WaveFormat, outStream))
{
byte[] buffer = new byte[source.WaveFormat.BytesPerSecond];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
{
encoder.Write(buffer, 0, read);
}
}
sourceDisposed = true;
}
_logger.Verbose("Encoding is complete");
return(outStream.ToArray());
}
finally
{
_logger.Verbose("Cleaning up resources");
if (inStream != null)
{
inStream.Dispose();
}
if (source != null && !sourceDisposed)
{
source.Dispose();
}
if (outStream != null)
{
inStream.Dispose();
}
}
}