Add option to (un)block updates from within the boot selector and update block warning

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/ci.yml

@@ -9,15 +9,22 @@ jobs:
   clang-format:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: clang-format
       run: |
-        docker run --rm -v ${PWD}:/src  wiiuenv/clang-format:13.0.0-2 -r ./source
+        docker run --rm -v ${PWD}:/src ghcr.io/wiiu-env/clang-format:13.0.0-2 -r ./source
   build-binary:
     runs-on: ubuntu-22.04
     needs: clang-format
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
+    - name: create version.h
+      run: |
+        git_hash=$(git rev-parse --short "$GITHUB_SHA")
+        cat <<EOF > ./source/version.h
+        #pragma once
+        #define AUTOBOOT_MODULE_VERSION_EXTRA " (nightly-$git_hash)"
+        EOF
     - name: build binary
       run: |
         docker build . -t builder
@@ -41,25 +48,12 @@ jobs:
     - name: zip artifact
       run: zip -r ${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip *.rpx
     - name: Create Release
-      id: create_release
-      uses: actions/create-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      uses: "softprops/action-gh-release@v2"
       with:
         tag_name: ${{ env.REPOSITORY_NAME }}-${{ env.DATETIME }}
-        release_name: Nightly-${{ env.REPOSITORY_NAME }}-${{ env.DATETIME }}
         draft: false
         prerelease: true
-        body: |
-           Not a stable release:
-           ${{ github.event.head_commit.message }}
-    - name: Upload Release Asset
-      id: upload-release-asset 
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
-        asset_path: ./${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip
-        asset_name: ${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip
-        asset_content_type: application/zip
+        generate_release_notes: true
+        name: Nightly-${{ env.REPOSITORY_NAME }}-${{ env.DATETIME }}
+        files: |
+          ./${{ env.REPOSITORY_NAME }}_${{ env.DATETIME }}.zip

.github/workflows/pr.yml

@@ -6,15 +6,15 @@ jobs:
   clang-format:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: clang-format
       run: |
-        docker run --rm -v ${PWD}:/src  wiiuenv/clang-format:13.0.0-2 -r ./source
+        docker run --rm -v ${PWD}:/src ghcr.io/wiiu-env/clang-format:13.0.0-2 -r ./source
   check-build-with-logging:
     runs-on: ubuntu-22.04
     needs: clang-format
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: build binary with logging
       run: |
         docker build . -t builder
@@ -25,7 +25,14 @@ jobs:
     runs-on: ubuntu-22.04
     needs: clang-format
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
+    - name: create version.h
+      run: |
+        git_hash=$(git rev-parse --short "${{ github.event.pull_request.head.sha }}")
+        cat <<EOF > ./source/version.h
+        #pragma once
+        #define AUTOBOOT_MODULE_VERSION_EXTRA " (nightly-$git_hash)"
+        EOF
     - name: build binary
       run: |
         docker build . -t builder

.gitignore

@@ -2,5 +2,7 @@
 *.rpx
 build/
 .idea/
+.vscode/
 cmake-build-debug/
 CMakeLists.txt
+*.zip

Dockerfile

@@ -1,5 +1,6 @@
-FROM wiiuenv/devkitppc:20220806
+FROM ghcr.io/wiiu-env/devkitppc:20240505
 
-COPY --from=wiiuenv/libmocha:20220903 /artifacts $DEVKITPRO
+COPY --from=ghcr.io/wiiu-env/libmocha:20230621 /artifacts $DEVKITPRO
+COPY --from=ghcr.io/wiiu-env/librpxloader:20240425 /artifacts $DEVKITPRO
 
-WORKDIR project
+WORKDIR project

Makefile

@@ -10,6 +10,8 @@ TOPDIR ?= $(CURDIR)
 
 include $(DEVKITPRO)/wut/share/wut_rules
 
+WUMS_ROOT := $(DEVKITPRO)/wums
+
 #-------------------------------------------------------------------------------
 # TARGET is the name of the output
 # BUILD is the directory where object files & intermediate files will be placed
@@ -36,7 +38,7 @@ CXXFLAGS	:= $(CFLAGS) -std=c++20 -fno-rtti
 ASFLAGS	:=	-g $(ARCH)
 LDFLAGS	=	-g $(ARCH) $(RPXSPECS) --entry=_start -Wl,-Map,$(notdir $*.map)
 
-LIBS	:= -lfreetype -lpng -lbz2 -lmocha -lwut -lz
+LIBS	:= -lrpxloader -lpng -lmocha -lwut -lz
 
 ifeq ($(DEBUG),1)
 CXXFLAGS += -DDEBUG -g
@@ -52,7 +54,7 @@ endif
 # list of directories containing libraries, this must be the top level
 # containing include and lib
 #-------------------------------------------------------------------------------
-LIBDIRS	:= $(PORTLIBS) $(WUT_ROOT) $(WUT_ROOT)/usr
+LIBDIRS	:= $(PORTLIBS) $(WUMS_ROOT) $(WUT_ROOT) $(WUT_ROOT)/usr
 
 #-------------------------------------------------------------------------------
 # no real need to edit anything past this point unless you need to add additional
@@ -95,7 +97,7 @@ export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
 
 export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
 			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I$(CURDIR)/$(BUILD) -I$(DEVKITPRO)/portlibs/ppc/include/freetype2
+			-I$(CURDIR)/$(BUILD)
 
 export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
 
@@ -105,7 +107,7 @@ export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
 all: $(BUILD)
 
 $(BUILD):
-	@[ -d $@ ] || mkdir -p $@
+	@$(shell [ ! -d $(BUILD) ] && mkdir -p $(BUILD))
 	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
 
 #-------------------------------------------------------------------------------

README.md

@@ -47,7 +47,7 @@ docker run -it --rm -v ${PWD}:/project autobootmodule-builder make clean
 
 ## Format the code via docker
 
-`docker run --rm -v ${PWD}:/src wiiuenv/clang-format:13.0.0-2 -r ./source -i`
+`docker run --rm -v ${PWD}:/src ghcr.io/wiiu-env/clang-format:13.0.0-2 -r ./source -i`
 
 ## Credits
 - GaryOderNichts

source/DrawUtils.cpp

@@ -1,14 +1,14 @@
 #include "DrawUtils.h"
-#include <malloc.h>
 
-#include <cmath>
+#include "MenuUtils.h"
+#include "logger.h"
+#include "utils.h"
 #include <coreinit/cache.h>
 #include <coreinit/memory.h>
 #include <coreinit/screen.h>
-#include <ft2build.h>
+#include <cstdlib>
+#include <malloc.h>
 #include <png.h>
-#include FT_FREETYPE_H
-#include "MenuUtils.h"
 
 // buffer width
 #define TV_WIDTH  0x500
@@ -20,11 +20,9 @@ uint8_t *DrawUtils::tvBuffer  = nullptr;
 uint32_t DrawUtils::tvSize    = 0;
 uint8_t *DrawUtils::drcBuffer = nullptr;
 uint32_t DrawUtils::drcSize   = 0;
+static SFT pFont              = {};
 
-// Don't put those into the class or we have to include ft everywhere
-static FT_Library ft_lib = nullptr;
-static FT_Face ft_face   = nullptr;
-static Color font_col    = {0xFFFFFFFF};
+static Color font_col(0xFFFFFFFF);
 
 void *DrawUtils::InitOSScreen() {
     OSScreenInit();
@@ -101,10 +99,17 @@ void DrawUtils::drawPixel(uint32_t x, uint32_t y, uint8_t r, uint8_t g, uint8_t
         }
     }
 
+    uint32_t USED_TV_WIDTH = TV_WIDTH;
+    float scale            = 1.5f;
+    if (DrawUtils::tvSize == 0x00FD2000) {
+        USED_TV_WIDTH = 1920;
+        scale         = 2.25f;
+    }
+
     // scale and put pixel in the tv buffer
-    for (uint32_t yy = (y * 1.5); yy < ((y * 1.5) + 1); yy++) {
-        for (uint32_t xx = (x * 1.5); xx < ((x * 1.5) + 1); xx++) {
-            uint32_t i = (xx + yy * TV_WIDTH) * 4;
+    for (uint32_t yy = (y * scale); yy < ((y * scale) + (uint32_t) scale); yy++) {
+        for (uint32_t xx = (x * scale); xx < ((x * scale) + (uint32_t) scale); xx++) {
+            uint32_t i = (xx + yy * USED_TV_WIDTH) * 4;
             if (i + 3 < tvSize / 2) {
                 if (isBackBuffer) {
                     i += tvSize / 2;
@@ -172,14 +177,14 @@ static void png_read_data(png_structp png_ptr, png_bytep outBytes, png_size_t by
 }
 
 void DrawUtils::drawPNG(uint32_t x, uint32_t y, const uint8_t *data) {
-    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-    if (png_ptr == NULL) {
+    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+    if (png_ptr == nullptr) {
         return;
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
-    if (info_ptr == NULL) {
-        png_destroy_read_struct(&png_ptr, NULL, NULL);
+    if (info_ptr == nullptr) {
+        png_destroy_read_struct(&png_ptr, nullptr, nullptr);
         return;
     }
 
@@ -191,16 +196,16 @@ void DrawUtils::drawPNG(uint32_t x, uint32_t y, const uint8_t *data) {
     uint32_t height = 0;
     int bitDepth    = 0;
     int colorType   = -1;
-    uint32_t retval = png_get_IHDR(png_ptr, info_ptr, &width, &height, &bitDepth, &colorType, NULL, NULL, NULL);
+    uint32_t retval = png_get_IHDR(png_ptr, info_ptr, &width, &height, &bitDepth, &colorType, nullptr, nullptr, nullptr);
     if (retval != 1) {
         return;
     }
 
     uint32_t bytesPerRow = png_get_rowbytes(png_ptr, info_ptr);
-    uint8_t *rowData     = new uint8_t[bytesPerRow];
+    auto *rowData        = new uint8_t[bytesPerRow];
 
     for (uint32_t yy = y; yy < y + height; yy++) {
-        png_read_row(png_ptr, (png_bytep) rowData, NULL);
+        png_read_row(png_ptr, (png_bytep) rowData, nullptr);
 
         for (uint32_t xx = x; xx < x + width; xx++) {
             if (colorType == PNG_COLOR_TYPE_RGB_ALPHA) {
@@ -214,37 +219,52 @@ void DrawUtils::drawPNG(uint32_t x, uint32_t y, const uint8_t *data) {
     }
 
     delete[] rowData;
-    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    png_destroy_read_struct(&png_ptr, &info_ptr, nullptr);
 }
 
-void DrawUtils::initFont() {
-    void *font    = NULL;
+bool DrawUtils::initFont() {
+    void *font    = nullptr;
     uint32_t size = 0;
     OSGetSharedData(OS_SHAREDDATATYPE_FONT_STANDARD, 0, &font, &size);
 
     if (font && size) {
-        FT_Init_FreeType(&ft_lib);
-        FT_New_Memory_Face(ft_lib, (FT_Byte *) font, size, 0, &ft_face);
+        pFont.xScale = 20;
+        pFont.yScale = 20,
+        pFont.flags  = SFT_DOWNWARD_Y;
+        pFont.font   = sft_loadmem(font, size);
+        if (!pFont.font) {
+            return false;
+        }
+        OSMemoryBarrier();
+        return true;
     }
+    return false;
 }
 
 void DrawUtils::deinitFont() {
-    FT_Done_Face(ft_face);
-    FT_Done_FreeType(ft_lib);
+    sft_freefont(pFont.font);
+    pFont.font = nullptr;
+    pFont      = {};
 }
 
 void DrawUtils::setFontSize(uint32_t size) {
-    FT_Set_Pixel_Sizes(ft_face, 0, size);
+    pFont.xScale = size;
+    pFont.yScale = size;
+    SFT_LMetrics metrics;
+    sft_lmetrics(&pFont, &metrics);
 }
 
 void DrawUtils::setFontColor(Color col) {
     font_col = col;
 }
 
-static void draw_freetype_bitmap(FT_Bitmap *bitmap, FT_Int x, FT_Int y) {
-    FT_Int i, j, p, q;
-    FT_Int x_max = x + bitmap->width;
-    FT_Int y_max = y + bitmap->rows;
+static void draw_freetype_bitmap(SFT_Image *bmp, int32_t x, int32_t y) {
+    int32_t i, j, p, q;
+
+    int32_t x_max = x + bmp->width;
+    int32_t y_max = y + bmp->height;
+
+    auto *src = (uint8_t *) bmp->pixels;
 
     for (i = x, p = 0; i < x_max; i++, p++) {
         for (j = y, q = 0; j < y_max; j++, q++) {
@@ -252,14 +272,14 @@ static void draw_freetype_bitmap(FT_Bitmap *bitmap, FT_Int x, FT_Int y) {
                 continue;
             }
 
-            float opacity = bitmap->buffer[q * bitmap->pitch + p] / 255.0f;
+            float opacity = src[q * bmp->width + p] / 255.0f;
             DrawUtils::drawPixel(i, j, font_col.r, font_col.g, font_col.b, font_col.a * opacity);
         }
     }
 }
 
 void DrawUtils::print(uint32_t x, uint32_t y, const char *string, bool alignRight) {
-    wchar_t *buffer = new wchar_t[strlen(string) + 1];
+    auto *buffer = new wchar_t[strlen(string) + 1];
 
     size_t num = mbstowcs(buffer, string, strlen(string));
     if (num > 0) {
@@ -275,32 +295,64 @@ void DrawUtils::print(uint32_t x, uint32_t y, const char *string, bool alignRigh
 }
 
 void DrawUtils::print(uint32_t x, uint32_t y, const wchar_t *string, bool alignRight) {
-    FT_GlyphSlot slot = ft_face->glyph;
-    FT_Vector pen     = {(int) x, (int) y};
+    auto penX = (int32_t) x;
+    auto penY = (int32_t) y;
 
     if (alignRight) {
-        pen.x -= getTextWidth(string);
+        penX -= getTextWidth(string);
     }
 
+    uint16_t textureWidth = 0, textureHeight = 0;
     for (; *string; string++) {
-        uint32_t charcode = *string;
+        SFT_Glyph gid; //  unsigned long gid;
+        if (sft_lookup(&pFont, *string, &gid) >= 0) {
+            SFT_GMetrics mtx;
+            if (sft_gmetrics(&pFont, gid, &mtx) < 0) {
+                DEBUG_FUNCTION_LINE_ERR("Failed to get glyph metrics");
+                return;
+            }
 
-        if (charcode == '\n') {
-            pen.y += ft_face->size->metrics.height >> 6;
-            pen.x = x;
-            continue;
+            if (*string == '\n') {
+                penY += mtx.minHeight;
+                penX = x;
+                continue;
+            }
+
+            textureWidth  = (mtx.minWidth + 3) & ~3;
+            textureHeight = mtx.minHeight;
+
+            SFT_Image img = {
+                    .pixels = nullptr,
+                    .width  = textureWidth,
+                    .height = textureHeight,
+            };
+
+            if (textureWidth == 0) {
+                textureWidth = 4;
+            }
+            if (textureHeight == 0) {
+                textureHeight = 4;
+            }
+
+            auto buffer = make_unique_nothrow<uint8_t[]>((uint32_t) (img.width * img.height));
+            if (!buffer) {
+                DEBUG_FUNCTION_LINE_ERR("Failed to allocate memory for glyph");
+                return;
+            }
+            img.pixels = buffer.get();
+            if (sft_render(&pFont, gid, img) < 0) {
+                DEBUG_FUNCTION_LINE_ERR("Failed to render glyph");
+                return;
+            } else {
+                draw_freetype_bitmap(&img, (int32_t) (penX + mtx.leftSideBearing), (int32_t) (penY + mtx.yOffset));
+                penX += (int32_t) mtx.advanceWidth;
+            }
         }
-
-        FT_Load_Glyph(ft_face, FT_Get_Char_Index(ft_face, charcode), FT_LOAD_DEFAULT);
-        FT_Render_Glyph(slot, FT_RENDER_MODE_NORMAL);
-
-        draw_freetype_bitmap(&slot->bitmap, pen.x + slot->bitmap_left, pen.y - slot->bitmap_top);
-        pen.x += slot->advance.x >> 6;
     }
 }
 
 uint32_t DrawUtils::getTextWidth(const char *string) {
-    wchar_t *buffer = new wchar_t[strlen(string) + 1];
+    auto *buffer = new wchar_t[strlen(string) + 1];
 
     size_t num = mbstowcs(buffer, string, strlen(string));
     if (num > 0) {
@@ -318,14 +370,18 @@ uint32_t DrawUtils::getTextWidth(const char *string) {
 }
 
 uint32_t DrawUtils::getTextWidth(const wchar_t *string) {
-    FT_GlyphSlot slot = ft_face->glyph;
-    uint32_t width    = 0;
+    uint32_t width = 0;
 
     for (; *string; string++) {
-        FT_Load_Glyph(ft_face, FT_Get_Char_Index(ft_face, *string), FT_LOAD_BITMAP_METRICS_ONLY);
-
-        width += slot->advance.x >> 6;
+        SFT_Glyph gid; //  unsigned long gid;
+        if (sft_lookup(&pFont, *string, &gid) >= 0) {
+            SFT_GMetrics mtx;
+            if (sft_gmetrics(&pFont, gid, &mtx) < 0) {
+                DEBUG_FUNCTION_LINE_ERR("bad glyph metrics");
+            }
+            width += (int32_t) mtx.advanceWidth;
+        }
     }
 
-    return width;
+    return (uint32_t) width;
 }

source/DrawUtils.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "schrift.h"
 #include <cstdint>
 
 // visible screen sizes
@@ -7,7 +8,7 @@
 #define SCREEN_HEIGHT 480
 
 union Color {
-    Color(uint32_t color) {
+    explicit Color(uint32_t color) {
         this->color = color;
     }
 
@@ -18,7 +19,7 @@ union Color {
         this->a = a;
     }
 
-    uint32_t color;
+    uint32_t color{};
     struct {
         uint8_t r;
         uint8_t g;
@@ -51,7 +52,7 @@ public:
 
     static void drawPNG(uint32_t x, uint32_t y, const uint8_t *data);
 
-    static void initFont();
+    static bool initFont();
 
     static void deinitFont();
 

source/InputUtils.cpp

@@ -0,0 +1,139 @@
+#include "InputUtils.h"
+#include <coreinit/thread.h>
+#include <padscore/kpad.h>
+#include <padscore/wpad.h>
+#include <vpad/input.h>
+
+uint32_t remapWiiMoteButtons(uint32_t buttons) {
+    uint32_t convButtons = 0;
+
+    if (buttons & WPAD_BUTTON_LEFT)
+        convButtons |= VPAD_BUTTON_LEFT;
+
+    if (buttons & WPAD_BUTTON_RIGHT)
+        convButtons |= VPAD_BUTTON_RIGHT;
+
+    if (buttons & WPAD_BUTTON_DOWN)
+        convButtons |= VPAD_BUTTON_DOWN;
+
+    if (buttons & WPAD_BUTTON_UP)
+        convButtons |= VPAD_BUTTON_UP;
+
+    if (buttons & WPAD_BUTTON_PLUS)
+        convButtons |= VPAD_BUTTON_PLUS;
+
+    if (buttons & WPAD_BUTTON_2)
+        convButtons |= VPAD_BUTTON_Y;
+
+    if (buttons & WPAD_BUTTON_1)
+        convButtons |= VPAD_BUTTON_X;
+
+    if (buttons & WPAD_BUTTON_B)
+        convButtons |= VPAD_BUTTON_B;
+
+    if (buttons & WPAD_BUTTON_A)
+        convButtons |= VPAD_BUTTON_A;
+
+    if (buttons & WPAD_BUTTON_MINUS)
+        convButtons |= VPAD_BUTTON_MINUS;
+
+    if (buttons & WPAD_BUTTON_HOME)
+        convButtons |= VPAD_BUTTON_HOME;
+
+    return convButtons;
+}
+
+uint32_t remapClassicButtons(uint32_t buttons) {
+    uint32_t convButtons = 0;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_LEFT)
+        convButtons |= VPAD_BUTTON_LEFT;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_RIGHT)
+        convButtons |= VPAD_BUTTON_RIGHT;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_DOWN)
+        convButtons |= VPAD_BUTTON_DOWN;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_UP)
+        convButtons |= VPAD_BUTTON_UP;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_PLUS)
+        convButtons |= VPAD_BUTTON_PLUS;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_X)
+        convButtons |= VPAD_BUTTON_X;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_Y)
+        convButtons |= VPAD_BUTTON_Y;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_B)
+        convButtons |= VPAD_BUTTON_B;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_A)
+        convButtons |= VPAD_BUTTON_A;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_MINUS)
+        convButtons |= VPAD_BUTTON_MINUS;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_HOME)
+        convButtons |= VPAD_BUTTON_HOME;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_ZR)
+        convButtons |= VPAD_BUTTON_ZR;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_ZL)
+        convButtons |= VPAD_BUTTON_ZL;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_R)
+        convButtons |= VPAD_BUTTON_R;
+
+    if (buttons & WPAD_CLASSIC_BUTTON_L)
+        convButtons |= VPAD_BUTTON_L;
+
+    return convButtons;
+}
+
+InputUtils::InputData InputUtils::getControllerInput() {
+    InputData inputData{};
+    VPADStatus vpadStatus{};
+    VPADReadError vpadError = VPAD_READ_UNINITIALIZED;
+    do {
+        if (VPADRead(VPAD_CHAN_0, &vpadStatus, 1, &vpadError) > 0 && vpadError == VPAD_READ_SUCCESS) {
+            inputData.trigger = vpadStatus.trigger;
+            inputData.hold    = vpadStatus.hold;
+            inputData.release = vpadStatus.release;
+        } else {
+            OSSleepTicks(OSMillisecondsToTicks(1));
+        }
+    } while (vpadError == VPAD_READ_NO_SAMPLES);
+
+    KPADStatus kpadStatus{};
+    KPADError kpadError = KPAD_ERROR_UNINITIALIZED;
+    for (int32_t i = 0; i < 4; i++) {
+        if (KPADReadEx((KPADChan) i, &kpadStatus, 1, &kpadError) > 0) {
+            if (kpadError == KPAD_ERROR_OK && kpadStatus.extensionType != 0xFF) {
+                if (kpadStatus.extensionType == WPAD_EXT_CORE || kpadStatus.extensionType == WPAD_EXT_NUNCHUK) {
+                    inputData.trigger |= remapWiiMoteButtons(kpadStatus.trigger);
+                    inputData.hold |= remapWiiMoteButtons(kpadStatus.hold);
+                    inputData.release |= remapWiiMoteButtons(kpadStatus.release);
+                } else {
+                    inputData.trigger |= remapClassicButtons(kpadStatus.classic.trigger);
+                    inputData.hold |= remapClassicButtons(kpadStatus.classic.hold);
+                    inputData.release |= remapClassicButtons(kpadStatus.classic.release);
+                }
+            }
+        }
+    }
+
+    return inputData;
+}
+
+void InputUtils::Init() {
+    KPADInit();
+    WPADEnableURCC(1);
+}
+
+void InputUtils::DeInit() {
+    KPADShutdown();
+}

source/InputUtils.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <cstdint>
+#include <vpad/input.h>
+
+class InputUtils {
+public:
+    typedef struct InputData {
+        uint32_t trigger = 0;
+        uint32_t hold    = 0;
+        uint32_t release = 0;
+    } InputData;
+
+    static void Init();
+    static void DeInit();
+
+    static InputData getControllerInput();
+};

source/MenuUtils.cpp

@@ -1,19 +1,26 @@
 #include "MenuUtils.h"
 #include "ACTAccountInfo.h"
 #include "DrawUtils.h"
-#include "icon_png.h"
+#include "InputUtils.h"
+#include "PairUtils.h"
 #include "logger.h"
+#include "main.h"
+#include "utils.h"
+#include "version.h"
 #include <coreinit/debug.h>
+#include <coreinit/filesystem_fsa.h>
 #include <coreinit/screen.h>
-#include <cstdint>
+#include <coreinit/thread.h>
 #include <cstring>
 #include <gx2/state.h>
 #include <malloc.h>
 #include <memory>
-#include <nn/act/client_cpp.h>
+#include <mocha/mocha.h>
 #include <string>
+#include <sysapp/title.h>
 #include <vector>
-#include <vpad/input.h>
+
+#define AUTOBOOT_MODULE_VERSION "v0.2.1"
 
 const char *autoboot_config_strings[] = {
         "wiiu_menu",
@@ -22,15 +29,6 @@ const char *autoboot_config_strings[] = {
         "vwii_homebrew_channel",
 };
 
-template<typename... Args>
-std::string string_format(const std::string &format, Args... args) {
-    int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
-    auto size  = static_cast<size_t>(size_s);
-    auto buf   = std::make_unique<char[]>(size);
-    std::snprintf(buf.get(), size, format.c_str(), args...);
-    return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
-}
-
 int32_t readAutobootOption(std::string &configPath) {
     FILE *f = fopen(configPath.c_str(), "r");
     if (f) {
@@ -60,6 +58,55 @@ void writeAutobootOption(std::string &configPath, int32_t autobootOption) {
     }
 }
 
+void drawMenuScreen(const std::map<uint32_t, std::string> &menu, uint32_t selectedIndex, uint32_t autobootIndex, bool updatesBlocked) {
+    DrawUtils::beginDraw();
+    DrawUtils::clear(COLOR_BACKGROUND);
+
+    // draw buttons
+    uint32_t index = 8 + 24 + 8 + 4;
+    for (uint32_t i = 0; i < menu.size(); i++) {
+        if (i == (uint32_t) selectedIndex) {
+            DrawUtils::drawRect(16, index, SCREEN_WIDTH - 16 * 2, 44, 4, COLOR_BORDER_HIGHLIGHTED);
+        } else {
+            DrawUtils::drawRect(16, index, SCREEN_WIDTH - 16 * 2, 44, 2, (i == (uint32_t) autobootIndex) ? COLOR_AUTOBOOT : COLOR_BORDER);
+        }
+
+        std::string curName = std::next(menu.begin(), i)->second;
+
+        DrawUtils::setFontSize(24);
+        DrawUtils::setFontColor((i == (uint32_t) autobootIndex) ? COLOR_AUTOBOOT : COLOR_TEXT);
+        DrawUtils::print(16 * 2, index + 8 + 24, curName.c_str());
+        index += 42 + 8;
+    }
+
+    DrawUtils::setFontColor(COLOR_TEXT);
+
+    // draw top bar
+    DrawUtils::setFontSize(24);
+    DrawUtils::print(16, 6 + 24, "Boot Selector");
+    DrawUtils::drawRectFilled(8, 8 + 24 + 4, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
+    DrawUtils::setFontSize(16);
+    DrawUtils::print(SCREEN_WIDTH - 16, 6 + 24, AUTOBOOT_MODULE_VERSION AUTOBOOT_MODULE_VERSION_EXTRA, true);
+
+    // draw bottom bar
+    DrawUtils::drawRectFilled(8, SCREEN_HEIGHT - 24 - 8 - 4, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
+    DrawUtils::setFontSize(18);
+    DrawUtils::print(16, SCREEN_HEIGHT - 8, "\ue07d Navigate ");
+    DrawUtils::print(SCREEN_WIDTH - 16, SCREEN_HEIGHT - 8, "\ue000 Choose", true);
+    const char *autobootHints = "\ue002/\ue046 Clear Autoboot / \ue003/\ue045 Select Autoboot";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(autobootHints) / 2, SCREEN_HEIGHT - 8, autobootHints, true);
+
+    if (updatesBlocked) {
+        DrawUtils::setFontSize(10);
+        DrawUtils::print(SCREEN_WIDTH - 16, SCREEN_HEIGHT - 24 - 8 - 4 - 10, "Updates blocked! Hold \ue045 + \ue046 to restore Update folder", true);
+    } else {
+        DrawUtils::setFontSize(10);
+        DrawUtils::print(SCREEN_WIDTH - 16, SCREEN_HEIGHT - 24 - 8 - 4 - 10, "Updates not blocked! Hold \ue045 + \ue046 to delete Update folder", true);
+    }
+
+    DrawUtils::endDraw();
+}
+
 int32_t handleMenuScreen(std::string &configPath, int32_t autobootOptionInput, const std::map<uint32_t, std::string> &menu) {
     auto screenBuffer = DrawUtils::InitOSScreen();
     if (!screenBuffer) {
@@ -70,7 +117,9 @@ int32_t handleMenuScreen(std::string &configPath, int32_t autobootOptionInput, c
     uint32_t drcBufferSize = OSScreenGetBufferSizeEx(SCREEN_DRC);
 
     DrawUtils::initBuffers(screenBuffer, tvBufferSize, (void *) ((uint32_t) screenBuffer + tvBufferSize), drcBufferSize);
-    DrawUtils::initFont();
+    if (!DrawUtils::initFont()) {
+        OSFatal("Failed to init font");
+    }
 
     int32_t selectedIndex = autobootOptionInput > 0 ? autobootOptionInput : 0;
     int autobootIndex     = autobootOptionInput;
@@ -95,78 +144,53 @@ int32_t handleMenuScreen(std::string &configPath, int32_t autobootOptionInput, c
         }
     }
 
-    bool redraw = true;
-    while (true) {
-        VPADStatus vpad{};
-        VPADRead(VPAD_CHAN_0, &vpad, 1, nullptr);
+    {
+        PairMenu pairMenu;
 
-        if (vpad.trigger & VPAD_BUTTON_UP) {
-            selectedIndex--;
-
-            if (selectedIndex < 0) {
-                selectedIndex = 0;
+        int32_t holdUpdateBlockedForFrames = 0;
+        while (true) {
+            if (pairMenu.ProcessPairScreen()) {
+                continue;
             }
 
-            redraw = true;
-        } else if (vpad.trigger & VPAD_BUTTON_DOWN) {
-            if (!menu.empty()) {
-                selectedIndex++;
 
-                if ((uint32_t) selectedIndex >= menu.size()) {
-                    selectedIndex = menu.size() - 1;
-                }
-                redraw = true;
-            }
-        } else if (vpad.trigger & VPAD_BUTTON_A) {
-            break;
-        } else if (vpad.trigger & VPAD_BUTTON_X) {
-            autobootIndex = -1;
-            redraw        = true;
-        } else if (vpad.trigger & VPAD_BUTTON_Y) {
-            autobootIndex = selectedIndex;
-            redraw        = true;
-        }
+            InputUtils::InputData input = InputUtils::getControllerInput();
 
-        if (redraw) {
-            DrawUtils::beginDraw();
-            DrawUtils::clear(COLOR_BACKGROUND);
+            if (input.trigger & VPAD_BUTTON_UP) {
+                selectedIndex--;
 
-            // draw buttons
-            uint32_t index = 8 + 24 + 8 + 4;
-            for (uint32_t i = 0; i < menu.size(); i++) {
-                if (i == (uint32_t) selectedIndex) {
-                    DrawUtils::drawRect(16, index, SCREEN_WIDTH - 16 * 2, 44, 4, COLOR_BORDER_HIGHLIGHTED);
-                } else {
-                    DrawUtils::drawRect(16, index, SCREEN_WIDTH - 16 * 2, 44, 2, (i == (uint32_t) autobootIndex) ? COLOR_AUTOBOOT : COLOR_BORDER);
+                if (selectedIndex < 0) {
+                    selectedIndex = 0;
                 }
 
-                std::string curName = std::next(menu.begin(), i)->second;
+            } else if (input.trigger & VPAD_BUTTON_DOWN) {
+                if (!menu.empty()) {
+                    selectedIndex++;
 
-                DrawUtils::setFontSize(24);
-                DrawUtils::setFontColor((i == (uint32_t) autobootIndex) ? COLOR_AUTOBOOT : COLOR_TEXT);
-                DrawUtils::print(16 * 2, index + 8 + 24, curName.c_str());
-                index += 42 + 8;
+                    if ((uint32_t) selectedIndex >= menu.size()) {
+                        selectedIndex = menu.size() - 1;
+                    }
+                }
+            } else if (input.trigger & VPAD_BUTTON_A) {
+                break;
+            } else if (input.trigger & (VPAD_BUTTON_X | VPAD_BUTTON_MINUS)) {
+                autobootIndex = -1;
+            } else if (input.trigger & (VPAD_BUTTON_Y | VPAD_BUTTON_PLUS)) {
+                autobootIndex = selectedIndex;
+            } else if ((input.hold & (VPAD_BUTTON_PLUS | VPAD_BUTTON_MINUS)) == (VPAD_BUTTON_PLUS | VPAD_BUTTON_MINUS)) {
+                if (holdUpdateBlockedForFrames++ > 50) {
+                    if (gUpdatesBlocked) {
+                        gUpdatesBlocked = !RestoreMLCUpdateDirectory();
+                    } else {
+                        gUpdatesBlocked = DeleteMLCUpdateDirectory();
+                    }
+                    holdUpdateBlockedForFrames = 0;
+                }
+            } else {
+                holdUpdateBlockedForFrames = 0;
             }
 
-            DrawUtils::setFontColor(COLOR_TEXT);
-
-            // draw top bar
-            DrawUtils::setFontSize(24);
-            DrawUtils::drawPNG(16, 2, icon_png);
-            DrawUtils::print(64 + 2, 6 + 24, "Boot Selector");
-            DrawUtils::drawRectFilled(8, 8 + 24 + 4, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
-
-            // draw bottom bar
-            DrawUtils::drawRectFilled(8, SCREEN_HEIGHT - 24 - 8 - 4, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
-            DrawUtils::setFontSize(18);
-            DrawUtils::print(16, SCREEN_HEIGHT - 8, "\ue07d Navigate ");
-            DrawUtils::print(SCREEN_WIDTH - 16, SCREEN_HEIGHT - 8, "\ue000 Choose", true);
-            const char *autobootHints = "\ue002 Clear Autoboot / \ue003 Select Autoboot";
-            DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(autobootHints) / 2, SCREEN_HEIGHT - 8, autobootHints, true);
-
-            DrawUtils::endDraw();
-
-            redraw = false;
+            drawMenuScreen(menu, selectedIndex, autobootIndex, gUpdatesBlocked);
         }
     }
 
@@ -198,7 +222,6 @@ int32_t handleMenuScreen(std::string &configPath, int32_t autobootOptionInput, c
     return selected;
 }
 
-
 nn::act::SlotNo handleAccountSelectScreen(const std::vector<std::shared_ptr<AccountInfo>> &data) {
     auto screenBuffer = DrawUtils::InitOSScreen();
     if (!screenBuffer) {
@@ -209,29 +232,32 @@ nn::act::SlotNo handleAccountSelectScreen(const std::vector<std::shared_ptr<Acco
     uint32_t drcBufferSize = OSScreenGetBufferSizeEx(SCREEN_DRC);
 
     DrawUtils::initBuffers(screenBuffer, tvBufferSize, (void *) ((uint32_t) screenBuffer + tvBufferSize), drcBufferSize);
-    DrawUtils::initFont();
+    if (!DrawUtils::initFont()) {
+        OSFatal("Failed to init font");
+    }
 
     int32_t selected = 0;
-    bool redraw      = true;
-    while (true) {
-        VPADStatus vpad{};
-        VPADRead(VPAD_CHAN_0, &vpad, 1, nullptr);
-
-        if (vpad.trigger & VPAD_BUTTON_UP) {
-            if (selected > 0) {
-                selected--;
-                redraw = true;
+    {
+        PairMenu pairMenu;
+        while (true) {
+            if (pairMenu.ProcessPairScreen()) {
+                continue;
             }
-        } else if (vpad.trigger & VPAD_BUTTON_DOWN) {
-            if (selected < (int32_t) data.size() - 1) {
-                selected++;
-                redraw = true;
-            }
-        } else if (vpad.trigger & VPAD_BUTTON_A) {
-            break;
-        }
 
-        if (redraw) {
+            InputUtils::InputData input = InputUtils::getControllerInput();
+            if (input.trigger & VPAD_BUTTON_UP) {
+                if (selected > 0) {
+                    selected--;
+                }
+            } else if (input.trigger & VPAD_BUTTON_DOWN) {
+                if (selected < (int32_t) data.size() - 1) {
+                    selected++;
+                }
+            } else if (input.trigger & VPAD_BUTTON_A) {
+                break;
+            }
+
+
             DrawUtils::beginDraw();
             DrawUtils::clear(COLOR_BACKGROUND);
 
@@ -302,8 +328,6 @@ nn::act::SlotNo handleAccountSelectScreen(const std::vector<std::shared_ptr<Acco
             }
 
             DrawUtils::endDraw();
-
-            redraw = false;
         }
     }
 
@@ -330,6 +354,45 @@ nn::act::SlotNo handleAccountSelectScreen(const std::vector<std::shared_ptr<Acco
     return resultSlot;
 }
 
+void drawUpdateWarningScreen() {
+    DrawUtils::beginDraw();
+    DrawUtils::clear(COLOR_BACKGROUND_WARN);
+
+    DrawUtils::setFontColor(COLOR_WARNING);
+
+    // draw top bar
+    DrawUtils::setFontSize(48);
+    const char *title = "! Warning !";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(title) / 2, 48 + 8, title, true);
+    DrawUtils::drawRectFilled(8, 48 + 8 + 16, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
+
+    DrawUtils::setFontSize(24);
+
+    const char *message = "The update folder currently exists and is not a file.";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT / 2 - 48, message, true);
+    message = "Your system might not be blocking updates properly!";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT / 2 - 24, message, true);
+
+    message = "Press \ue002 to block the updates! This can be reverted in the Boot Selector.";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT / 2 + 24, message, true);
+
+    message = "See https://wiiu.hacks.guide/#/block-updates for more information.";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT / 2 + 64 + 24, message, true);
+
+    DrawUtils::setFontSize(16);
+
+    message = "Press the SYNC Button on the Wii U console to connect a controller or GamePad.";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT - 48, message, true);
+
+    // draw bottom bar
+    DrawUtils::drawRectFilled(8, SCREEN_HEIGHT - 24 - 8 - 4, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
+    DrawUtils::setFontSize(18);
+    const char *exitHints = "\ue000 Continue without blocking / \ue001 Don't show this again";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(exitHints) / 2, SCREEN_HEIGHT - 8, exitHints, true);
+
+    DrawUtils::endDraw();
+}
+
 void handleUpdateWarningScreen() {
     FILE *f = fopen(UPDATE_SKIP_PATH, "r");
     if (f) {
@@ -347,52 +410,42 @@ void handleUpdateWarningScreen() {
     uint32_t drcBufferSize = OSScreenGetBufferSizeEx(SCREEN_DRC);
 
     DrawUtils::initBuffers(screenBuffer, tvBufferSize, (void *) ((uint32_t) screenBuffer + tvBufferSize), drcBufferSize);
-    DrawUtils::initFont();
+    if (!DrawUtils::initFont()) {
+        OSFatal("Failed to init font");
+    }
 
-    DrawUtils::beginDraw();
-    DrawUtils::clear(COLOR_BACKGROUND_WARN);
+    {
+        PairMenu pairMenu;
 
-    DrawUtils::setFontColor(COLOR_TEXT);
-
-    // draw top bar
-    DrawUtils::setFontSize(48);
-    const char *title = "! Warning !";
-    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(title) / 2, 48 + 8, title, true);
-    DrawUtils::drawRectFilled(8, 48 + 8 + 16, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
-
-    DrawUtils::setFontSize(24);
-
-    const char *message = "The update folder currently exists.";
-    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT / 2 - 24, message, true);
-    message = "Your system might not be blocking updates properly!";
-    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT / 2 + 0, message, true);
-    message = "See https://wiiu.hacks.guide/#/block-updates for more information.";
-    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(message) / 2, SCREEN_HEIGHT / 2 + 24, message, true);
-
-    // draw bottom bar
-    DrawUtils::drawRectFilled(8, SCREEN_HEIGHT - 24 - 8 - 4, SCREEN_WIDTH - 8 * 2, 3, COLOR_WHITE);
-    DrawUtils::setFontSize(18);
-    const char *exitHints = "\ue000 Continue / \ue001 Don't show this again";
-    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(exitHints) / 2, SCREEN_HEIGHT - 8, exitHints, true);
-
-    DrawUtils::endDraw();
-
-    while (true) {
-        VPADStatus vpad{};
-        VPADRead(VPAD_CHAN_0, &vpad, 1, nullptr);
-
-        if (vpad.trigger & VPAD_BUTTON_A) {
-            break;
-        } else if (vpad.trigger & VPAD_BUTTON_B) {
-            f = fopen(UPDATE_SKIP_PATH, "w");
-            if (f) {
-                fputs("If this file exists, the Autoboot Module will not warn you about not blocking updates", f);
-                fclose(f);
+        while (true) {
+            if (pairMenu.ProcessPairScreen()) {
+                continue;
+            }
+
+            drawUpdateWarningScreen();
+
+            InputUtils::InputData input = InputUtils::getControllerInput();
+            if (input.trigger & VPAD_BUTTON_A) {
+                break;
+            } else if (input.trigger & VPAD_BUTTON_X) {
+                gUpdatesBlocked = DeleteMLCUpdateDirectory();
+                break;
+            } else if (input.trigger & VPAD_BUTTON_B) {
+                f = fopen(UPDATE_SKIP_PATH, "w");
+                if (f) {
+                    // It's **really** important to have this text on the stack.
+                    // If it's read from the .rodata section the fwrite will softlock the console because the OSEffectiveToPhysical returns NULL for
+                    // everything between 0x00800000 - 0x01000000 at this stage.
+                    const char text[] = "If this file exists, the Autoboot Module will not warn you about not blocking updates";
+                    fputs(text, f);
+                    fclose(f);
+                }
+                break;
             }
-            break;
         }
     }
 
+    DrawUtils::beginDraw();
     DrawUtils::clear(COLOR_BLACK);
     DrawUtils::endDraw();
 
@@ -400,3 +453,124 @@ void handleUpdateWarningScreen() {
 
     free(screenBuffer);
 }
+
+void drawDiscInsert(bool wrongDiscInserted) {
+    DrawUtils::beginDraw();
+    DrawUtils::clear(COLOR_BACKGROUND);
+    DrawUtils::setFontColor(COLOR_TEXT);
+
+    DrawUtils::setFontSize(48);
+
+    if (wrongDiscInserted) {
+        const char *title = "The disc inserted into the console";
+        DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(title) / 2, 40 + 48 + 8, title, true);
+        title = "is for a different software title.";
+        DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(title) / 2, 40 + 2 * 48 + 8, title, true);
+        title = "Please change the disc.";
+        DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(title) / 2, 40 + 4 * 48 + 8, title, true);
+    } else {
+        const char *title = "Please insert a disc.";
+        DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(title) / 2, 40 + 48 + 8, title, true);
+    }
+
+    DrawUtils::setFontSize(18);
+    const char *exitHints = "\ue000 Launch Wii U Menu";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(exitHints) / 2, SCREEN_HEIGHT - 8, exitHints, true);
+
+    DrawUtils::endDraw();
+}
+
+bool handleDiscInsertScreen(uint64_t expectedTitleId, uint64_t *titleIdToLaunch) {
+    if (titleIdToLaunch == nullptr) {
+        DEBUG_FUNCTION_LINE_ERR("titleIdToLaunch is NULL");
+        return false;
+    }
+
+    if (SYSCheckTitleExists(expectedTitleId)) {
+        *titleIdToLaunch = expectedTitleId;
+        return true;
+    }
+
+    auto result       = false;
+    auto screenBuffer = DrawUtils::InitOSScreen();
+    if (!screenBuffer) {
+        OSFatal("Failed to alloc memory for screen");
+    }
+
+    uint32_t tvBufferSize  = OSScreenGetBufferSizeEx(SCREEN_TV);
+    uint32_t drcBufferSize = OSScreenGetBufferSizeEx(SCREEN_DRC);
+
+    DrawUtils::initBuffers(screenBuffer, tvBufferSize, (void *) ((uint32_t) screenBuffer + tvBufferSize), drcBufferSize);
+    if (!DrawUtils::initFont()) {
+        OSFatal("Failed to init font");
+    }
+    DrawUtils::beginDraw();
+    DrawUtils::clear(COLOR_BACKGROUND);
+    DrawUtils::endDraw();
+
+    uint64_t titleIdOfDisc = 0;
+    bool discInserted;
+
+    uint32_t attempt = 0;
+    while (!GetTitleIdOfDisc(&titleIdOfDisc, &discInserted)) {
+        if (++attempt > 20) {
+            break;
+        }
+        OSSleepTicks(OSMillisecondsToTicks(100));
+    }
+
+    bool wrongDiscInserted = discInserted && (titleIdOfDisc != expectedTitleId);
+
+    if (discInserted && !wrongDiscInserted) {
+        *titleIdToLaunch = expectedTitleId;
+        DrawUtils::deinitFont();
+        free(screenBuffer);
+        return true;
+    }
+
+    // When an unexpected disc was inserted we need to eject it first.
+    bool allowDisc = !wrongDiscInserted;
+
+    {
+        PairMenu pairMenu;
+
+        while (true) {
+            if (pairMenu.ProcessPairScreen()) {
+                continue;
+            }
+
+            drawDiscInsert(wrongDiscInserted);
+
+            InputUtils::InputData input = InputUtils::getControllerInput();
+            if (input.trigger & VPAD_BUTTON_A) {
+                result = false;
+                break;
+            }
+
+
+            if (GetTitleIdOfDisc(&titleIdOfDisc, &discInserted)) {
+                if (discInserted) {
+                    if (!allowDisc) {
+                        continue;
+                    }
+                    *titleIdToLaunch = titleIdOfDisc;
+                    DEBUG_FUNCTION_LINE("Disc inserted! %016llX", titleIdOfDisc);
+                    result = true;
+                    break;
+                }
+            } else {
+                allowDisc = true;
+            }
+        }
+    }
+
+    DrawUtils::beginDraw();
+    DrawUtils::clear(COLOR_BLACK);
+    DrawUtils::endDraw();
+
+    DrawUtils::deinitFont();
+
+    free(screenBuffer);
+
+    return result;
+}

source/MenuUtils.h

@@ -13,8 +13,9 @@
 #define COLOR_WHITE              Color(0xffffffff)
 #define COLOR_BLACK              Color(0, 0, 0, 255)
 #define COLOR_BACKGROUND         COLOR_BLACK
-#define COLOR_BACKGROUND_WARN    Color(255, 40, 0, 255)
+#define COLOR_BACKGROUND_WARN    Color(255, 251, 4, 255)
 #define COLOR_TEXT               COLOR_WHITE
+#define COLOR_WARNING            COLOR_BLACK
 #define COLOR_TEXT2              Color(0xB3ffffff)
 #define COLOR_AUTOBOOT           Color(0xaeea00ff)
 #define COLOR_BORDER             Color(204, 204, 204, 255)
@@ -36,3 +37,5 @@ int32_t handleMenuScreen(std::string &configPath, int32_t autobootOptionInput, c
 nn::act::SlotNo handleAccountSelectScreen(const std::vector<std::shared_ptr<AccountInfo>> &data);
 
 void handleUpdateWarningScreen();
+
+bool handleDiscInsertScreen(uint64_t expectedTitleId, uint64_t *titleIdToLaunch);

source/PairUtils.cpp

@@ -0,0 +1,241 @@
+#include "PairUtils.h"
+#include "DrawUtils.h"
+#include "InputUtils.h"
+#include "logger.h"
+#include "utils.h"
+#include <coreinit/cache.h>
+#include <coreinit/thread.h>
+#include <malloc.h>
+#include <nn/ccr/sys.h>
+#include <padscore/kpad.h>
+#include <padscore/wpad.h>
+#include <vpad/input.h>
+
+void PairMenu::drawPairKPADScreen() const {
+    DrawUtils::beginDraw();
+    DrawUtils::clear(COLOR_BACKGROUND);
+
+    DrawUtils::setFontColor(COLOR_TEXT);
+
+    DrawUtils::setFontSize(26);
+
+    std::string textLine1 = "Press the SYNC Button on the controller you want to pair.";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(textLine1.c_str()) / 2, 40, textLine1.c_str(), true);
+
+
+    WPADExtensionType ext{};
+    for (int i = 0; i < 4; i++) {
+        bool isConnected     = WPADProbe((WPADChan) i, &ext) == 0;
+        std::string textLine = string_format("Slot %d: ", i + 1);
+        if (isConnected) {
+            textLine += ext == WPAD_EXT_PRO_CONTROLLER ? "Pro Controller" : "Wiimote";
+        } else {
+            textLine += "No controller";
+        }
+
+        DrawUtils::print(300, 140 + (i * 30), textLine.c_str());
+    }
+
+    DrawUtils::setFontSize(26);
+
+    std::string gamepadSyncText1 = "If you are pairing a Wii U GamePad, press the SYNC Button";
+    std::string gamepadSyncText2 = "on your Wii U console one more time";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(gamepadSyncText1.c_str()) / 2, SCREEN_HEIGHT - 100, gamepadSyncText1.c_str(), true);
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(gamepadSyncText2.c_str()) / 2, SCREEN_HEIGHT - 70, gamepadSyncText2.c_str(), true);
+
+    DrawUtils::setFontSize(16);
+
+    const char *exitHints = "Press \ue001 to return";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(exitHints) / 2, SCREEN_HEIGHT - 8, exitHints, true);
+
+    DrawUtils::endDraw();
+}
+
+void PairMenu::drawPairScreen() const {
+    DrawUtils::beginDraw();
+    DrawUtils::clear(COLOR_BACKGROUND);
+
+    DrawUtils::setFontColor(COLOR_TEXT);
+
+    // Convert the pin to symbols and set the text
+    static char pinSymbols[][4] = {
+            "\u2660",
+            "\u2665",
+            "\u2666",
+            "\u2663"};
+
+    uint32_t pincode = mGamePadPincode;
+
+    std::string pin = std::string(pinSymbols[(pincode / 1000) % 10]) +
+                      pinSymbols[(pincode / 100) % 10] +
+                      pinSymbols[(pincode / 10) % 10] +
+                      pinSymbols[pincode % 10];
+
+    std::string textLine1 = "Press the SYNC Button on the Wii U GamePad,";
+    std::string textLine2 = "and enter the four symbols shown below.";
+
+    DrawUtils::setFontSize(26);
+
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(textLine1.c_str()) / 2, 60, textLine1.c_str(), true);
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(textLine2.c_str()) / 2, 100, textLine2.c_str(), true);
+
+    DrawUtils::setFontSize(100);
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(pin.c_str()) / 2, (SCREEN_HEIGHT / 2) + 40, pin.c_str(), true);
+
+    DrawUtils::setFontSize(20);
+
+    std::string textLine3 = string_format("(%d seconds remaining) ", mGamePadSyncTimeout - (uint32_t) (OSTicksToSeconds(OSGetTime() - mSyncGamePadStartTime)));
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(textLine3.c_str()) / 2, SCREEN_HEIGHT - 80, textLine3.c_str(), true);
+
+    DrawUtils::setFontSize(26);
+
+    std::string textLine4 = "Press the SYNC Button on the Wii U console to exit.";
+    DrawUtils::print(SCREEN_WIDTH / 2 + DrawUtils::getTextWidth(textLine4.c_str()) / 2, SCREEN_HEIGHT - 40, textLine4.c_str(), true);
+
+    DrawUtils::endDraw();
+}
+
+PairMenu::PairMenu() {
+    CCRSysInit();
+
+    mState              = STATE_WAIT;
+    mGamePadSyncTimeout = 120;
+
+    // Initialize IM
+    mIMHandle = IM_Open();
+    if (mIMHandle < 0) {
+        DEBUG_FUNCTION_LINE_ERR("PairMenu: IM_Open failed");
+        OSFatal("PairMenu: IM_Open failed");
+    }
+    mIMRequest = (IMRequest *) memalign(0x40, sizeof(IMRequest));
+
+    // Allocate a separate request for IM_CancelGetEventNotify to avoid conflict with the pending IM_GetEventNotify request
+    mIMCancelRequest = (IMRequest *) memalign(0x40, sizeof(IMRequest));
+
+    if (!mIMRequest || !mIMCancelRequest) {
+        DEBUG_FUNCTION_LINE_ERR("Failed to allocate im request");
+        OSFatal("PairMenu: Failed to allocate im request");
+    }
+
+    mIMEventMask = IM_EVENT_SYNC;
+
+    // Notify about sync button events
+    IM_GetEventNotify(mIMHandle, mIMRequest, &mIMEventMask, PairMenu::SyncButtonCallback, this);
+}
+
+PairMenu::~PairMenu() {
+    // Close IM
+    IM_CancelGetEventNotify(mIMHandle, mIMCancelRequest, nullptr, nullptr);
+    IM_Close(mIMHandle);
+    if (mIMCancelRequest) {
+        free(mIMCancelRequest);
+        mIMCancelRequest = {};
+    }
+    if (mIMRequest) {
+        free(mIMRequest);
+        mIMRequest = {};
+    }
+
+    // Deinit CCRSys
+    CCRSysExit();
+}
+
+extern "C" bool WPADStartSyncDevice();
+
+bool PairMenu::ProcessPairScreen() {
+    switch (mState) {
+        case STATE_SYNC_WPAD: {
+            // WPAD syncing stops after ~18 seconds, make sure to restart it.
+            if ((uint32_t) OSTicksToSeconds(OSGetTime() - mSyncWPADStartTime) >= 18) {
+                WPADStartSyncDevice();
+                mSyncWPADStartTime = OSGetTime();
+            }
+
+            InputUtils::InputData input = InputUtils::getControllerInput();
+
+            // Stop syncing when pressing A or B.
+            if (input.trigger & (VPAD_BUTTON_A | VPAD_BUTTON_B)) {
+                mState = STATE_WAIT;
+            }
+
+            break;
+        }
+        case STATE_SYNC_GAMEPAD: {
+            if (CCRSysGetPincode(&mGamePadPincode) != 0) {
+                DEBUG_FUNCTION_LINE_ERR("CCRSysGetPincode failed");
+                mState = STATE_WAIT;
+                break;
+            }
+
+            // Start pairing to slot 1 (second gamepad)
+            if (CCRSysStartPairing(0, mGamePadSyncTimeout) != 0) {
+                DEBUG_FUNCTION_LINE_ERR("CCRSysStartPairing failed.");
+                mState = STATE_WAIT;
+                break;
+            }
+
+            // Pairing has started, save start time
+            mSyncGamePadStartTime = OSGetTime();
+            mState                = STATE_PAIRING;
+
+            DEBUG_FUNCTION_LINE("Started GamePad syncing.");
+
+            break;
+        }
+        case STATE_PAIRING: {
+            // Get the current pairing state
+            CCRSysPairingState pairingState = CCRSysGetPairingState();
+            if (pairingState == CCR_SYS_PAIRING_TIMED_OUT) {
+                DEBUG_FUNCTION_LINE("GamePad SYNC timed out.");
+                // Pairing has timed out or was cancelled
+                CCRSysStopPairing();
+                mState = STATE_WAIT;
+            } else if (pairingState == CCR_SYS_PAIRING_FINISHED) {
+                DEBUG_FUNCTION_LINE("GamePad paired.");
+                mState = STATE_WAIT;
+            }
+            break;
+        }
+        case STATE_CANCEL: {
+            CCRSysStopPairing();
+            mState = STATE_WAIT;
+            break;
+        }
+        case STATE_WAIT:
+            break;
+    }
+    switch (mState) {
+        case STATE_WAIT: {
+            return false;
+        }
+        case STATE_SYNC_WPAD:
+            drawPairKPADScreen();
+            break;
+        case STATE_SYNC_GAMEPAD:
+        case STATE_PAIRING:
+        case STATE_CANCEL: {
+            drawPairScreen();
+            break;
+        }
+    }
+    return true;
+}
+
+
+void PairMenu::SyncButtonCallback(IOSError error, void *arg) {
+    auto *pairMenu = (PairMenu *) arg;
+
+    if (error == IOS_ERROR_OK && pairMenu && (pairMenu->mIMEventMask & IM_EVENT_SYNC)) {
+        if (pairMenu->mState == STATE_WAIT) {
+            pairMenu->mState = STATE_SYNC_WPAD;
+            // We need to restart the WPAD pairing every 18 seconds. For the timing we need to save the current time.
+            pairMenu->mSyncWPADStartTime = OSGetTime();
+        } else if (pairMenu->mState == STATE_SYNC_WPAD) {
+            pairMenu->mState = STATE_SYNC_GAMEPAD;
+        } else if (pairMenu->mState == STATE_SYNC_GAMEPAD || pairMenu->mState == STATE_PAIRING) {
+            pairMenu->mState = STATE_CANCEL;
+        }
+        OSMemoryBarrier();
+        IM_GetEventNotify(pairMenu->mIMHandle, pairMenu->mIMRequest, &pairMenu->mIMEventMask, PairMenu::SyncButtonCallback, pairMenu);
+    }
+}

source/PairUtils.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "MenuUtils.h"
+#include "logger.h"
+#include <coreinit/cache.h>
+#include <coreinit/im.h>
+#include <coreinit/ios.h>
+#include <coreinit/time.h>
+#include <malloc.h>
+#include <nn/ccr/sys.h>
+
+
+class PairMenu {
+public:
+    PairMenu();
+
+    ~PairMenu();
+
+    bool ProcessPairScreen();
+
+    static void SyncButtonCallback(IOSError error, void *arg);
+
+    void drawPairScreen() const;
+
+    void drawPairKPADScreen() const;
+
+private:
+    enum PairMenuState {
+        STATE_WAIT, // Wait for SYNC button press
+        STATE_SYNC_WPAD,
+        STATE_SYNC_GAMEPAD,
+        STATE_PAIRING,
+        STATE_CANCEL,
+    };
+
+    IOSHandle mIMHandle{};
+    IMRequest *mIMRequest{};
+    IMRequest *mIMCancelRequest{};
+    OSTime mSyncWPADStartTime    = 0;
+    OSTime mSyncGamePadStartTime = 0;
+    uint32_t mGamePadPincode     = 0;
+    PairMenuState mState         = STATE_WAIT;
+    uint32_t mGamePadSyncTimeout = 120;
+    IMEventMask mIMEventMask{};
+};

source/QuickStartUtils.cpp

@@ -1,22 +1,31 @@
 #include <malloc.h>
 
 #include "BootUtils.h"
+#include "MenuUtils.h"
 #include "QuickStartUtils.h"
 #include "logger.h"
 
 #include <coreinit/exit.h>
 #include <coreinit/foreground.h>
+#include <coreinit/launch.h>
 #include <coreinit/memdefaultheap.h>
 #include <coreinit/thread.h>
 #include <nn/acp/title.h>
 #include <nn/act/client_cpp.h>
 #include <nn/ccr/sys_caffeine.h>
 #include <nn/sl.h>
+#include <nsysccr/cdc.h>
+#include <optional>
 #include <proc_ui/procui.h>
+#include <rpxloader/rpxloader.h>
 #include <sysapp/launch.h>
 #include <sysapp/title.h>
 
 extern "C" void __fini_wut();
+extern "C" void CCRSysCaffeineBootCheckAbort();
+
+#define UPPER_TITLE_ID_HOMEBREW 0x0005000F
+#define TITLE_ID_HOMEBREW_MASK  (((uint64_t) UPPER_TITLE_ID_HOMEBREW) << 32)
 
 static void StartAppletAndExit() {
     DEBUG_FUNCTION_LINE("Wait for applet");
@@ -78,42 +87,131 @@ void loadConsoleAccount(const char *data_uuid) {
     nn::act::Finalize();
 }
 
-bool getQuickBoot() {
+class FileStreamWrapper {
+public:
+    static std::unique_ptr<FileStreamWrapper> CreateFromPath(std::string_view path, std::string_view mode = "r") {
+        return std::unique_ptr<FileStreamWrapper>(new FileStreamWrapper(path, mode));
+    }
+
+    ~FileStreamWrapper() {
+        mFileStream.reset();
+        FSDelClient(&mFsClient, FS_ERROR_FLAG_NONE);
+    }
+
+    nn::sl::details::IStreamBase &GetStream() {
+        return *mFileStream;
+    }
+
+private:
+    explicit FileStreamWrapper(std::string_view path, std::string_view mode) {
+        FSAddClient(&mFsClient, FS_ERROR_FLAG_NONE);
+        FSInitCmdBlock(&mCmdBlock);
+        mFileStream = std::make_unique<nn::sl::FileStream>();
+        mFileStream->Initialize(&mFsClient, &mCmdBlock, path.data(), mode.data());
+    }
+
+    std::unique_ptr<nn::sl::FileStream> mFileStream{};
+    FSClient mFsClient{};
+    FSCmdBlock mCmdBlock{};
+};
+
+class QuickStartAutoAbort {
+public:
+    QuickStartAutoAbort() {
+        OSCreateAlarm(&mAlarm);
+        OSSetPeriodicAlarm(&mDRCConnectedAlarm,
+                           OSSecondsToTicks(10),
+                           OSSecondsToTicks(1),
+                           &AbortOnDRCDisconnect);
+        OSSetAlarm(&mAlarm, OSSecondsToTicks(120), AbortQuickStartTitle);
+        mDRCConnected = IsDRCConnected();
+    }
+    ~QuickStartAutoAbort() {
+        OSCancelAlarm(&mDRCConnectedAlarm);
+        OSCancelAlarm(&mAlarm);
+
+        // Reconnect the DRC if it was connected at launch but then disconnected;
+        if (mDRCConnected && !IsDRCConnected()) {
+            DEBUG_FUNCTION_LINE_VERBOSE("Wake up GamePad");
+            CCRCDCWowlWakeDrcArg args = {.state = 1};
+            CCRCDCWowlWakeDrc(&args);
+        }
+    }
+
+    static bool IsDRCConnected() {
+        CCRCDCDrcState state = {};
+        CCRCDCSysGetDrcState(CCR_CDC_DESTINATION_DRC0, &state);
+        return state.state != 0;
+    }
+
+    static void AbortQuickStartTitle(OSAlarm *alarm, OSContext *) {
+        DEBUG_FUNCTION_LINE_VERBOSE("Selecting a title takes too long, lets abort the quick start menu");
+        CCRSysCaffeineBootCheckAbort();
+    }
+
+    static void AbortOnDRCDisconnect(OSAlarm *alarm, OSContext *) {
+        if (!IsDRCConnected()) {
+            DEBUG_FUNCTION_LINE_VERBOSE("GamePad was disconnected, lets abort the quick start menu");
+            CCRSysCaffeineBootCheckAbort();
+        }
+    }
+
+private:
+    OSAlarm mDRCConnectedAlarm{};
+    OSAlarm mAlarm{};
+    bool mDRCConnected = false;
+};
+
+bool launchQuickStartTitle() {
+    // Automatically abort quick start if selecting takes longer than 120 seconds or the DRC disconnects
+    QuickStartAutoAbort quickStartAutoAbort;
+
+    // Waits until the quick start menu has been closed.
     auto bootCheck = CCRSysCaffeineBootCheck();
     if (bootCheck == 0) {
         nn::sl::Initialize(MEMAllocFromDefaultHeapEx, MEMFreeToDefaultHeap);
         char path[0x80];
         nn::sl::GetDefaultDatabasePath(path, 0x80, 0x0005001010066000); // ECO process
-        FSCmdBlock cmdBlock;
-        FSInitCmdBlock(&cmdBlock);
-
-        auto fileStream = new nn::sl::FileStream;
-        auto *fsClient  = (FSClient *) memalign(0x40, sizeof(FSClient));
-        if (!fsClient) {
-            DEBUG_FUNCTION_LINE("Couldn't alloc memory for fsClient.");
-            return false;
+        nn::sl::LaunchInfoDatabase launchInfoDatabase;
+        nn::sl::LaunchInfo info;
+        {
+            // In theory the region doesn't even matter.
+            // The region is to load a "system table" into the LaunchInfoDatabase which provides the LaunchInfos for
+            // the Wii U Menu and System Settings. In the code below we check for all possible System Settings title id and
+            // have a fallback to the Wii U Menu... This means we could get away a wrong region, but let's use the correct one
+            // anyway
+            const auto region = []() {
+                if (SYSCheckTitleExists(0x0005001010047000L)) { // JPN System Settings
+                    return nn::sl::REGION_JPN;
+                } else if (SYSCheckTitleExists(0x0005001010047100L)) { // USA System Settings
+                    return nn::sl::REGION_USA;
+                } else if (SYSCheckTitleExists(0x0005001010047200L)) { // EUR System Settings
+                    return nn::sl::REGION_EUR;
+                }
+                return nn::sl::REGION_EUR;
+            }();
+            auto fileStream = FileStreamWrapper::CreateFromPath(path);
+            if (launchInfoDatabase.Load(fileStream->GetStream(), region).IsFailure()) {
+                DEBUG_FUNCTION_LINE_ERR("Failed to load LaunchInfoDatabase");
+                return false;
+            }
         }
-        memset(fsClient, 0, sizeof(*fsClient));
-        FSAddClient(fsClient, FS_ERROR_FLAG_NONE);
-
-        fileStream->Initialize(fsClient, &cmdBlock, path, "r");
-
-        auto database = new nn::sl::LaunchInfoDatabase;
-        database->Load(fileStream, nn::sl::REGION_EUR);
 
         CCRAppLaunchParam data; // load sys caffeine data
         // load app launch param
         CCRSysCaffeineGetAppLaunchParam(&data);
 
-        // get launch info for id
-        nn::sl::LaunchInfo info;
-        auto result = database->GetLaunchInfoById(&info, data.titleId);
+        if (data.launchInfoDatabaseEntryId == 1) { // This id is hardcoded into the nn_sl.rpl
+            DEBUG_FUNCTION_LINE("Launch Quick Start Settings");
+            SysAppSettingsArgs args{};
+            args.jumpTo = SYS_SETTINGS_JUMP_TO_QUICK_START_SETTINGS; // quick start settings
+            _SYSLaunchSettings(&args);
+            return true;
+        }
 
-        delete database;
-        delete fileStream;
+        loadConsoleAccount(data.uuid);
 
-        FSDelClient(fsClient, FS_ERROR_FLAG_NONE);
-        free(fsClient);
+        auto result = launchInfoDatabase.GetLaunchInfoById(&info, data.launchInfoDatabaseEntryId);
 
         nn::sl::Finalize();
 
@@ -122,7 +220,16 @@ bool getQuickBoot() {
             return false;
         }
 
-        DEBUG_FUNCTION_LINE("Trying to autoboot for titleId %016llX", info.titleId);
+        if ((info.titleId & TITLE_ID_HOMEBREW_MASK) == TITLE_ID_HOMEBREW_MASK) {
+            std::string homebrewPath = info.parameter;
+            DEBUG_FUNCTION_LINE("Trying to launch homebrew title: \"%s\"", homebrewPath.c_str());
+
+            if (auto err = RPXLoader_LaunchHomebrew(homebrewPath.c_str()); err != RPX_LOADER_RESULT_SUCCESS) {
+                DEBUG_FUNCTION_LINE_WARN("Failed to launch homebrew title: %s (%d)", RPXLoader_GetStatusStr(err), err);
+                return false;
+            }
+            return true;
+        }
 
         if (info.titleId == 0x0005001010040000L ||
             info.titleId == 0x0005001010040100L ||
@@ -131,6 +238,14 @@ bool getQuickBoot() {
             return false;
         }
 
+        if (info.titleId == 0x0005001010047000L ||
+            info.titleId == 0x0005001010047100L ||
+            info.titleId == 0x0005001010047200L) {
+            DEBUG_FUNCTION_LINE("Launch System Settings");
+            _SYSLaunchSettings(nullptr);
+            return true;
+        }
+
         if (info.titleId == 0x000500301001220AL ||
             info.titleId == 0x000500301001210AL ||
             info.titleId == 0x000500301001200AL) {
@@ -205,22 +320,36 @@ bool getQuickBoot() {
             return true;
         }
 
-        if (!SYSCheckTitleExists(info.titleId)) {
-            DEBUG_FUNCTION_LINE("Title %016llX doesn't exist", info.titleId);
-            return false;
+        uint64_t titleIdToLaunch = info.titleId;
+
+        switch (info.mediaType) {
+            case nn::sl::NN_SL_MEDIA_TYPE_ODD: {
+                if (!handleDiscInsertScreen(titleIdToLaunch, &titleIdToLaunch)) {
+                    DEBUG_FUNCTION_LINE("Launch Wii U Menu!");
+                    return false;
+                }
+                break;
+            }
+            default: {
+                if (!SYSCheckTitleExists(titleIdToLaunch)) {
+                    DEBUG_FUNCTION_LINE("Title %016llX doesn't exist", titleIdToLaunch);
+                    return false;
+                }
+            }
         }
 
         MCPTitleListType titleInfo;
         int32_t handle = MCP_Open();
-        auto err       = MCP_GetTitleInfo(handle, info.titleId, &titleInfo);
+        auto err       = MCP_GetTitleInfo(handle, titleIdToLaunch, &titleInfo);
         MCP_Close(handle);
         if (err == 0) {
-            loadConsoleAccount(data.uuid);
+            DEBUG_FUNCTION_LINE("Launch %016llX", titleIdToLaunch);
             ACPAssignTitlePatch(&titleInfo);
-            _SYSLaunchTitleWithStdArgsInNoSplash(info.titleId, nullptr);
+            _SYSLaunchTitleWithStdArgsInNoSplash(titleIdToLaunch, nullptr);
             return true;
         }
 
+        DEBUG_FUNCTION_LINE("Launch Wii U Menu!");
         return false;
     } else {
         DEBUG_FUNCTION_LINE("No quick start");

source/QuickStartUtils.h

@@ -1,3 +1,3 @@
 #pragma once
 
-bool getQuickBoot();
+bool launchQuickStartTitle();

source/StorageUtils.cpp

@@ -90,23 +90,21 @@ void initExternalStorage() {
         // the lib before actually using it.
         return;
     }
-    int connectedStorage = 0;
-    if ((connectedStorage = numberUSBStorageDevicesConnected()) <= 0) {
-        nn::spm::Initialize();
-        InitEmptyExternalStorage();
-        nn::spm::Finalize();
-        return;
+    int numConnectedStorage;
+    int maxTries = 1200; // Wait up to 20 seconds, like the Wii U Menu
+    if ((numConnectedStorage = numberUSBStorageDevicesConnected()) <= 0) {
+        maxTries = 1; // Only try once if no USBStorageDrive is connected
+    } else {
+        DEBUG_FUNCTION_LINE("Connected StorageDevices = %d", numConnectedStorage);
     }
 
-    DEBUG_FUNCTION_LINE("Connected StorageDevices = %d", connectedStorage);
-
     nn::spm::Initialize();
 
     nn::spm::StorageListItem items[0x20];
     int tries  = 0;
     bool found = false;
 
-    while (tries < 1200) { // Wait up to 20 seconds, like the Wii U Menu
+    while (tries < maxTries) {
         int32_t numItems = nn::spm::GetStorageList(items, 0x20);
 
         DEBUG_FUNCTION_LINE("Number of items: %d", numItems);
@@ -127,7 +125,7 @@ void initExternalStorage() {
                 }
             }
         }
-        if (found || (connectedStorage == numItems)) {
+        if (found || (numConnectedStorage == numItems)) {
             DEBUG_FUNCTION_LINE("Found all expected items, breaking.");
             break;
         }
@@ -135,7 +133,9 @@ void initExternalStorage() {
         tries++;
     }
     if (!found) {
-        DEBUG_FUNCTION_LINE("USB Storage is connected but either it doesn't have a WFS partition or we ran into a timeout.");
+        if (numConnectedStorage > 0) {
+            DEBUG_FUNCTION_LINE("USB Storage is connected but either it doesn't have a WFS partition or we ran into a timeout.");
+        }
         InitEmptyExternalStorage();
     }
 

source/logger.h

@@ -41,6 +41,7 @@ extern "C" {
 
 #define DEBUG_FUNCTION_LINE_WARN(FMT, ARGS...)                                 LOG_EX_DEFAULT(WHBLogPrintf, "## WARN## ", "", FMT, ##ARGS)
 #define DEBUG_FUNCTION_LINE_ERR(FMT, ARGS...)                                  LOG_EX_DEFAULT(WHBLogPrintf, "##ERROR## ", "", FMT, ##ARGS)
+#define DEBUG_FUNCTION_LINE_INFO(FMT, ARGS...)                                 LOG_EX_DEFAULT(WHBLogPrintf, "## INFO## ", "", FMT, ##ARGS)
 
 #define DEBUG_FUNCTION_LINE_ERR_LAMBDA(FILENAME, FUNCTION, LINE, FMT, ARGS...) LOG_EX(FILENAME, FUNCTION, LINE, WHBLogPrintf, "##ERROR## ", "", FMT, ##ARGS);
 
@@ -58,6 +59,7 @@ extern "C" {
 
 #define DEBUG_FUNCTION_LINE_WARN(FMT, ARGS...)                                 LOG_EX_DEFAULT(OSReport, "## WARN## ", "\n", FMT, ##ARGS)
 #define DEBUG_FUNCTION_LINE_ERR(FMT, ARGS...)                                  LOG_EX_DEFAULT(OSReport, "##ERROR## ", "\n", FMT, ##ARGS)
+#define DEBUG_FUNCTION_LINE_INFO(FMT, ARGS...)                                 LOG_EX_DEFAULT(OSReport, "## INFO## ", "\n", FMT, ##ARGS)
 
 #define DEBUG_FUNCTION_LINE_ERR_LAMBDA(FILENAME, FUNCTION, LINE, FMT, ARGS...) LOG_EX(FILENAME, FUNCTION, LINE, OSReport, "##ERROR## ", "\n", FMT, ##ARGS);
 

source/main.cpp

@@ -1,16 +1,21 @@
 #include "BootUtils.h"
 #include "DrawUtils.h"
+#include "InputUtils.h"
 #include "MenuUtils.h"
 #include "QuickStartUtils.h"
 #include "StorageUtils.h"
 #include "logger.h"
 #include <coreinit/debug.h>
 #include <coreinit/filesystem_fsa.h>
+#include <coreinit/title.h>
 #include <gx2/state.h>
 #include <malloc.h>
 #include <mocha/mocha.h>
+#include <rpxloader/rpxloader.h>
+#include <sndcore2/core.h>
 #include <string>
 #include <sys/stat.h>
+#include <sysapp/launch.h>
 #include <vpad/input.h>
 
 void clearScreen() {
@@ -26,16 +31,35 @@ void clearScreen() {
     free(buffer);
 }
 
+bool gUpdatesBlocked = false;
+
 int32_t main(int32_t argc, char **argv) {
     initLogging();
     DEBUG_FUNCTION_LINE("Hello from Autoboot Module");
+    AXInit();
+    AXQuit();
+
+    InputUtils::Init();
 
     // Clear screen to avoid screen corruptions when loading the Wii U Menu
     clearScreen();
 
     initExternalStorage();
 
-    if (getQuickBoot()) {
+    // Use librpxloader.
+    RPXLoaderStatus error3;
+    if ((error3 = RPXLoader_InitLibrary()) != RPX_LOADER_RESULT_SUCCESS) {
+        DEBUG_FUNCTION_LINE_ERR("AutobootModule: Failed to init RPXLoader. This can be ignored when not running Aroma. Error %s [%d]", RPXLoader_GetStatusStr(error3), error3);
+    }
+
+    // If we are in System Transfer context we need to restart the app to actually
+    if (OSGetTitleID() == 0x0005001010062000L || OSGetTitleID() == 0x0005001010062100L || OSGetTitleID() == 0x0005001010062200L) {
+        _SYSLaunchTitleWithStdArgsInNoSplash(OSGetTitleID(), nullptr);
+        deinitLogging();
+        return 0;
+    }
+
+    if (launchQuickStartTitle()) {
         deinitLogging();
         return 0;
     }
@@ -44,18 +68,34 @@ int32_t main(int32_t argc, char **argv) {
         OSFatal("AutobootModule: Mocha_InitLibrary failed");
     }
 
+    InputUtils::InputData buttons = InputUtils::getControllerInput();
+
     FSAInit();
     auto client = FSAAddClient(nullptr);
     if (client > 0) {
         if (Mocha_UnlockFSClientEx(client) == MOCHA_RESULT_SUCCESS) {
             // test if the update folder exists
-            FSStat stat;
-            if (FSAGetStat(client, "/vol/storage_mlc01/sys/update", &stat) >= 0) {
+            FSADirectoryHandle dirHandle{};
+            if (FSAOpenDir(client, "/vol/storage_mlc01/sys/update", &dirHandle) >= 0) {
+                FSACloseDir(client, dirHandle);
+                gUpdatesBlocked = false;
                 handleUpdateWarningScreen();
+            } else {
+                FSAStat st{};
+                if (FSAGetStat(client, "/vol/storage_mlc01/sys/update", &st) != FS_ERROR_OK) {
+                    DEBUG_FUNCTION_LINE_INFO("Created \"/vol/storage_mlc01/sys/update\" as file");
+                    FSAFileHandle fd;
+                    FSAOpenFileEx(client, "/vol/storage_mlc01/sys/update", "w", static_cast<FSMode>(0x666), FS_OPEN_FLAG_NONE, 0, &fd);
+                }
+                gUpdatesBlocked = true;
             }
+        } else {
+            DEBUG_FUNCTION_LINE_ERR("Failed to unlock FSA Client");
         }
 
         FSADelClient(client);
+    } else {
+        DEBUG_FUNCTION_LINE_ERR("Failed to create FSA Client");
     }
 
     bool showvHBL          = getVWiiHBLTitleId() != 0;
@@ -73,9 +113,6 @@ int32_t main(int32_t argc, char **argv) {
 
     int32_t bootSelection = readAutobootOption(configPath);
 
-    VPADStatus vpad{};
-    VPADRead(VPAD_CHAN_0, &vpad, 1, nullptr);
-
     std::map<uint32_t, std::string> menu;
     menu[BOOT_OPTION_WII_U_MENU] = "Wii U Menu";
     if (showHBL) {
@@ -89,7 +126,7 @@ int32_t main(int32_t argc, char **argv) {
     if ((bootSelection == -1) ||
         (bootSelection == BOOT_OPTION_HOMEBREW_LAUNCHER && !showHBL) ||
         (bootSelection == BOOT_OPTION_VWII_HOMEBREW_CHANNEL && !showvHBL) ||
-        (vpad.hold & VPAD_BUTTON_PLUS)) {
+        (buttons.hold & VPAD_BUTTON_PLUS)) {
         bootSelection = handleMenuScreen(configPath, bootSelection, menu);
     }
 
@@ -123,7 +160,9 @@ int32_t main(int32_t argc, char **argv) {
         bootWiiUMenu();
     }
 
-    deinitLogging();
+    InputUtils::DeInit();
     Mocha_DeInitLibrary();
+    deinitLogging();
+
     return 0;
 }

source/main.h

@@ -1 +1,3 @@
 #pragma once
+
+extern bool gUpdatesBlocked;

source/schrift.h

@@ -0,0 +1,88 @@
+/* This file is part of libschrift.
+ *
+ * © 2019-2022 Thomas Oltmann and contributors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#ifndef SCHRIFT_H
+#define SCHRIFT_H 1
+
+#include <stddef.h> /* size_t */
+#include <stdint.h> /* uint_fast32_t, uint_least32_t */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SFT_DOWNWARD_Y 0x01
+
+typedef struct SFT SFT;
+typedef struct SFT_Font SFT_Font;
+typedef uint_least32_t SFT_UChar; /* Guaranteed to be compatible with char32_t. */
+typedef uint_fast32_t SFT_Glyph;
+typedef struct SFT_LMetrics SFT_LMetrics;
+typedef struct SFT_GMetrics SFT_GMetrics;
+typedef struct SFT_Kerning SFT_Kerning;
+typedef struct SFT_Image SFT_Image;
+
+struct SFT {
+    SFT_Font *font;
+    double xScale;
+    double yScale;
+    double xOffset;
+    double yOffset;
+    int flags;
+};
+
+struct SFT_LMetrics {
+    double ascender;
+    double descender;
+    double lineGap;
+};
+
+struct SFT_GMetrics {
+    double advanceWidth;
+    double leftSideBearing;
+    int yOffset;
+    int minWidth;
+    int minHeight;
+};
+
+struct SFT_Kerning {
+    double xShift;
+    double yShift;
+};
+
+struct SFT_Image {
+    void *pixels;
+    int width;
+    int height;
+};
+
+const char *sft_version(void);
+
+SFT_Font *sft_loadmem(const void *mem, size_t size);
+void sft_freefont(SFT_Font *font);
+
+int sft_lmetrics(const SFT *sft, SFT_LMetrics *metrics);
+int sft_lookup(const SFT *sft, SFT_UChar codepoint, SFT_Glyph *glyph);
+int sft_gmetrics(const SFT *sft, SFT_Glyph glyph, SFT_GMetrics *metrics);
+int sft_kerning(const SFT *sft, SFT_Glyph leftGlyph, SFT_Glyph rightGlyph,
+                SFT_Kerning *kerning);
+int sft_render(const SFT *sft, SFT_Glyph glyph, SFT_Image image);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

source/utils.cpp

@@ -0,0 +1,79 @@
+#include "logger.h"
+#include <coreinit/filesystem_fsa.h>
+#include <coreinit/mcp.h>
+#include <mocha/mocha.h>
+
+bool GetTitleIdOfDisc(uint64_t *titleId, bool *discPresent) {
+    if (discPresent) {
+        *discPresent = false;
+    }
+    alignas(0x40) MCPTitleListType titles[4];
+    uint32_t count = 0;
+
+    int handle = MCP_Open();
+    if (handle < 0) {
+        DEBUG_FUNCTION_LINE_ERR("MCP_Open failed");
+        return false;
+    }
+    auto res = MCP_TitleListByDeviceType(handle, MCP_DEVICE_TYPE_ODD, &count, titles, sizeof(titles));
+    MCP_Close(handle);
+
+    if (res >= 0 && count > 0) {
+        if (discPresent) {
+            *discPresent = true;
+        }
+        for (uint32_t i = 0; i < count; i++) {
+            if ((titles[i].titleId & 0xFFFFFFFF00000000L) == (0x0005000000000000)) {
+                if (titleId) {
+                    *titleId = titles[i].titleId;
+                }
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool DeleteMLCUpdateDirectory() {
+    bool result = false;
+    auto client = FSAAddClient(nullptr);
+    if (client > 0) {
+        if (Mocha_UnlockFSClientEx(client) == MOCHA_RESULT_SUCCESS) {
+            if (FSARemove(client, "/vol/storage_mlc01/sys/update") != FS_ERROR_OK) {
+                DEBUG_FUNCTION_LINE_ERR("Failed to remove update directory");
+            } else {
+                FSAFileHandle fd;
+                if (FSAOpenFileEx(client, "/vol/storage_mlc01/sys/update", "w", static_cast<FSMode>(0x666), FS_OPEN_FLAG_NONE, 0, &fd) != FS_ERROR_OK) {
+                    DEBUG_FUNCTION_LINE_WARN("Failed to create update file");
+                }
+                result = true;
+            }
+        } else {
+            DEBUG_FUNCTION_LINE_ERR("Failed to unlock FSA Client");
+        }
+        FSADelClient(client);
+    } else {
+        DEBUG_FUNCTION_LINE_ERR("Failed to create FSA Client");
+    }
+    return result;
+}
+
+bool RestoreMLCUpdateDirectory() {
+    bool result = false;
+    auto client = FSAAddClient(nullptr);
+    if (client > 0) {
+        if (Mocha_UnlockFSClientEx(client) == MOCHA_RESULT_SUCCESS) {
+            FSARemove(client, "/vol/storage_mlc01/sys/update"); // Remove any existing files
+            if (FSAMakeDir(client, "/vol/storage_mlc01/sys/update", static_cast<FSMode>(0x666)) != FS_ERROR_OK) {
+                DEBUG_FUNCTION_LINE_WARN("Failed to restore update directory");
+            }
+            result = true;
+        } else {
+            DEBUG_FUNCTION_LINE_ERR("Failed to unlock FSA Client");
+        }
+        FSADelClient(client);
+    } else {
+        DEBUG_FUNCTION_LINE_ERR("Failed to create FSA Client");
+    }
+    return result;
+}

source/utils.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cstdint>
+#include <malloc.h>
+#include <memory>
+
+template<class T, class... Args>
+std::unique_ptr<T> make_unique_nothrow(Args &&...args) noexcept(noexcept(T(std::forward<Args>(args)...))) {
+    return std::unique_ptr<T>(new (std::nothrow) T(std::forward<Args>(args)...));
+}
+
+template<typename T>
+inline typename std::unique_ptr<T> make_unique_nothrow(size_t num) noexcept {
+    return std::unique_ptr<T>(new (std::nothrow) std::remove_extent_t<T>[num]());
+}
+
+template<class T, class... Args>
+std::shared_ptr<T> make_shared_nothrow(Args &&...args) noexcept(noexcept(T(std::forward<Args>(args)...))) {
+    return std::shared_ptr<T>(new (std::nothrow) T(std::forward<Args>(args)...));
+}
+
+template<typename... Args>
+std::string string_format(const std::string &format, Args... args) {
+    int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
+    auto size  = static_cast<size_t>(size_s);
+    auto buf   = std::make_unique<char[]>(size);
+    std::snprintf(buf.get(), size, format.c_str(), args...);
+    return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
+}
+
+bool GetTitleIdOfDisc(uint64_t *titleId, bool *discPresent);
+
+bool DeleteMLCUpdateDirectory();
+
+bool RestoreMLCUpdateDirectory();

source/version.h

@@ -0,0 +1,2 @@
+#pragma once
+#define AUTOBOOT_MODULE_VERSION_EXTRA ""