Mirror
/
NAudio
mirror of https://github.com/naudio/NAudio.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

some code cleanup

pull/1031/head
Mark Heath 2 years ago
parent
8c90daa464
commit
143365f030
2 changed files with 406 additions and 415 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 790
      NAudio.Wasapi/MediaFoundationEncoder.cs
  2. 31
      NAudioTests/Mixer/MixerApiTests.cs

790
NAudio.Wasapi/MediaFoundationEncoder.cs
View File

@ -1,418 +1,418 @@
using System;
using System.Collections.Generic;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using NAudio.MediaFoundation;
using NAudio.Utils;
namespace NAudio.Wave
{
/// <summary>
/// Media Foundation Encoder class allows you to use Media Foundation to encode an IWaveProvider
/// to any supported encoding format
/// </summary>
public class MediaFoundationEncoder : IDisposable
{
/// <summary>
/// Queries the available bitrates for a given encoding output type, sample rate and number of channels
/// </summary>
/// <param name="audioSubtype">Audio subtype - a value from the AudioSubtypes class</param>
/// <param name="sampleRate">The sample rate of the PCM to encode</param>
/// <param name="channels">The number of channels of the PCM to encode</param>
/// <returns>An array of available bitrates in average bits per second</returns>
public static int[] GetEncodeBitrates(Guid audioSubtype, int sampleRate, int channels)
{
return GetOutputMediaTypes(audioSubtype)
.Where(mt => mt.SampleRate == sampleRate && mt.ChannelCount == channels)
.Select(mt => mt.AverageBytesPerSecond*8)
.Distinct()
.OrderBy(br => br)
.ToArray();
}
/// <summary>
/// Gets all the available media types for a particular
/// </summary>
/// <param name="audioSubtype">Audio subtype - a value from the AudioSubtypes class</param>
/// <returns>An array of available media types that can be encoded with this subtype</returns>
public static MediaType[] GetOutputMediaTypes(Guid audioSubtype)
{
MediaFoundationApi.Startup();
IMFCollection availableTypes;
try
{
MediaFoundationInterop.MFTranscodeGetAudioOutputAvailableTypes(
audioSubtype, _MFT_ENUM_FLAG.MFT_ENUM_FLAG_ALL, null, out availableTypes);
}
catch (COMException c)
{
if (c.GetHResult() == MediaFoundationErrors.MF_E_NOT_FOUND)
{
// Don't worry if we didn't find any - just means no encoder available for this type
return new MediaType[0];
}
else
{
throw;
}
}
availableTypes.GetElementCount(out int count);
var mediaTypes = new List<MediaType>(count);
for (int n = 0; n < count; n++)
{
availableTypes.GetElement(n, out object mediaTypeObject);
var mediaType = (IMFMediaType)mediaTypeObject;
mediaTypes.Add(new MediaType(mediaType));
}
Marshal.ReleaseComObject(availableTypes);
return mediaTypes.ToArray();
}
/// <summary>
/// Helper function to simplify encoding Window Media Audio
/// Should be supported on Vista and above (not tested)
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputFile">Output file path, should end with .wma</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToWma(IWaveProvider inputProvider, string outputFile, int desiredBitRate = 192000)
{
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_WMAudioV8, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable WMA encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType))
{
encoder.Encode(outputFile, inputProvider);
}
}
/// <summary>
/// Helper function to simplify encoding Window Media Audio
/// Should be supported on Vista and above (not tested)
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputStream">Output stream</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToWma(IWaveProvider inputProvider, Stream outputStream, int desiredBitRate = 192000) {
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_WMAudioV8, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable WMA encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType)) {
encoder.Encode(outputStream, inputProvider, TranscodeContainerTypes.MFTranscodeContainerType_ASF);
}
}
/// <summary>
/// Helper function to simplify encoding to MP3
/// By default, will only be available on Windows 8 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputFile">Output file path, should end with .mp3</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToMp3(IWaveProvider inputProvider, string outputFile, int desiredBitRate = 192000)
{
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_MP3, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable MP3 encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType))
{
encoder.Encode(outputFile, inputProvider);
}
}
/// <summary>
/// Helper function to simplify encoding to MP3
/// By default, will only be available on Windows 8 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputStream">Output stream</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToMp3(IWaveProvider inputProvider, Stream outputStream, int desiredBitRate = 192000)
{
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_MP3, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable MP3 encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType)) {
encoder.Encode(outputStream, inputProvider, TranscodeContainerTypes.MFTranscodeContainerType_MP3);
}
}
/// <summary>
/// Helper function to simplify encoding to AAC
/// By default, will only be available on Windows 7 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputFile">Output file path, should end with .mp4 (or .aac on Windows 8)</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToAac(IWaveProvider inputProvider, string outputFile, int desiredBitRate = 192000)
{
// Information on configuring an AAC media type can be found here:
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd742785%28v=vs.85%29.aspx
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_AAC, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable AAC encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType))
{
// should AAC container have ADTS, or is that just for ADTS?
// http://www.hydrogenaudio.org/forums/index.php?showtopic=97442
encoder.Encode(outputFile, inputProvider);
}
}
/// <summary>
/// Helper function to simplify encoding to AAC
/// By default, will only be available on Windows 7 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputStream">Output stream</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToAac(IWaveProvider inputProvider, Stream outputStream, int desiredBitRate = 192000) {
// Information on configuring an AAC media type can be found here:
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd742785%28v=vs.85%29.aspx
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_AAC, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable AAC encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType)) {
// should AAC container have ADTS, or is that just for ADTS?
// http://www.hydrogenaudio.org/forums/index.php?showtopic=97442
encoder.Encode(outputStream, inputProvider, TranscodeContainerTypes.MFTranscodeContainerType_MPEG4);
}
}
/// <summary>
/// Tries to find the encoding media type with the closest bitrate to that specified
/// </summary>
/// <param name="audioSubtype">Audio subtype, a value from AudioSubtypes</param>
/// <param name="inputFormat">Your encoder input format (used to check sample rate and channel count)</param>
/// <param name="desiredBitRate">Your desired bitrate</param>
/// <returns>The closest media type, or null if none available</returns>
public static MediaType SelectMediaType(Guid audioSubtype, WaveFormat inputFormat, int desiredBitRate)
{
MediaFoundationApi.Startup();
return GetOutputMediaTypes(audioSubtype)
.Where(mt => mt.SampleRate == inputFormat.SampleRate && mt.ChannelCount == inputFormat.Channels)
.Select(mt => new { MediaType = mt, Delta = Math.Abs(desiredBitRate - mt.AverageBytesPerSecond * 8) } )
.OrderBy(mt => mt.Delta)
.Select(mt => mt.MediaType)
.FirstOrDefault();
}
public int DefaultReadBufferSize { get; set; }
private readonly MediaType outputMediaType;
private bool disposed;
/// <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;
}
/// <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");
}
using NAudio.MediaFoundation;
using NAudio.Utils;
namespace NAudio.Wave
{
/// <summary>
/// Media Foundation Encoder class allows you to use Media Foundation to encode an IWaveProvider
/// to any supported encoding format
/// </summary>
public class MediaFoundationEncoder : IDisposable
{
/// <summary>
/// Queries the available bitrates for a given encoding output type, sample rate and number of channels
/// </summary>
/// <param name="audioSubtype">Audio subtype - a value from the AudioSubtypes class</param>
/// <param name="sampleRate">The sample rate of the PCM to encode</param>
/// <param name="channels">The number of channels of the PCM to encode</param>
/// <returns>An array of available bitrates in average bits per second</returns>
public static int[] GetEncodeBitrates(Guid audioSubtype, int sampleRate, int channels)
{
return GetOutputMediaTypes(audioSubtype)
.Where(mt => mt.SampleRate == sampleRate && mt.ChannelCount == channels)
.Select(mt => mt.AverageBytesPerSecond*8)
.Distinct()
.OrderBy(br => br)
.ToArray();
}
/// <summary>
/// Gets all the available media types for a particular
/// </summary>
/// <param name="audioSubtype">Audio subtype - a value from the AudioSubtypes class</param>
/// <returns>An array of available media types that can be encoded with this subtype</returns>
public static MediaType[] GetOutputMediaTypes(Guid audioSubtype)
{
MediaFoundationApi.Startup();
IMFCollection availableTypes;
try
{
MediaFoundationInterop.MFTranscodeGetAudioOutputAvailableTypes(
audioSubtype, _MFT_ENUM_FLAG.MFT_ENUM_FLAG_ALL, null, out availableTypes);
}
catch (COMException c)
{
if (c.GetHResult() == MediaFoundationErrors.MF_E_NOT_FOUND)
{
// Don't worry if we didn't find any - just means no encoder available for this type
return new MediaType[0];
}
else
{
throw;
}
}
availableTypes.GetElementCount(out int count);
var mediaTypes = new List<MediaType>(count);
for (int n = 0; n < count; n++)
{
availableTypes.GetElement(n, out object mediaTypeObject);
var mediaType = (IMFMediaType)mediaTypeObject;
mediaTypes.Add(new MediaType(mediaType));
}
Marshal.ReleaseComObject(availableTypes);
return mediaTypes.ToArray();
}
/// <summary>
/// Helper function to simplify encoding Window Media Audio
/// Should be supported on Vista and above (not tested)
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputFile">Output file path, should end with .wma</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToWma(IWaveProvider inputProvider, string outputFile, int desiredBitRate = 192000)
{
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_WMAudioV8, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable WMA encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType))
{
encoder.Encode(outputFile, inputProvider);
}
}
/// <summary>
/// Helper function to simplify encoding Window Media Audio
/// Should be supported on Vista and above (not tested)
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputStream">Output stream</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToWma(IWaveProvider inputProvider, Stream outputStream, int desiredBitRate = 192000) {
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_WMAudioV8, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable WMA encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType)) {
encoder.Encode(outputStream, inputProvider, TranscodeContainerTypes.MFTranscodeContainerType_ASF);
}
}
/// <summary>
/// Helper function to simplify encoding to MP3
/// By default, will only be available on Windows 8 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputFile">Output file path, should end with .mp3</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToMp3(IWaveProvider inputProvider, string outputFile, int desiredBitRate = 192000)
{
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_MP3, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable MP3 encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType))
{
encoder.Encode(outputFile, inputProvider);
}
}
/// <summary>
/// Helper function to simplify encoding to MP3
/// By default, will only be available on Windows 8 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputStream">Output stream</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToMp3(IWaveProvider inputProvider, Stream outputStream, int desiredBitRate = 192000)
{
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_MP3, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable MP3 encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType)) {
encoder.Encode(outputStream, inputProvider, TranscodeContainerTypes.MFTranscodeContainerType_MP3);
}
}
/// <summary>
/// Helper function to simplify encoding to AAC
/// By default, will only be available on Windows 7 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputFile">Output file path, should end with .mp4 (or .aac on Windows 8)</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToAac(IWaveProvider inputProvider, string outputFile, int desiredBitRate = 192000)
{
// Information on configuring an AAC media type can be found here:
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd742785%28v=vs.85%29.aspx
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_AAC, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable AAC encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType))
{
// should AAC container have ADTS, or is that just for ADTS?
// http://www.hydrogenaudio.org/forums/index.php?showtopic=97442
encoder.Encode(outputFile, inputProvider);
}
}
/// <summary>
/// Helper function to simplify encoding to AAC
/// By default, will only be available on Windows 7 and above
/// </summary>
/// <param name="inputProvider">Input provider, must be PCM</param>
/// <param name="outputStream">Output stream</param>
/// <param name="desiredBitRate">Desired bitrate. Use GetEncodeBitrates to find the possibilities for your input type</param>
public static void EncodeToAac(IWaveProvider inputProvider, Stream outputStream, int desiredBitRate = 192000) {
// Information on configuring an AAC media type can be found here:
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd742785%28v=vs.85%29.aspx
var mediaType = SelectMediaType(AudioSubtypes.MFAudioFormat_AAC, inputProvider.WaveFormat, desiredBitRate);
if (mediaType == null) throw new InvalidOperationException("No suitable AAC encoders available");
using (var encoder = new MediaFoundationEncoder(mediaType)) {
// should AAC container have ADTS, or is that just for ADTS?
// http://www.hydrogenaudio.org/forums/index.php?showtopic=97442
encoder.Encode(outputStream, inputProvider, TranscodeContainerTypes.MFTranscodeContainerType_MPEG4);
}
}
/// <summary>
/// Tries to find the encoding media type with the closest bitrate to that specified
/// </summary>
/// <param name="audioSubtype">Audio subtype, a value from AudioSubtypes</param>
/// <param name="inputFormat">Your encoder input format (used to check sample rate and channel count)</param>
/// <param name="desiredBitRate">Your desired bitrate</param>
/// <returns>The closest media type, or null if none available</returns>
public static MediaType SelectMediaType(Guid audioSubtype, WaveFormat inputFormat, int desiredBitRate)
{
MediaFoundationApi.Startup();
return GetOutputMediaTypes(audioSubtype)
.Where(mt => mt.SampleRate == inputFormat.SampleRate && mt.ChannelCount == inputFormat.Channels)
.Select(mt => new { MediaType = mt, Delta = Math.Abs(desiredBitRate - mt.AverageBytesPerSecond * 8) } )
.OrderBy(mt => mt.Delta)
.Select(mt => mt.MediaType)
.FirstOrDefault();
}
public int DefaultReadBufferSize { get; set; }
private readonly MediaType outputMediaType;
private bool disposed;
/// <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;
}
/// <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
var writer = CreateSinkWriter(outputFile);
try
{
writer.AddStream(outputMediaType.MediaFoundationObject, out int streamIndex);
// n.b. can get 0xC00D36B4 - MF_E_INVALIDMEDIATYPE here
writer.SetInputMediaType(streamIndex, inputMediaType.MediaFoundationObject, null);
PerformEncode(writer, streamIndex, inputProvider);
}
finally
{
writer.AddStream(outputMediaType.MediaFoundationObject, out int streamIndex);
// n.b. can get 0xC00D36B4 - MF_E_INVALIDMEDIATYPE here
writer.SetInputMediaType(streamIndex, inputMediaType.MediaFoundationObject, null);
PerformEncode(writer, streamIndex, inputProvider);
}
finally
{
if (writer != null)
{
Marshal.ReleaseComObject(writer);
}
}
if (inputMediaType.MediaFoundationObject != null)
{
Marshal.ReleaseComObject(inputMediaType.MediaFoundationObject);
}
}
}
/// <summary>
/// Encodes a file
/// </summary>
/// <param name="outputStream">Output stream</param>
/// <param name="inputProvider">Input provider (should be PCM, some encoders will also allow IEEE float)</param>
/// <param name="transcodeContainerType">One of <see cref="TranscodeContainerTypes"/></param>
public void Encode(Stream outputStream, IWaveProvider inputProvider, Guid transcodeContainerType)
{
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(new ComStream(outputStream), transcodeContainerType);
Marshal.ReleaseComObject(inputMediaType.MediaFoundationObject);
}
}
}
/// <summary>
/// Encodes a file
/// </summary>
/// <param name="outputStream">Output stream</param>
/// <param name="inputProvider">Input provider (should be PCM, some encoders will also allow IEEE float)</param>
/// <param name="transcodeContainerType">One of <see cref="TranscodeContainerTypes"/></param>
public void Encode(Stream outputStream, IWaveProvider inputProvider, Guid transcodeContainerType)
{
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(new ComStream(outputStream), transcodeContainerType);
try
{
writer.AddStream(outputMediaType.MediaFoundationObject, out int streamIndex);
// n.b. can get 0xC00D36B4 - MF_E_INVALIDMEDIATYPE here
writer.SetInputMediaType(streamIndex, inputMediaType.MediaFoundationObject, null);
PerformEncode(writer, streamIndex, inputProvider);
}
finally
{
writer.SetInputMediaType(streamIndex, inputMediaType.MediaFoundationObject, null);
PerformEncode(writer, streamIndex, inputProvider);
}
finally
{
if (writer != null)
{
Marshal.ReleaseComObject(writer);
}
}
if (inputMediaType.MediaFoundationObject != null)
{
Marshal.ReleaseComObject(inputMediaType.MediaFoundationObject);
}
}
}
private static IMFSinkWriter CreateSinkWriter(string outputFile)
{
// n.b. could try specifying the container type using attributes, but I think
// it does a decent job of working it out from the file extension
// n.b. AAC encode on Win 8 can have AAC extension, but use MP4 in win 7
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd389284%28v=vs.85%29.aspx
IMFSinkWriter writer;
var attributes = MediaFoundationApi.CreateAttributes(1);
Marshal.ReleaseComObject(inputMediaType.MediaFoundationObject);
}
}
}
private static IMFSinkWriter CreateSinkWriter(string outputFile)
{
// n.b. could try specifying the container type using attributes, but I think
// it does a decent job of working it out from the file extension
// n.b. AAC encode on Win 8 can have AAC extension, but use MP4 in win 7
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd389284%28v=vs.85%29.aspx
IMFSinkWriter writer;
var attributes = MediaFoundationApi.CreateAttributes(1);
attributes.SetUINT32(MediaFoundationAttributes.MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, 1);
try
{
MediaFoundationInterop.MFCreateSinkWriterFromURL(outputFile, null, attributes, out writer);
}
catch (COMException e)
{
if (e.GetHResult() == MediaFoundationErrors.MF_E_NOT_FOUND)
{
throw new ArgumentException("Was not able to create a sink writer for this file extension");
}
throw;
}
finally
{
Marshal.ReleaseComObject(attributes);
}
return writer;
}
private static IMFSinkWriter CreateSinkWriter(IStream outputStream, Guid TranscodeContainerType)
{
// n.b. could try specifying the container type using attributes, but I think
// it does a decent job of working it out from the file extension
// n.b. AAC encode on Win 8 can have AAC extension, but use MP4 in win 7
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd389284%28v=vs.85%29.aspx
IMFSinkWriter writer;
var attributes = MediaFoundationApi.CreateAttributes(1);
try
{
MediaFoundationInterop.MFCreateSinkWriterFromURL(outputFile, null, attributes, out writer);
}
catch (COMException e)
{
if (e.GetHResult() == MediaFoundationErrors.MF_E_NOT_FOUND)
{
throw new ArgumentException("Was not able to create a sink writer for this file extension");
}
throw;
}
finally
{
Marshal.ReleaseComObject(attributes);
}
return writer;
}
private static IMFSinkWriter CreateSinkWriter(IStream outputStream, Guid TranscodeContainerType)
{
// n.b. could try specifying the container type using attributes, but I think
// it does a decent job of working it out from the file extension
// n.b. AAC encode on Win 8 can have AAC extension, but use MP4 in win 7
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd389284%28v=vs.85%29.aspx
IMFSinkWriter writer;
var attributes = MediaFoundationApi.CreateAttributes(1);
attributes.SetGUID(MediaFoundationAttributes.MF_TRANSCODE_CONTAINERTYPE, TranscodeContainerType);
try
{
MediaFoundationInterop.MFCreateMFByteStreamOnStream(outputStream, out var ppByteStream);
MediaFoundationInterop.MFCreateSinkWriterFromURL(null, ppByteStream, attributes, out writer);
}
finally
{
Marshal.ReleaseComObject(attributes);
}
return writer;
}
private void PerformEncode(IMFSinkWriter writer, int streamIndex, IWaveProvider inputProvider)
{
if (DefaultReadBufferSize== 0) DefaultReadBufferSize = inputProvider.WaveFormat.AverageBytesPerSecond * 4;
var managedBuffer = new byte[DefaultReadBufferSize];
writer.BeginWriting();
long position = 0;
long duration;
do
{
duration = ConvertOneBuffer(writer, streamIndex, inputProvider, position, managedBuffer);
position += duration;
} while (duration > 0);
writer.DoFinalize();
}
private static long BytesToNsPosition(int bytes, WaveFormat waveFormat)
{
long nsPosition = (10000000L * bytes) / waveFormat.AverageBytesPerSecond;
return nsPosition;
}
private long ConvertOneBuffer(IMFSinkWriter writer, int streamIndex, IWaveProvider inputProvider, long position, byte[] managedBuffer)
{
long durationConverted = 0;
IMFMediaBuffer buffer = MediaFoundationApi.CreateMemoryBuffer(managedBuffer.Length);
buffer.GetMaxLength(out var maxLength);
IMFSample sample = MediaFoundationApi.CreateSample();
sample.AddBuffer(buffer);
int read = inputProvider.Read(managedBuffer, 0, maxLength);
if (read > 0)
{
buffer.Lock(out var ptr, out maxLength, out int currentLength);
durationConverted = BytesToNsPosition(read, inputProvider.WaveFormat);
Marshal.Copy(managedBuffer, 0, ptr, read);
buffer.SetCurrentLength(read);
buffer.Unlock();
sample.SetSampleTime(position);
sample.SetSampleDuration(durationConverted);
writer.WriteSample(streamIndex, sample);
//writer.Flush(streamIndex);
}
Marshal.ReleaseComObject(sample);
Marshal.ReleaseComObject(buffer);
return durationConverted;
}
/// <summary>
/// Disposes this instance
/// </summary>
/// <param name="disposing"></param>
protected void Dispose(bool disposing)
{
Marshal.ReleaseComObject(outputMediaType.MediaFoundationObject);
}
/// <summary>
/// Disposes this instance
/// </summary>
public void Dispose()
{
if (!disposed)
{
disposed = true;
Dispose(true);
}
GC.SuppressFinalize(this);
}
/// <summary>
/// Finalizer
/// </summary>
~MediaFoundationEncoder()
{
Dispose(false);
}
}
}
MediaFoundationInterop.MFCreateMFByteStreamOnStream(outputStream, out var ppByteStream);
MediaFoundationInterop.MFCreateSinkWriterFromURL(null, ppByteStream, attributes, out writer);
}
finally
{
Marshal.ReleaseComObject(attributes);
}
return writer;
}
private void PerformEncode(IMFSinkWriter writer, int streamIndex, IWaveProvider inputProvider)
{
if (DefaultReadBufferSize== 0) DefaultReadBufferSize = inputProvider.WaveFormat.AverageBytesPerSecond * 4;
var managedBuffer = new byte[DefaultReadBufferSize];
writer.BeginWriting();
long position = 0;
long duration;
do
{
duration = ConvertOneBuffer(writer, streamIndex, inputProvider, position, managedBuffer);
position += duration;
} while (duration > 0);
writer.DoFinalize();
}
private static long BytesToNsPosition(int bytes, WaveFormat waveFormat)
{
long nsPosition = (10000000L * bytes) / waveFormat.AverageBytesPerSecond;
return nsPosition;
}
private long ConvertOneBuffer(IMFSinkWriter writer, int streamIndex, IWaveProvider inputProvider, long position, byte[] managedBuffer)
{
long durationConverted = 0;
IMFMediaBuffer buffer = MediaFoundationApi.CreateMemoryBuffer(managedBuffer.Length);
buffer.GetMaxLength(out var maxLength);
IMFSample sample = MediaFoundationApi.CreateSample();
sample.AddBuffer(buffer);
int read = inputProvider.Read(managedBuffer, 0, maxLength);
if (read > 0)
{
buffer.Lock(out var ptr, out maxLength, out int currentLength);
durationConverted = BytesToNsPosition(read, inputProvider.WaveFormat);
Marshal.Copy(managedBuffer, 0, ptr, read);
buffer.SetCurrentLength(read);
buffer.Unlock();
sample.SetSampleTime(position);
sample.SetSampleDuration(durationConverted);
writer.WriteSample(streamIndex, sample);
//writer.Flush(streamIndex);
}
Marshal.ReleaseComObject(sample);
Marshal.ReleaseComObject(buffer);
return durationConverted;
}
/// <summary>
/// Disposes this instance
/// </summary>
/// <param name="disposing"></param>
protected void Dispose(bool disposing)
{
Marshal.ReleaseComObject(outputMediaType.MediaFoundationObject);
}
/// <summary>
/// Disposes this instance
/// </summary>
public void Dispose()
{
if (!disposed)
{
disposed = true;
Dispose(true);
}
GC.SuppressFinalize(this);
}
/// <summary>
/// Finalizer
/// </summary>
~MediaFoundationEncoder()
{
Dispose(false);
}
}
}

