public EntryPoint(
EasyHook.RemoteHooking.IContext context,
String channelName,
CaptureConfig config)
{
// Get reference to IPC to host application
// Note: any methods called or events triggered against _interface will execute in the host process.
_interface = EasyHook.RemoteHooking.IpcConnectClient<CaptureInterface>(channelName);
// We try to ping immediately, if it fails then injection fails
_interface.Ping();
#region Allow client event handlers (bi-directional IPC)
// Attempt to create a IpcServerChannel so that any event handlers on the client will function correctly
System.Collections.IDictionary properties = new System.Collections.Hashtable();
properties["name"] = channelName;
properties["portName"] = channelName + Guid.NewGuid().ToString("N"); // random portName so no conflict with existing channels of channelName
System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider binaryProv = new System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider();
binaryProv.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
System.Runtime.Remoting.Channels.Ipc.IpcServerChannel _clientServerChannel = new System.Runtime.Remoting.Channels.Ipc.IpcServerChannel(properties, binaryProv);
System.Runtime.Remoting.Channels.ChannelServices.RegisterChannel(_clientServerChannel, false);
#endregion
}
/// <summary>
/// Prepares capturing in the target process. Note that the process must not already be hooked, and must have a <see cref="Process.MainWindowHandle"/>.
/// </summary>
/// <param name="process">The process to inject into</param>
/// <exception cref="ProcessHasNoWindowHandleException">Thrown if the <paramref name="process"/> does not have a window handle. This could mean that the process does not have a UI, or that the process has not yet finished starting.</exception>
/// <exception cref="ProcessAlreadyHookedException">Thrown if the <paramref name="process"/> is already hooked</exception>
/// <exception cref="InjectionFailedException">Thrown if the injection failed - see the InnerException for more details.</exception>
/// <remarks>The target process will have its main window brought to the foreground after successful injection.</remarks>
public CaptureProcess(Process process, CaptureConfig config, CaptureInterface captureInterface)
{
// If the process doesn't have a mainwindowhandle yet, skip it (we need to be able to get the hwnd to set foreground etc)
//if (process.MainWindowHandle == IntPtr.Zero)
//{
// throw new ProcessHasNoWindowHandleException();
//}
// Skip if the process is already hooked (and we want to hook multiple applications)
if (HookManager.IsHooked(process.Id))
{
throw new ProcessAlreadyHookedException();
}
captureInterface.ProcessId = process.Id;
this._serverInterface = captureInterface;
//_serverInterface = new CaptureInterface() { ProcessId = process.Id };
// Initialise the IPC server (with our instance of _serverInterface)
this._screenshotServer = RemoteHooking.IpcCreateServer<CaptureInterface>(
ref this._channelName,
WellKnownObjectMode.Singleton,
this._serverInterface);
try
{
var location = typeof(CaptureInterface).Assembly.Location;
if (String.IsNullOrEmpty(location))
{
var dllName = typeof(CaptureInterface).Assembly.GetName().Name + ".dll";
location = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dllName);
}
// Inject DLL into target process
RemoteHooking.Inject(
process.Id,
InjectionOptions.Default,
location,
//"Capture.dll", // 32-bit version (the same because AnyCPU) could use different assembly that links to 32-bit C++ helper dll
location,
//"Capture.dll", // 64-bit version (the same because AnyCPU) could use different assembly that links to 64-bit C++ helper dll
// the optional parameter list...
this._channelName,
// The name of the IPC channel for the injected assembly to connect to
config
);
}
catch (Exception e)
{
throw new InjectionFailedException(e);
}
HookManager.AddHookedProcess(process.Id);
this.Process = process;
}
/// <summary>
/// Prepares capturing in the target process. Note that the process must not already be hooked, and must have a <see cref="Process.MainWindowHandle"/>.
/// </summary>
/// <param name="process">The process to inject into</param>
/// <exception cref="ProcessHasNoWindowHandleException">Thrown if the <paramref name="process"/> does not have a window handle. This could mean that the process does not have a UI, or that the process has not yet finished starting.</exception>
/// <exception cref="ProcessAlreadyHookedException">Thrown if the <paramref name="process"/> is already hooked</exception>
/// <exception cref="InjectionFailedException">Thrown if the injection failed - see the InnerException for more details.</exception>
/// <remarks>The target process will have its main window brought to the foreground after successful injection.</remarks>
public CaptureProcess(Process process, CaptureConfig config, CaptureInterface captureInterface)
{
// If the process doesn't have a mainwindowhandle yet, skip it (we need to be able to get the hwnd to set foreground etc)
if (process.MainWindowHandle == IntPtr.Zero)
{
throw new ProcessHasNoWindowHandleException();
}
// Skip if the process is already hooked (and we want to hook multiple applications)
if (HookManager.IsHooked(process.Id))
{
throw new ProcessAlreadyHookedException();
}
captureInterface.ProcessId = process.Id;
_serverInterface = captureInterface;
//_serverInterface = new CaptureInterface() { ProcessId = process.Id };
// Initialise the IPC server (with our instance of _serverInterface)
_screenshotServer = RemoteHooking.IpcCreateServer<CaptureInterface>(
ref _channelName,
WellKnownObjectMode.Singleton,
_serverInterface);
try
{
// Inject DLL into target process
RemoteHooking.Inject(
process.Id,
InjectionOptions.Default,
typeof(CaptureInterface).Assembly.Location,//"Capture.dll", // 32-bit version (the same because AnyCPU) could use different assembly that links to 32-bit C++ helper dll
typeof(CaptureInterface).Assembly.Location, //"Capture.dll", // 64-bit version (the same because AnyCPU) could use different assembly that links to 64-bit C++ helper dll
// the optional parameter list...
_channelName, // The name of the IPC channel for the injected assembly to connect to
config
);
}
catch (Exception e)
{
throw new InjectionFailedException(e);
}
HookManager.AddHookedProcess(process.Id);
Process = process;
// Ensure the target process is in the foreground,
// this prevents an issue where the target app appears to be in
// the foreground but does not receive any user inputs.
// Note: the first Alt+Tab out of the target application after injection
// may still be an issue - switching between windowed and
// fullscreen fixes the issue however (see ScreenshotInjection.cs for another option)
BringProcessWindowToFront();
}
public BaseDXHook(CaptureInterface ssInterface)
{
this.Interface = ssInterface;
this.Timer = new Stopwatch();
this.Timer.Start();
this.FPS = new FramesPerSecond();
Interface.ScreenshotRequested += InterfaceEventProxy.ScreenshotRequestedProxyHandler;
Interface.DisplayText += InterfaceEventProxy.DisplayTextProxyHandler;
InterfaceEventProxy.ScreenshotRequested += new ScreenshotRequestedEvent(InterfaceEventProxy_ScreenshotRequested);
InterfaceEventProxy.DisplayText += new DisplayTextEvent(InterfaceEventProxy_DisplayText);
}
public DXHookD3D9(CaptureInterface ssInterface)
: base(ssInterface)
{
}
protected BaseDXHook(CaptureInterface ssInterface)
{
this.Interface = ssInterface;
this.Interface.ScreenshotRequested += this.InterfaceEventProxy.ScreenshotRequestedProxyHandler;
this.InterfaceEventProxy.ScreenshotRequested += this.InterfaceEventProxy_ScreenshotRequested;
}
public DXHookD3D10_1(CaptureInterface ssInterface)
: base(ssInterface)
{
this.DebugMessage("Create");
}
private void AttachProcess()
{
string exeName = Path.GetFileNameWithoutExtension(textBox1.Text);
Process[] processes = Process.GetProcessesByName(exeName);
foreach (Process process in processes)
{
// Simply attach to the first one found.
// If the process doesn't have a mainwindowhandle yet, skip it (we need to be able to get the hwnd to set foreground etc)
if (process.MainWindowHandle == IntPtr.Zero)
{
continue;
}
// Skip if the process is already hooked (and we want to hook multiple applications)
if (HookManager.IsHooked(process.Id))
{
continue;
}
Direct3DVersion direct3DVersion = Direct3DVersion.Direct3D10;
if (rbDirect3D11.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D11;
}
else if (rbDirect3D10_1.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D10_1;
}
else if (rbDirect3D10.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D10;
}
else if (rbDirect3D9.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D9;
}
else if (rbAutodetect.Checked)
{
direct3DVersion = Direct3DVersion.AutoDetect;
}
CaptureConfig cc = new CaptureConfig()
{
Direct3DVersion = direct3DVersion,
ShowOverlay = cbDrawOverlay.Checked
};
processId = process.Id;
_process = process;
var captureInterface = new CaptureInterface();
captureInterface.RemoteMessage += new MessageReceivedEvent(CaptureInterface_RemoteMessage);
_captureProcess = new CaptureProcess(process, cc, captureInterface);
break;
}
Thread.Sleep(10);
if (_captureProcess == null)
{
MessageBox.Show("No executable found matching: '" + exeName + "'");
}
else
{
btnLoadTest.Enabled = true;
btnCapture.Enabled = true;
}
}
private void CreateCaptureProcess(Process process)
{
_process = process;
Direct3DVersion direct3DVersion = Direct3DVersion.Direct3D10;
if (rbDirect3D11.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D11;
}
else if (rbDirect3D10_1.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D10_1;
}
else if (rbDirect3D10.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D10;
}
else if (rbDirect3D9.Checked)
{
direct3DVersion = Direct3DVersion.Direct3D9;
}
else if (rbAutodetect.Checked)
{
direct3DVersion = Direct3DVersion.AutoDetect;
}
var cc = new CaptureConfig
{
Direct3DVersion = direct3DVersion,
ShowOverlay = cbDrawOverlay.Checked,
TestThisShit = 300
};
var captureInterface = new CaptureInterface();
if (frm2 != null)
{
frm2.Close();
frm2.Dispose();
}
frm2 = new form2JT(captureInterface);
captureInterface.RemoteMessage += CaptureInterface_RemoteMessage;
_captureProcess = new CaptureProcess(process, cc, captureInterface);
}
public form2JT(CaptureInterface captureInterface)
{
this.CaptureInterface = captureInterface;
this.StartPosition = FormStartPosition.CenterScreen;
InitializeComponent();
}
public DXHookD3D9SharedMem(CaptureInterface ssInterface)
: base(ssInterface)
{
var security = new MutexSecurity();
security.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow));
bool created;
sharedMemMutexes = new[]
{
new Mutex(false, "Global\\DXHookD3D9Shared0", out created, security),
new Mutex(false, "Global\\DXHookD3D9Shared1", out created, security)
};
var ewsecurity = new EventWaitHandleSecurity();
ewsecurity.AddAccessRule(new EventWaitHandleAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), EventWaitHandleRights.FullControl, AccessControlType.Allow));
captureWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset, "Global\\DXHookD3D9Capture", out created, ewsecurity);
hookReadyWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset, "Global\\DXHookD3D9CaptureReady", out created, ewsecurity);
}
private bool AttachHookToProcess()
{
if (attached)
{
return true;
}
var processes = Process.GetProcessesByName(HEARTHSTONE_PROCESS_NAME);
if (processes.Length <= 0)
{
Log.Debug("GetProcessesByName failed.");
return false;
}
var process = processes[0];
// Check incompatible modules:
foreach (ProcessModule module in process.Modules)
{
if (module.ModuleName.ToLower().StartsWith("rtsshooks"))
{
Publish(new IncompatibleHooksFound("RTSSHooks", "MSI Afterburner / Riva Tuner Statistics Server"));
}
}
//if (process.MainWindowHandle == IntPtr.Zero)
//{
// Log.Debug("Could not get MainWindowHandle.");
// return false;
//}
if (HookManager.IsHooked(process.Id))
{
return true;
}
if (captureProcess != null)
{
Log.Warn("Call DettachHookFromProcess first");
DettachHookFromProcess();
extraDelay = 200;
Thread.Sleep(200);
}
captureInterface = new CaptureInterface();
captureInterface.RemoteMessage += CaptureInterfaceOnRemoteMessage;
captureProcess = new CaptureProcess(process, captureConfig, captureInterface);
attached = true;
return true;
}
public DXHookD3D9Obs(CaptureInterface ssInterface)
: base(ssInterface)
{
InterfaceEventProxy.RecordingStarted += Interface_RecordingStarted;
InterfaceEventProxy.RecordingStopped += Interface_RecordingStopped;
}
public DebugListener(Capture.Interface.CaptureInterface captureInterface)
{
_captureInterface = captureInterface;
}
