private static long GetDuration(IMFSourceReader reader)
{
var variantPtr = Marshal.AllocHGlobal(MarshalHelpers.SizeOf <PropVariant>());
try
{
int hResult = reader.GetPresentationAttribute(MediaFoundationInterop.MF_SOURCE_READER_MEDIASOURCE,
MediaFoundationAttributes.MF_PD_DURATION, variantPtr);
if (hResult == MediaFoundationErrors.MF_E_ATTRIBUTENOTFOUND)
{
return(0);
}
if (hResult != 0)
{
Marshal.ThrowExceptionForHR(hResult);
}
var variant = MarshalHelpers.PtrToStructure <PropVariant> (variantPtr);
return((long)variant.Value);
}
finally
{
PropVariant.Clear(variantPtr);
Marshal.FreeHGlobal(variantPtr);
}
}
private long GetLength(IMFSourceReader reader)
{
var variantPtr = Marshal.AllocHGlobal(MarshalHelpers.SizeOf <PropVariant>());
try
{
// http://msdn.microsoft.com/en-gb/library/windows/desktop/dd389281%28v=vs.85%29.aspx#getting_file_duration
int hResult = reader.GetPresentationAttribute(MediaFoundationInterop.MF_SOURCE_READER_MEDIASOURCE,
MediaFoundationAttributes.MF_PD_DURATION, variantPtr);
if (hResult == MediaFoundationErrors.MF_E_ATTRIBUTENOTFOUND)
{
// this doesn't support telling us its duration (might be streaming)
return(0);
}
if (hResult != 0)
{
Marshal.ThrowExceptionForHR(hResult);
}
var variant = MarshalHelpers.PtrToStructure <PropVariant>(variantPtr);
var lengthInBytes = (((long)variant.Value) * waveFormat.AverageBytesPerSecond) / 10000000L;
return(lengthInBytes);
}
finally
{
PropVariant.Clear(variantPtr);
Marshal.FreeHGlobal(variantPtr);
}
}
private long GetLength(IMFSourceReader reader)
{
IntPtr intPtr = Marshal.AllocHGlobal(MarshalHelpers.SizeOf <PropVariant>());
long result;
try
{
int presentationAttribute = reader.GetPresentationAttribute(-1, MediaFoundationAttributes.MF_PD_DURATION, intPtr);
if (presentationAttribute == -1072875802)
{
result = 0L;
}
else
{
if (presentationAttribute != 0)
{
Marshal.ThrowExceptionForHR(presentationAttribute);
}
result = (long)MarshalHelpers.PtrToStructure <PropVariant>(intPtr).Value *(long)this.waveFormat.AverageBytesPerSecond / 10000000L;
}
}
finally
{
PropVariant.Clear(intPtr);
Marshal.FreeHGlobal(intPtr);
}
return(result);
}
/// <summary>
/// Sets the parameters that describe the properties of the client's audio stream.
/// </summary>
/// <param name="useHardwareOffload">Boolean value to indicate whether or not the audio stream is hardware-offloaded.</param>
/// <param name="category">An enumeration that is used to specify the category of the audio stream.</param>
/// <param name="options">A bit-field describing the characteristics of the stream. Supported in Windows 8.1 and later.</param>
public void SetClientProperties(bool useHardwareOffload, AudioStreamCategory category, AudioClientStreamOptions options)
{
audioClientProperties = new AudioClientProperties()
{
cbSize = (uint)MarshalHelpers.SizeOf <AudioClientProperties>(),
bIsOffload = Convert.ToInt32(useHardwareOffload),
eCategory = category,
Options = options
};
}
private static void AddAttribute(IMFActivate mft, int index, StringBuilder sb)
{
var variantPtr = Marshal.AllocHGlobal(MarshalHelpers.SizeOf <PropVariant>());
try
{
Guid key;
mft.GetItemByIndex(index, out key, variantPtr);
var value = MarshalHelpers.PtrToStructure <PropVariant>(variantPtr);
string propertyName = FieldDescriptionHelper.Describe(typeof(MediaFoundationAttributes), key);
if (key == MediaFoundationAttributes.MFT_INPUT_TYPES_Attributes ||
key == MediaFoundationAttributes.MFT_OUTPUT_TYPES_Attributes)
{
var types = value.GetBlobAsArrayOf <MFT_REGISTER_TYPE_INFO>();
sb.AppendFormat("{0}: {1} items:", propertyName, types.Length);
sb.AppendLine();
foreach (var t in types)
{
sb.AppendFormat(" {0}-{1}",
FieldDescriptionHelper.Describe(typeof(MediaTypes), t.guidMajorType),
FieldDescriptionHelper.Describe(typeof(AudioSubtypes), t.guidSubtype));
sb.AppendLine();
}
}
else if (key == MediaFoundationAttributes.MF_TRANSFORM_CATEGORY_Attribute)
{
sb.AppendFormat("{0}: {1}", propertyName,
FieldDescriptionHelper.Describe(typeof(MediaFoundationTransformCategories), (Guid)value.Value));
sb.AppendLine();
}
else if (value.DataType == (VarEnum.VT_VECTOR | VarEnum.VT_UI1))
{
var b = (byte[])value.Value;
sb.AppendFormat("{0}: Blob of {1} bytes", propertyName, b.Length);
sb.AppendLine();
}
else
{
sb.AppendFormat("{0}: {1}", propertyName, value.Value);
sb.AppendLine();
}
}
finally
{
PropVariant.Clear(variantPtr);
Marshal.FreeHGlobal(variantPtr);
}
}
private static void DescribeAttribute(IMFMediaType mediaType, int n, StringBuilder sb)
{
var variantPtr = Marshal.AllocHGlobal(MarshalHelpers.SizeOf <PropVariant>());
try
{
Guid key;
mediaType.GetItemByIndex(n, out key, variantPtr);
var val = MarshalHelpers.PtrToStructure <PropVariant>(variantPtr);
string propertyName = FieldDescriptionHelper.Describe(typeof(MediaFoundationAttributes), key);
sb.AppendFormat("{0}={1}\r\n", propertyName, val.Value);
}
finally
{
PropVariant.Clear(variantPtr);
Marshal.FreeHGlobal(variantPtr);
}
}
/// <summary>
/// Gets all the mixer controls
/// </summary>
/// <param name="mixerHandle">Mixer Handle</param>
/// <param name="mixerLine">Mixer Line</param>
/// <param name="mixerHandleType">Mixer Handle Type</param>
/// <returns></returns>
public static IList <MixerControl> GetMixerControls(IntPtr mixerHandle, MixerLine mixerLine,
MixerFlags mixerHandleType)
{
var controls = new List <MixerControl>();
if (mixerLine.ControlsCount > 0)
{
int mixerControlSize = MarshalHelpers.SizeOf <MixerInterop.MIXERCONTROL>();
var mlc = new MixerInterop.MIXERLINECONTROLS();
IntPtr pmc = Marshal.AllocHGlobal(mixerControlSize * mixerLine.ControlsCount);
mlc.cbStruct = Marshal.SizeOf(mlc);
mlc.dwLineID = mixerLine.LineId;
mlc.cControls = mixerLine.ControlsCount;
mlc.pamxctrl = pmc;
mlc.cbmxctrl = MarshalHelpers.SizeOf <MixerInterop.MIXERCONTROL>();
try
{
MmResult err = MixerInterop.mixerGetLineControls(mixerHandle, ref mlc, MixerFlags.All | mixerHandleType);
if (err != MmResult.NoError)
{
throw new MmException(err, "mixerGetLineControls");
}
for (int i = 0; i < mlc.cControls; i++)
{
Int64 address = pmc.ToInt64() + mixerControlSize * i;
var mc =
MarshalHelpers.PtrToStructure <MixerInterop.MIXERCONTROL>((IntPtr)address);
var mixerControl = GetMixerControl(mixerHandle, mixerLine.LineId, mc.dwControlID, mixerLine.Channels,
mixerHandleType);
controls.Add(mixerControl);
}
}
finally
{
Marshal.FreeHGlobal(pmc);
}
}
return(controls);
}
private IntPtr GetPointerToPointer()
{
return(Marshal.AllocHGlobal(MarshalHelpers.SizeOf <IntPtr>()));
}
/// <summary>
/// Gets the control details
/// </summary>
protected void GetControlDetails()
{
mixerControlDetails.cbStruct = Marshal.SizeOf(mixerControlDetails);
mixerControlDetails.dwControlID = mixerControl.dwControlID;
if (IsCustom)
{
mixerControlDetails.cChannels = 0;
}
else if ((mixerControl.fdwControl & MixerInterop.MIXERCONTROL_CONTROLF_UNIFORM) != 0)
{
mixerControlDetails.cChannels = 1;
}
else
{
mixerControlDetails.cChannels = nChannels;
}
if ((mixerControl.fdwControl & MixerInterop.MIXERCONTROL_CONTROLF_MULTIPLE) != 0)
{
mixerControlDetails.hwndOwner = (IntPtr)mixerControl.cMultipleItems;
}
else if (IsCustom)
{
mixerControlDetails.hwndOwner = IntPtr.Zero; // TODO: special cases
}
else
{
mixerControlDetails.hwndOwner = IntPtr.Zero;
}
if (IsBoolean)
{
mixerControlDetails.cbDetails = MarshalHelpers.SizeOf <MixerInterop.MIXERCONTROLDETAILS_BOOLEAN>();
}
else if (IsListText)
{
mixerControlDetails.cbDetails = MarshalHelpers.SizeOf <MixerInterop.MIXERCONTROLDETAILS_LISTTEXT>();
}
else if (IsSigned)
{
mixerControlDetails.cbDetails = MarshalHelpers.SizeOf <MixerInterop.MIXERCONTROLDETAILS_SIGNED>();
}
else if (IsUnsigned)
{
mixerControlDetails.cbDetails = MarshalHelpers.SizeOf <MixerInterop.MIXERCONTROLDETAILS_UNSIGNED>();
}
else
{
// must be custom
mixerControlDetails.cbDetails = mixerControl.Metrics.customData;
}
var detailsSize = mixerControlDetails.cbDetails * mixerControlDetails.cChannels;
if ((mixerControl.fdwControl & MixerInterop.MIXERCONTROL_CONTROLF_MULTIPLE) != 0)
{
// fixing issue 16390 - calculating size correctly for multiple items
detailsSize *= (int)mixerControl.cMultipleItems;
}
IntPtr buffer = Marshal.AllocCoTaskMem(detailsSize);
// To copy stuff in:
// Marshal.StructureToPtr( theStruct, buffer, false );
mixerControlDetails.paDetails = buffer;
MmResult err = MixerInterop.mixerGetControlDetails(mixerHandle, ref mixerControlDetails,
MixerFlags.Value | mixerHandleType);
// let the derived classes get the details before we free the handle
if (err == MmResult.NoError)
{
GetDetails(mixerControlDetails.paDetails);
}
Marshal.FreeCoTaskMem(buffer);
if (err != MmResult.NoError)
{
throw new MmException(err, "mixerGetControlDetails");
}
}