31
NAudioTests/Mixer/MixerApiTests.cs
View File

@ -1,11 +1,7 @@
using System;
using System.Collections.Generic;
using System.Text;
using NAudio.Mixer;
using NAudio.Wave;
using NUnit.Framework;
using NAudio.Mixer;
using System.Diagnostics;
using NAudio;
using NAudio.Wave;
namespace NAudioTests
{
@ -32,23 +28,21 @@ namespace NAudioTests
Mixer mixer = new Mixer(defaultWaveInMixerId);
foreach (MixerLine destination in mixer.Destinations)
{
Debug.WriteLine(String.Format("DESTINATION: {0} {1} (Type: {2}, Target: {3})",
destination.Name, destination.TypeDescription, destination.ComponentType, destination.TargetName));
Debug.WriteLine($"DESTINATION: {destination.Name} {destination.TypeDescription} (Type: {destination.ComponentType}, Target: {destination.TargetName})");
if (destination.ComponentType == MixerLineComponentType.DestinationWaveIn)
{
foreach (MixerLine source in destination.Sources)
{
Debug.WriteLine(String.Format("{0} {1} (Source: {2}, Target: {3})",
source.Name, source.TypeDescription, source.IsSource, source.TargetName));
Debug.WriteLine($"{source.Name} {source.TypeDescription} (Source: {source.IsSource}, Target: {source.TargetName})");
if (source.ComponentType == MixerLineComponentType.SourceMicrophone)
{
Debug.WriteLine(String.Format("Found the microphone: {0}", source.Name));
Debug.WriteLine($"Found the microphone: {source.Name}");
foreach (MixerControl control in source.Controls)
{
if (control.ControlType == MixerControlType.Volume)
{
Debug.WriteLine(String.Format("Volume Found: {0}", control));
Debug.WriteLine($"Volume Found: {control}");
UnsignedMixerControl umc = (UnsignedMixerControl)control;
uint originalValue = umc.Value;
umc.Value = umc.MinValue;
@ -80,7 +74,7 @@ namespace NAudioTests
private static void ExploreMixerDevice(int deviceIndex)
{
Mixer mixer = new Mixer(deviceIndex);
Debug.WriteLine(String.Format("Device {0}: {1}",deviceIndex,mixer.Name));
Debug.WriteLine($"Device {deviceIndex}: {mixer.Name}");
Debug.WriteLine("--------------------------------------------");
int destinations = mixer.DestinationCount;
Assert.That(destinations > 0, "Expected at least one destination");
@ -93,12 +87,10 @@ namespace NAudioTests
private static void ExploreMixerDestination(Mixer mixer, int destinationIndex)
{
var destination = mixer.GetDestination(destinationIndex);
Debug.WriteLine(String.Format("Destination {0}: {1}",
destinationIndex, destination));
int channels = destination.Channels;
Debug.WriteLine($"Destination {destinationIndex}: {destination} ({destination.Channels})");
foreach (MixerControl control in destination.Controls)
{
Debug.WriteLine(String.Format("CONTROL: {0}", control));
Debug.WriteLine($"CONTROL: {control}");
}
int sources = destination.SourceCount;
for (int sourceIndex = 0; sourceIndex < sources; sourceIndex++)
@ -110,11 +102,10 @@ namespace NAudioTests
private static void ExploreMixerSource(MixerLine destinationLine, int sourceIndex)
{
var sourceLine = destinationLine.GetSource(sourceIndex);
Debug.WriteLine(String.Format("Source {0}: {1}",
sourceIndex, sourceLine));
Debug.WriteLine($"Source {sourceIndex}: {sourceLine}");
foreach (MixerControl control in sourceLine.Controls)
{
Debug.WriteLine(String.Format("CONTROL: {0}", control));
Debug.WriteLine($"CONTROL: {control}");
}
}
}

Write Preview
Loading…
Cancel
Save