protected override IMFSourceReader CreateReader(MediaFoundationReaderSettings settings)
{
var source_reader = base.CreateReader(settings);
Duration = GetDuration(source_reader);
return(source_reader);
}
/// <summary>
/// Creates the reader (overridable by )
/// </summary>
protected virtual IMFSourceReader CreateReader(MediaFoundationReaderSettings settings)
{
IMFSourceReader reader;
// If the file exists.
if (!String.IsNullOrEmpty(file))
{
MediaFoundationInterop.MFCreateSourceReaderFromURL(file, null, out reader);
}
else
{
IMFByteStream byteStream = MediaFoundationApi.CreateByteStreamFromStream(_inputStream);
MediaFoundationInterop.MFCreateSourceReaderFromByteStream(byteStream, 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;
// 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 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 the reader
/// </summary>
protected override IMFSourceReader CreateReader(MediaFoundationReaderSettings settings)
{
var ppSourceReader = MediaFoundationApi.CreateSourceReaderFromByteStream(MediaFoundationApi.CreateByteStream(new ComStream(stream)));
ppSourceReader.SetStreamSelection(-2, false);
ppSourceReader.SetStreamSelection(-3, true);
ppSourceReader.SetCurrentMediaType(-3, IntPtr.Zero, new MediaType
{
MajorType = MediaTypes.MFMediaType_Audio,
SubType = settings.RequestFloatOutput ? AudioSubtypes.MFAudioFormat_Float : AudioSubtypes.MFAudioFormat_PCM
}.MediaFoundationObject);
return(ppSourceReader);
}
/// <summary>
/// Creates a new MediaFoundationReader based on the supplied file
/// </summary>
/// <param name="file">Filename</param>
/// <param name="settings">Advanced settings</param>
public MediaFoundationReaderX(string file, MediaFoundationReaderSettings settings)
{
MediaFoundationApi.Startup();
this.settings = settings;
this.file = file;
var reader = CreateReader(settings);
waveFormat = GetCurrentWaveFormat(reader, false, 0, 0, 0);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
length = GetLength(reader);
if (settings.SingleReaderObject)
{
pReader = reader;
}
}
/// <summary>
/// Creates a new MediaFoundationReader based on the supplied file
/// </summary>
/// <param name="file">Filename</param>
/// <param name="settings">Advanced settings</param>
public MediaFoundationReaderX(string file, bool useOverrides, int sampleRate, int numChannels, int bitDepth)
{
MediaFoundationApi.Startup();
this.settings = new MediaFoundationReaderSettings();
this.file = file;
var reader = CreateReader(settings);
waveFormat = GetCurrentWaveFormat(reader, useOverrides, sampleRate, numChannels, bitDepth);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
length = GetLength(reader);
if (settings.SingleReaderObject)
{
pReader = reader;
}
}
/// <summary>
/// Initializes
/// </summary>
protected void Init(MediaFoundationReaderSettings initialSettings)
{
MediaFoundationApi.Startup();
settings = initialSettings ?? new MediaFoundationReaderSettings();
var reader = CreateReader(settings);
waveFormat = GetCurrentWaveFormat(reader);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
length = GetLength(reader);
if (settings.SingleReaderObject)
{
pReader = reader;
}
}
/// <summary>
/// Creates the reader (overridable by )
/// </summary>
protected virtual IMFSourceReader CreateReader2(byte[] buffer, MediaFoundationReaderSettings settings)
{
IMFSourceReader reader = null;
//MediaFoundationInterop.MFCreateSourceReaderFromURL(file, null, out reader);
reader = MediaFoundationApi.CreateSourceReaderFromByteStream(MediaFoundationApi.CreateByteStream(new ComStream(new MemoryStream(buffer))));
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;
try
{
// 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);
}
catch (COMException ex) when(ex.GetHResult() == MediaFoundationErrors.MF_E_INVALIDMEDIATYPE)
{
// HE-AAC (and v2) seems to halve the samplerate
if (currentMediaType.SubType == AudioSubtypes.MFAudioFormat_AAC && currentMediaType.ChannelCount == 1)
{
partialMediaType.SampleRate = currentMediaType.SampleRate *= 2;
partialMediaType.ChannelCount = currentMediaType.ChannelCount *= 2;
reader.SetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, IntPtr.Zero, partialMediaType.MediaFoundationObject);
}
else
{
throw;
}
}
Marshal.ReleaseComObject(currentMediaType.MediaFoundationObject);
return(reader);
}
/// <summary>
/// Creates a new MediaFoundationReader based on the supplied file
/// </summary>
/// <param name="inputStream">The input stream containing a WAV.</param>
/// <param name="settings">Advanced settings</param>
public MediaFoundationReader(System.IO.Stream inputStream, MediaFoundationReaderSettings settings)
{
MediaFoundationApi.Startup();
this.settings = settings;
_inputStream = inputStream;
var reader = CreateReader(settings);
waveFormat = GetCurrentWaveFormat(reader);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
length = GetLength(reader);
if (settings.SingleReaderObject)
{
pReader = 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);
waveFormat = GetCurrentWaveFormat(reader);
reader.SetStreamSelection(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
length = GetLength(reader);
if (settings.SingleReaderObject)
{
pReader = reader;
}
}
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;
}
/// <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;
}
}
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 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);
}
/// <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;
}
}
protected override IMFSourceReader CreateReader(MediaFoundationReaderSettings settings)
{
const int MF_SOURCE_READER_ALL_STREAMS = -2;
const int MF_SOURCE_READER_FIRST_AUDIO_STREAM = -3;
IMFByteStream byteStream;
MFCreateMFByteStreamOnStream(new ComStream(m_stream), out byteStream);
var source_reader = MediaFoundationApi.CreateSourceReaderFromByteStream(byteStream);
source_reader.SetStreamSelection(MF_SOURCE_READER_ALL_STREAMS, false);
source_reader.SetStreamSelection(MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
source_reader.SetCurrentMediaType(MF_SOURCE_READER_FIRST_AUDIO_STREAM, IntPtr.Zero, new MediaType
{
MajorType = MediaTypes.MFMediaType_Audio,
SubType = settings.RequestFloatOutput ? AudioSubtypes.MFAudioFormat_Float : AudioSubtypes.MFAudioFormat_PCM
}.MediaFoundationObject);
Duration = GetDuration(source_reader);
return(source_reader);
}
public static WaveFormat GetCurrentWaveFormat(byte[] buffer)
{
MediaFoundationApi.Startup();
var settings = new MediaFoundationReaderSettings();
IMFSourceReader reader = null;
//MediaFoundationInterop.MFCreateSourceReaderFromURL(file, null, out reader);
reader = MediaFoundationApi.CreateSourceReaderFromByteStream(MediaFoundationApi.CreateByteStream(new ComStream(new MemoryStream(buffer))));
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;
try
{
// 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);
}
catch (COMException ex) when(ex.GetHResult() == MediaFoundationErrors.MF_E_INVALIDMEDIATYPE)
{
// HE-AAC (and v2) seems to halve the samplerate
if (currentMediaType.SubType == AudioSubtypes.MFAudioFormat_AAC && currentMediaType.ChannelCount == 1)
{
partialMediaType.SampleRate = currentMediaType.SampleRate *= 2;
partialMediaType.ChannelCount = currentMediaType.ChannelCount *= 2;
reader.SetCurrentMediaType(MediaFoundationInterop.MF_SOURCE_READER_FIRST_AUDIO_STREAM, IntPtr.Zero, partialMediaType.MediaFoundationObject);
}
else
{
throw;
}
}
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;
Marshal.ReleaseComObject(currentMediaType.MediaFoundationObject);
//Marshal.ReleaseComObject(reader);
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));
}
public CustomMediaFoundationReader(Stream stream, MediaFoundationReaderSettings settings = null)
: base(stream, settings)
{
}
/// <summary>
/// Constructs a new media foundation reader from a stream
/// </summary>
public StreamMediaFoundationReader(Stream stream, MediaFoundationReaderSettings settings = null)
{
this.stream = stream;
Init(settings);
}
/// <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 MediaFoundationReader based on the supplied file
/// </summary>
/// <param name="file">Filename</param>
/// <param name="settings">Advanced settings</param>
public MediaFoundationReader(string file, MediaFoundationReaderSettings settings)
{
this.file = file;
Init(settings);
}
public CustomMediaFoundationReader(Stream stream, MediaFoundationReaderSettings settings = null)
{
m_stream = stream;
Init(settings);
}
