Update change log and tag v2.1.0

Relative coordinates make it easier to center the image.
The value "auto" is now replaced with simply 0.
The value "native" is replaced with "keep" for consistency.
The value is clamped, so x=-9999 will align to the left border etc.

CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to this project will be documented in this file.
 
+## 2.1.0 - 2023-10-04
+
+### Added
+- Check image size, crop if it's bigger than the screen.
+- Check BitLocker status to avoid unbootable machine.
+
+## 2.0.0 - 2023-09-10
+
+### Added
+- Log to `setup.log`.
+- Image conversion (GIF, EXIF, JPG, PNG, TIFF) to BMP during setup.
+- Quiet (batch) setup.
+- Dry run in setup.
+- EFI boot entry support in setup.
+- Orientation parameter (o=0|90|180|270) for images.
+
+### Changed
+- Configure (edit config and images) before installing.
+- Escalate privileges only when needed (after the menu).
+- Try to detect and avoid some configuration errors.
+- Wait at most 15 seconds for key presses during boot.
+- Image coordinates are now relative to the center.
+
+## 1.5.1 - 2018-08-11
+
+### Fixed
+- Clarify the default config.txt.
+- Fix an exception in some cases when trying to boot to UEFI setup.
+
 ## 1.5.0 - 2017-09-30
 
 ### Added

Makefile

