public HResult Shutdown()
{
Debug.WriteLine("StreamSink:Shutdown");
lock (this)
{
HResult hr = CheckShutdown();
if (Failed(hr))
{
return(hr);
}
if (EventQueue != null)
{
hr = EventQueue.Shutdown();
if (hr.Failed())
{
Debug.WriteLine("Could not shutdown EventQueue: " + hr.ToString() + " " + hr.GetDescription());
Debug.WriteLine("EventQueue Shutdown: " + hr.ToString() + " " + hr.GetDescription());
}
}
SafeRelease(MediaType);
MediaType = null;
SafeRelease(BaseSink);
BaseSink = null;
SafeRelease(EventQueue);
EventQueue = null;
State = StreamState.Finalized;
}
return(S_OK);
}
public void ToString_FormatsNumberAsDecimalOrName()
{
HResult hr = 0x80000000;
Assert.Equal("2147483648", hr.ToString());
hr = HResult.Code.E_INVALIDARG;
Assert.Equal("E_INVALIDARG", hr.ToString());
}
/// <include file='doc\COMException.uex' path='docs/doc[@for="COMException.ToString"]/*' />
public override String ToString()
{
String message = Message;
String s;
String _className = GetType().ToString();
s = _className + " (0x" + HResult.ToString("X8") + ")";
if (!(message == null || message.Length <= 0))
{
s = s + ": " + message;
}
Exception _innerException = InnerException;
if (_innerException != null)
{
s = s + " ---> " + _innerException.ToString();
}
if (StackTrace != null)
{
s += Environment.NewLine + StackTrace;
}
return(s);
}
private void LogIfFailed(HResult hr)
{
if (Failed(hr))
{
Debug.WriteLine("HResult Error: " + hr.ToString() + " " + hr.GetDescription());
}
}
public override String ToString()
{
String message = Message;
String s;
String _className = GetType().ToString();
s = _className + " (0x" + HResult.ToString("X8", CultureInfo.InvariantCulture) + ")";
if (!(String.IsNullOrEmpty(message)))
{
s = s + ": " + message;
}
Exception _innerException = InnerException;
if (_innerException != null)
{
s = s + " ---> " + _innerException.ToString();
}
if (StackTrace != null)
{
s += Environment.NewLine + StackTrace;
}
return(s);
}
/// <summary>
/// Returns a formatted, Unicode string representation of a property value.
/// </summary>
/// <param name="format">
/// One or more of the PropertyDescriptionFormat flags
/// that indicate the desired format.
/// </param>
/// <returns>
/// The formatted value as a string, or null if this property
/// cannot be formatted for display.
/// </returns>
public string FormatForDisplay(PropertyDescriptionFormatOptions format)
{
string formattedString;
if (Description == null || Description.NativePropertyDescription == null)
{
// We cannot do anything without a property description
return(null);
}
IPropertyStore store = ShellPropertyCollection.CreateDefaultPropertyStore(ParentShellObject);
using (PropVariant propVar = new PropVariant())
{
store.GetValue(ref propertyKey, propVar);
// Release the Propertystore
Marshal.ReleaseComObject(store);
store = null;
HResult hr = Description.NativePropertyDescription.FormatForDisplay(propVar, ref format,
out formattedString);
// Sometimes, the value cannot be displayed properly, such as for blobs
// or if we get argument exception
if (!CoreErrorHelper.Succeeded(hr))
{
throw new Exception(hr.ToString());
}
return(formattedString);
}
}
/// <summary>
/// Returns a string that contains the HRESULT of the error.
/// </summary>
/// <returns>A string that represents the HRESULT.</returns>
public override string ToString()
{
var builder = new StringBuilder();
builder.Append(GetType())
.Append(" (0x")
.Append(HResult.ToString("X8", CultureInfo.InvariantCulture))
.Append(")");
if (!string.IsNullOrEmpty(Message))
{
builder.Append(": ")
.Append(Message);
}
if (InnerException != null)
{
builder.Append(" ---> ")
.Append(InnerException);
}
if (StackTrace != null)
{
builder.Append(Environment.NewLine)
.Append(StackTrace);
}
return(builder.ToString());
}
internal static void CheckHr(HResult hr, string message)
{
if (hr != 0)
{
throw new COMException(message + " (" + hr.ToString() + ")", (int)hr);
}
}
public override string ToString()
{
string message = Message;
string className = GetType().ToString();
string s = className + " (0x" + HResult.ToString("X8", CultureInfo.InvariantCulture) + ")";
if (!string.IsNullOrEmpty(message))
{
s = s + ": " + message;
}
Exception?innerException = InnerException;
if (innerException != null)
{
s = s + Environment.NewLine + InnerExceptionPrefix + innerException.ToString();
}
if (StackTrace != null)
{
s += Environment.NewLine + StackTrace;
}
return(s);
}
public override bool TryStartVirtualizationInstance(Enlistment enlistment, out string error)
{
this.virtualizationInstance.OnStartDirectoryEnumeration = this.StartDirectoryEnumeration;
this.virtualizationInstance.OnEndDirectoryEnumeration = this.EndDirectoryEnumeration;
this.virtualizationInstance.OnGetDirectoryEnumeration = this.GetDirectoryEnumeration;
this.virtualizationInstance.OnQueryFileName = this.QueryFileName;
this.virtualizationInstance.OnGetPlaceholderInformation = this.GetPlaceholderInformation;
this.virtualizationInstance.OnGetFileStream = this.GetFileStream;
this.virtualizationInstance.OnNotifyFileHandleClosedFileModifiedOrDeleted = this.OnFileModifiedOrDeleted;
uint threadCount = (uint)Environment.ProcessorCount * 2;
NotificationMapping[] notificationMappings = new NotificationMapping[]
{
new NotificationMapping(NotificationType.FileHandleClosedFileModified, string.Empty),
};
HResult result = this.virtualizationInstance.StartVirtualizationInstance(
enlistment.SrcRoot,
poolThreadCount: threadCount,
concurrentThreadCount: threadCount,
enableNegativePathCache: false,
notificationMappings: notificationMappings);
if (result == HResult.Ok)
{
return(base.TryStartVirtualizationInstance(enlistment, out error));
}
error = result.ToString("F");
return(false);
}
public override string ToString()
{
StringBuilder s = new StringBuilder();
string className = GetType().ToString();
s.Append(className).Append(" (0x").Append(HResult.ToString("X8", CultureInfo.InvariantCulture)).Append(')');
string message = Message;
if (!string.IsNullOrEmpty(message))
{
s.Append(": ").Append(message);
}
Exception?innerException = InnerException;
if (innerException != null)
{
s.Append(Environment.NewLineConst + InnerExceptionPrefix).Append(innerException.ToString());
}
string?stackTrace = StackTrace;
if (stackTrace != null)
{
s.AppendLine().Append(stackTrace);
}
return(s.ToString());
}
/// <summary>
/// Sets folder logical view mode. The default settings are based on the FolderTypeID which is set
/// by the SearchFolder::SetFolderTypeID method.
/// </summary>
/// <param name="mode">The logical view mode to set.</param>
public void SetFolderLogicalViewMode(FolderLogicalViewMode mode)
{
HResult hr = NativeSearchFolderItemFactory.SetFolderLogicalViewMode(mode);
if (hr != HResult.S_OK)
{
throw new Exception(hr.ToString());
}
}
/// <summary>
/// Sets the search folder display name.
/// </summary>
public void SetDisplayName(string displayName)
{
HResult hr = NativeSearchFolderItemFactory.SetDisplayName(displayName);
if (hr != HResult.S_OK)
{
throw new Exception(hr.ToString());
}
}
/// <summary>
/// Sets a search folder type ID, as specified.
/// </summary>
public void SetFolderTypeID(Guid value)
{
HResult hr = NativeSearchFolderItemFactory.SetFolderTypeID(value);
if (hr != HResult.S_OK)
{
throw new Exception(hr.ToString());
}
}
/// <summary>
/// Sets the search folder icon size.
/// The default settings are based on the FolderTypeID which is set by the
/// SearchFolder::SetFolderTypeID method.
/// </summary>
public void SetIconSize(int value)
{
HResult hr = NativeSearchFolderItemFactory.SetIconSize(value);
if (hr != HResult.S_OK)
{
throw new Exception(hr.ToString());
}
}
public override bool TryConvertVirtualizationRoot(string directory, out string error)
{
error = string.Empty;
HResult result = VirtualizationInstance.ConvertDirectoryToVirtualizationRoot(Guid.NewGuid(), directory);
if (result != HResult.Ok)
{
error = result.ToString("F");
return(false);
}
return(true);
}
/// <summary>
/// Updates the native shell item that maps to this shell object. This is necessary when the shell item
/// changes after the shell object has been created. Without this method call, the retrieval of properties will
/// return stale data.
/// </summary>
/// <param name="bindContext">Bind context object</param>
public void Update(IBindCtx bindContext)
{
HResult hr = HResult.Ok;
if (NativeShellItem2 != null)
{
hr = NativeShellItem2.Update(bindContext);
}
if (CoreErrorHelper.Failed(hr))
{
throw new Exception(hr.ToString());
}
}
/// <summary>
/// Inject a <see cref="Assembly">Assembly</see> in the target process and
/// invoke the specified method.
/// </summary>
/// <param name="AssemblyPath">The <see cref="Assembly">Assembly</see> file path</param>
/// <param name="TypeName">The Full Name to the method class</param>
/// <param name="MethodName">The Method Name in the Class</param>
/// <param name="Argument">A Argument to give to the invoke method</param>
/// <returns>The returned value from the invoked method</returns>
public int CLRInvoke(string AssemblyPath, string TypeName, string MethodName, string Argument)
{
if (!(MIntPtr)ExecuteInDefaultAppDomain)
{
StartCLR();
}
IntPtr Ret = Target.MAlloc(new byte[4]);
IntPtr AsmPath = Target.MAllocString(AssemblyPath, true);
IntPtr TpName = Target.MAllocString(TypeName, true);
IntPtr MthdName = Target.MAllocString(MethodName, true);
IntPtr Arg = Target.MAllocString(Argument, true);
HResult Failed = (MIntPtr <HResult>)Invoke(ExecuteInDefaultAppDomain, CLRRuntimeHost, AsmPath, TpName, MthdName, Arg, Ret);
switch (Failed)
{
case HResult.S_OK:
break;
case HResult.HOST_E_CLRNOTAVAILABLE:
if (CLRNOTAVAILABLE)
{
goto default;
}
CLRNOTAVAILABLE = true;
ExecuteInDefaultAppDomain = IntPtr.Zero;
return(CLRInvoke(AssemblyPath, TypeName, MethodName, Argument));
default:
throw new Exception($"Error: {Failed.ToString()} (0x{((uint)Failed).ToString("X8")})");
}
int Result = Target.Read(Ret, 4).ToInt32();
Target.MFree(AsmPath);
Target.MFree(TpName);
Target.MFree(MthdName);
Target.MFree(Arg);
Target.MFree(Ret);
return(Result);
}
/// <summary>
/// Returns a known folder given a globally unique identifier.
/// </summary>
/// <param name="knownFolderId">A GUID for the requested known folder.</param>
/// <returns>A known folder representing the specified name.</returns>
/// <exception cref="System.ArgumentException">Thrown if the given Known Folder ID is invalid.</exception>
public static IKnownFolder FromKnownFolderId(Guid knownFolderId)
{
IKnownFolderNative knownFolderNative;
KnownFolderManagerClass knownFolderManager = new KnownFolderManagerClass();
HResult hr = knownFolderManager.GetFolder(knownFolderId, out knownFolderNative);
if (hr != HResult.S_OK)
{
throw new Exception(hr.ToString());
}
IKnownFolder kf = GetKnownFolder(knownFolderNative);
if (kf == null)
{
throw new ArgumentException("Invalid GUID", "knownFolderId");
}
return(kf);
}
public override bool TryStartVirtualizationInstance(Enlistment enlistment, out string error)
{
this.virtualizationInstance.OnQueryFileName = this.QueryFileName;
this.virtualizationInstance.OnNotifyPreDelete = this.OnPreDelete;
this.virtualizationInstance.OnNotifyNewFileCreated = this.OnNewFileCreated;
this.virtualizationInstance.OnNotifyFileHandleClosedFileModifiedOrDeleted = this.OnFileModifiedOrDeleted;
this.virtualizationInstance.OnNotifyFileRenamed = this.OnFileRenamed;
this.virtualizationInstance.OnNotifyHardlinkCreated = this.OnHardlinkCreated;
this.virtualizationInstance.OnNotifyFilePreConvertToFull = this.OnFilePreConvertToFull;
uint threadCount = (uint)Environment.ProcessorCount * 2;
NotificationMapping[] notificationMappings = new NotificationMapping[]
{
new NotificationMapping(
NotificationType.NewFileCreated |
NotificationType.PreDelete |
NotificationType.FileRenamed |
NotificationType.HardlinkCreated |
NotificationType.FileHandleClosedFileModified,
string.Empty),
};
this.virtualizationInstance = new VirtualizationInstance(
enlistment.SrcRoot,
poolThreadCount: threadCount,
concurrentThreadCount: threadCount,
enableNegativePathCache: false,
notificationMappings: notificationMappings);
HResult result = this.virtualizationInstance.StartVirtualizing(this);
if (result == HResult.Ok)
{
return(base.TryStartVirtualizationInstance(enlistment, out error));
}
error = result.ToString("F");
return(false);
}
/// <summary>
/// Retrieves an array of the sub-conditions.
/// </summary>
public IEnumerable <SearchCondition> GetSubConditions()
{
// Our list that we'll return
var subConditionsList = new List <SearchCondition>();
// Get the sub-conditions from the native API
object subConditionObj;
var guid = new Guid(InterfaceGuids.IEnumUnknown);
HResult hr = NativeSearchCondition.GetSubConditions(ref guid, out subConditionObj);
if (hr != HResult.S_OK)
{
throw new Exception(hr.ToString());
}
// Convert each ICondition to SearchCondition
if (subConditionObj != null)
{
var enumUnknown = subConditionObj as IEnumUnknown;
IntPtr buffer = IntPtr.Zero;
uint fetched = 0;
while (hr == HResult.S_OK)
{
hr = enumUnknown.Next(1, ref buffer, ref fetched);
if (hr == HResult.S_OK && fetched == 1)
{
subConditionsList.Add(new SearchCondition((ICondition)Marshal.GetObjectForIUnknown(buffer)));
}
}
}
return(subConditionsList);
}
// Using an Impl method allows TryPrepareFolderForCallbacks to catch any ProjFS dependency related exceptions
// thrown in the process of calling this method.
private bool TryPrepareFolderForCallbacksImpl(string folderPath, out string error)
{
error = string.Empty;
Guid virtualizationInstanceGuid = Guid.NewGuid();
HResult result = VirtualizationInstance.ConvertDirectoryToVirtualizationRoot(virtualizationInstanceGuid, folderPath);
if (result != HResult.Ok)
{
error = "Failed to prepare \"" + folderPath + "\" for callbacks, error: " + result.ToString("F");
return(false);
}
return(true);
}
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
/// <summary>
/// This gets called when a Called IMFSourceReader.ReadSample method completes
/// (assuming the SourceReader has been given this class during setup with
/// an attribute of MFAttributesClsid.MF_SOURCE_READER_ASYNC_CALLBACK).
///
/// The first ReadSample triggers it after that it continues by itself
/// </summary>
/// <param name="hrStatus">The status code. If an error occurred while processing the next sample, this parameter contains the error code.</param>
/// <param name="streamIndex">The zero-based index of the stream that delivered the sample.</param>
/// <param name="streamFlags">A bitwise OR of zero or more flags from the MF_SOURCE_READER_FLAG enumeration.</param>
/// <param name="sampleTimeStamp">The time stamp of the sample, or the time of the stream event indicated in streamFlags. The time is given in 100-nanosecond units. </param>
/// <param name="mediaSample">A pointer to the IMFSample interface of a media sample. This parameter might be NULL.</param>
/// <returns>Returns an HRESULT value. Reputedly, the source reader ignores the return value.</returns>
/// <history>
/// 01 Nov 18 Cynic - Started
/// </history>
public HResult OnReadSample(HResult hrStatus, int streamIndex, MF_SOURCE_READER_FLAG streamFlags, long sampleTimeStamp, IMFSample mediaSample)
{
HResult hr = HResult.S_OK;
try
{
lock (this)
{
// are we capturing? if not leave
if (IsCapturing() == false)
{
return(HResult.S_OK);
}
// have we got an error?
if (Failed(hrStatus))
{
string errMsg = "OnReadSample, Error on call =" + hrStatus.ToString();
SourceReaderAsyncCallBackError(this, errMsg, null);
return(hrStatus);
}
// have we got a sample? It seems this can be null on the first sample
// in after the ReadSample that triggered this. So we just ignore it
// and request the next to get things rolling
if (mediaSample != null)
{
/* This rebases the timestamps coming off the webcam so that
* the first one starts at zero. Not needed in later versions
* of WMF apparently. It seems the Media Sink now does this automatically
*
* If the data is not being written correctly, try uncommenting this.
*
* // we have a sample, if so is it the first non null one?
* if (isFirstSample)
* {
* // yes it is set up our timestamp
* firstSampleBaseTime = sampleTimeStamp;
* isFirstSample = false;
* }
*
* // Samples have a time stamp and a duration. The time stamp indicates when the data in the sample
* // should be rendered, relative to the presentation clock. The duration is the length of time
* // for which the data should be rendered.
* //
* // We now set the presentation time of the sample. This is the presentation time
* // in 100-nanosecond units. We rebase this using the first sample
* // processed as zero.
*
* // rebase the time stamp
* sampleTimeStamp -= firstSampleBaseTime;
* hr = mediaSample.SetSampleTime(sampleTimeStamp);
* if (Failed(hr))
* {
* string errMsg = "OnReadSample, Error on SetSampleTime =" + hr.ToString();
* SourceReaderAsyncCallBackError(this, errMsg, null);
* return hr;
* } */
// write the sample out
hr = sinkWriter.WriteSample(0, mediaSample);
if (Failed(hr))
{
string errMsg = "OnReadSample, Error on WriteSample =" + hr.ToString();
SourceReaderAsyncCallBackError(this, errMsg, null);
return(hr);
}
}
// Read another sample.
hr = (sourceReader as IMFSourceReaderAsync).ReadSample(
TantaWMFUtils.MF_SOURCE_READER_FIRST_VIDEO_STREAM,
0,
IntPtr.Zero, // actual
IntPtr.Zero, // flags
IntPtr.Zero, // timestamp
IntPtr.Zero // sample
);
if (Failed(hr))
{
string errMsg = "OnReadSample, Error on ReadSample =" + hr.ToString();
SourceReaderAsyncCallBackError(this, errMsg, null);
return(hr);
}
}
}
catch (Exception ex)
{
if (SourceReaderAsyncCallBackError != null)
{
SourceReaderAsyncCallBackError(this, ex.Message, ex);
}
}
finally
{
SafeRelease(mediaSample);
}
return(hr);
}
// NotifyState: Notifies the application when an error occurs.
protected void NotifyError(HResult hr)
{
TRACE("NotifyError: 0x" + hr.ToString("X"));
PostMessage(m_hwndEvent, WM_APP_PREVIEW_ERROR, new IntPtr((int)hr), IntPtr.Zero);
}
/// <summary>
/// Inject the CLR in the target process
/// </summary>
/// <param name="Version">Version to load in the target process</param>
/// <returns>A Pointer to the <a href="https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/iclrruntimehost-executeindefaultappdomain-method">ExecuteInDefaultAppDomain</a> function</returns>
public void StartCLR(FrameworkVersion Version = FrameworkVersion.DotNet40)
{
if (!IsCompatibleProcess())
{
throw new Exception($"The Target Process isn't an {(Environment.Is64BitProcess ? "x64" : "x32")} Process");
}
if (Debugging)
{
WaitInitialize();
}
if (IsManaged)
{
ResumeProcess();
}
IntPtr ICLRMetaHost = Target.MAlloc(new byte[IntPtr.Size]); //http://source.roslyn.codeplex.com/#Microsoft.CodeAnalysis/Interop/IClrMetaHost.cs
IntPtr ICLRRuntimeInfo = Target.MAlloc(new byte[IntPtr.Size]); //http://source.roslyn.codeplex.com/#microsoft.codeanalysis/Interop/IClrRuntimeInfo.cs,485a48c96d61baeb,references
IntPtr ICLRRuntimeHost = Target.MAlloc(new byte[IntPtr.Size]); //https://github.com/CentroEPiaggio/SoftLEGS-Project/blob/5b2eb55b8f43f07189118e477bd4e5c0114f6c8e/casadi-matlabR2013a-v3.1.1/casadi/jit/mingw/mscoree.h#L1230
IntPtr CLSID_CLRMetaHost = Target.MAlloc(new Guid("9280188D-0E8E-4867-B30C-7FA83884E8DE").ToByteArray());
IntPtr CLSID_CLRRuntimeHost = Target.MAlloc(new Guid("90F1A06E-7712-4762-86B5-7A5EBA6BDB02").ToByteArray());
IntPtr IID_ICLRMetaHost = Target.MAlloc(new Guid("D332DB9E-B9B3-4125-8207-A14884F53216").ToByteArray());
IntPtr IID_ICLRRuntimeInfo = Target.MAlloc(new Guid("BD39D1D2-BA2F-486A-89B0-B4B0CB466891").ToByteArray());
IntPtr IID_ICLRRuntimeHost = Target.MAlloc(new Guid("90F1A06C-7712-4762-86B5-7A5EBA6BDB02").ToByteArray());
HResult Result = (MIntPtr <HResult>)Invoke("mscoree.dll", "CLRCreateInstance", CLSID_CLRMetaHost, IID_ICLRMetaHost, ICLRMetaHost);
if (Result != HResult.S_OK)
{
throw new Exception($"Error: {Result.ToString()} (0x{((uint)Result).ToString("X8")})");
}
byte[] Data = Target.Read(ICLRMetaHost, (uint)IntPtr.Size);
IntPtr GetRuntime = Data.ToIntPtr(x64Bits);
IntPtr MetaHostIntance = GetRuntime;
Data = Target.Read(GetRuntime, (uint)IntPtr.Size);
GetRuntime = Data.ToIntPtr(x64Bits).Sum(IntPtr.Size * 3);//1st function, The vTable have 3 pointers before the first function
Data = Target.Read(GetRuntime, (uint)IntPtr.Size);
GetRuntime = Data.ToIntPtr(x64Bits);
IntPtr pVersion = Target.MAllocString(DotNetVerName(FrameworkVersion.DotNet40), true);
Result = (MIntPtr <HResult>)Invoke(GetRuntime, MetaHostIntance, pVersion, IID_ICLRRuntimeInfo, ICLRRuntimeInfo);
if (Result != HResult.S_OK)
{
throw new Exception($"Error: {Result.ToString()} (0x{((uint)Result).ToString("X8")})");
}
Data = Target.Read(ICLRRuntimeInfo, (uint)IntPtr.Size);
IntPtr GetInterface = Data.ToIntPtr(x64Bits);
IntPtr RuntimeInfoInstance = GetInterface;
Data = Target.Read(GetInterface, (uint)IntPtr.Size);
GetInterface = Data.ToIntPtr(x64Bits);
Data = Target.Read(GetInterface.Sum(IntPtr.Size * 9), (uint)IntPtr.Size);//6th Function + vTable Prefix
GetInterface = Data.ToIntPtr(x64Bits);
Result = (MIntPtr <HResult>)Invoke(GetInterface, RuntimeInfoInstance, CLSID_CLRRuntimeHost, IID_ICLRRuntimeHost, ICLRRuntimeHost);
if (Result != HResult.S_OK)
{
throw new Exception($"Error: {Result.ToString()} (0x{((uint)Result).ToString("X8")})");
}
Data = Target.Read(ICLRRuntimeHost, (uint)IntPtr.Size);
IntPtr Start = Data.ToIntPtr(x64Bits);
IntPtr HostInstance = Start;
Data = Target.Read(Start, (uint)IntPtr.Size);
Start = Data.ToIntPtr(x64Bits);
if (IsManaged || (CLRAvaliable() && !CLRNOTAVAILABLE))
{
Data = Target.Read(Start.Sum(IntPtr.Size * 11), (uint)IntPtr.Size);
ExecuteInDefaultAppDomain = Data.ToIntPtr(x64Bits);
Target.MFree(ICLRMetaHost);
Target.MFree(ICLRRuntimeInfo);
Target.MFree(ICLRRuntimeHost);
Target.MFree(CLSID_CLRMetaHost);
Target.MFree(CLSID_CLRRuntimeHost);
Target.MFree(IID_ICLRMetaHost);
Target.MFree(IID_ICLRRuntimeHost);
Target.MFree(pVersion);
return;
}
Data = Target.Read(Start.Sum(IntPtr.Size * 3), (uint)IntPtr.Size);
Start = Data.ToIntPtr(x64Bits);
Result = (MIntPtr <HResult>)Invoke(Start, HostInstance);
if (Result != HResult.S_OK)
{
throw new Exception($"Error: {Result.ToString()} (0x{((uint)Result).ToString("X8")})");
}
Data = Target.Read(ICLRRuntimeHost, (uint)IntPtr.Size);
ExecuteInDefaultAppDomain = Data.ToIntPtr(x64Bits);
CLRRuntimeHost = ExecuteInDefaultAppDomain;
Data = Target.Read(ExecuteInDefaultAppDomain, (uint)IntPtr.Size);
ExecuteInDefaultAppDomain = Data.ToIntPtr(x64Bits);
Data = Target.Read(ExecuteInDefaultAppDomain.Sum(IntPtr.Size * 11), (uint)IntPtr.Size);
ExecuteInDefaultAppDomain = Data.ToIntPtr(x64Bits);
Target.MFree(ICLRMetaHost);
Target.MFree(ICLRRuntimeInfo);
Target.MFree(ICLRRuntimeHost);
Target.MFree(CLSID_CLRMetaHost);
Target.MFree(CLSID_CLRRuntimeHost);
Target.MFree(IID_ICLRMetaHost);
Target.MFree(IID_ICLRRuntimeHost);
Target.MFree(pVersion);
}
// NotifyState: Notifies the application when an error occurs.
protected void NotifyError(HResult hr)
{
TRACE("NotifyError: 0x" + hr.ToString("X"));
m_state = PlayerState.Ready;
PostMessage(m_hwndEvent, WM_APP_ERROR, new IntPtr((int)hr), IntPtr.Zero);
}
/// <summary>
/// This is the routine that performs the transform. Unless the sinkWriter object
/// is set all we do is pass the sample on. If the sink writer object is set
/// we give the sample to it for writing. There are two modes - one where we just
/// give the sinkwriter the input sample and the other where we clone the input
/// sample and rebase the timestamps.
///
/// An override of the abstract version in MFTBase_Sync.
/// </summary>
/// <param name="pOutputSamples">The structure to populate with output values.</param>
/// <returns>S_Ok unless error.</returns>
protected override HResult OnProcessOutput(ref MFTOutputDataBuffer outputSampleDataStruct)
{
HResult hr = HResult.S_OK;
IMFMediaBuffer inputMediaBuffer = null;
IMFSample sinkWriterSample = null;
IMFAttributes sampleAttributes;
// in this MFT we are processing in place, the input sample is the output sample, the media buffer of the
// input sample is the media buffer of the output sample. Thats for the pipeline. If a sink writer exists
// we also write the sample data out to the sink writer. This provides the effect of displaying on the
// screen and simultaneously recording.
// There are two ways the sink writer can be given the media sample data. It can just be given the
// input sample directly or a copy of the sample can be made and that copy given to the sink writer.
// There is also an additional complication - the sample has a timestamp and video cameras tend
// to just use the current date and time as a timestamp. There are several reports that MP4 files
// need to have their first frame starting at zero and then every subsequent frame adjusted to that
// new base time. Certainly the Microsoft supplied example code (and see the
// CaptureToFileViaReaderWriter also) take great care to do this. This requirement does not
// seem to exist - my tests indicate it is not necessary to start from 0 in the mp4 file. Maybe the
// Sink Writer has been improved and now does this automatically. For demonstration purposes
// the timebase-rebase functionality has been included and choosing that mode copies the sample
// and resets the time. If the user does not rebase the time we simply send the input sample
// to the Sink Writer as-is.
try
{
// Set status flags.
outputSampleDataStruct.dwStatus = MFTOutputDataBufferFlags.None;
// The output sample is the input sample. We get a new IUnknown for the Input
// sample since we are going to release it below. The client will release this
// new IUnknown
outputSampleDataStruct.pSample = Marshal.GetIUnknownForObject(InputSample);
// are we recording?
if (workingSinkWriter != null)
{
// we do everything in a lock
lock (sinkWriterLockObject)
{
// are we in timebase rebase mode?
if (wantTimebaseRebase == false)
{
// we are not. Just give the input sample to the Sink Writer which will
// write it out.
hr = workingSinkWriter.WriteSample(sinkWriterVideoStreamId, InputSample);
if (hr != HResult.S_OK)
{
throw new Exception("OnProcessOutput call to WriteSample(a) failed. Err=" + hr.ToString());
}
}
else
{
// the timebase rebase option has been chosen. We need to create a copy of the input sample
// so we can adjust the time on it.
// Get the data buffer from the input sample. If the sample contains more than one buffer,
// this method copies the data from the original buffers into a new buffer, and replaces
// the original buffer list with the new buffer. The new buffer is returned in the inputMediaBuffer parameter.
// If the sample contains a single buffer, this method returns a pointer to the original buffer.
// In typical use, most samples do not contain multiple buffers.
hr = InputSample.ConvertToContiguousBuffer(out inputMediaBuffer);
if (hr != HResult.S_OK)
{
throw new Exception("OnProcessOutput call to InputSample.ConvertToContiguousBuffer failed. Err=" + hr.ToString());
}
// get some other things from the input sample
hr = InputSample.GetSampleDuration(out long sampleDuration);
if (hr != HResult.S_OK)
{
throw new Exception("OnProcessOutput call to InputSample.GetSampleDuration failed. Err=" + hr.ToString());
}
hr = InputSample.GetTotalLength(out int sampleSize);
if (hr != HResult.S_OK)
{
throw new Exception("OnProcessOutput call to InputSample.GetTotalLength failed. Err=" + hr.ToString());
}
hr = InputSample.GetSampleTime(out long sampleTimeStamp);
if (hr != HResult.S_OK)
{
throw new Exception("OnProcessOutput call to InputSample.GetSampleTime failed. Err=" + hr.ToString());
}
// get the attributes from the input sample
if (InputSample is IMFAttributes)
{
sampleAttributes = (InputSample as IMFAttributes);
}
else
{
sampleAttributes = null;
}
// we have all the information we need to create a new output sample
sinkWriterSample = WMFUtils.CreateMediaSampleFromBuffer(sampleTimeStamp, sampleDuration, inputMediaBuffer, sampleSize, sampleAttributes);
if (sinkWriterSample == null)
{
throw new Exception("OnProcessOutput, Error on call to CreateMediaSampleFromBuffer sinkWriterSample == null");
}
// we have a sample, if so is it the first non null one?
if (isFirstSample)
{
// yes it is set up our timestamp
firstSampleBaseTime = sampleTimeStamp;
isFirstSample = false;
}
// rebase the time stamp
sampleTimeStamp -= firstSampleBaseTime;
hr = sinkWriterSample.SetSampleTime(sampleTimeStamp);
if (hr != HResult.S_OK)
{
throw new Exception("OnProcessOutput call to InputSample.SetSampleTime failed. Err=" + hr.ToString());
}
// write the sample out
hr = workingSinkWriter.WriteSample(sinkWriterVideoStreamId, sinkWriterSample);
if (hr != HResult.S_OK)
{
throw new Exception("OnProcessOutput call to WriteSample(b) failed. Err=" + hr.ToString());
}
}
}
}
}
finally
{
// clean up
if (inputMediaBuffer != null)
{
Marshal.ReleaseComObject(inputMediaBuffer);
}
if (sinkWriterSample != null)
{
Marshal.ReleaseComObject(sinkWriterSample);
}
// Release the current input sample so we can get another one.
// the act of setting it to null releases it because the property
// is coded that way
InputSample = null;
}
return(HResult.S_OK);
}
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
/// <summary>
/// Constructor
/// </summary>
/// <history>
/// 01 Nov 18 Cynic - Originally Written
/// </history>
public frmMain()
{
bool retBOOL = false;
HResult hr = 0;
if (DesignMode == false)
{
// set the current directory equal to the exe directory. We do this because
// people can start from a link and if the start-in directory is not right
// it can put the log file in strange places
Directory.SetCurrentDirectory(Application.StartupPath);
// set up the Singleton g_Logger instance. Simply using it in a test
// creates it.
if (g_Logger == null)
{
// did not work, nothing will start say so now in a generic way
MessageBox.Show("Logger Class Failed to Initialize. Nothing will work well.");
return;
}
// record this in the logger for everybodys use
g_Logger.ApplicationMainForm = this;
g_Logger.DefaultDialogBoxTitle = APPLICATION_NAME;
try
{
// set the icon for this form and for all subsequent forms
g_Logger.AppIcon = new Icon(GetType(), "App.ico");
this.Icon = new Icon(GetType(), "App.ico");
}
catch (Exception)
{
}
// Register the global error handler as soon as we can in Main
// to make sure that we catch as many exceptions as possible
// this is a last resort. All execeptions should really be trapped
// and handled by the code.
OISGlobalExceptions ex1 = new OISGlobalExceptions();
Application.ThreadException += new ThreadExceptionEventHandler(ex1.OnThreadException);
// set the culture so our numbers convert consistently
System.Threading.Thread.CurrentThread.CurrentCulture = g_Logger.GetDefaultCulture();
}
InitializeComponent();
if (DesignMode == false)
{
// set up our logging
retBOOL = g_Logger.InitLogging(DEFAULTLOGDIR, APPLICATION_NAME, false);
if (retBOOL == false)
{
// did not work, nothing will start say so now in a generic way
MessageBox.Show("The log file failed to create. No log file will be recorded.");
}
// pump out the header
g_Logger.EmitStandardLogfileheader(APPLICATION_NAME);
LogMessage("");
LogMessage("Version: " + APPLICATION_VERSION);
LogMessage("");
// we always have to initialize MF. The 0x00020070 here is the WMF version
// number used by the MF.Net samples. Not entirely sure if it is appropriate
hr = MFExtern.MFStartup(0x00020070, MFStartup.Full);
if (hr != 0)
{
LogMessage("Constructor: call to MFExtern.MFStartup returned " + hr.ToString());
}
// some initial configuration
this.textBoxVideoFileNameAndPath.Text = INITIALFILE;
ctlTantaEVRFilePlayer1.VideoFileAndPathToPlay = INITIALFILE;
// set our heartbeat going
LaunchHeartBeat();
}
}
public static string GetDescription(this HResult HResult)
{
return(HResult.GetType().GetField(HResult.ToString())?.GetCustomAttribute <DescriptionAttribute>()?.Description);
}
protected void CreateOutputNode(
IMFStreamDescriptor pSourceSD,
out IMFTopologyNode ppNode
)
{
IMFTopologyNode pNode = null;
IMFMediaTypeHandler pHandler = null;
IMFActivate pRendererActivate = null;
Guid guidMajorType = Guid.Empty;
HResult hr = HResult.S_OK;
// Get the stream ID.
int streamID = 0;
try
{
try
{
hr = pSourceSD.GetStreamIdentifier(out streamID); // Just for debugging, ignore any failures.
MFError.ThrowExceptionForHR(hr);
}
catch
{
TRACE("IMFStreamDescriptor::GetStreamIdentifier" + hr.ToString());
}
// Get the media type handler for the stream.
hr = pSourceSD.GetMediaTypeHandler(out pHandler);
MFError.ThrowExceptionForHR(hr);
// Get the major media type.
hr = pHandler.GetMajorType(out guidMajorType);
MFError.ThrowExceptionForHR(hr);
// Create a downstream node.
hr = MFExtern.MFCreateTopologyNode(MFTopologyType.OutputNode, out pNode);
MFError.ThrowExceptionForHR(hr);
// Create an IMFActivate object for the renderer, based on the media type.
if (MFMediaType.Audio == guidMajorType)
{
// Create the audio renderer.
TRACE(string.Format("Stream {0}: audio stream", streamID));
hr = MFExtern.MFCreateAudioRendererActivate(out pRendererActivate);
MFError.ThrowExceptionForHR(hr);
}
else if (MFMediaType.Video == guidMajorType)
{
// Create the video renderer.
TRACE(string.Format("Stream {0}: video stream", streamID));
hr = MFExtern.MFCreateVideoRendererActivate(m_hwndVideo, out pRendererActivate);
MFError.ThrowExceptionForHR(hr);
}
else
{
TRACE(string.Format("Stream {0}: Unknown format", streamID));
throw new COMException("Unknown format", (int)HResult.E_FAIL);
}
// Set the IActivate object on the output node.
hr = pNode.SetObject(pRendererActivate);
MFError.ThrowExceptionForHR(hr);
// Return the IMFTopologyNode pointer to the caller.
ppNode = pNode;
}
catch
{
// If we failed, release the pNode
SafeRelease(pNode);
throw;
}
finally
{
// Clean up.
SafeRelease(pHandler);
SafeRelease(pRendererActivate);
}
}
