(pVals[i]);
475 | }
476 | std::string monitorName(ws.begin(), ws.end());
477 | monitorInfo.friendlyDisplayNames.push_back(monitorName);
478 |
479 | SafeArrayUnaccessData(sa);
480 | monitorInfo.success = true;
481 | }
482 | }
483 | VariantClear(&vtProp);
484 |
485 | pclsObj->Release();
486 | }
487 |
488 | // Cleanup
489 | pSvc->Release();
490 | pLoc->Release();
491 | pEnumerator->Release();
492 | CoUninitialize();
493 |
494 | return monitorInfo;
495 | }
496 |
497 | // Function to check if ParsecVDA is among the friendly display names
498 | void CheckForParsecVDA() {
499 | while (running) {
500 | std::this_thread::sleep_for(std::chrono::seconds(1)); // Cannot be too long, otherwise joining the thread takes just as long aswell
501 |
502 | MonitorInfo monitorInfo = GetMonitorFriendlyNamesUsingWMI();
503 |
504 | if (!monitorInfo.success) {
505 | ParsecVDAfound = true; // Added in the event the query fails, otherwise it would cause the program to always disconnect and reconnect the display
506 | return;
507 | }
508 |
509 | bool ParsecVDAresult = std::any_of(monitorInfo.friendlyDisplayNames.begin(), monitorInfo.friendlyDisplayNames.end(), [](const std::string& name) {
510 | return name.find("ParsecVDA") != std::string::npos;
511 | });
512 |
513 | if (!ParsecVDAresult) {
514 | std::this_thread::sleep_for(std::chrono::seconds(3)); // This is triggered before the driver crash event. Ensures that this is only logged if its not a driver crash
515 | ParsecVDAfound = false;
516 | }
517 | }
518 | }
519 |
520 | // Function for disconnecting the display or doing the cleanup procedure in case of a driver crash or a lost display
521 | void SleepCrashAction() {
522 | while (!finalshutdown) {
523 | std::this_thread::sleep_for(std::chrono::milliseconds(50));
524 |
525 | if (receivedeventsleep || receivedeventdrivercrash || !ParsecVDAfound) {
526 | if (!cleanupstarted) {
527 | if (receivedeventdrivercrash) {
528 | Log("Driver crashed!");
529 | }
530 | else if (receivedeventsleep) {
531 | Log("Cleanup code reached!");
532 | }
533 | else if (!ParsecVDAfound) {
534 | Log("ParsecVDA not found!");
535 | }
536 | cleanupstarted = true; // Solves reaching the cleanup procedure twice, because it it quite common to receive EventID 187 and 42 right after each other
537 | running = false;
538 | suspend = true;
539 | if (receivedeventsleep) {
540 | for (int index : displays) {
541 | VddRemoveDisplay(vdd, index);
542 | }
543 | }
544 | if (updater.joinable()) {
545 | updater.join();
546 | }
547 | if (CheckForParsecVDAThread.joinable()) {
548 | CheckForParsecVDAThread.join();
549 | }
550 | // Close the device handle.
551 | CloseDeviceHandle(vdd);
552 | Log("Cleanup done!");
553 | stopmainloop = true; // In the end, so that the main loop not finishes until cleanup routine is done
554 | }
555 | }
556 | }
557 | }
558 |
559 | // Function for connecting the monitor
560 | int MainLoop() {
561 | Log("New Session started!");
562 |
563 | // Check driver status.
564 | bool firstattemptfail = false;
565 | DeviceStatus status = QueryDeviceStatus(&VDD_CLASS_GUID, VDD_HARDWARE_ID);
566 | if (status != DEVICE_OK) {
567 | Log("Parsec VDD device is not OK. Trying to recover the driver!");
568 | if (DriverRecover(deviceInstanceId)) {
569 | DeviceStatus status = QueryDeviceStatus(&VDD_CLASS_GUID, VDD_HARDWARE_ID);
570 | if (status != DEVICE_OK) {
571 | firstattemptfail = true;
572 | Log("Parsec VDD device is not OK. Trying a second time!");
573 | }
574 | else if (status == DEVICE_OK) {
575 | Log("Parsec VDD device recovered!");
576 | }
577 | }
578 | else {
579 | firstattemptfail = true;
580 | Log("Parsec VDD device is not OK. Trying a second time!");
581 | }
582 | if (firstattemptfail == true) {
583 | std::this_thread::sleep_for(std::chrono::seconds(2));
584 | if (DriverRecover(deviceInstanceId)) {
585 | DeviceStatus status = QueryDeviceStatus(&VDD_CLASS_GUID, VDD_HARDWARE_ID);
586 | if (status != DEVICE_OK) {
587 | Log("Parsec VDD device is not OK. Exiting program!");
588 | return 1;
589 | }
590 | Log("Parsec VDD device recovered!");
591 | }
592 | else {
593 | Log("Parsec VDD device is not OK. Exiting program!");
594 | return 1;
595 | }
596 | }
597 | }
598 |
599 | // Obtain device handle.
600 | vdd = OpenDeviceHandle(&VDD_ADAPTER_GUID);
601 | if (vdd == NULL || vdd == INVALID_HANDLE_VALUE) {
602 | Log("Failed to obtain the device handle. Trying a second time!");
603 | std::this_thread::sleep_for(std::chrono::seconds(2));
604 | if (vdd == NULL || vdd == INVALID_HANDLE_VALUE) {
605 | Log("Failed to obtain the device handle. Exiting program!");
606 | return 1;
607 | }
608 | }
609 |
610 | // Side thread for updating vdd.
611 | updater = std::thread([] {
612 | while (running) {
613 | VddUpdate(vdd);
614 | std::this_thread::sleep_for(std::chrono::milliseconds(100));
615 | }
616 | });
617 |
618 | //Ad the Display
619 | if (displays.size() < VDD_MAX_DISPLAYS) {
620 | int index = VddAddDisplay(vdd);
621 | displays.push_back(index);
622 | displays.resize(index+1); // Important! Without it, the size increases in every run of the MainLoop!
623 | char logMessageDisplay[100];
624 | snprintf(logMessageDisplay, sizeof(logMessageDisplay), "Added a new virtual display, index: %d.", index);
625 | Log(logMessageDisplay);
626 | }
627 | else {
628 | Log("Limit exceeded, could not add more virtual displays.");
629 | }
630 |
631 | // Start the thread to periodically check if display is still connected
632 | CheckForParsecVDAThread = std::thread(CheckForParsecVDA);
633 |
634 | // Let the program run indefinitely
635 | while (running || !stopmainloop) {
636 | std::this_thread::sleep_for(std::chrono::milliseconds(10)); // Sleep briefly to avoid high CPU usage
637 | }
638 |
639 | return 0;
640 | }
641 |
642 | int main() {
643 |
644 | // Open log file
645 | if (!OpenLogFile()) {
646 | printf("Error opening log file.\n");
647 | return 1;
648 | }
649 |
650 | // Set console control handler to listen for CTRL_C_EVENT
651 | if (!SetConsoleCtrlHandler(ConsoleHandler, TRUE)) {
652 | Log("Error setting console control handler.");
653 | return 1;
654 | }
655 |
656 | // Start the threads to periodically check for system events and execute sleep action
657 | std::thread SystemEventThread(CheckSystemEventLog);
658 | std::thread SleepCrashActionThread(SleepCrashAction);
659 |
660 | // Start the main loop and manage the occurring states
661 | while (!finalshutdown) {
662 | if (!suspend) {
663 | MainLoopResult = MainLoop();
664 | if (MainLoopResult != 0) {
665 | finalshutdown = true;
666 | }
667 | }
668 | else if (suspend) {
669 | if (receivedeventsleep) {
670 | Log("Suspend stage reached.");
671 | while (!receivedeventwake) {
672 | std::this_thread::sleep_for(std::chrono::milliseconds(50));
673 | }
674 | // Prevent race hazard between !receivedeventwake and systemalreadyawake
675 | std::this_thread::sleep_for(std::chrono::milliseconds(50));
676 | }
677 | // Second waiting time is necessary for three reasons:
678 | // EventID 107 is received so early, that adding a virtual display right after receiving the message is in some cases not possible.
679 | // Furthermore, while systemalreadyawake is true, other EventIDs (506 and 507 after waking from hibernation with modern standby enabled)
680 | // can not be triggered, as intended, because we already received a wakeup event.
681 | // In the event of driver crash a waiting time is necessary before the Parsec Virtual Display Adapter can be disabled and re-enabled.
682 | if (systemalreadyawake || receivedeventdrivercrash || !ParsecVDAfound) {
683 | std::this_thread::sleep_for(std::chrono::seconds(3));
684 | }
685 | receivedeventsleep = false;
686 | receivedeventwake = false;
687 | receivedeventdrivercrash = false;
688 | systemalreadyawake = false;
689 | ParsecVDAfound = true;
690 | suspend = false;
691 | running = true;
692 | cleanupstarted = false;
693 | stopmainloop = false;
694 | }
695 | }
696 |
697 | // Join the threads
698 | if (SystemEventThread.joinable()) {
699 | SystemEventThread.join();
700 | }
701 | if (SleepCrashActionThread.joinable()) {
702 | SleepCrashActionThread.join();
703 | }
704 |
705 | Log("Program is closing!");
706 | fclose(logfile); // Close log file
707 |
708 | return MainLoopResult;
709 | }
--------------------------------------------------------------------------------
/ParsecVDAAC.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | ParsecVDAAC
5 | ParsecVDA - Always Connected
6 | This service adds a Virtual Display to your system.
7 |
8 |
9 | %BASE%\ParsecVDA - Always Connected.exe
10 |
11 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | 
3 |
ParsecVDA - Always Connected
4 |
5 | Connects a Virtual Display to your PC
6 |
7 | and allows for a headless operation -
8 |
9 | no need for Dummy Plugs anymore!
10 |
11 |
12 |
13 |
14 |
15 | ## ℹ About
16 |
17 | This project is based on the "parsec-vdd" project from nomi-san. It adds a Virtual Display to your system by using the [Parsec VDD Driver](https://support.parsec.app/hc/en-us/articles/4422939339789-Overview-Prerequisites-and-Installation), without relying on the [Parsec app](https://parsec.app/).
18 |
19 | With the newest release this application runs as a service in the background by using the Windows Service Wrapper [winsw](https://github.com/winsw/winsw). The Virtual Display will stay connected until the next shutdown or restart even when disconnecting through remote apps like Parsec, which is an important feature of this project.
20 |
21 | The latest update also allows the program to correctly handle sleep and hibernation events. Modern Standby is also supported.
22 |
23 | With this application it is possible to run a PC completely headless without relying on Dummy Plugs.
24 |
25 | Furthermore this program can be used in the Hyper-V environment in combination with GPU-Paravirtualization (see GPU-PV) where it is not possible to disconnect the Hyper-V-Monitor which leads to Parsec not automatically falling back to its Virtual Display. This program adds a Virtual Display nonetheless.
26 |
27 |
28 |
29 | > The Virtual Display Driver (VDD) is required to enable virtual displays on a Windows host. Virtual displays is a feature available for **Teams** and **Warp** customers that lets you add up to 3 additional virtual displays to the host while connecting to a machine you own through Parsec.
30 |
31 | > **Parsec VDD** is a perfect software driver developed by Parsec. It utilizes the [IddCx API](https://learn.microsoft.com/en-us/windows-hardware/drivers/display/indirect-display-driver-model-overview) (Indirect Display Driver) to create virtual displays on Windows 10+. This virtual display is particularly useful in situations where a physical monitor may not be available or when additional screens are desired.
32 |
33 | > One of the notable features of Parsec VDD is its support for a wide range of [resolutions and refresh rates](#preset-display-modes), including up to 4K and 240 Hz. This makes it well-suited for gaming, as it can provide a high-quality visual experience. It enables users to simulate the presence of additional screens or work without a physical monitor, enhancing flexibility and customization in display management.
34 |
35 |
36 | ## Steps to get it running:
37 |
38 | 1. Download the latest release and follow the instructions of the Setup Wizard.
39 |
40 | That's all you have to do! A Virtual Display should be added to your system!
41 |
42 |
43 | ## Notes:
44 |
45 | - If you receive a Windows Defender Smartscreen prompt when executing the setup, click on "More info" and then on "Run anyway".
46 | - You will hear a connect/disconnect sound at startup/shutdown and at sleep/hibernation events because the Virtual Display is added/removed at every start/shutdown or sleep/hibernation event.
47 | - If you're using this program together with Parsec, you have to make sure that "Fallback to Virtual Display" in the Parsec App settings under Host is set to off.
48 | - The program also creates a basic logfile in its working directory.
49 | - If you used the application before version 1.2.0, please uninstall it before installing the new version.
50 |
51 | ## Stopping the service:
52 |
53 | If you want to stop the service, are encountering problems or if you want to remove the screen, type "Services" in the Windows search bar and open the application with the same name. Look for the service "ParsecVDA - Always Connected". After clicking on it options for stopping or restarting the service are in the left upper corner.
54 |
55 | ## 😥 Known Limitations
56 |
57 | > This list shows the known limitations of Parsec VDD.
58 |
59 | ### 1. HDR support
60 |
61 | Parsec VDD does not support HDR on its displays (see the EDID below). Theoretically, you can unlock support by editing the EDID, then adding HDR metadata and setting 10-bit+ color depth. Unfortunately, you cannot flash its firmware like a physical device, or modify the registry value.
62 |
63 | All IDDs have their own fixed EDID block inside the driver binary to initialize the monitor specs. So the solution is to modify this block in the driver DLL (mm.dll), then reinstall it with nefconw CLI (see Readme instructions in the project "parsec-vdd" from nomi-san).
64 |
65 |
66 | ### 2. Custom resolutions
67 |
68 | Before connecting, the virtual display looks in the `HKEY_LOCAL_MACHINE\SOFTWARE\Parsec\vdd` registry for additional preset resolutions. Currently this supports a maximum of 5 values.
69 |
70 | ```
71 | SOFTWARE\Parsec\vdd
72 | key: 0 -> 5 | (width, height, hz)
73 | ```
74 |
75 | To unlock this limit, you need to patch the driver DLL the same way as above, but **5 is enough** for personal use.
76 |
77 | ## 😑 Known Bugs
78 |
79 | > This is a list of known issues when working with standalone Parsec VDD.
80 |
81 | ### 1. Incompatible with Parsec Privacy Mode
82 |
83 | 
84 |
85 | If you have enabled "Privacy Mode" in Parsec Host settings, please disable it and clear the connected display configruations in the following Registry path.
86 |
87 | ```
88 | HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\Connectivity
89 | ```
90 |
91 | This option causes your main display to turn off when virtual displays are added, making it difficult to turn the display on and disrupting the remote desktop session.
92 |
93 | ## 🤔 Comparison with other IDDs
94 |
95 | The table below shows a comparison with other popular Indirect Display Driver projects.
96 |
97 | | Project | Iddcx version | Signed | Gaming | HDR | H-Cursor | Tweakable | Controller
98 | | :-- | :--: | :--: | :--: | :--: | :--: | :-: | :-:
99 | | [usbmmidd_v2] | | ✅ | ❌ | ❌ | ❌ | |
100 | | [IddSampleDriver] | 1.2 | ❌ | ❌ | ❌ | ❌ | |
101 | | [RustDeskIddDriver] | 1.2 | ❌ | ❌ | ❌ | ❌ | |
102 | | [Virtual-Display-Driver (HDR)] | 1.10 | ❌ | | ✅ | ❌ | |
103 | | [virtual-display-rs] | 1.5 | ❌ | | ❌ | ❌ | ✅ | ✅
104 | | parsec-vdd | 1.4 | ✅ | ✅ | ❌ | ✅ | 🆗 | ✅
105 |
106 | ✅ - full support, 🆗 - limited support
107 |
108 | [usbmmidd_v2]: https://www.amyuni.com/forum/viewtopic.php?t=3030
109 | [IddSampleDriver]: https://github.com/roshkins/IddSampleDriver
110 | [RustDeskIddDriver]: https://github.com/fufesou/RustDeskIddDriver
111 | [virtual-display-rs]: https://github.com/MolotovCherry/virtual-display-rs
112 | [Virtual-Display-Driver (HDR)]: https://github.com/itsmikethetech/Virtual-Display-Driver
113 |
114 | **Signed** means that the driver files have a valid digital signature.
115 | **H-Cursor** means hardware cursor support, without it you will get double cursor on some remote desktop apps.
116 | **Tweakable** is the ability to customize display modes. Visit [MSDN IddCx versions](https://learn.microsoft.com/en-us/windows-hardware/drivers/display/iddcx-versions) to check the minimum supported Windows version.
117 |
118 | ## 📘 Parsec VDD Specs
119 |
120 | ### Preset display modes
121 |
122 | All of the following display modes are set by driver default.
123 |
124 | | Resolution | Common name | Aspect ratio | Refresh rates (Hz)
125 | | - | :-: | :-: | :-:
126 | | 4096 x 2160 | DCI 4K | 1.90:1 (256:135) | 24/30/60/144/240
127 | | 3840 x 2160 | 4K UHD | 16:9 | 24/30/60/144/240
128 | | 3840 x 1600 | UltraWide | 24:10 | 24/30/60/144/240
129 | | 3840 x 1080 | UltraWide | 32:9 (2x 16:9 FHD) | 24/30/60/144/240
130 | | 3440 x 1440 | | 21.5:9 (43:18) | 24/30/60/144/240
131 | | 3240 x 2160 | | 3:2 | 60
132 | | 3200 x 1800 | 3K | 16:9 | 24/30/60/144/240
133 | | 3000 x 2000 | | 3:2 | 60
134 | | 2880 x 1800 | 2.8K | 16:10 | 60
135 | | 2880 x 1620 | 2.8K | 16:9 | 24/30/60/144/240
136 | | 2736 x 1824 | | | 60
137 | | 2560 x 1600 | 2K | 16:10 | 24/30/60/144/240
138 | | 2560 x 1440 | 2K | 16:9 | 24/30/60/144/240
139 | | 2560 x 1080 | UltraWide | 21:9 | 24/30/60/144/240
140 | | 2496 x 1664 | | | 60
141 | | 2256 x 1504 | | | 60
142 | | 2048 x 1152 | | | 60/144/240
143 | | 1920 x 1200 | FHD | 16:10 | 60/144/240
144 | |**1920 x 1080**| **FHD** | **16:9** | 24/30/**60**/144/240
145 | | 1800 x 1200 | FHD | 3:2 | 60
146 | | 1680 x 1050 | HD+ | 16:10 | 60/144/240
147 | | 1600 x 1200 | HD+ | 4:3 | 24/30/60/144/240
148 | | 1600 x 900 | HD+ | 16:9 | 60/144/240
149 | | 1440 x 900 | HD | 16:10 | 60/144/240
150 | | 1366 x 768 | | | 60/144/240
151 | | 1280 x 800 | HD | 16:10 | 60/144/240
152 | | 1280 x 720 | HD | 16:9 | 60/144/240
153 |
154 | Notes:
155 | - Low GPUs, e.g GTX 1650 will not support the highest DCI 4K.
156 | - All resolutions are compatible with 60 Hz refresh rates.
157 |
158 |
159 | ### Adapter info
160 |
161 | - Name: `Parsec Virtual Display Adapter`
162 | - Hardware ID: `Root\Parsec\VDA`
163 | - Adapter GUID: `{00b41627-04c4-429e-a26e-0265cf50c8fa}`
164 | - Class GUID: `{4d36e968-e325-11ce-bfc1-08002be10318}`
165 |
166 | ### Monitor info
167 |
168 | - ID: `PSCCDD0`
169 | - Name: `ParsecVDA`
170 | - EDID:
171 |
172 | ```
173 | 00 FF FF FF FF FF FF 00 42 63 D0 CD ED 5F 84 00
174 | 11 1E 01 04 A5 35 1E 78 3B 57 E0 A5 54 4F 9D 26
175 | 12 50 54 27 CF 00 71 4F 81 80 81 40 81 C0 81 00
176 | 95 00 B3 00 01 01 86 6F 80 A0 70 38 40 40 30 20
177 | 35 00 E0 0E 11 00 00 1A 00 00 00 FD 00 30 A5 C1
178 | C1 29 01 0A 20 20 20 20 20 20 00 00 00 FC 00 50
179 | 61 72 73 65 63 56 44 41 0A 20 20 20 00 00 00 10
180 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 C6
181 | 02 03 10 00 4B 90 05 04 03 02 01 11 12 13 14 1F
182 | 8A 4D 80 A0 70 38 2C 40 30 20 35 00 E0 0E 11 00
183 | 00 1A FE 5B 80 A0 70 38 35 40 30 20 35 00 E0 0E
184 | 11 00 00 1A FC 7E 80 88 70 38 12 40 18 20 35 00
185 | E0 0E 11 00 00 1E A4 9C 80 A0 70 38 59 40 30 20
186 | 35 00 E0 0E 11 00 00 1A 02 3A 80 18 71 38 2D 40
187 | 58 2C 45 00 E0 0E 11 00 00 1E 00 00 00 00 00 00
188 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 A6
189 | ```
190 |
191 | Visit http://www.edidreader.com/ to view it online or use an advanced tool [AW EDID Editor](https://www.analogway.com/apac/products/software-tools/aw-edid-editor/)
192 |
--------------------------------------------------------------------------------
/Setup.bat:
--------------------------------------------------------------------------------
1 | @echo off
2 | setlocal
3 |
4 | IF "%1"=="install" (
5 | rem Run install and start commands
6 | ParsecVDAAC.exe install
7 | ParsecVDAAC.exe start
8 | )
9 |
10 | IF "%1"=="uninstall" (
11 | rem Run stop and uninstall commands, delete created files
12 | ParsecVDAAC.exe stopwait
13 | ParsecVDAAC.exe uninstall
14 | del "%~dp0Logfile ParsecVDA - Always Connected.txt"
15 | del "%~dp0ParsecVDAAC.err.log"
16 | del "%~dp0ParsecVDAAC.out.log"
17 | del "%~dp0ParsecVDAAC.wrapper.log"
18 | )
19 |
20 | IF "%1"=="" (
21 | echo Missing argument! Valid arguments are "install" or "uninstall".
22 | )
23 |
24 | endlocal
--------------------------------------------------------------------------------
/Setup.iss:
--------------------------------------------------------------------------------
1 | #define MyAppName "ParsecVDA - Always Connected"
2 | #define MyAppVersion "1.4.1"
3 | #define MyAppURL "https://github.com/timminator/ParsecVDA-Always-Connected"
4 | #define MyAppExeName "ParsecVDA - Always Connected.exe"
5 |
6 | #define _Major
7 | #define _Minor
8 | #define _Rev
9 | #define _Build
10 | #define VddVersion GetVersionComponents(".\parsec-vdd-setup.exe", _Major, _Minor, _Rev, _Build), Str(_Major) + "." + Str(_Minor)
11 |
12 | [Setup]
13 | SignTool=signtool $f
14 | AppId={{4EC2E655-53B0-4B4A-A3C9-42C445FA22CE}
15 | AppName={#MyAppName}
16 | AppVersion={#MyAppVersion}
17 | AppPublisherURL={#MyAppURL}
18 | AppSupportURL={#MyAppURL}
19 | AppUpdatesURL={#MyAppURL}
20 | DefaultDirName={commonpf64}\{#MyAppName}
21 | UsePreviousAppDir=yes
22 | LicenseFile=..\..\LICENSE
23 | DisableProgramGroupPage=yes
24 | PrivilegesRequired=admin
25 | OutputBaseFilename={#MyAppName}-v{#MyAppVersion}-setup-x64
26 | SetupIconFile=..\..\parsec.ico
27 | Compression=lzma
28 | SolidCompression=yes
29 | WizardStyle=classic
30 | UninstallDisplayName={#MyAppName}
31 | UninstallDisplayIcon={app}\{#MyAppExeName}
32 |
33 | [Languages]
34 | Name: "english"; MessagesFile: "compiler:Default.isl"
35 |
36 | [Messages]
37 | SelectTasksLabel2=Select the additional tasks you would like Setup to perform.%nParsecVDA - Always Connected requires the Parsec Virtual Display Driver. If the driver is already installed, you can uncheck this task. To continue, click Next.
38 | FinishedLabel=Setup has finished installing [name] on your computer.%n%nAdditional notice: If you are using this software in combination with the Parsec App, make sure that under Settings > Host > "Fallback to Virtual Display" is set to off.
39 |
40 | [Dirs]
41 | Name: "{app}"; Permissions: everyone-full
42 |
43 | [Files]
44 | Source: ".\{#MyAppExeName}"; DestDir: "{app}"; Flags: ignoreversion
45 | Source: ".\parsec-vdd-setup.exe"; DestDir: "{app}\driver"
46 | Source: ".\Setup.bat"; DestDir: "{app}"; Flags: ignoreversion
47 | Source: ".\CheckPrerequisites.bat"; DestDir: "{app}"; Flags: ignoreversion
48 | Source: ".\ParsecVDAAC.xml"; DestDir: "{app}"; Flags: onlyifdoesntexist
49 | Source: ".\ParsecVDAAC.exe"; DestDir: "{app}"; Flags: onlyifdoesntexist
50 | Source: ".\LICENSE_parsec-vdd.txt"; Flags: dontcopy
51 | Source: ".\LICENSE_winsw.txt"; Flags: dontcopy
52 |
53 | [Code]
54 | procedure RunBatchFile(FileName: String; WorkingDir: String);
55 | var
56 | ResultCode: Integer;
57 | begin
58 | Exec(ExpandConstant(FileName), '', WorkingDir, SW_HIDE, ewWaitUntilTerminated, ResultCode);
59 | end;
60 |
61 | function PrepareToInstall(var NeedsRestart: Boolean): String;
62 | begin
63 | ExtractTemporaryFile('CheckPrerequisites.bat');
64 | RunBatchFile('{tmp}\CheckPrerequisites.bat', ExpandConstant('{app}'));
65 | Result := '';
66 | end;
67 |
68 | var
69 | LicenseAcceptedRadioButtons: array of TRadioButton;
70 |
71 | procedure CheckLicenseAccepted(Sender: TObject);
72 | begin
73 | // Update Next button when user (un)accepts the license
74 | WizardForm.NextButton.Enabled :=
75 | LicenseAcceptedRadioButtons[TComponent(Sender).Tag].Checked;
76 | end;
77 |
78 | procedure LicensePageActivate(Sender: TWizardPage);
79 | begin
80 | // Update Next button when user gets to second license page
81 | CheckLicenseAccepted(LicenseAcceptedRadioButtons[Sender.Tag]);
82 | end;
83 |
84 | function CloneLicenseRadioButton(
85 | Page: TWizardPage; Source: TRadioButton): TRadioButton;
86 | begin
87 | Result := TRadioButton.Create(WizardForm);
88 | Result.Parent := Page.Surface;
89 | Result.Caption := Source.Caption;
90 | Result.Left := Source.Left;
91 | Result.Top := Source.Top;
92 | Result.Width := Source.Width;
93 | Result.Height := Source.Height;
94 | // Needed for WizardStyle=modern / WizardResizable=yes
95 | Result.Anchors := Source.Anchors;
96 | Result.OnClick := @CheckLicenseAccepted;
97 | Result.Tag := Page.Tag;
98 | end;
99 |
100 | var
101 | LicenseAfterPage: Integer;
102 |
103 | procedure AddLicensePage(LicenseFileName: string);
104 | var
105 | Idx: Integer;
106 | Page: TOutputMsgMemoWizardPage;
107 | LicenseFilePath: string;
108 | RadioButton: TRadioButton;
109 | begin
110 | Idx := GetArrayLength(LicenseAcceptedRadioButtons);
111 | SetArrayLength(LicenseAcceptedRadioButtons, Idx + 1);
112 |
113 | Page :=
114 | CreateOutputMsgMemoPage(
115 | LicenseAfterPage, SetupMessage(msgWizardLicense),
116 | SetupMessage(msgLicenseLabel), SetupMessage(msgLicenseLabel3), '');
117 | Page.Tag := Idx;
118 |
119 | // Shrink license box to make space for radio buttons
120 | Page.RichEditViewer.Height := WizardForm.LicenseMemo.Height;
121 | Page.OnActivate := @LicensePageActivate;
122 |
123 | // Load license
124 | // Loading ex-post, as Lines.LoadFromFile supports UTF-8,
125 | // contrary to LoadStringFromFile.
126 | ExtractTemporaryFile(LicenseFileName);
127 | LicenseFilePath := ExpandConstant('{tmp}\' + LicenseFileName);
128 | Page.RichEditViewer.Lines.LoadFromFile(LicenseFilePath);
129 | DeleteFile(LicenseFilePath);
130 |
131 | // Clone accept/do not accept radio buttons
132 | RadioButton :=
133 | CloneLicenseRadioButton(Page, WizardForm.LicenseAcceptedRadio);
134 | LicenseAcceptedRadioButtons[Idx] := RadioButton;
135 |
136 | RadioButton :=
137 | CloneLicenseRadioButton(Page, WizardForm.LicenseNotAcceptedRadio);
138 | // Initially not accepted
139 | RadioButton.Checked := True;
140 |
141 | LicenseAfterPage := Page.ID;
142 | end;
143 |
144 | procedure InitializeWizard();
145 | begin
146 | LicenseAfterPage := wpLicense;
147 | AddLicensePage('LICENSE_parsec-vdd.txt');
148 | AddLicensePage('LICENSE_winsw.txt');
149 | end;
150 |
151 | var
152 | isSilent: Boolean;
153 |
154 | function InitializeSetup(): Boolean;
155 | var
156 | j: Integer;
157 | begin
158 | Result := True;
159 | IsSilent := False;
160 | for j := 1 to ParamCount do
161 | begin
162 | if (CompareText(ParamStr(j), '/verysilent') = 0) or
163 | (CompareText(ParamStr(j), '/silent') = 0) then
164 | begin
165 | IsSilent := True;
166 | Break;
167 | end;
168 | end;
169 | end;
170 |
171 | procedure CurPageChanged(CurPageID: Integer);
172 | var
173 | I: Integer;
174 | begin
175 | // Automatically accept licenses if running in silent mode
176 | if IsSilent then
177 | begin
178 | for I := 0 to GetArrayLength(LicenseAcceptedRadioButtons) - 1 do
179 | begin
180 | LicenseAcceptedRadioButtons[I].Checked := True;
181 | end;
182 | end;
183 | end;
184 |
185 | [Tasks]
186 | Name: install_vdd; Description: "Install Parsec VDD v{#VddVersion}"
187 |
188 | [Icons]
189 | Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
190 |
191 | [Run]
192 | Filename: "{app}\driver\parsec-vdd-setup.exe"; Parameters: "/S"; Flags: runascurrentuser; Tasks: install_vdd
193 | Filename: "{app}\Setup.bat"; Parameters: "install"; Flags: runhidden
194 |
195 | [UninstallRun]
196 | Filename: "{app}\Setup.bat"; Parameters: "uninstall"; Flags: runhidden
--------------------------------------------------------------------------------
/parsec-vdd.h:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2023, Nguyen Duy All rights reserved.
3 | * GitHub repo: https://github.com/nomi-san/parsec-vdd/
4 | *
5 | * Redistribution and use in source and binary forms, with or without
6 | * modification, are permitted provided that the following conditions are met:
7 | *
8 | * * Redistributions of source code must retain the above copyright notice,
9 | * this list of conditions and the following disclaimer.
10 | * * Redistributions in binary form must reproduce the above copyright
11 | * notice, this list of conditions and the following disclaimer in the
12 | * documentation and/or other materials provided with the distribution.
13 | *
14 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
18 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
24 | * POSSIBILITY OF SUCH DAMAGE.
25 | *
26 | */
27 |
28 | #ifndef __PARSEC_VDD_H
29 | #define __PARSEC_VDD_H
30 |
31 | #include
32 | #include
33 | #include
34 |
35 | #ifdef _MSC_VER
36 | #pragma comment(lib, "cfgmgr32.lib")
37 | #pragma comment(lib, "setupapi.lib")
38 | #endif
39 |
40 | #ifdef __cplusplus
41 | namespace parsec_vdd
42 | {
43 | #endif
44 |
45 | // Device helper.
46 | //////////////////////////////////////////////////
47 |
48 | typedef enum {
49 | DEVICE_OK = 0, // Ready to use
50 | DEVICE_INACCESSIBLE, // Inaccessible
51 | DEVICE_UNKNOW, // Unknow status
52 | DEVICE_UNKNOW_PROBLEM, // Unknow problem
53 | DEVICE_DISABLED, // Device is disabled
54 | DEVICE_DRIVER_ERROR, // Device encountered error
55 | DEVICE_RESTART_REQUIRED, // Must restart PC to use (could ignore but would have issue)
56 | DEVICE_DISABLED_SERVICE, // Service is disabled
57 | DEVICE_NOT_INSTALLED // Driver is not installed
58 | } DeviceStatus;
59 |
60 | /**
61 | * Query the driver status.
62 | *
63 | * @param classGuid The GUID of the class.
64 | * @param deviceId The device/hardware ID of the driver.
65 | * @return DeviceStatus
66 | */
67 | static DeviceStatus QueryDeviceStatus(const GUID *classGuid, const char *deviceId)
68 | {
69 | DeviceStatus status = DEVICE_INACCESSIBLE;
70 |
71 | SP_DEVINFO_DATA devInfoData;
72 | ZeroMemory(&devInfoData, sizeof(SP_DEVINFO_DATA));
73 | devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
74 |
75 | HDEVINFO devInfo = SetupDiGetClassDevsA(classGuid, NULL, NULL, DIGCF_PRESENT);
76 |
77 | if (devInfo != INVALID_HANDLE_VALUE)
78 | {
79 | BOOL foundProp = FALSE;
80 | UINT deviceIndex = 0;
81 |
82 | do
83 | {
84 | if (!SetupDiEnumDeviceInfo(devInfo, deviceIndex, &devInfoData))
85 | break;
86 |
87 | DWORD requiredSize = 0;
88 | SetupDiGetDeviceRegistryPropertyA(devInfo, &devInfoData,
89 | SPDRP_HARDWAREID, NULL, NULL, 0, &requiredSize);
90 |
91 | if (requiredSize > 0)
92 | {
93 | DWORD regDataType = 0;
94 | LPBYTE propBuffer = (LPBYTE)calloc(1, requiredSize);
95 |
96 | if (SetupDiGetDeviceRegistryPropertyA(
97 | devInfo,
98 | &devInfoData,
99 | SPDRP_HARDWAREID,
100 | ®DataType,
101 | propBuffer,
102 | requiredSize,
103 | &requiredSize))
104 | {
105 | if (regDataType == REG_SZ || regDataType == REG_MULTI_SZ)
106 | {
107 | for (LPCSTR cp = (LPCSTR)propBuffer; ; cp += lstrlenA(cp) + 1)
108 | {
109 | if (!cp || *cp == 0 || cp >= (LPCSTR)(propBuffer + requiredSize))
110 | {
111 | status = DEVICE_NOT_INSTALLED;
112 | goto except;
113 | }
114 |
115 | if (lstrcmpA(deviceId, cp) == 0)
116 | break;
117 | }
118 |
119 | foundProp = TRUE;
120 | ULONG devStatus, devProblemNum;
121 |
122 | if (CM_Get_DevNode_Status(&devStatus, &devProblemNum, devInfoData.DevInst, 0) != CR_SUCCESS)
123 | {
124 | status = DEVICE_NOT_INSTALLED;
125 | goto except;
126 | }
127 |
128 | if ((devStatus & (DN_DRIVER_LOADED | DN_STARTED)) != 0)
129 | {
130 | status = DEVICE_OK;
131 | }
132 | else if ((devStatus & DN_HAS_PROBLEM) != 0)
133 | {
134 | switch (devProblemNum)
135 | {
136 | case CM_PROB_NEED_RESTART:
137 | status = DEVICE_RESTART_REQUIRED;
138 | break;
139 | case CM_PROB_DISABLED:
140 | case CM_PROB_HARDWARE_DISABLED:
141 | status = DEVICE_DISABLED;
142 | break;
143 | case CM_PROB_DISABLED_SERVICE:
144 | status = DEVICE_DISABLED_SERVICE;
145 | break;
146 | default:
147 | if (devProblemNum == CM_PROB_FAILED_POST_START)
148 | status = DEVICE_DRIVER_ERROR;
149 | else
150 | status = DEVICE_UNKNOW_PROBLEM;
151 | break;
152 | }
153 | }
154 | else
155 | {
156 | status = DEVICE_UNKNOW;
157 | }
158 | }
159 | }
160 |
161 | except:
162 | free(propBuffer);
163 | }
164 |
165 | ++deviceIndex;
166 | } while (!foundProp);
167 |
168 | if (!foundProp && GetLastError() != 0)
169 | status = DEVICE_NOT_INSTALLED;
170 |
171 | SetupDiDestroyDeviceInfoList(devInfo);
172 | }
173 |
174 | return status;
175 | }
176 |
177 | /**
178 | * Obtain the device handle.
179 | * Returns NULL or INVALID_HANDLE_VALUE if fails, otherwise a valid handle.
180 | * Should call CloseDeviceHandle to close this handle after use.
181 | *
182 | * @param interfaceGuid The adapter/interface GUID of the target device.
183 | * @return HANDLE
184 | */
185 | static HANDLE OpenDeviceHandle(const GUID *interfaceGuid)
186 | {
187 | HANDLE handle = INVALID_HANDLE_VALUE;
188 | HDEVINFO devInfo = SetupDiGetClassDevsA(interfaceGuid,
189 | NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
190 |
191 | if (devInfo != INVALID_HANDLE_VALUE)
192 | {
193 | SP_DEVICE_INTERFACE_DATA devInterface;
194 | ZeroMemory(&devInterface, sizeof(SP_DEVICE_INTERFACE_DATA));
195 | devInterface.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
196 |
197 | for (DWORD i = 0; SetupDiEnumDeviceInterfaces(devInfo, NULL, interfaceGuid, i, &devInterface); ++i)
198 | {
199 | DWORD detailSize = 0;
200 | SetupDiGetDeviceInterfaceDetailA(devInfo, &devInterface, NULL, 0, &detailSize, NULL);
201 |
202 | SP_DEVICE_INTERFACE_DETAIL_DATA_A *detail = (SP_DEVICE_INTERFACE_DETAIL_DATA_A *)calloc(1, detailSize);
203 | detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
204 |
205 | if (SetupDiGetDeviceInterfaceDetailA(devInfo, &devInterface, detail, detailSize, &detailSize, NULL))
206 | {
207 | handle = CreateFileA(detail->DevicePath,
208 | GENERIC_READ | GENERIC_WRITE,
209 | FILE_SHARE_READ | FILE_SHARE_WRITE,
210 | NULL,
211 | OPEN_EXISTING,
212 | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED | FILE_FLAG_WRITE_THROUGH,
213 | NULL);
214 |
215 | if (handle != NULL && handle != INVALID_HANDLE_VALUE)
216 | break;
217 | }
218 |
219 | free(detail);
220 | }
221 |
222 | SetupDiDestroyDeviceInfoList(devInfo);
223 | }
224 |
225 | return handle;
226 | }
227 |
228 | /* Release the device handle */
229 | static void CloseDeviceHandle(HANDLE handle)
230 | {
231 | if (handle != NULL && handle != INVALID_HANDLE_VALUE)
232 | CloseHandle(handle);
233 | }
234 |
235 | // Parsec VDD core.
236 | //////////////////////////////////////////////////
237 |
238 | // Display name info.
239 | static const char *VDD_DISPLAY_ID = "PSCCDD0"; // You will see it in registry (HKLM\SYSTEM\CurrentControlSet\Enum\DISPLAY)
240 | static const char *VDD_DISPLAY_NAME = "ParsecVDA"; // You will see it in the [Advanced display settings] tab.
241 |
242 | // Apdater GUID to obtain the device handle.
243 | // {00b41627-04c4-429e-a26e-0265cf50c8fa}
244 | static const GUID VDD_ADAPTER_GUID = { 0x00b41627, 0x04c4, 0x429e, { 0xa2, 0x6e, 0x02, 0x65, 0xcf, 0x50, 0xc8, 0xfa } };
245 | static const char *VDD_ADAPTER_NAME = "Parsec Virtual Display Adapter";
246 |
247 | // Class and hwid to query device status.
248 | // {4d36e968-e325-11ce-bfc1-08002be10318}
249 | static const GUID VDD_CLASS_GUID = { 0x4d36e968, 0xe325, 0x11ce, { 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18 } };
250 | static const char *VDD_HARDWARE_ID = "Root\\Parsec\\VDA";
251 |
252 | // Actually up to 16 devices could be created per adapter
253 | // so just use a half to avoid plugging lag.
254 | static const int VDD_MAX_DISPLAYS = 8;
255 |
256 | // Core IoControl codes, see usage below.
257 | typedef enum {
258 | VDD_IOCTL_ADD = 0x0022e004,
259 | VDD_IOCTL_REMOVE = 0x0022a008,
260 | VDD_IOCTL_UPDATE = 0x0022a00c,
261 | VDD_IOCTL_VERSION = 0x0022e010,
262 | } VddCtlCode;
263 |
264 | // Generic DeviceIoControl for all IoControl codes.
265 | static DWORD VddIoControl(HANDLE vdd, VddCtlCode code, const void *data, size_t size)
266 | {
267 | if (vdd == NULL || vdd == INVALID_HANDLE_VALUE)
268 | return 0;
269 |
270 | BYTE InBuffer[32];
271 | ZeroMemory(InBuffer, sizeof(InBuffer));
272 |
273 | OVERLAPPED Overlapped;
274 | ZeroMemory(&Overlapped, sizeof(OVERLAPPED));
275 |
276 | DWORD OutBuffer = 0;
277 | DWORD NumberOfBytesTransferred;
278 |
279 | if (data != NULL && size > 0)
280 | memcpy(InBuffer, data, (size < sizeof(InBuffer)) ? size : sizeof(InBuffer));
281 |
282 | Overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
283 | DeviceIoControl(vdd, (DWORD)code, InBuffer, sizeof(InBuffer), &OutBuffer, sizeof(DWORD), NULL, &Overlapped);
284 |
285 | if (!GetOverlappedResultEx(vdd, &Overlapped, &NumberOfBytesTransferred, 5000, FALSE))
286 | {
287 | CloseHandle(Overlapped.hEvent);
288 | return 0;
289 | }
290 |
291 | if (Overlapped.hEvent != NULL)
292 | CloseHandle(Overlapped.hEvent);
293 |
294 | return OutBuffer;
295 | }
296 |
297 | /**
298 | * Query VDD minor version.
299 | *
300 | * @param vdd The device handle of VDD.
301 | * @return The number of minor version.
302 | */
303 | static int VddVersion(HANDLE vdd)
304 | {
305 | int minor = VddIoControl(vdd, VDD_IOCTL_VERSION, NULL, 0);
306 | return minor;
307 | }
308 |
309 | /**
310 | * Update/ping to VDD.
311 | * Should call this function in a side thread for each
312 | * less than 100ms to keep all added virtual displays alive.
313 | *
314 | * @param vdd The device handle of VDD.
315 | */
316 | static void VddUpdate(HANDLE vdd)
317 | {
318 | VddIoControl(vdd, VDD_IOCTL_UPDATE, NULL, 0);
319 | }
320 |
321 | /**
322 | * Add/plug a virtual display.
323 | *
324 | * @param vdd The device handle of VDD.
325 | * @return The index of the added display.
326 | */
327 | static int VddAddDisplay(HANDLE vdd)
328 | {
329 | int idx = VddIoControl(vdd, VDD_IOCTL_ADD, NULL, 0);
330 | VddUpdate(vdd);
331 |
332 | return idx;
333 | }
334 |
335 | /**
336 | * Remove/unplug a virtual display.
337 | *
338 | * @param vdd The device handle of VDD.
339 | * @param index The index of the display will be removed.
340 | */
341 | static void VddRemoveDisplay(HANDLE vdd, int index)
342 | {
343 | // 16-bit BE index
344 | UINT16 indexData = ((index & 0xFF) << 8) | ((index >> 8) & 0xFF);
345 |
346 | VddIoControl(vdd, VDD_IOCTL_REMOVE, &indexData, sizeof(indexData));
347 | VddUpdate(vdd);
348 | }
349 |
350 | #ifdef __cplusplus
351 | }
352 | #endif
353 |
354 | #endif
--------------------------------------------------------------------------------