@@ -9,15 +9,15 @@ GNUEFI_LIB = /usr/$(CC_PREFIX)/lib
 
 FILES_C = src/main.c src/util.c src/types.c src/config.c
 FILES_H = $(wildcard src/*.h)
-FILES_CS = src/Setup.cs src/SetupHelper.cs src/Esp.cs src/Efi.cs
+FILES_CS = src/Setup.cs src/Esp.cs src/Efi.cs
 GIT_DESCRIBE = $(firstword $(shell git describe --tags) unknown)
 CFLAGS += '-DGIT_DESCRIBE=L"$(GIT_DESCRIBE)"'
 ZIPDIR = HackBGRT-$(GIT_DESCRIBE:v%=%)
 ZIP = $(ZIPDIR).zip
 
+all: efi setup zip
 efi: bootx64.efi bootia32.efi
 setup: setup.exe
-all: efi setup
 
 zip: $(ZIP)
 $(ZIP): bootx64.efi bootia32.efi config.txt splash.bmp setup.exe README.md CHANGELOG.md README.efilib LICENSE
@@ -28,10 +28,10 @@ $(ZIP): bootx64.efi bootia32.efi config.txt splash.bmp setup.exe README.md CHANG
 	rm -rf "$(ZIPDIR)"
 
 src/GIT_DESCRIBE.cs: $(FILES_CS) $(FILES_C) $(FILES_H)
-	echo 'public class GIT_DESCRIBE { public static string data = "$(GIT_DESCRIBE)"; }' > $@
+	echo 'public class GIT_DESCRIBE { public const string data = "$(GIT_DESCRIBE)"; }' > $@
 
 setup.exe: $(FILES_CS) src/GIT_DESCRIBE.cs
-	mcs -define:GIT_DESCRIBE -out:$@ $^
+	csc /define:GIT_DESCRIBE /out:$@ $^
 
 bootx64.efi: CC_PREFIX = x86_64-w64-mingw32
 bootx64.efi: GNUEFI_ARCH = x86_64

README.md

@@ -4,7 +4,7 @@ HackBGRT is intended as a boot logo changer for UEFI-based Windows systems.
 
 ## Summary
 
-When booting on a UEFI-based computer, Windows may show a vendor-defined logo which is stored on the UEFI firmware in a section called Boot Graphics Resource Table (BGRT). It's usually very difficult to change the image permamently, but a custom UEFI application may be used to overwrite it during the boot. HackBGRT does exactly that.
+When booting on a UEFI-based computer, Windows may show a vendor-defined logo which is stored on the UEFI firmware in a section called Boot Graphics Resource Table (BGRT). It's usually very difficult to change the image permanently, but a custom UEFI application may be used to overwrite it during the boot. HackBGRT does exactly that.
 
 ## Usage
 
@@ -12,55 +12,67 @@ When booting on a UEFI-based computer, Windows may show a vendor-defined logo wh
 
 * Make sure that your computer is booting with UEFI.
 * Make sure that Secure Boot is disabled, unless you know how to sign EFI applications.
+* Make sure that BitLocker is disabled, or find your recovery key.
 
 ### Windows installation
 
 * Get the latest release from the Releases page.
 * Start `setup.exe` and follow the instructions.
 	* You may need to manually disable Secure Boot and then retry.
-	* The installer will launch Notepad for modifying the configuration.
-		* If you need only one custom image, the defaults are fine.
-		* Otherwise, check out the examples in the configuration file.
-	* The installer will launch Paint for creating the image(s).
-		* You can create multiple images by using Save As.
-		* Be sure to always use the 24-bit BMP/DIB format.
+	* The installer will launch Paint for editing the image.
 	* If Windows later restores the original boot loader, just reinstall.
 	* If you wish to change the image or other configuration, just reinstall.
+	* For advanced settings, edit `config.txt` before installing. No extra support provided!
+
+### Quiet (batch) installation
+
+* Edit the `config.txt` and `splash.bmp` (or any other images) to your needs.
+* Run `setup.exe batch COMMANDS` as administrator, with some of the following commands:
+	* `install` – copy the files but don't enable.
+	* `enable-entry` – create a new EFI boot entry.
+	* `disable-entry` – disable the EFI boot entry.
+	* `enable-bcdedit` – use `bcdedit` to create a new EFI boot entry.
+	* `disable-bootmgr` – use `bcdedit` to disable the EFI boot entry.
+	* `enable-overwrite` – overwrite the MS boot loader.
+	* `disable-overwrite` – restore the MS boot loader.
+	* `allow-secure-boot` – ignore Secure Boot in subsequent commands.
+	* `allow-bitlocker` – ignore BitLocker in subsequent commands.
+	* `allow-bad-loader` – ignore bad boot loader configuration in subsequent commands.
+	* `disable` – run all relevant `disable-*` commands.
+	* `uninstall` – disable and remove completely.
+* For example, run `setup.exe batch install allow-secure-boot enable-overwrite` to copy files and overwrite the MS boot loader regardless of Secure Boot status.
 
 ### Multi-boot configurations
 
 If you only need HackBGRT for Windows:
 
-* Extract the latest release to `[EFI System Partition]\EFI\HackBGRT\`.
-* Set `boot=\EFI\Microsoft\Boot\bootmgfw.efi` in `config.txt`.
-* Point your boot loader to `\EFI\HackBGRT\bootx64.efi`.
+* Run `setup.exe`, install files without enabling.
+* Configure your boot loader to start `\EFI\HackBGRT\loader.efi`.
 
 If you need it for other systems as well:
 
-* Extract the latest release to `[EFI System Partition]\EFI\HackBGRT\`.
-* Set `boot=\EFI\your-actual-boot-loader.efi` in `config.txt`.
-* Set `\EFI\HackBGRT\bootx64.efi` as your default boot loader with `efibootmgr` or some other EFI boot manager tool.
+* Configure HackBGRT to start your boot loader (such as systemd-boot): `boot=\EFI\systemd\systemd-bootx64.efi`.
+* Run `setup.exe`, install as a new EFI boot entry.
 
-On 32-bit machines, use `bootia32.efi` instead of `bootx64.efi`.
+To install purely on Linux, you can install with `setup.exe dry-run` and then manually copy files from `dry-run/EFI` to your `[EFI System Partition]/EFI`. For further instructions, consult the documentation of your own Linux system.
 
 ## Configuration
 
-The configuration options are described in `config.txt`, which should be stored in `[EFI System Partition]\EFI\HackBGRT\config.txt`.
+The configuration options are described in `config.txt`, which the installer copies into `[EFI System Partition]\EFI\HackBGRT\config.txt`.
 
 ## Images
 
 The image path can be changed in the configuration file. The default path is `[EFI System Partition]\EFI\HackBGRT\splash.bmp`.
 
-The image must be a 24-bit BMP file with a 54-byte header. That's a TrueColor BMP3 in Imagemagick, or 24-bit BMP/DIB in Microsoft Paint.
+The installer copies and converts files whose `path` starts with `\EFI\HackBGRT\`. For example, to use a file named `my.jpg`, copy it in the installer folder (same folder as `setup.exe`) and set the image path in `config.txt` to `path=\EFI\HackBGFT\my.jpg`.
 
-Multiple images may be specified, in which case one is picked at random.
+If you copy an image file to ESP manually, note that the image must be a 24-bit BMP file with a 54-byte header. That's a TrueColor BMP3 in Imagemagick, or 24-bit BMP/DIB in Microsoft Paint.
+
+Advanced users may edit the `config.txt` to define multiple images, in which case one is picked at random.
 
 ## Recovery
 
-If something breaks and you can't boot to Windows, you have the following options:
-
-* Windows installation (or recovery) media can fix boot issues.
-* You can copy `[EFI System Partition]\EFI\HackBGRT\bootmgfw-original.efi` into `[EFI System Partition]\EFI\Microsoft\Boot\bootmgfw.efi` by some other means such as Linux or Windows command prompt.
+If something breaks and you can't boot to Windows, you need to use the Windows installation disk (or recovery disk) to fix boot issues.
 
 ## Building
 

config.txt

@@ -1,35 +1,43 @@
 # vim: set fileencoding=utf-8
 # The same options may be given also as command line parameters in the EFI Shell, which is useful for debugging.
 
-# Boot loader path. Point to the real Windows boot loader.
-boot=\EFI\HackBGRT\bootmgfw-original.efi
+# Boot loader path. MS = either backup or original Windows boot loader.
+boot=MS
 
 # The image is specified with an image line.
 # Multiple image lines may be present, in which case one will be picked by random.
 # The image line may contain the following parts:
 # Any of the following:
-#  - "n=[0-9]+", a weight for this image in the randomization process. Default: n=1.
-#  - "x={auto|native|[0-9]+}", the x coordinate. Default: x=auto.
-#  - "y={auto|native|[0-9]+}", the y coordinate. Default: y=auto.
+#  - "n=(number)", a weight for this image in the randomization process. Default: n=1.
+#  - "x=(number)" or "x=keep", the x offset from the center. Default: x=0.
+#  - "y=(number)" or "y=keep", the y offset from the center. Default: y=0.
+#  - "o=(0|90|180|270|keep)", the screen orientation, degrees anticlockwise. Default: o=keep.
 # One of the following:
-#  - "keep" to keep the firmware logo. Sets also x=native,y=native by default.
+#  - "keep" to keep the firmware logo. Also keeps coordinates by default.
 #  - "remove" to remove the BGRT. Makes x and y meaningless.
 #  - "black" to use only a black image. Makes x and y meaningless.
-#  - "path=..." to read a BMP file. The file must be a 24-bit BMP file with a 54-byte header.
+#  - "path=..." to read a BMP file.
+#    * NOTE: For path=\EFI\HackBGRT\*, the installer will copy and convert the file if necessary.
+#    * NOTE: For other paths, make sure that the file is a 24-bit BMP file with a 54-byte header.
+#    * NOTE: The file must be on the EFI System Partition. Do not add a drive letter!
 # Examples:
 #  - image=remove
 #  - image=black
-#  - image=x=auto,y=0,path=\EFI\HackBGRT\topimage.bmp
-#  - image=n=1,path=\EFI\HackBGRT\splash.bmp
-#  - image=n=50,path=\EFI\HackBGRT\probable.bmp
+#  - image= x=0 y=-200 path=\EFI\HackBGRT\topimage.bmp
+#  - image= n=1 o=90 path=\EFI\HackBGRT\sideways.bmp
+#  - image= n=50 y=999999 o=keep path=\EFI\HackBGRT\probable.bmp
 # The above examples together would produce
 #  - 1/54 chance for the default OS logo
 #  - 1/54 chance for black screen
-#  - 1/54 chance for topimage.bmp, centered at the top of the screen
-#  - 1/54 chance for splash.bmp, automatically positioned
-#  - 50/54 chance for probable.bmp, automatically positioned
+#  - 1/54 chance for topimage.bmp, 200 px above the center of the screen
+#  - 1/54 chance for splash.bmp, centered, orientation set to 90 degrees
+#  - 50/54 chance for probable.bmp, at the bottom edge, explicitly default orientation
 # Default: just one image.
-image=path=\EFI\HackBGRT\splash.bmp
+image= y=-200 path=\EFI\HackBGRT\splash.bmp
 
 # Preferred resolution. Use 0x0 for maximum and -1x-1 for original.
 resolution=0x0
+
+# Debug mode (0 for disabled, 1 for enabled).
+# Shows debug information and prompts for keypress before booting.
+debug=0

src/Efi.cs

@@ -1,4 +1,7 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
 using System.Linq;
 using System.Runtime.InteropServices;
 using Microsoft.Win32;
@@ -28,6 +31,9 @@ public class Efi {
 	[DllImport("kernel32.dll", SetLastError = true)]
 	private static extern bool CloseHandle(IntPtr hObject);
 
+	[DllImport("kernel32.dll", SetLastError = true)]
+	private static extern UInt32 GetSystemFirmwareTable(UInt32 provider, UInt32 table, [MarshalAs(UnmanagedType.LPArray)] byte[] buffer, UInt32 len);
+
 	[StructLayout(LayoutKind.Sequential, Pack = 1)]
 	private struct TokPriv1Luid {
 		public int Count;
@@ -39,17 +45,115 @@ public class Efi {
 	 * Information about an EFI variable.
 	 */
 	public class Variable {
-		public string name, guid;
-		public UInt32 attributes;
-		public byte[] data;
+		public string Name, Guid;
+		public UInt32 Attributes;
+		public byte[] Data;
+
+		/**
+		 * Convert to string.
+		 *
+		 * @return String representation of this object.
+		 */
+		public override string ToString() {
+			var hex = BitConverter.ToString(Data).Replace("-", " ");
+			var text = new string(Data.Select(c => 0x20 <= c && c <= 0x7f ? (char) c : ' ').ToArray());
+			return $"{Name} Guid={Guid} Attributes={Attributes} Text='{text}' Bytes='{hex}'";
+		}
+	}
+
+	/**
+	 * Information about an EFI boot entry.
+	 */
+	public class BootEntryData {
+		public UInt32 Attributes;
+		public string Label;
+		public class DevicePathNode {
+			public byte Type, SubType;
+			public byte[] Data;
+			public DevicePathNode(byte[] data) {
+				Type = data[0];
+				SubType = data[1];
+				Data = data.Skip(4).ToArray();
+			}
+			public byte[] ToBytes() {
+				var len = Data.Length + 4;
+				return new byte[] { Type, SubType, (byte)(len & 0xff), (byte)(len >> 8) }.Concat(Data).ToArray();
+			}
+		}
+		public List<DevicePathNode> DevicePathNodes;
+		public byte[] Arguments;
+
+		public BootEntryData(byte[] data) {
+			Attributes = BitConverter.ToUInt32(data, 0);
+			var pathNodesLength = BitConverter.ToUInt16(data, 4);
+			Label = new string(BytesToUInt16s(data).Skip(3).TakeWhile(i => i != 0).Select(i => (char)i).ToArray());
+			var pos = 6 + 2 * (Label.Length + 1);
+			var pathNodesEnd = pos + pathNodesLength;
+			DevicePathNodes = new List<DevicePathNode>();
+			while (pos + 4 <= pathNodesEnd) {
+				var len = BitConverter.ToUInt16(data, pos + 2);
+				if (len < 4 || pos + len > pathNodesEnd) {
+					return; // throw new Exception("Bad entry.");
+				}
+				DevicePathNodes.Add(new DevicePathNode(data.Skip(pos).Take(len).ToArray()));
+				pos += len;
+			}
+			Arguments = data.Skip(pathNodesEnd).ToArray();
+		}
+		public byte[] ToBytes() {
+			return new byte[0]
+				.Concat(BitConverter.GetBytes((UInt32) Attributes))
+				.Concat(BitConverter.GetBytes((UInt16) DevicePathNodes.Sum(n => n.Data.Length + 4)))
+				.Concat(Encoding.Unicode.GetBytes(Label + "\0"))
+				.Concat(DevicePathNodes.SelectMany(n => n.ToBytes()))
+				.Concat(Arguments)
+				.ToArray();
+		}
+		public DevicePathNode FileNameNode {
+			get {
+				var d = DevicePathNodes;
+				return d.Count > 1 && d[d.Count - 1].Type == 0x7F && d[d.Count - 2].Type == 0x04 ? d[d.Count - 2] : null;
+			}
+		}
+		public bool HasFileName {
+			get {
+				return FileNameNode != null;
+			}
+		}
+		public string FileName {
+			get {
+				if (!HasFileName) {
+					return "";
+				}
+				return new string(Encoding.Unicode.GetChars(FileNameNode.Data).TakeWhile(c => c != '\0').ToArray());
+			}
+			set {
+				if (!HasFileName) {
+					throw new Exception("Logic error: Setting FileName on a bad boot entry.");
+				}
+				FileNameNode.Data = Encoding.Unicode.GetBytes(value + "\0");
+			}
+		}
 	}
 
 	public const string EFI_GLOBAL_GUID = "{8be4df61-93ca-11d2-aa0d-00e098032b8c}";
 
+	public const string LinuxEfiDir = "/sys/firmware/efi/efivars";
+
 	/**
 	 * Enable the privilege to access EFI variables.
 	 */
 	public static void EnablePrivilege() {
+		if (Directory.Exists(LinuxEfiDir)) {
+			var linuxEfiFile = $"{LinuxEfiDir}/BootOrder-8be4df61-93ca-11d2-aa0d-00e098032b8c";
+			if (File.Exists(linuxEfiFile)) {
+				using (FileStream fs = File.OpenWrite(linuxEfiFile)) {
+					// OpenWrite throws an exception on error.
+				}
+			}
+			return;
+		}
+
 		const int SE_PRIVILEGE_ENABLED = 0x00000002;
 		const int TOKEN_QUERY = 0x00000008;
 		const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
@@ -83,19 +187,30 @@ public class Efi {
 	 */
 	private static Variable GetVariable(string name, string guid = EFI_GLOBAL_GUID) {
 		Variable result = new Variable();
-		result.name = name;
-		result.guid = guid;
-		result.data = null;
-		result.attributes = 0;
+		result.Name = name;
+		result.Guid = guid;
+		result.Data = null;
+		result.Attributes = 0;
+
+		if (Directory.Exists(LinuxEfiDir)) {
+			var linuxEfiFile = $"{LinuxEfiDir}/{name}-{guid.Substring(1, guid.Length - 2)}";
+			if (File.Exists(linuxEfiFile)) {
+				var d = File.ReadAllBytes(linuxEfiFile);
+				result.Attributes = (UInt32)(d[0] + 0x100 * d[1] + 0x10000 * d[2] + 0x1000000 * d[3]);
+				result.Data = d.Skip(4).ToArray();
+			}
+			return result;
+		}
+
 		for (UInt32 i = 4096; i <= 1024*1024; i *= 2) {
 			byte[] buf = new byte[i];
-			UInt32 len = GetFirmwareEnvironmentVariableEx(name, guid, buf, (UInt32) buf.Length, out result.attributes);
+			UInt32 len = GetFirmwareEnvironmentVariableEx(name, guid, buf, (UInt32) buf.Length, out result.Attributes);
 			if (len == buf.Length) {
 				continue;
 			}
 			if (len > 0 || Marshal.GetLastWin32Error() == 0) {
-				result.data = new byte[len];
-				Array.Copy(buf, 0, result.data, 0, len);
+				result.Data = new byte[len];
+				Array.Copy(buf, 0, result.Data, 0, len);
 				return result;
 			}
 			switch (len != 0 ? 0 : Marshal.GetLastWin32Error()) {
@@ -117,17 +232,33 @@ public class Efi {
 	 * Set an EFI variable.
 	 *
 	 * @param v Information of the variable.
+	 * @param dryRun Don't actually set the variable.
 	 */
-	private static void SetVariable(Variable v) {
-		UInt32 r = SetFirmwareEnvironmentVariableEx(v.name, v.guid, v.data, (UInt32) v.data.Length, v.attributes);
+	private static void SetVariable(Variable v, bool dryRun = false) {
+		Setup.WriteLine($"Writing EFI variable {v.Name} (see log for details)");
+		Setup.Log($"Writing EFI variable: {v}");
+		if (dryRun) {
+			return;
+		}
+
+		if (Directory.Exists(LinuxEfiDir)) {
+			var linuxEfiFile = $"{LinuxEfiDir}/{v.Name}-{v.Guid.Substring(1, v.Guid.Length - 2)}";
+			var a = v.Attributes;
+			var b = new byte[] { (byte) a, (byte) (a >> 8), (byte) (a >> 16), (byte) (a >> 24) };
+			// FIXME: Just writing won't work: File.WriteAllBytes(linuxEfiFile, b.Concat(v.Data).ToArray());
+			Setup.WriteLine("FIXME: Can't yet write EFI variables in Linux.");
+			return;
+		}
+
+		UInt32 r = SetFirmwareEnvironmentVariableEx(v.Name, v.Guid, v.Data, (UInt32) v.Data.Length, v.Attributes);
 		if (r == 0) {
 			switch (Marshal.GetLastWin32Error()) {
 				case 87:
-					throw new Exception("GetVariable: Invalid parameter");
+					throw new Exception("SetVariable: Invalid parameter");
 				case 1314:
-					throw new Exception("GetVariable: Privilege not held");
+					throw new Exception("SetVariable: Privilege not held");
 				default:
-					throw new Exception("GetVariable: error " + Marshal.GetLastWin32Error());
+					throw new Exception("SetVariable: error " + Marshal.GetLastWin32Error());
 			}
 		}
 	}
@@ -159,7 +290,7 @@ public class Efi {
 	public static bool CanBootToFW() {
 		try {
 			Variable tmp = GetVariable("OsIndicationsSupported");
-			return tmp.data != null && (tmp.data[0] & 1) != 0;
+			return tmp.Data != null && (tmp.Data[0] & 1) != 0;
 		} catch {
 			return false;
 		}
@@ -170,7 +301,169 @@ public class Efi {
 	 */
 	public static void SetBootToFW() {
 		Variable tmp = GetVariable("OsIndications");
-		tmp.data[0] |= 1;
+		if (tmp.Data == null) {
+			tmp.Data = new byte[8];
+			tmp.Attributes = 7;
+		}
+		tmp.Data[0] |= 1;
 		SetVariable(tmp);
 	}
+
+	/**
+	 * Convert bytes into UInt16 values.
+	 *
+	 * @param bytes The byte array.
+	 * @return An enumeration of UInt16 values.
+	 */
+	public static IEnumerable<UInt16> BytesToUInt16s(byte[] bytes) {
+		// TODO: return bytes.Chunk(2).Select(b => (UInt16) (b[0] + 0x100 * b[1])).ToArray();
+		return Enumerable.Range(0, bytes.Length / 2).Select(i => (UInt16) (bytes[2 * i] + 0x100 * bytes[2 * i + 1]));
+	}
+
+	/**
+	 * Disable the said boot entry from BootOrder.
+	 *
+	 * @param label Label of the boot entry.
+	 * @param fileName File name of the boot entry.
+	 * @param dryRun Don't actually disable the entry.
+	 * @return True, if the entry was found in BootOrder.
+	 */
+	public static bool DisableBootEntry(string label, string fileName, bool dryRun = false) {
+		Variable bootOrder;
+		try {
+			bootOrder = GetVariable("BootOrder");
+		} catch {
+			return false;
+		}
+		if (bootOrder.Data == null) {
+			return false;
+		}
+		Setup.Log($"Read EFI variable: {bootOrder}");
+		var found = false;
+		var bootOrderInts = new List<UInt16>();
+		foreach (var num in BytesToUInt16s(bootOrder.Data)) {
+			var entry = GetVariable(String.Format("Boot{0:X04}", num));
+			if (entry.Data != null) {
+				var entryData = new BootEntryData(entry.Data);
+				if (entryData.Label == label && entryData.FileName == fileName) {
+					found = true;
+					continue;
+				}
+			}
+			bootOrderInts.Add(num);
+		}
+		if (found) {
+			bootOrder.Data = bootOrderInts.SelectMany(num => new byte[] { (byte)(num & 0xff), (byte)(num >> 8) }).ToArray();
+			SetVariable(bootOrder, dryRun);
+		}
+		return found;
+	}
+
+	/**
+	 * Create and enable the said boot entry from BootOrder.
+	 *
+	 * @param label Label of the boot entry.
+	 * @param fileName File name of the boot entry.
+	 * @param dryRun Don't actually create the entry.
+	 */
+	public static void MakeAndEnableBootEntry(string label, string fileName, bool dryRun = false) {
+		Variable msEntry = null, ownEntry = null;
+		UInt16 msNum = 0, ownNum = 0;
+
+		// Find a free entry and the MS bootloader entry.
+		Variable bootOrder = null;
+		try {
+			bootOrder = GetVariable("BootOrder");
+		} catch {
+			if (dryRun) {
+				return;
+			}
+		}
+		if (bootOrder == null || bootOrder.Data == null) {
+			throw new Exception("MakeBootEntry: Could not read BootOrder. Maybe your computer is defective.");
+		}
+		var bootCurrent = GetVariable("BootCurrent");
+		if (bootCurrent.Data == null) {
+			throw new Exception("MakeBootEntry: Could not read BootCurrent. Maybe your computer is defective.");
+		}
+		Setup.Log($"Read EFI variable: {bootOrder}");
+		Setup.Log($"Read EFI variable: {bootCurrent}");
+		var bootOrderInts = new List<UInt16>(BytesToUInt16s(bootOrder.Data));
+		foreach (var num in BytesToUInt16s(bootCurrent.Data).Concat(bootOrderInts).Concat(Enumerable.Range(0, 0xffff).Select(i => (UInt16) i))) {
+			var entry = GetVariable(String.Format("Boot{0:X04}", num));
+			if (entry.Data == null) {
+				if (ownEntry == null) {
+					ownNum = num;
+					ownEntry = entry;
+				}
+			} else {
+				var entryData = new BootEntryData(entry.Data);
+				if (!entryData.HasFileName) {
+					continue;
+				}
+				if (entryData.Label == label && entryData.FileName == fileName) {
+					ownNum = num;
+					ownEntry = entry;
+				}
+				if (msEntry == null && entryData.FileName.StartsWith("\\EFI\\Microsoft\\Boot\\bootmgfw.efi", StringComparison.OrdinalIgnoreCase)) {
+					msNum = num;
+					msEntry = entry;
+				}
+			}
+			if (ownEntry != null && msEntry != null) {
+				break;
+			}
+		}
+		if (ownEntry == null) {
+			throw new Exception("MakeBootEntry: Boot entry list is full.");
+		} else if (msEntry == null) {
+			throw new Exception("MakeBootEntry: Windows Boot Manager not found.");
+		} else {
+			Setup.Log($"Read EFI variable: {msEntry}");
+			// Make a new boot entry using the MS entry as a starting point.
+			var entryData = new BootEntryData(msEntry.Data);
+			entryData.Arguments = Encoding.UTF8.GetBytes(label + "\0");
+			entryData.Attributes = 1; // LOAD_OPTION_ACTIVE
+			entryData.Label = label;
+			entryData.FileName = fileName;
+			ownEntry.Attributes = 7; // EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS
+			ownEntry.Data = entryData.ToBytes();
+			SetVariable(ownEntry, dryRun);
+		}
+
+		var msPos = bootOrderInts.IndexOf(msNum);
+		var ownPos = bootOrderInts.IndexOf(ownNum);
+		var mustAdd = ownPos == -1;
+		var mustMove = 0 <= msPos && msPos <= ownPos;
+		if (mustAdd || mustMove) {
+			if (mustMove) {
+				bootOrderInts.RemoveAt(ownPos);
+			}
+			bootOrderInts.Insert(msPos < 0 ? 0 : msPos, ownNum);
+			bootOrder.Data = bootOrderInts.SelectMany(num => new byte[] { (byte)(num & 0xff), (byte)(num >> 8) }).ToArray();
+			SetVariable(bootOrder, dryRun);
+		}
+	}
+
+	/**
+	 * Log the BGRT table (for debugging).
+	 */
+	public static void LogBGRT() {
+		try {
+			const UInt32 acpiBE = 0x41435049, bgrtLE = 0x54524742;
+			UInt32 size = GetSystemFirmwareTable(acpiBE, bgrtLE, null, 0);
+			byte[] buf = new byte[size];
+			var ret = GetSystemFirmwareTable(acpiBE, bgrtLE, buf, size);
+			if (ret == size) {
+				var hex = BitConverter.ToString(buf).Replace("-", " ");
+				Setup.Log($"LogBGRT: {hex}");
+			} else if (ret == 0) {
+				Setup.Log($"LogBGRT: Win32Error {Marshal.GetLastWin32Error()}");
+			} else {
+				Setup.Log($"LogBGRT: Size problems: spec {0x38}, buf {size}, ret {ret}");
+			}
+		} catch (Exception e) {
+			Setup.Log($"LogBGRT: {e}");
+		}
+	}
 }

src/Esp.cs

@@ -6,16 +6,16 @@ using System.Text.RegularExpressions;
  * EFI System Partition mounter.
  */
 public sealed class Esp {
-	/** The singleton instance of this class, if Path is mounted. */
+	/** The singleton instance of this class, if ESP is mounted. */
 	private static Esp MountInstance;
 
-	/** EFI System Partition location, internal variable. */
-	private static string RealPath;
+	/** EFI System Partition location. */
+	public static string Location { get; private set; }
 
-	/** EFI System Partition location, read-only. */
-	public static string Path {
+	/** MS boot loader path on ESP. */
+	public static string MsLoaderPath {
 		get {
-			return RealPath;
+			return Path.Combine(new string[] { Location, "EFI", "Microsoft", "Boot", "bootmgfw.efi"});
 		}
 	}
 
@@ -42,44 +42,54 @@ public sealed class Esp {
 	 * @return true if the path was given and seems valid, false otherwise.
 	 */
 	public static bool TryPath(string tryPath, bool requireMsLoader = true) {
-		if (MountInstance != null && Path != null) {
+		if (MountInstance != null && Location != null) {
 			Unmount();
 		}
-		RealPath = tryPath;
-		if (Path != null && Path != "") {
-			if (File.Exists(Path + "\\EFI\\Microsoft\\Boot\\bootmgfw.efi")) {
+		Location = tryPath;
+		if (Location != null && Location != "") {
+			if (File.Exists(MsLoaderPath)) {
+				Setup.Log($"Esp.TryPath: {Location} has MS boot loader");
 				return true;
 			}
-			if (!requireMsLoader && Directory.Exists(Path + "\\EFI")) {
+			if (Directory.Exists(Path.Combine(Location, "EFI"))) {
+				Setup.Log($"Esp.TryPath: {Location} has EFI directory but no loader");
+				if (!requireMsLoader) {
 					return true;
 				}
 			}
-		RealPath = null;
+		}
+		Location = null;
 		return false;
 	}
 
 	/**
 	 * Find the EFI System Partition, if it's already mounted.
 	 *
-	 * @return true if the drive vas found.
+	 * @return true if the drive was found.
 	 */
 	public static bool Find() {
 		if (MountInstance != null) {
 			return true;
 		}
+		Setup.Log("Esp.Find()");
 		try {
 			// Match "The EFI System Partition is mounted at E:\" with some language support.
-			var re = new Regex(" EFI[^\n]*(?:\n[ \t]*)?([A-Z]:)\\\\");
-			if (TryPath(re.Match(Setup.Execute("mountvol", "", false)).Groups[1].Captures[0].Value)) {
+			var re = new Regex(" EFI[^\n]*(?:\n[ \t]*)?([A-Z]:\\\\)");
+			var m = re.Match(Setup.Execute("mountvol", "", false));
+			if (m.Success && TryPath(m.Groups[1].Captures[0].Value)) {
 				return true;
 			}
-		} catch {
+			Setup.Log("Esp.Find: no match");
+		} catch (Exception e) {
+			Setup.Log($"Esp.Find: {e.ToString()}");
 		}
 		for (char c = 'A'; c <= 'Z'; ++c) {
-			if (TryPath(c + ":")) {
+			if (TryPath(c + ":\\")) {
+				Setup.Log($"Esp.Find: found {c}");
 				return true;
 			}
 		}
+		Setup.Log("Esp.Find: not found");
 		return false;
 	}
 
@@ -93,12 +103,13 @@ public sealed class Esp {
 			return true;
 		}
 		for (char c = 'A'; c <= 'Z'; ++c) {
+			Setup.Log($"Esp.Mount: {c}");
 			if (Setup.Execute("mountvol", c + ": /S", true) != null) {
 				MountInstance = new Esp();
-				if (TryPath(c + ":", false)) {
+				if (TryPath(c + ":\\", false)) {
 					return true;
 				} else {
-					throw new Exception("Mounted ESP at " + c + ": but it seems to be invalid!");
+					throw new Exception("Mounted ESP at " + c + ":\\ but it seems to be invalid!");
 				}
 			}
 		}
@@ -110,8 +121,8 @@ public sealed class Esp {
 	 */
 	private static void Unmount() {
 		if (MountInstance != null) {
-			Setup.Execute("mountvol", Path + " /D", true);
-			RealPath = null;
+			Setup.Execute("mountvol", Location + " /D", true);
+			Location = null;
 			MountInstance = null;
 		}
 	}

src/SetupHelper.cs

@@ -1,104 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Reflection;
-using System.Security.Principal;
-using System.Linq;
-
-/**
- * Helper functions.
- */
-public class SetupHelper {
-	/**
-	 * Start another process.
-	 *
-	 * @param app Path to the application.
-	 * @param args The argument string.
-	 * @return The started process.
-	 */
-	public static Process StartProcess(string app, string args) {
-		try {
-			var info = new ProcessStartInfo(app, args);
-			info.UseShellExecute = false;
-			return Process.Start(info);
-		} catch {
-			return null;
-		}
-	}
-
-	/**
-	 * Execute another process, return the output.
-	 *
-	 * @param app Path to the application.
-	 * @param args The argument string.
-	 * @param nullOnFail If set, return null if the program exits with a code other than 0, even if there was some output.
-	 * @return The output, or null if the execution failed.
-	 */
-	public static string Execute(string app, string args, bool nullOnFail) {
-		try {
-			var info = new ProcessStartInfo(app, args);
-			info.UseShellExecute = false;
-			info.RedirectStandardOutput = true;
-			var p = Process.Start(info);
-			string output = p.StandardOutput.ReadToEnd();
-			p.WaitForExit();
-			return (nullOnFail && p.ExitCode != 0) ? null : output;
-		} catch {
-			return null;
-		}
-	}
-
-	/**
-	 * Copy a file, overwrite by default.
-	 *
-	 * @param src The source path.
-	 * @param dest The destination path.
-	 * @return True, if the file was successfully copied.
-	 */
-	public static bool Copy(string src, string dest) {
-		try {
-			File.Copy(src, dest, true);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-
-	/**
-	 * The Main program.
-	 *
-	 * @param args The arguments.
-	 */
-	public static void Main(string[] args) {
-		#if GIT_DESCRIBE
-			Console.WriteLine("HackBGRT installer version: {0}", GIT_DESCRIBE.data);
-		#else
-			Console.WriteLine("HackBGRT installer version: unknown; not an official release?");
-		#endif
-		var self = Assembly.GetExecutingAssembly().Location;
-		try {
-			// Relaunch as admin, if needed.
-			var id = WindowsIdentity.GetCurrent();
-			var principal = new WindowsPrincipal(id);
-			var admin = WindowsBuiltInRole.Administrator;
-			if (!principal.IsInRole(admin) && !args.Contains("no-elevate")) {
-				ProcessStartInfo startInfo = new ProcessStartInfo(self);
-				startInfo.Arguments = "no-elevate";
-				startInfo.Verb = "runas";
-				startInfo.UseShellExecute = true;
-				Process p = Process.Start(startInfo);
-				p.WaitForExit();
-				Environment.ExitCode = p.ExitCode;
-				return;
-			}
-			Efi.EnablePrivilege();
-		} catch {
-			Console.WriteLine("This installer needs to be run as administrator!");
-			Console.WriteLine("Press any key to quit.");
-			Console.ReadKey();
-			Environment.ExitCode = 1;
-			return;
-		}
-		Setup.RunSetup(Path.GetDirectoryName(self));
-	}
-}

src/config.c

@@ -70,35 +70,37 @@ BOOLEAN ReadConfigFile(struct HackBGRT_config* config, EFI_FILE_HANDLE root_dir,
 	return TRUE;
 }
 
-static void SetBMPWithRandom(struct HackBGRT_config* config, int weight, enum HackBGRT_action action, int x, int y, const CHAR16* path) {
+static void SetBMPWithRandom(struct HackBGRT_config* config, int weight, enum HackBGRT_action action, int x, int y, int o, const CHAR16* path) {
 	config->image_weight_sum += weight;
 	UINT32 random = Random();
 	UINT32 limit = 0xfffffffful / config->image_weight_sum * weight;
 	if (config->debug) {
-		Print(L"HackBGRT: weight %d, action %d, x %d, y %d, path %s, random = %08x, limit = %08x\n", weight, action, x, y, path, random, limit);
+		Print(L"HackBGRT: weight %d, action %d, x %d, y %d, o %d, path %s, random = %08x, limit = %08x\n", weight, action, x, y, o, path, random, limit);
 	}
 	if (!config->image_weight_sum || random <= limit) {
 		config->action = action;
 		config->image_path = path;
+		config->orientation = o;
 		config->image_x = x;
 		config->image_y = y;
 	}
 }
 
 static int ParseCoordinate(const CHAR16* str, enum HackBGRT_action action) {
-	if (str && L'0' <= str[0] && str[0] <= L'9') {
-		return Atoi(str);
+	if (str && ((L'0' <= str[0] && str[0] <= L'9') || str[0] == L'-')) {
+		return str[0] == L'-' ? -(int)Atoi(str+1) : (int)Atoi(str);
 	}
-	if ((str && StrnCmp(str, L"native", 6) == 0) || action == HackBGRT_KEEP) {
-		return HackBGRT_coord_native;
+	if ((str && StrnCmp(str, L"keep", 4) == 0) || action == HackBGRT_KEEP) {
+		return HackBGRT_coord_keep;
 	}
-	return HackBGRT_coord_auto;
+	return 0;
 }
 
 static void ReadConfigImage(struct HackBGRT_config* config, const CHAR16* line) {
 	const CHAR16* n = StrStrAfter(line, L"n=");
 	const CHAR16* x = StrStrAfter(line, L"x=");
 	const CHAR16* y = StrStrAfter(line, L"y=");
+	const CHAR16* o = StrStrAfter(line, L"o=");
 	const CHAR16* f = StrStrAfter(line, L"path=");
 	enum HackBGRT_action action = HackBGRT_KEEP;
 	if (f) {
@@ -114,7 +116,10 @@ static void ReadConfigImage(struct HackBGRT_config* config, const CHAR16* line)
 		return;
 	}
 	int weight = n && (!f || n < f) ? Atoi(n) : 1;
-	SetBMPWithRandom(config, weight, action, ParseCoordinate(x, action), ParseCoordinate(y, action), f);
+	int x_val = ParseCoordinate(x, action);
+	int y_val = ParseCoordinate(y, action);
+	int o_val = o ? ParseCoordinate(o, action) : HackBGRT_coord_keep;
+	SetBMPWithRandom(config, weight, action, x_val, y_val, o_val, f);
 }
 
 static void ReadConfigResolution(struct HackBGRT_config* config, const CHAR16* line) {

src/config.h

@@ -14,8 +14,7 @@ enum HackBGRT_action {
  * @see struct HackBGRT_config
  */
 enum HackBGRT_coordinate {
-	HackBGRT_coord_auto = 0x10000001,
-	HackBGRT_coord_native = 0x10000002
+	HackBGRT_coord_keep = -1000000001
 };
 
 /**
@@ -28,8 +27,11 @@ struct HackBGRT_config {
 	int image_x;
 	int image_y;
 	int image_weight_sum;
+	int orientation;
 	int resolution_x;
 	int resolution_y;
+	int old_resolution_x;
+	int old_resolution_y;
 	const CHAR16* boot_path;
 };
 

src/main.c

@@ -8,7 +8,7 @@
 /**
  * The Print function signature.
  */
-typedef UINTN print_t(IN CHAR16 *fmt, ...);
+typedef UINTN print_t(IN CONST CHAR16 *fmt, ...);
 
 /**
  * The function for debug printing; either Print or NullPrint.
@@ -43,14 +43,16 @@ static EFI_GRAPHICS_OUTPUT_PROTOCOL* GOP(void) {
 static void SetResolution(int w, int h) {
 	EFI_GRAPHICS_OUTPUT_PROTOCOL* gop = GOP();
 	if (!gop) {
+		config.old_resolution_x = config.resolution_x = 0;
+		config.old_resolution_y = config.resolution_y = 0;
 		Debug(L"GOP not found!\n");
 		return;
 	}
 	UINTN best_i = gop->Mode->Mode;
-	int best_w = gop->Mode->Info->HorizontalResolution;
-	int best_h = gop->Mode->Info->VerticalResolution;
-	w = (w <= 0 ? w < 0 ? best_w : 0x7fffffff : w);
-	h = (h <= 0 ? h < 0 ? best_h : 0x7fffffff : h);
+	int best_w = config.old_resolution_x = gop->Mode->Info->HorizontalResolution;
+	int best_h = config.old_resolution_y = gop->Mode->Info->VerticalResolution;
+	w = (w <= 0 ? w < 0 ? best_w : 999999 : w);
+	h = (h <= 0 ? h < 0 ? best_h : 999999 : h);
 
 	Debug(L"Looking for resolution %dx%d...\n", w, h);
 	for (UINT32 i = gop->Mode->MaxMode; i--;) {
@@ -86,29 +88,13 @@ static void SetResolution(int w, int h) {
 		best_i = i;
 	}
 	Debug(L"Found resolution %dx%d.\n", best_w, best_h);
+	config.resolution_x = best_w;
+	config.resolution_y = best_h;
 	if (best_i != gop->Mode->Mode) {
 		gop->SetMode(gop, best_i);
 	}
 }
 
-/**
- * Select the correct coordinate (manual, automatic, native)
- *
- * @param value The configured coordinate value; has special values for automatic and native.
- * @param automatic The automatically calculated alternative.
- * @param native The original coordinate.
- * @see enum HackBGRT_coordinate
- */
-static int SelectCoordinate(int value, int automatic, int native) {
-	if (value == HackBGRT_coord_auto) {
-		return automatic;
-	}
-	if (value == HackBGRT_coord_native) {
-		return native;
-	}
-	return value;
-}
-
 /**
  * Create a new XSDT with the given number of entries.
  *
@@ -153,7 +139,7 @@ static ACPI_BGRT* HandleAcpiTables(enum HackBGRT_action action, ACPI_BGRT* bgrt)
 		if (CompareMem(rsdp->signature, "RSD PTR ", 8) != 0 || rsdp->revision < 2 || !VerifyAcpiRsdp2Checksums(rsdp)) {
 			continue;
 		}
-		Debug(L"RSDP: revision = %d, OEM ID = %s\n", rsdp->revision, TmpStr(rsdp->oem_id, 6));
+		Debug(L"RSDP @%x: revision = %d, OEM ID = %s\n", (UINTN)rsdp, rsdp->revision, TmpStr(rsdp->oem_id, 6));
 
 		ACPI_SDT_HEADER* xsdt = (ACPI_SDT_HEADER *) (UINTN) rsdp->xsdt_address;
 		if (!xsdt || CompareMem(xsdt->signature, "XSDT", 4) != 0 || !VerifyAcpiSdtChecksum(xsdt)) {
@@ -163,7 +149,7 @@ static ACPI_BGRT* HandleAcpiTables(enum HackBGRT_action action, ACPI_BGRT* bgrt)
 		UINT64* entry_arr = (UINT64*)&xsdt[1];
 		UINT32 entry_arr_length = (xsdt->length - sizeof(*xsdt)) / sizeof(UINT64);
 
-		Debug(L"* XSDT: OEM ID = %s, entry count = %d\n", TmpStr(xsdt->oem_id, 6), entry_arr_length);
+		Debug(L"* XSDT @%x: OEM ID = %s, entry count = %d\n", (UINTN)xsdt, TmpStr(xsdt->oem_id, 6), entry_arr_length);
 
 		int bgrt_count = 0;
 		for (int j = 0; j < entry_arr_length; j++) {
@@ -171,7 +157,7 @@ static ACPI_BGRT* HandleAcpiTables(enum HackBGRT_action action, ACPI_BGRT* bgrt)
 			if (CompareMem(entry->signature, "BGRT", 4) != 0) {
 				continue;
 			}
-			Debug(L" - ACPI table: %s, revision = %d, OEM ID = %s\n", TmpStr(entry->signature, 4), entry->revision, TmpStr(entry->oem_id, 6));
+			Debug(L" - ACPI table @%x: %s, revision = %d, OEM ID = %s\n", (UINTN)entry, TmpStr(entry->signature, 4), entry->revision, TmpStr(entry->oem_id, 6));
 			switch (action) {
 				case HackBGRT_KEEP:
 					if (!bgrt) {
@@ -208,6 +194,44 @@ static ACPI_BGRT* HandleAcpiTables(enum HackBGRT_action action, ACPI_BGRT* bgrt)
 	return bgrt;
 }
 
+/**
+ * Generate a BMP with the given size and color.
+ *
+ * @param w The width.
+ * @param h The height.
+ * @param r The red component.
+ * @param g The green component.
+ * @param b The blue component.
+ * @return The generated BMP, or 0 on failure.
+ */
+static BMP* MakeBMP(int w, int h, UINT8 r, UINT8 g, UINT8 b) {
+	BMP* bmp = 0;
+	BS->AllocatePool(EfiBootServicesData, 54 + w * h * 4, (void**) &bmp);
+	if (!bmp) {
+		Print(L"HackBGRT: Failed to allocate a blank BMP!\n");
+		BS->Stall(1000000);
+		return 0;
+	}
+	*bmp = (BMP) {
+		.magic_BM = { 'B', 'M' },
+		.file_size = 54 + w * h * 4,
+		.pixel_data_offset = 54,
+		.dib_header_size = 40,
+		.width = w,
+		.height = h,
+		.planes = 1,
+		.bpp = 32,
+	};
+	UINT8* data = (UINT8*) bmp + bmp->pixel_data_offset;
+	for (int y = 0; y < h; ++y) for (int x = 0; x < w; ++x) {
+		*data++ = b;
+		*data++ = g;
+		*data++ = r;
+		*data++ = 0;
+	}
+	return bmp;
+}
+
 /**
  * Load a bitmap or generate a black one.
  *
@@ -216,32 +240,50 @@ static ACPI_BGRT* HandleAcpiTables(enum HackBGRT_action action, ACPI_BGRT* bgrt)
  * @return The loaded BMP, or 0 if not available.
  */
 static BMP* LoadBMP(EFI_FILE_HANDLE root_dir, const CHAR16* path) {
-	BMP* bmp = 0;
 	if (!path) {
-		BS->AllocatePool(EfiBootServicesData, 58, (void**) &bmp);
-		if (!bmp) {
-			Print(L"HackBGRT: Failed to allocate a blank BMP!\n");
-			BS->Stall(1000000);
-			return 0;
-		}
-		CopyMem(
-			bmp,
-			"\x42\x4d\x3a\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x28\x00"
-			"\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x18\x00\x00\x00"
-			"\x00\x00\x04\x00\x00\x00\x13\x0b\x00\x00\x13\x0b\x00\x00\x00\x00"
-			"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-			58
-		);
-		return bmp;
+		return MakeBMP(1, 1, 0, 0, 0); // empty path = black image
 	}
 	Debug(L"HackBGRT: Loading %s.\n", path);
-	bmp = LoadFile(root_dir, path, 0);
-	if (!bmp) {
-		Print(L"HackBGRT: Failed to load BMP (%s)!\n", path);
-		BS->Stall(1000000);
-		return 0;
-	}
+	UINTN size = 0;
+	BMP* bmp = LoadFile(root_dir, path, &size);
+	if (bmp) {
+		if (size >= bmp->file_size && CompareMem(bmp, "BM", 2) == 0 && bmp->file_size - bmp->pixel_data_offset > 4 && bmp->width && bmp->height && (bmp->bpp == 32 || bmp->bpp == 24) && bmp->compression == 0) {
 			return bmp;
+		}
+		Print(L"HackBGRT: Invalid BMP (%s)!\n", path);
+	} else {
+		Print(L"HackBGRT: Failed to load BMP (%s)!\n", path);
+	}
+	BS->Stall(1000000);
+	return MakeBMP(16, 16, 255, 0, 0); // error = red image
+}
+
+/**
+ * Crop a BMP to the given size.
+ *
+ * @param bmp The BMP to crop.
+ * @param w The maximum width.
+ * @param h The maximum height.
+ */
+static void CropBMP(BMP* bmp, int w, int h) {
+	const int old_pitch = -(-(bmp->width * (bmp->bpp / 8)) & ~3);
+	bmp->image_size = 0;
+	bmp->width = min(bmp->width, w);
+	bmp->height = min(bmp->height, h);
+	const int h_max = (bmp->file_size - bmp->pixel_data_offset) / old_pitch;
+	bmp->height = min(bmp->height, h_max);
+	const int new_pitch = -(-(bmp->width * (bmp->bpp / 8)) & ~3);
+
+	if (new_pitch < old_pitch) {
+		for (int i = 1; i < bmp->height; ++i) {
+			CopyMem(
+				(UINT8*) bmp + bmp->pixel_data_offset + i * new_pitch,
+				(UINT8*) bmp + bmp->pixel_data_offset + i * old_pitch,
+				new_pitch
+			);
+		}
+	}
+	bmp->file_size = bmp->pixel_data_offset + bmp->height * new_pitch;
 }
 
 /**
@@ -259,14 +301,15 @@ void HackBgrt(EFI_FILE_HANDLE root_dir) {
 	// KEEP/REPLACE: first get the old BGRT entry.
 	ACPI_BGRT* bgrt = HandleAcpiTables(HackBGRT_KEEP, 0);
 
-	// Get the old BMP and position, if possible.
-	BMP* old_bmp = 0;
-	int old_x = 0, old_y = 0;
-	if (bgrt && VerifyAcpiSdtChecksum(bgrt)) {
-		old_bmp = (BMP*) (UINTN) bgrt->image_address;
-		old_x = bgrt->image_offset_x;
-		old_y = bgrt->image_offset_y;
-	}
+	// Get the old BMP and position (relative to screen center), if possible.
+	const int old_valid = bgrt && VerifyAcpiSdtChecksum(bgrt);
+	BMP* old_bmp = old_valid ? (BMP*) (UINTN) bgrt->image_address : 0;
+	const int old_orientation = old_valid ? ((bgrt->status >> 1) & 3) : 0;
+	const int old_swap = old_orientation & 1;
+	const int old_reso_x = old_swap ? config.old_resolution_y : config.old_resolution_x;
+	const int old_reso_y = old_swap ? config.old_resolution_x : config.old_resolution_y;
+	const int old_x = old_bmp ? bgrt->image_offset_x + (old_bmp->width - old_reso_x) / 2 : 0;
+	const int old_y = old_bmp ? bgrt->image_offset_y + (old_bmp->height - old_reso_y) / 2 : 0;
 
 	// Missing BGRT?
 	if (!bgrt) {
@@ -282,12 +325,19 @@ void HackBgrt(EFI_FILE_HANDLE root_dir) {
 		}
 	}
 
-	// Clear the BGRT.
-	const char data[0x38] =
-		"BGRT" "\x38\x00\x00\x00" "\x00" "\xd6" "Mtblx*" "HackBGRT"
-		"\x20\x17\x00\x00" "PTL " "\x02\x00\x00\x00"
-		"\x01\x00" "\x00" "\x00";
-	CopyMem(bgrt, data, sizeof(data));
+	*bgrt = (ACPI_BGRT) {
+		.header = {
+			.signature = "BGRT",
+			.length = sizeof(*bgrt),
+			.revision = 1,
+			.oem_id = "Mtblx*",
+			.oem_table_id = "HackBGRT",
+			.oem_revision = 1,
+			.asl_compiler_id = *(const UINT32*) "None",
+			.asl_compiler_revision = 1,
+		},
+		.version = 1,
+	};
 
 	// Get the image (either old or new).
 	BMP* new_bmp = old_bmp;
@@ -301,28 +351,52 @@ void HackBgrt(EFI_FILE_HANDLE root_dir) {
 		return;
 	}
 
+	// Crop the image to screen.
+	CropBMP(new_bmp, config.resolution_x, config.resolution_y);
+
+	// Set the image address and orientation.
 	bgrt->image_address = (UINTN) new_bmp;
+	const int new_orientation = config.orientation == HackBGRT_coord_keep ? old_orientation : ((config.orientation / 90) & 3);
+	bgrt->status = new_orientation << 1;
 
-	// Calculate the automatically centered position for the image.
-	int auto_x = 0, auto_y = 0;
-	if (GOP()) {
-		auto_x = max(0, ((int)GOP()->Mode->Info->HorizontalResolution - (int)new_bmp->width) / 2);
-		auto_y = max(0, ((int)GOP()->Mode->Info->VerticalResolution * 2/3 - (int)new_bmp->height) / 2);
-	} else if (old_bmp) {
-		auto_x = max(0, old_x + ((int)old_bmp->width - (int)new_bmp->width) / 2);
-		auto_y = max(0, old_y + ((int)old_bmp->height - (int)new_bmp->height) / 2);
-	}
+	// New center coordinates.
+	const int new_x = config.image_x == HackBGRT_coord_keep ? old_x : config.image_x;
+	const int new_y = config.image_y == HackBGRT_coord_keep ? old_y : config.image_y;
+	const int new_swap = new_orientation & 1;
+	const int new_reso_x = new_swap ? config.resolution_y : config.resolution_x;
+	const int new_reso_y = new_swap ? config.resolution_x : config.resolution_y;
 
-	// Set the position (manual, automatic, original).
-	bgrt->image_offset_x = SelectCoordinate(config.image_x, auto_x, old_x);
-	bgrt->image_offset_y = SelectCoordinate(config.image_y, auto_y, old_y);
-	Debug(L"HackBGRT: BMP at (%d, %d).\n", (int) bgrt->image_offset_x, (int) bgrt->image_offset_y);
+	// Calculate absolute position.
+	const int max_x = new_reso_x - new_bmp->width;
+	const int max_y = new_reso_y - new_bmp->height;
+	bgrt->image_offset_x = max(0, min(max_x, new_x + (new_reso_x - new_bmp->width) / 2));
+	bgrt->image_offset_y = max(0, min(max_y, new_y + (new_reso_y - new_bmp->height) / 2));
+
+	Debug(
+		L"HackBGRT: BMP at (%d, %d), center (%d, %d), resolution (%d, %d) with orientation %d applied.\n",
+		(int) bgrt->image_offset_x, (int) bgrt->image_offset_y,
+		new_x, new_y, new_reso_x, new_reso_y,
+		new_orientation * 90
+	);
 
 	// Store this BGRT in the ACPI tables.
 	SetAcpiSdtChecksum(bgrt);
 	HandleAcpiTables(HackBGRT_REPLACE, bgrt);
 }
 
+/**
+ * Load an application.
+ */
+static EFI_HANDLE LoadApp(print_t* print_failure, EFI_HANDLE image_handle, EFI_LOADED_IMAGE* image, const CHAR16* path) {
+	EFI_DEVICE_PATH* boot_dp = FileDevicePath(image->DeviceHandle, (CHAR16*) path);
+	EFI_HANDLE result = 0;
+	Debug(L"HackBGRT: Loading application %s.\n", path);
+	if (EFI_ERROR(BS->LoadImage(0, image_handle, boot_dp, 0, 0, &result))) {
+		print_failure(L"HackBGRT: Failed to load application %s.\n", path);
+	}
+	return result;
+}
+
 /**
  * The main program.
  */
@@ -356,33 +430,38 @@ EFI_STATUS EFIAPI EfiMain(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *ST_) {
 	HackBgrt(root_dir);
 
 	EFI_HANDLE next_image_handle = 0;
-	if (!config.boot_path) {
-		Print(L"HackBGRT: Boot path not specified.\n");
+	static CHAR16 backup_boot_path[] = L"\\EFI\\HackBGRT\\bootmgfw-original.efi";
+	static CHAR16 ms_boot_path[] = L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi";
+
+	if (config.boot_path && StriCmp(config.boot_path, L"MS") != 0) {
+		next_image_handle = LoadApp(Print, image_handle, image, config.boot_path);
 	} else {
-		Debug(L"HackBGRT: Loading application %s.\n", config.boot_path);
-		EFI_DEVICE_PATH* boot_dp = FileDevicePath(image->DeviceHandle, (CHAR16*) config.boot_path);
-		if (EFI_ERROR(BS->LoadImage(0, image_handle, boot_dp, 0, 0, &next_image_handle))) {
-			Print(L"HackBGRT: Failed to load application %s.\n", config.boot_path);
+		config.boot_path = backup_boot_path;
+		next_image_handle = LoadApp(Debug, image_handle, image, config.boot_path);
+		if (!next_image_handle) {
+			config.boot_path = ms_boot_path;
+			next_image_handle = LoadApp(Debug, image_handle, image, config.boot_path);
 		}
 	}
 	if (!next_image_handle) {
-		static CHAR16 default_boot_path[] = L"\\EFI\\HackBGRT\\bootmgfw-original.efi";
-		Debug(L"HackBGRT: Loading application %s.\n", default_boot_path);
-		EFI_DEVICE_PATH* boot_dp = FileDevicePath(image->DeviceHandle, default_boot_path);
-		if (EFI_ERROR(BS->LoadImage(0, image_handle, boot_dp, 0, 0, &next_image_handle))) {
-			Print(L"HackBGRT: Also failed to load application %s.\n", default_boot_path);
+		config.boot_path = backup_boot_path;
+		next_image_handle = LoadApp(Print, image_handle, image, config.boot_path);
+		if (!next_image_handle) {
+			config.boot_path = ms_boot_path;
+			next_image_handle = LoadApp(Print, image_handle, image, config.boot_path);
+			if (!next_image_handle) {
 				goto fail;
 			}
-		Print(L"HackBGRT: Reverting to %s.\n", default_boot_path);
-		Print(L"Press escape to cancel, any other key to boot.\n");
-		if (ReadKey().ScanCode == SCAN_ESC) {
+		}
+		Print(L"HackBGRT: Reverting to %s.\n", config.boot_path);
+		Print(L"Press escape to cancel or any other key (or wait 15 seconds) to boot.\n");
+		if (ReadKey(15000).ScanCode == SCAN_ESC) {
 			goto fail;
 		}
-		config.boot_path = default_boot_path;
-	}
-	if (config.debug) {
-		Print(L"HackBGRT: Ready to boot.\nPress escape to cancel, any other key to boot.\n");
-		if (ReadKey().ScanCode == SCAN_ESC) {
+	} else if (config.debug) {
+		Print(L"HackBGRT: Ready to boot. Disable debug mode to skip this screen.\n");
+		Print(L"Press escape to cancel or any other key (or wait 15 seconds) to boot.\n");
+		if (ReadKey(15000).ScanCode == SCAN_ESC) {
 			return 0;
 		}
 	}
@@ -391,6 +470,7 @@ EFI_STATUS EFIAPI EfiMain(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *ST_) {
 		goto fail;
 	}
 	Print(L"HackBGRT: Started %s. Why are we still here?!\n", config.boot_path);
+	Print(L"Please check that %s is not actually HackBGRT!\n", config.boot_path);
 	goto fail;
 
 	fail: {
@@ -401,8 +481,8 @@ EFI_STATUS EFIAPI EfiMain(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *ST_) {
 		#else
 			Print(L"HackBGRT version: unknown; not an official release?\n");
 		#endif
-		Print(L"Press any key to exit.\n");
-		ReadKey();
+		Print(L"Press any key (or wait 15 seconds) to exit.\n");
+		ReadKey(15000);
 		return 1;
 	}
 }

src/types.h

@@ -52,6 +52,12 @@ typedef struct {
 	UINT32 height;
 	UINT16 planes;
 	UINT16 bpp;
+	UINT32 compression;
+	UINT32 image_size;
+	UINT32 x_pixels_per_meter;
+	UINT32 y_pixels_per_meter;
+	UINT32 colors_used;
+	UINT32 important_colors;
 } BMP;
 
 /**

src/util.c

@@ -14,7 +14,7 @@ const CHAR16* TmpStr(CHAR8 *src, int length) {
 	return dest;
 }
 
-UINTN NullPrint(IN CHAR16 *fmt, ...) {
+UINTN NullPrint(IN CONST CHAR16 *fmt, ...) {
 	return 0;
 }
 
@@ -68,14 +68,15 @@ void RandomSeedAuto(void) {
 	RandomSeed(a, b), Random(), Random();
 }
 
-void WaitKey(void) {
+EFI_STATUS WaitKey(UINT64 timeout_ms) {
 	ST->ConIn->Reset(ST->ConIn, FALSE);
-	WaitForSingleEvent(ST->ConIn->WaitForKey, 0);
+	const int ms_to_100ns = 10000;
+	return WaitForSingleEvent(ST->ConIn->WaitForKey, timeout_ms * ms_to_100ns);
 }
 
-EFI_INPUT_KEY ReadKey(void) {
-	WaitKey();
+EFI_INPUT_KEY ReadKey(UINT64 timeout_ms) {
 	EFI_INPUT_KEY key = {0};
+	WaitKey(timeout_ms);
 	ST->ConIn->ReadKeyStroke(ST->ConIn, &key);
 	return key;
 }

src/util.h

@@ -14,7 +14,7 @@ extern const CHAR16* TmpStr(CHAR8 *src, int length);
 /**
  * Empty function that has the same signature as Print.
  */
-extern UINTN NullPrint(IN CHAR16 *fmt, ...);
+extern UINTN NullPrint(IN CONST CHAR16 *fmt, ...);
 
 /**
  * Return the greater of two numbers.
@@ -82,15 +82,18 @@ extern void RandomSeedAuto(void);
 
 /**
  * Wait for a key press. It will still remain in the buffer.
+ *
+ * @param timeout_ms The timeout in milliseconds, or 0 for no timeout.
  */
-extern void WaitKey(void);
+extern EFI_STATUS WaitKey(UINT64 timeout_ms);
 
 /**
  * Wait for a key press and read it.
  *
+ * @param timeout_ms The timeout in milliseconds, or 0 for no timeout.
  * @return The pressed key.
  */
-extern EFI_INPUT_KEY ReadKey(void);
+extern EFI_INPUT_KEY ReadKey(UINT64 timeout_ms);
 
 /**
  * Load a file, allocate some extra bytes as well.