/// <summary>
/// Convert WAV to AAC
/// </summary>
/// <param name="waveFileName"></param>
/// <param name="mp3FileName"></param>
/// <param name="bitRate"></param>
public void WaveToAAC(string waveFileName, string aacFileName, int bitRate = 44100)
{
using (MediaFoundationReader reader = new MediaFoundationReader(waveFileName))
{
NAudio.MediaFoundation.MediaType mt = new NAudio.MediaFoundation.MediaType();
mt.MajorType = NAudio.MediaFoundation.MediaTypes.MFMediaType_Audio;
mt.SubType = NAudio.MediaFoundation.AudioSubtypes.MFAudioFormat_AAC;
mt.BitsPerSample = 16;
mt.SampleRate = bitRate;
mt.ChannelCount = 2;
using (MediaFoundationEncoder mfe = new MediaFoundationEncoder(mt))
{
mfe.Encode(aacFileName, reader);
}
//MediaFoundationEncoder.EncodeToAac(reader, aacFileName, bitRate);
}
}
private string ShortDescription(MediaType mediaType)
{
Guid subType = mediaType.SubType;
int sampleRate = mediaType.SampleRate;
int bytesPerSecond = mediaType.AverageBytesPerSecond;
int channels = mediaType.ChannelCount;
int bitsPerSample = mediaType.TryGetUInt32(MediaFoundationAttributes.MF_MT_AUDIO_BITS_PER_SAMPLE);
//int bitsPerSample;
//mediaType.GetUINT32(MediaFoundationAttributes.MF_MT_AUDIO_BITS_PER_SAMPLE, out bitsPerSample);
var shortDescription = new StringBuilder();
shortDescription.AppendFormat("{0:0.#}kbps, ", (8 * bytesPerSecond) / 1000M);
shortDescription.AppendFormat("{0:0.#}kHz, ", sampleRate / 1000M);
if (bitsPerSample != -1)
shortDescription.AppendFormat("{0} bit, ", bitsPerSample);
shortDescription.AppendFormat("{0}, ", channels == 1 ? "mono" : channels == 2 ? "stereo" : channels.ToString() + " channels");
if (subType == AudioSubtypes.MFAudioFormat_AAC)
{
int payloadType = mediaType.TryGetUInt32(MediaFoundationAttributes.MF_MT_AAC_PAYLOAD_TYPE);
if (payloadType != -1)
shortDescription.AppendFormat("Payload Type: {0}, ", (AacPayloadType)payloadType);
}
shortDescription.Length -= 2;
return shortDescription.ToString();
}
/// <summary>
/// Convert WAV to AAC
/// </summary>
/// <param name="waveFileName"></param>
/// <param name="mp3FileName"></param>
/// <param name="bitRate"></param>
public void WaveToAAC(string waveFileName, string aacFileName, int bitRate = 44100)
{
using (MediaFoundationReader reader = new MediaFoundationReader(waveFileName))
{
NAudio.MediaFoundation.MediaType mt = new NAudio.MediaFoundation.MediaType();
mt.MajorType = NAudio.MediaFoundation.MediaTypes.MFMediaType_Audio;
mt.SubType = NAudio.MediaFoundation.AudioSubtypes.MFAudioFormat_AAC;
mt.BitsPerSample = 16;
mt.SampleRate = bitRate;
mt.ChannelCount = 2;
using (MediaFoundationEncoder mfe = new MediaFoundationEncoder(mt))
{
mfe.Encode(aacFileName, reader);
}
//MediaFoundationEncoder.EncodeToAac(reader, aacFileName, bitRate);
}
}
protected override IMFSourceReader CreateReader(MediaFoundationReaderSettings settings)
{
var fileStream = ((MediaFoundationReaderRTSettings) settings).Stream;
var byteStream = MediaFoundationApi.CreateByteStream(fileStream);
var reader = MediaFoundationApi.CreateSourceReaderFromByteStream(byteStream);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_ALL_STREAMS, false);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
// Create a partial media type indicating that we want uncompressed PCM audio
var partialMediaType = new MediaType();
partialMediaType.MajorType = MediaTypes.MFMediaType_Audio;
partialMediaType.SubType = settings.RequestFloatOutput ? AudioSubtypes.MFAudioFormat_Float : AudioSubtypes.MFAudioFormat_PCM;
// set the media type
// can return MF_E_INVALIDMEDIATYPE if not supported
reader.SetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, IntPtr.Zero, partialMediaType.MediaFoundationObject);
return reader;
}
protected override IMFSourceReader CreateReader(MediaFoundationReaderSettings settings)
{
var fileStream = ((MediaFoundationReaderUniversalSettings)settings).Stream;
var byteStream = MediaFoundationApi.CreateByteStream(fileStream);
var reader = MediaFoundationApi.CreateSourceReaderFromByteStream(byteStream);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_ALL_STREAMS, false);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
// Create a partial media type indicating that we want uncompressed PCM audio
var partialMediaType = new NAudio.MediaFoundation.MediaType
{
MajorType = MediaTypes.MFMediaType_Audio,
SubType = settings.RequestFloatOutput ? AudioSubtypes.MFAudioFormat_Float : AudioSubtypes.MFAudioFormat_PCM
};
// set the media type
// can return MF_E_INVALIDMEDIATYPE if not supported
reader.SetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, IntPtr.Zero, partialMediaType.MediaFoundationObject);
return(reader);
}
/// <summary>
/// Creates a new MediaFoundationReader based on the supplied file
/// </summary>
/// <param name="file">Filename</param>
/// <param name="settings">Advanced settings</param>
public MediaFoundationReader(string file, MediaFoundationReaderSettings settings)
{
MediaFoundationApi.Startup();
this.settings = settings;
this.file = file;
var reader = CreateReader(settings);
/* IMFMediaType currentMediaType;
reader.GetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, out currentMediaType);
var current = new MediaType(currentMediaType);
IMFMediaType nativeMediaType;
reader.GetNativeMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, out nativeMediaType);
var native = new MediaType(nativeMediaType);*/
// now let's find out what we actually got
IMFMediaType uncompressedMediaType;
reader.GetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, out uncompressedMediaType);
// Two ways to query it, first is to ask for properties (second is to convert into WaveFormatEx using MFCreateWaveFormatExFromMFMediaType)
var outputMediaType = new MediaType(uncompressedMediaType);
Guid actualMajorType = outputMediaType.MajorType;
Debug.Assert(actualMajorType == MediaTypes.MFMediaType_Audio);
Guid audioSubType = outputMediaType.SubType;
int channels = outputMediaType.ChannelCount;
int bits = outputMediaType.BitsPerSample;
int sampleRate = outputMediaType.SampleRate;
waveFormat = audioSubType == AudioSubtypes.MFAudioFormat_PCM
? new WaveFormat(sampleRate, bits, channels)
: WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, channels);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
length = GetLength(reader);
if (settings.SingleReaderObject)
{
pReader = reader;
}
}
/// <summary>
/// Creates a new encoder that encodes to the specified output media type
/// </summary>
/// <param name="outputMediaType"></param>
public MediaFoundationEncoder(MediaType outputMediaType)
{
this.outputMediaType = outputMediaType;
}
/// <summary>
/// Encodes a file
/// </summary>
/// <param name="outputFile">Output filename (container type is deduced from the filename)</param>
/// <param name="inputProvider">Input provider (should be PCM, some encoders will also allow IEEE float)</param>
public void Encode(string outputFile, IWaveProvider inputProvider)
{
if (inputProvider.WaveFormat.Encoding != WaveFormatEncoding.Pcm && inputProvider.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
{
throw new ArgumentException("Encode input format must be PCM or IEEE float");
}
var inputMediaType = new MediaType(inputProvider.WaveFormat);
var writer = CreateSinkWriter(outputFile);
try
{
int streamIndex;
writer.AddStream(outputMediaType.MediaFoundationObject, out streamIndex);
// n.b. can get 0xC00D36B4 - MF_E_INVALIDMEDIATYPE here
writer.SetInputMediaType(streamIndex, inputMediaType.MediaFoundationObject, null);
PerformEncode(writer, streamIndex, inputProvider);
}
finally
{
Marshal.ReleaseComObject(writer);
Marshal.ReleaseComObject(inputMediaType.MediaFoundationObject);
}
}
private WaveFormat GetCurrentWaveFormat(IMFSourceReader reader)
{
IMFMediaType uncompressedMediaType;
reader.GetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, out uncompressedMediaType);
// Two ways to query it, first is to ask for properties (second is to convert into WaveFormatEx using MFCreateWaveFormatExFromMFMediaType)
var outputMediaType = new MediaType(uncompressedMediaType);
Guid actualMajorType = outputMediaType.MajorType;
Debug.Assert(actualMajorType == MediaTypes.MFMediaType_Audio);
Guid audioSubType = outputMediaType.SubType;
int channels = outputMediaType.ChannelCount;
int bits = outputMediaType.BitsPerSample;
int sampleRate = outputMediaType.SampleRate;
if (audioSubType == AudioSubtypes.MFAudioFormat_PCM)
return new WaveFormat(sampleRate, bits, channels);
if (audioSubType == AudioSubtypes.MFAudioFormat_Float)
return WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, channels);
var subTypeDescription = FieldDescriptionHelper.Describe(typeof (AudioSubtypes), audioSubType);
throw new InvalidDataException(String.Format("Unsupported audio sub Type {0}", subTypeDescription));
}
/// <summary>
/// Creates the reader (overridable by )
/// </summary>
protected virtual IMFSourceReader CreateReader(MediaFoundationReaderSettings settings)
{
IMFSourceReader reader;
MediaFoundationInterop.MFCreateSourceReaderFromURL(file, null, out reader);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_ALL_STREAMS, false);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
// Create a partial media type indicating that we want uncompressed PCM audio
var partialMediaType = new MediaType();
partialMediaType.MajorType = MediaTypes.MFMediaType_Audio;
partialMediaType.SubType = settings.RequestFloatOutput ? AudioSubtypes.MFAudioFormat_Float : AudioSubtypes.MFAudioFormat_PCM;
var currentMediaType = GetCurrentMediaType(reader);
// mono, low sample rate files can go wrong on Windows 10 unless we specify here
partialMediaType.ChannelCount = currentMediaType.ChannelCount;
partialMediaType.SampleRate = currentMediaType.SampleRate;
// set the media type
// can return MF_E_INVALIDMEDIATYPE if not supported
reader.SetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, IntPtr.Zero, partialMediaType.MediaFoundationObject);
Marshal.ReleaseComObject(currentMediaType.MediaFoundationObject);
return reader;
}
/// <summary>
/// Creates a new encoder that encodes to the specified output media type
/// </summary>
/// <param name="outputMediaType">Desired output media type</param>
public MediaFoundationEncoder(MediaType outputMediaType)
{
if (outputMediaType == null) throw new ArgumentNullException("outputMediaType");
this.outputMediaType = outputMediaType;
}
private WaveFormat GetCurrentWaveFormat(IMFSourceReader reader)
{
IMFMediaType uncompressedMediaType;
reader.GetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, out uncompressedMediaType);
// Two ways to query it, first is to ask for properties (second is to convert into WaveFormatEx using MFCreateWaveFormatExFromMFMediaType)
var outputMediaType = new MediaType(uncompressedMediaType);
Guid actualMajorType = outputMediaType.MajorType;
Debug.Assert(actualMajorType == MediaTypes.MFMediaType_Audio);
Guid audioSubType = outputMediaType.SubType;
int channels = outputMediaType.ChannelCount;
int bits = outputMediaType.BitsPerSample;
int sampleRate = outputMediaType.SampleRate;
return audioSubType == AudioSubtypes.MFAudioFormat_PCM
? new WaveFormat(sampleRate, bits, channels)
: WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, channels);
}
public MediaTypeViewModel(MediaType mediaType)
{
this.MediaType = mediaType;
this.Name = ShortDescription(mediaType);
this.Description = DescribeMediaType(mediaType.MediaFoundationObject);
}