public override DirectShowLib.IBaseFilter Create()
{
DirectShowLib.IBaseFilter result = null;
try
{
IntPtr handle = FromFile.LoadLibrary(this.path);
IntPtr dllGetClassObjectPointer = FromFile.GetProcAddress(handle, "DllGetClassObject");
//Convert the function pointer to a .net delegate
DllGetClassObject dllGetClassObject = (DllGetClassObject)System.Runtime.InteropServices.Marshal.GetDelegateForFunctionPointer(dllGetClassObjectPointer, typeof(DllGetClassObject));
System.Guid IClassFactoryGUID = new System.Guid("00000001-0000-0000-C000-000000000046"); //IClassFactory class id
object classFactory;
System.Guid identifier = this.Identifier;
if (dllGetClassObject(ref identifier, ref IClassFactoryGUID, out classFactory) == 0)
{
System.Guid iBaseFilter = new System.Guid("56a86895-0ad4-11ce-b03a-0020af0ba770");
object filter;
(classFactory as IClassFactory).CreateInstance(null, ref iBaseFilter, out filter);
result = filter as DirectShowLib.IBaseFilter;
}
}
catch (System.Exception e)
{
string message = "Filter \"" + this.Description + "\" could not find the file \"" + this.path.ToString() + "\".";
new DirectShow.Binding.Exception.FilterNotFound(Error.Level.Debug, message, e.Message).Throw();
}
if (result.IsNull())
{
result = base.Create();
}
return(result);
}
private static IClassFactory GetClassFactoryFromDll(string dllName, string filterPersistClass)
{
//Load the dll
IntPtr dllHandle=Win32NativeMethods.LoadLibrary(dllName);
if (dllHandle==IntPtr.Zero)
return null;
//Keep a reference to the dll until the process\AppDomain dies
_dllList.AddDllHandle(dllHandle);
//Get a pointer to the DllGetClassObject function
IntPtr dllGetClassObjectPtr=Win32NativeMethods.GetProcAddress(dllHandle, "DllGetClassObject");
if (dllGetClassObjectPtr==IntPtr.Zero)
return null;
//Convert the function pointer to a .net delegate
DllGetClassObject dllGetClassObject=(DllGetClassObject)Marshal.GetDelegateForFunctionPointer(dllGetClassObjectPtr, typeof(DllGetClassObject));
//Call the DllGetClassObject to retreive a class factory for out Filter class
Guid filterPersistGUID=new Guid(filterPersistClass);
Guid IClassFactoryGUID=new Guid("00000001-0000-0000-C000-000000000046"); //IClassFactory class id
Object unk;
if (dllGetClassObject(ref filterPersistGUID, ref IClassFactoryGUID, out unk)!=0)
return null;
//Yippie! cast the returned object to IClassFactory
return (unk as IClassFactory);
}
private static IntPtr FindProxyDllInfo(SafeLibraryHandle lib, Guid clsid)
{
try
{
GetProxyDllInfo get_proxy_dllinfo = lib.GetFunctionPointer <GetProxyDllInfo>();
IntPtr pInfo;
IntPtr pId;
get_proxy_dllinfo(out pInfo, out pId);
return(pInfo);
}
catch (Win32Exception)
{
}
IntPtr psfactory = IntPtr.Zero;
try
{
DllGetClassObject dll_get_class_object = lib.GetFunctionPointer <DllGetClassObject>();
Guid IID_IPSFactoryBuffer = COMInterfaceEntry.IID_IPSFactoryBuffer;
int hr = dll_get_class_object(ref clsid, ref IID_IPSFactoryBuffer, out psfactory);
if (hr != 0)
{
throw new Win32Exception(hr);
}
// The PSFactoryBuffer object seems to be structured like on Win10 at least.
// VTABLE*
// Reference Count
// ProxyFileInfo*
IntPtr pInfo = Marshal.ReadIntPtr(psfactory, 2 * IntPtr.Size);
// TODO: Should add better checks here,
// for example VTable should be in COMBASE and the pointer should be in the
// server DLL's rdata section. But this is probably good enough for now.
using (SafeLibraryHandle module = COMUtilities.SafeGetModuleHandle(pInfo))
{
if (module == null || lib.DangerousGetHandle() != module.DangerousGetHandle())
{
return(IntPtr.Zero);
}
}
return(pInfo);
}
catch (Win32Exception)
{
return(IntPtr.Zero);
}
finally
{
if (psfactory != IntPtr.Zero)
{
Marshal.Release(psfactory);
}
}
}
private static IUnknown NewRedemptionObject(Guid guid)
{
//try to set the thread COM apartment
//Thread.CurrentThread.ApartmentState = ApartmentState.STA;
object res = null;
lock (_criticalSection)
{
IClassFactory ClassFactory;
if (_redemptionDllHandle.Equals(IntPtr.Zero))
{
string dllPath;
if (IntPtr.Size == 8)
{
dllPath = DllLocation64Bit;
}
else
{
dllPath = DllLocation32Bit;
}
_redemptionDllHandle = Win32NativeMethods.LoadLibraryW(dllPath);
if (_redemptionDllHandle.Equals(IntPtr.Zero))
{
//throw new Exception(string.Format("Could not load '{0}'\nMake sure the dll exists.", dllPath));
throw new Win32Exception(Marshal.GetLastWin32Error());
}
_dllGetClassObjectPtr = Win32NativeMethods.GetProcAddress(_redemptionDllHandle, "DllGetClassObject");
if (_dllGetClassObjectPtr.Equals(IntPtr.Zero))
{
//throw new Exception("Could not retrieve a pointer to the 'DllGetClassObject' function exported by the dll");
throw new Win32Exception(Marshal.GetLastWin32Error());
}
_dllGetClassObject =
(DllGetClassObject)
Marshal.GetDelegateForFunctionPointer(_dllGetClassObjectPtr, typeof(DllGetClassObject));
}
Object unk;
int hr = _dllGetClassObject(ref guid, ref IID_IClassFactory, out unk);
if (hr != 0)
{
throw new Exception("DllGetClassObject failed with error code 0x" + hr.ToString("x8"));
}
ClassFactory = unk as IClassFactory;
ClassFactory.CreateInstance(null, ref IID_IUnknown, out res);
//If the same class factory is returned as the one still
//referenced by .Net, the call will be marshalled to the original thread
//where that class factory was retrieved first.
//Make .Net forget these objects
Marshal.ReleaseComObject(unk);
Marshal.ReleaseComObject(ClassFactory);
} //lock
return(res as IUnknown);
}
/// <summary>
/// Gets a class factory for a specific COM Class ID.
/// </summary>
/// <param name="dllName">The dll where the COM class is implemented.</param>
/// <param name="filterPersistClass">The requested Class ID.</param>
/// <returns>IClassFactory instance used to create instances of that class.</returns>
internal static IClassFactory GetClassFactory(string dllName, Guid filterPersistClass)
{
// Load the class factory from the dll.
// By specifying the flags we allow to search for dependencies in the same folder as the file to be loaded
// as well as default dirs like System32 and the Application folder.
IntPtr dllHandle = Utilities.SystemAPI.NativeMethods.LoadLibraryEx(dllName, IntPtr.Zero,
Utilities.SystemAPI.NativeMethods.LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | Utilities.SystemAPI.NativeMethods.LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
if (dllHandle == IntPtr.Zero)
{
return(null);
}
// Keep a reference to the dll until the process\AppDomain dies.
DLL_LIST.AddDllHandle(dllHandle);
//Get a pointer to the DllGetClassObject function
IntPtr dllGetClassObjectPtr = Utilities.SystemAPI.NativeMethods.GetProcAddress(dllHandle, "DllGetClassObject");
if (dllGetClassObjectPtr == IntPtr.Zero)
{
return(null);
}
// Convert the function pointer to a .net delegate.
DllGetClassObject dllGetClassObject = (DllGetClassObject)Marshal.GetDelegateForFunctionPointer(dllGetClassObjectPtr, typeof(DllGetClassObject));
// Call the DllGetClassObject to retreive a class factory for out Filter class.
Guid baseFilterGuid = filterPersistClass;
Guid classFactoryGuid = typeof(IClassFactory).GUID;
Object unk;
if (dllGetClassObject(ref baseFilterGuid, ref classFactoryGuid, out unk) != 0)
{
return(null);
}
return(unk as IClassFactory);
}
/// <summary>
/// Gets a class factory for a specific COM Class ID.
/// </summary>
/// <param name="dllName">The dll where the COM class is implemented</param>
/// <param name="filterPersistClass">The requested Class ID</param>
/// <returns>IClassFactory instance used to create instances of that class</returns>
/// <exception cref="System.Runtime.InteropServices.COMException">Thrown if the method can't creat COM-object</exception>
/// <exception cref="System.Runtime.DllNotFoundException">Thrown if the dll not found</exception>
public static IClassFactory GetClassFactory(string dllName, Guid filtersGuiid)
{
IntPtr dllHandle = loader.GetDLLHandle(dllName);
Object unk;
//Get a pointer to the DllGetClassObject function
IntPtr dllGetClassObjectPtr = GetProcAddress(dllHandle, "DllGetClassObject");
if (dllGetClassObjectPtr == IntPtr.Zero)
{
return(null);
}
//Call the DllGetClassObject to retreive a class factory for out Filter class
Guid IClassFactory_GUID = typeof(IClassFactory).GUID; //IClassFactory class id
//Convert the function pointer to a .net delegate
DllGetClassObject dllGetClassObject = (DllGetClassObject)Marshal.GetDelegateForFunctionPointer(dllGetClassObjectPtr, typeof(DllGetClassObject));
return((dllGetClassObject(ref filtersGuiid, ref IClassFactory_GUID, out unk) != 0) ? null : (unk as IClassFactory));
}
private static ClassFactoryWrapper GetClassFactoryFromDll(string dllName, string filterPersistClass)
{
//Load the dll
IntPtr dllHandle = LoadLibrary(dllName);
if (dllHandle == IntPtr.Zero)
{
return(null);
}
//Get a pointer to the DllGetClassObject function
IntPtr dllGetClassObjectPtr = GetProcAddress(dllHandle, "DllGetClassObject");
if (dllGetClassObjectPtr == IntPtr.Zero)
{
return(null);
}
//Convert the function pointer to a .net delegate
DllGetClassObject dllGetClassObject =
(DllGetClassObject)Marshal.GetDelegateForFunctionPointer(dllGetClassObjectPtr, typeof(DllGetClassObject));
//Call the DllGetClassObject to retreive a class factory for out Filter class
Guid filterPersistGuid = new Guid(filterPersistClass);
Guid classFactoryGuid = new Guid("00000001-0000-0000-C000-000000000046"); //IClassFactory class id
Object unk;
if (dllGetClassObject(ref filterPersistGuid, ref classFactoryGuid, out unk) != 0)
{
return(null);
}
IClassFactory result = unk as IClassFactory;
return(result != null ? new ClassFactoryWrapper(dllHandle, result) : null);
}
private static IClassFactory GetClassFactoryFromDll(string dllName, string filterPersistClass)
{
IntPtr dllHandle = Win32NativeMethods.LoadLibrary(dllName);
if (dllHandle == IntPtr.Zero)
{
return(null);
}
_dllList.AddDllHandle(dllHandle);
IntPtr dllGetClassObjectPtr = Win32NativeMethods.GetProcAddress(dllHandle, "DllGetClassObject");
if (dllGetClassObjectPtr == IntPtr.Zero)
{
return(null);
}
DllGetClassObject dllGetClassObject = (DllGetClassObject)Marshal.GetDelegateForFunctionPointer(dllGetClassObjectPtr, typeof(DllGetClassObject));
Guid filterPersistGUID = new Guid(filterPersistClass);
Guid IClassFactoryGUID = new Guid("00000001-0000-0000-C000-000000000046");
Object unk;
if (dllGetClassObject(ref filterPersistGUID, ref IClassFactoryGUID, out unk) != 0)
{
return(null);
}
return(unk as IClassFactory);
}
/// <summary>
/// Gets a class factory for a specific COM Class ID.
/// </summary>
/// <returns>IClassFactory instance used to create instances of that class.</returns>
public IBaseFilter GetFilter()
{
if (_filter != null)
{
return(_filter);
}
// Load the class factory from the dll.
// By specifying the flags we allow to search for dependencies in the same folder as the file to be loaded
// as well as default dirs like System32 and the Application folder.
List <uint> loadFlagsToTry = new List <uint>
{
Utilities.SystemAPI.NativeMethods.LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | Utilities.SystemAPI.NativeMethods.LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,
0x00000010 /*LOAD_IGNORE_CODE_AUTHZ_LEVEL*/,
0 /*NONE*/
};
_dllHandle = IntPtr.Zero;
foreach (var flags in loadFlagsToTry)
{
_dllHandle = Utilities.SystemAPI.NativeMethods.LoadLibraryEx(_dllName, IntPtr.Zero, flags);
if (_dllHandle != IntPtr.Zero)
{
break;
}
#if DEBUG
int error = Marshal.GetLastWin32Error();
ServiceRegistration.Get <ILogger>().Warn("Failed to load library {0}, Flags: {1:X}, HR: {2:X}", _dllName, flags, error);
#endif
}
if (_dllHandle == IntPtr.Zero)
{
return(null);
}
//Get a pointer to the DllGetClassObject function
IntPtr dllGetClassObjectPtr = Utilities.SystemAPI.NativeMethods.GetProcAddress(_dllHandle, "DllGetClassObject");
if (dllGetClassObjectPtr == IntPtr.Zero)
{
#if DEBUG
int error = Marshal.GetLastWin32Error();
ServiceRegistration.Get <ILogger>().Warn("Failed to GetProcAddress of DllGetClassObject in library {0} HR: {1:X}", _dllName, error);
return(null);
#endif
}
// Convert the function pointer to a .net delegate.
DllGetClassObject dllGetClassObject = (DllGetClassObject)Marshal.GetDelegateForFunctionPointer(dllGetClassObjectPtr, typeof(DllGetClassObject));
// Call the DllGetClassObject to retreive a class factory for out Filter class.
Guid classFactoryGuid = typeof(IClassFactory).GUID;
object unk;
if (dllGetClassObject(ref _classId, ref classFactoryGuid, out unk) != 0)
{
#if DEBUG
int error = Marshal.GetLastWin32Error();
ServiceRegistration.Get <ILogger>().Warn("Failed to get class factory in library {0} HR: {1:X}", _dllName, error);
#endif
return(null);
}
var classFactory = (unk as IClassFactory);
if (classFactory == null)
{
return(null);
}
// And create an IFilter instance using that class factory
Guid baseFilterGuid = typeof(IBaseFilter).GUID;
object obj;
classFactory.CreateInstance(null, ref baseFilterGuid, out obj);
Marshal.ReleaseComObject(classFactory);
_filter = obj as IBaseFilter;
return(_filter);
}
private static IUnknown NewRedemptionObject(Guid guid)
{
//try to set the thread COM apartment
//Thread.CurrentThread.ApartmentState = ApartmentState.STA;
object res = null;
lock (_criticalSection)
{
IClassFactory ClassFactory;
if (_redemptionDllHandle.Equals(IntPtr.Zero))
{
string dllPath;
if (IntPtr.Size == 8) dllPath = DllLocation64Bit;
else dllPath = DllLocation32Bit;
_redemptionDllHandle = Win32NativeMethods.LoadLibraryW(dllPath);
if (_redemptionDllHandle.Equals(IntPtr.Zero))
//throw new Exception(string.Format("Could not load '{0}'\nMake sure the dll exists.", dllPath));
throw new Win32Exception(Marshal.GetLastWin32Error());
_dllGetClassObjectPtr = Win32NativeMethods.GetProcAddress(_redemptionDllHandle, "DllGetClassObject");
if (_dllGetClassObjectPtr.Equals(IntPtr.Zero))
//throw new Exception("Could not retrieve a pointer to the 'DllGetClassObject' function exported by the dll");
throw new Win32Exception(Marshal.GetLastWin32Error());
_dllGetClassObject =
(DllGetClassObject)
Marshal.GetDelegateForFunctionPointer(_dllGetClassObjectPtr, typeof (DllGetClassObject));
}
Object unk;
int hr = _dllGetClassObject(ref guid, ref IID_IClassFactory, out unk);
if (hr != 0) throw new Exception("DllGetClassObject failed with error code 0x"+hr.ToString("x8"));
ClassFactory = unk as IClassFactory;
ClassFactory.CreateInstance(null, ref IID_IUnknown, out res);
//If the same class factory is returned as the one still
//referenced by .Net, the call will be marshalled to the original thread
//where that class factory was retrieved first.
//Make .Net forget these objects
Marshal.ReleaseComObject(unk);
Marshal.ReleaseComObject(ClassFactory);
} //lock
return (res as IUnknown);
}
