OmniNX/Horizon-OC
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.18

Browse Source
This commit is contained in:
souldbminersmwc
2025-12-23 19:10:41 -05:00
parent 152f92a9a9
commit b5022ea839
43 changed files with 5143 additions and 3939 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Source/sys-clk/common/include/sysclk/board.h
View File

@@ -76,6 +76,7 @@ typedef enum
SysClkModule_CPU = 0,
SysClkModule_GPU,
SysClkModule_MEM,
HorizonOCModule_Governor,
SysClkModule_EnumMax,
} SysClkModule;
@@ -129,8 +130,10 @@ static inline const char* sysclkFormatModule(SysClkModule module, bool pretty)
return pretty ? "GPU" : "gpu";
case SysClkModule_MEM:
return pretty ? "Memory" : "mem";
case HorizonOCModule_Governor:
return pretty ? "Governor" : "gov";
default:
return NULL;
return "null";
}
}

12
Source/sys-clk/common/include/sysclk/config.h
View File

@@ -50,9 +50,6 @@ typedef enum {
HocClkConfigValue_ThermalThrottle,
HocClkConfigValue_ThermalThrottleThreshold,
HocClkConfigValue_HandheldGovernor,
HocClkConfigValue_DockedGovernor,
HocClkConfigValue_HandheldTDP,
HocClkConfigValue_HandheldTDPLimit,
@@ -212,11 +209,6 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr
case HocClkConfigValue_ThermalThrottleThreshold:
return pretty ? "Thermal Throttle Threshold" : "thermal_throttle_threshold";
case HocClkConfigValue_HandheldGovernor:
return pretty ? "Handheld Governor" : "governor";
case HocClkConfigValue_DockedGovernor:
return pretty ? "Docked Governor" : "governor_docked";
case HocClkConfigValue_HandheldTDP:
return pretty ? "Handheld TDP" : "handheld_tdp";
@@ -422,8 +414,6 @@ static inline uint64_t sysclkDefaultConfigValue(SysClkConfigValue val)
return 1862ULL;
case HocClkConfigValue_ThermalThrottle:
case HocClkConfigValue_DockedGovernor:
case HocClkConfigValue_HandheldGovernor:
case HocClkConfigValue_HandheldTDP:
case HocClkConfigValue_EnforceBoardLimit:
case HocClkConfigValue_KipEditing:
@@ -464,8 +454,6 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in
case HocClkConfigValue_UncappedClocks:
case HocClkConfigValue_OverwriteBoostMode:
case HocClkConfigValue_ThermalThrottle:
case HocClkConfigValue_DockedGovernor:
case HocClkConfigValue_HandheldGovernor:
case HocClkConfigValue_HandheldTDP:
case HocClkConfigValue_EnforceBoardLimit:
case HocClkConfigValue_KipEditing:

4
Source/sys-clk/overlay/lib/libultrahand/README.md
View File

@@ -78,7 +78,7 @@ Together, these flags (-ffunction-sections, -fdata-sections, -Wl,--gc-sections,
- [Status Monitor Overlay](https://github.com/ppkantorski/Status-Monitor-Overlay)
- [Edizon Overlay](https://github.com/ppkantorski/EdiZon-Overlay)
- [Edizon Overlay](https://github.com/proferabg/EdiZon-Overlay)
- [Sysmodules](https://github.com/ppkantorski/ovl-sysmodules)
@@ -208,4 +208,4 @@ Contributions are welcome! If you have any ideas, suggestions, or bug reports, p
This project is licensed and distributed under [GPLv2](LICENSE) with a [custom library](libultra) utilizing [CC-BY-4.0](SUB_LICENSE).
Copyright (c) 2024 ppkantorski
Copyright (c) 2023-2025 ppkantorski

119
Source/sys-clk/overlay/lib/libultrahand/libtesla/include/stb_truetype.h
View File

@@ -1520,140 +1520,85 @@ static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, in
// Force inline for maximum performance
static inline int stbtt_FindGlyphIndex_impl(stbtt_uint8 *data, stbtt_uint32 index_map, int unicode_codepoint)
{
// Read format once - single memory access
stbtt_uint16 format = FAST_USHORT(data + index_map);
stbtt_uint32 uc = (stbtt_uint32)unicode_codepoint;
// Variables used across multiple cases or frequently in loops
stbtt_uint32 low, high, mid;
stbtt_uint8 *group;
stbtt_uint32 start_char, end_char;
stbtt_uint32 uc;
// Switch for jump table optimization
switch (format) {
case 4: { // Windows fonts - most common
// Early exit for out-of-range Unicode
if ((unsigned)unicode_codepoint > 0xffff) return 0;
case 4: {
if (uc > 0xffff) return 0;
// Cache all header values in one go - burst read
stbtt_uint8 *header = data + index_map;
stbtt_uint16 segcount = FAST_USHORT(header + 6) >> 1;
stbtt_uint16 searchRange = FAST_USHORT(header + 8) >> 1;
stbtt_uint16 entrySelector = FAST_USHORT(header + 10);
stbtt_uint16 rangeShift = FAST_USHORT(header + 12) >> 1;
// Optimized binary search with fewer memory accesses
stbtt_uint32 endCount = index_map + 14;
stbtt_uint32 search = endCount;
// Use the precomputed rangeShift for initial jump
if (unicode_codepoint >= FAST_USHORT(data + search + (rangeShift << 1)))
if (uc >= (stbtt_uint16)FAST_USHORT(data + search + (rangeShift << 1)))
search += rangeShift << 1;
search -= 2;
stbtt_uint16 entrySelector = FAST_USHORT(header + 10);
stbtt_uint16 searchRange = FAST_USHORT(header + 8) >> 1;
// Unrolled binary search - most critical path
while (entrySelector) {
searchRange >>= 1;
stbtt_uint32 test_pos = search + (searchRange << 1);
if (unicode_codepoint > FAST_USHORT(data + test_pos))
if (uc > (stbtt_uint16)FAST_USHORT(data + test_pos))
search = test_pos;
--entrySelector;
}
search += 2;
stbtt_uint16 item = (stbtt_uint16)((search - endCount) >> 1);
stbtt_uint32 base = index_map + 14;
// Calculate all offsets upfront - better instruction scheduling
stbtt_uint32 base1 = index_map + 14;
stbtt_uint32 startCode_offset = base1 + (segcount << 1) + 2 + (item << 1);
stbtt_uint32 endCode_offset = endCount + (item << 1);
stbtt_uint32 idRangeOffset_offset = base1 + (segcount * 6) + 2 + (item << 1);
stbtt_uint16 start = FAST_USHORT(data + base + (segcount << 1) + 2 + (item << 1));
stbtt_uint16 end = FAST_USHORT(data + endCount + (item << 1));
stbtt_uint16 start = FAST_USHORT(data + startCode_offset);
stbtt_uint16 end = FAST_USHORT(data + endCode_offset);
// Single comparison using unsigned arithmetic trick
if ((unsigned)(unicode_codepoint - start) > (unsigned)(end - start))
if ((stbtt_uint32)(uc - start) > (stbtt_uint32)(end - start))
return 0;
stbtt_uint16 offset = FAST_USHORT(data + idRangeOffset_offset);
if (offset == 0) {
stbtt_uint32 idDelta_offset = base1 + (segcount << 2) + 2 + (item << 1);
return (stbtt_uint16)(unicode_codepoint + FAST_SHORT(data + idDelta_offset));
stbtt_uint16 offset = FAST_USHORT(data + base + (segcount * 6) + 2 + (item << 1));
if (offset == 0)
return (stbtt_uint16)(uc + FAST_SHORT(data + base + (segcount << 2) + 2 + (item << 1)));
return FAST_USHORT(data + offset + ((uc - start) << 1) + base + (segcount * 6) + 2 + (item << 1));
}
return FAST_USHORT(data + offset + ((unicode_codepoint - start) << 1) + idRangeOffset_offset);
}
case 12: { // 32-bit format
stbtt_uint32 ngroups = FAST_ULONG(data + index_map + 12);
uc = (stbtt_uint32)unicode_codepoint;
// Optimized binary search with minimal memory access
low = 0; high = ngroups;
case 12:
case 13: {
stbtt_uint32 low = 0, high = FAST_ULONG(data + index_map + 12);
stbtt_uint8 *groups_base = data + index_map + 16;
while (low < high) {
mid = (low + high) >> 1;
group = groups_base + (mid * 12);
stbtt_uint32 mid = (low + high) >> 1;
stbtt_uint8 *group = groups_base + (mid * 12);
stbtt_uint32 start_char = FAST_ULONG(group);
start_char = FAST_ULONG(group);
if (uc < start_char) {
high = mid;
} else {
end_char = FAST_ULONG(group + 4);
if (uc <= end_char) {
} else if (uc <= FAST_ULONG(group + 4)) {
stbtt_uint32 start_glyph = FAST_ULONG(group + 8);
return start_glyph + uc - start_char;
}
low = mid + 1;
}
}
return 0;
}
case 13: { // 32-bit format, many-to-one mapping
stbtt_uint32 ngroups = FAST_ULONG(data + index_map + 12);
uc = (stbtt_uint32)unicode_codepoint;
low = 0; high = ngroups;
stbtt_uint8 *groups_base = data + index_map + 16;
while (low < high) {
mid = (low + high) >> 1;
group = groups_base + (mid * 12);
start_char = FAST_ULONG(group);
if (uc < start_char) {
high = mid;
return (format == 12) ? (start_glyph + uc - start_char) : start_glyph;
} else {
end_char = FAST_ULONG(group + 4);
if (uc <= end_char) {
return FAST_ULONG(group + 8); // Same glyph for all chars in range
}
low = mid + 1;
}
}
return 0;
}
case 0: { // Apple byte encoding - simple and fast
stbtt_int32 bytes = FAST_USHORT(data + index_map + 2);
return ((unsigned)unicode_codepoint < (unsigned)(bytes - 6)) ?
data[index_map + 6 + unicode_codepoint] : 0;
}
case 0:
return (uc < (stbtt_uint32)(FAST_USHORT(data + index_map + 2) - 6)) ?
data[index_map + 6 + uc] : 0;
case 6: { // Trimmed table mapping
stbtt_uint32 first = FAST_USHORT(data + index_map + 6);
stbtt_uint32 count = FAST_USHORT(data + index_map + 8);
uc = (stbtt_uint32)unicode_codepoint;
stbtt_uint32 offset = uc - first;
return (offset < count) ? FAST_USHORT(data + index_map + 10 + (offset << 1)) : 0;
case 6: {
stbtt_uint32 offset = uc - FAST_USHORT(data + index_map + 6);
return (offset < (stbtt_uint32)FAST_USHORT(data + index_map + 8)) ?
FAST_USHORT(data + index_map + 10 + (offset << 1)) : 0;
}
default:
return 0; // Unsupported format
return 0;
}
}

4336
Source/sys-clk/overlay/lib/libultrahand/libtesla/include/tesla.hpp
View File

File diff suppressed because it is too large Load Diff

9
Source/sys-clk/overlay/lib/libultrahand/libultra/include/audio_player.hpp → Source/sys-clk/overlay/lib/libultrahand/libultra/include/audio.hpp
View File

@@ -1,8 +1,8 @@
/********************************************************************************
* File: audio_player.hpp
* File: audio.hpp
* Author: ppkantorski
* Description:
* This header defines the AudioPlayer class and related structures used for
* This header defines the Audio class and related structures used for
* handling sound playback within the Ultrahand Overlay. It provides interfaces
* for loading, caching, and playing WAV audio through libnx’s audout service,
* along with basic sound type management and synchronization support.
@@ -25,9 +25,10 @@
#include <atomic>
#include <cstring>
#include <mutex>
#include "tsl_utils.hpp"
namespace ult {
class AudioPlayer {
class Audio {
public:
enum class SoundType : uint8_t { // <- uint8_t saves space
Navigate,
@@ -64,7 +65,7 @@ namespace ult {
static void setMasterVolume(float volume);
static void setEnabled(bool enabled);
static bool isEnabled();
static bool isDocked();
//static bool isDocked();
static bool reloadIfDockedChanged();
static void reloadAllSounds();
static void unloadAllSounds(const std::initializer_list<SoundType>& excludeSounds = {});

2
Source/sys-clk/overlay/lib/libultrahand/libultra/include/debug_funcs.hpp
View File

@@ -12,7 +12,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once

2
Source/sys-clk/overlay/lib/libultrahand/libultra/include/download_funcs.hpp
View File

@@ -13,7 +13,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once

2
Source/sys-clk/overlay/lib/libultrahand/libultra/include/get_funcs.hpp
View File

@@ -14,7 +14,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once

21
Source/sys-clk/overlay/lib/libultrahand/libultra/include/global_vars.hpp
View File

@@ -13,7 +13,7 @@
* altered or removed.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
@@ -39,6 +39,11 @@ namespace ult {
extern const std::string ROOT_PATH;
extern const std::string SETTINGS_PATH;
extern const std::string NX_OVLLOADER_PATH;
extern const std::string OVL_HEAP_CONFIG_PATH;
extern const std::string OVL_EXIT_FLAG_PATH;
extern const std::string ULTRAHAND_CONFIG_INI_PATH;
extern const std::string TESLA_CONFIG_INI_PATH;
extern const std::string LANG_PATH;
@@ -63,7 +68,8 @@ namespace ult {
extern const std::string PACKAGE_FILENAME;
extern const std::string DOWNLOADS_PATH;
extern const std::string EXPANSION_PATH;
//extern const std::string EXPANSION_PATH;
extern const std::string FUSE_DATA_INI_PATH;
extern const std::string PACKAGE_PATH;
extern const std::string OVERLAY_PATH;
@@ -77,12 +83,13 @@ namespace ult {
extern const std::string ULTRAHAND_REPO_URL;
extern const std::string INCLUDED_THEME_FOLDER_URL;
extern const std::string LATEST_RELEASE_INFO_URL;
extern const std::string NX_OVLLOADER_ZIP_URL;
extern const std::string NX_OVLLOADER_PLUS_ZIP_URL;
extern const std::string LATEST_UPDATER_INI_URL;
//extern const std::string NX_OVLLOADER_ZIP_URL;
//extern const std::string NX_OVLLOADER_PLUS_ZIP_URL;
extern const std::string OLD_NX_OVLLOADER_ZIP_URL;
extern const std::string OLD_NX_OVLLOADER_PLUS_ZIP_URL;
//extern const std::string OLD_NX_OVLLOADER_PLUS_ZIP_URL;
extern const std::string UPDATER_PAYLOAD_URL;
extern const std::string SOUND_EFFECTS_URL;
//extern const std::string SOUND_EFFECTS_URL;
extern const std::string LAUNCH_ARGS_STR;
extern const std::string USE_LAUNCH_ARGS_STR;
@@ -137,6 +144,7 @@ namespace ult {
extern const std::string FALSE_STR;
extern const std::string GLOBAL_STR;
extern const std::string DEFAULT_STR;
extern const std::string HOLD_STR;
extern const std::string SLOT_STR;
extern const std::string OPTION_STR;
extern const std::string FORWARDER_STR;
@@ -161,6 +169,7 @@ namespace ult {
extern const std::string INPROGRESS_SYMBOL;
extern const std::string STAR_SYMBOL;
extern const std::string DIVIDER_SYMBOL;
extern const std::string NOTIFY_HEADER;
extern const std::vector<std::string> THROBBER_SYMBOLS;

8
Source/sys-clk/overlay/lib/libultrahand/libultra/include/haptics.hpp
View File

@@ -26,12 +26,12 @@
namespace ult {
//extern bool rumbleInitialized;
extern std::atomic<bool> rumbleActive;
extern std::atomic<bool> clickActive;
extern std::atomic<bool> doubleClickActive;
//void initRumble();
void deinitRumble();
void checkAndReinitRumble();
void initHaptics();
void deinitHaptics();
void checkAndReinitHaptics();
void rumbleClick();
void rumbleDoubleClick();

5
Source/sys-clk/overlay/lib/libultrahand/libultra/include/hex_funcs.hpp
View File

@@ -13,7 +13,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once
@@ -206,6 +206,9 @@ namespace ult {
std::string extractVersionFromBinary(const std::string &filePath);
std::string decodeBase64ToString(const std::string& b64);
}
#endif

34
Source/sys-clk/overlay/lib/libultrahand/libultra/include/ini_funcs.hpp
View File

@@ -13,7 +13,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once
@@ -290,7 +290,7 @@ namespace ult {
//}
void syncIniValue(std::map<std::string, std::map<std::string, std::string>>& packageConfigData,
bool syncIniValue(std::map<std::string, std::map<std::string, std::string>>& packageConfigData,
const std::string& packageConfigIniPath,
const std::string& optionName,
const std::string& key,
@@ -339,6 +339,36 @@ namespace ult {
* @param data The complete INI data structure to save.
*/
void saveIniFileData(const std::string& filePath, const std::map<std::string, std::map<std::string, std::string>>& data);
/**
* @brief Adds a key-value pair to all sections that contain a specified pattern key.
*
* If patternKey is empty, the key-value pair will be added to ALL sections.
* If patternKey is specified, only sections containing that key will be modified.
*
* @param filePath The path to the INI file.
* @param patternKey The key to search for (empty = all sections).
* @param newKey The new key to add.
* @param newValue The value for the new key.
*/
void addKeyToMatchingSections(const std::string& filePath, const std::string& patternKey,
const std::string& newKey, const std::string& newValue);
/**
* @brief Removes a key from all sections that contain a specified pattern key.
*
* If patternKey is empty, the key will be removed from ALL sections.
* If patternKey is specified, only sections containing that key will have keyToRemove deleted.
*
* @param filePath The path to the INI file.
* @param patternKey The key to search for (empty = all sections).
* @param keyToRemove The key to remove from matching sections.
*/
void removeKeyFromMatchingSections(const std::string& filePath, const std::string& patternKey,
const std::string& keyToRemove);
}
#endif

3
Source/sys-clk/overlay/lib/libultrahand/libultra/include/json_funcs.hpp
View File

@@ -12,8 +12,9 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once
#ifndef JSON_FUNCS_HPP
#define JSON_FUNCS_HPP

6
Source/sys-clk/overlay/lib/libultrahand/libultra/include/list_funcs.hpp
View File

@@ -14,7 +14,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
@@ -70,7 +70,7 @@ namespace ult {
// Function to read file into a vector of strings
std::vector<std::string> readListFromFile(const std::string& filePath, size_t maxLines=0);
std::vector<std::string> readListFromFile(const std::string& filePath, size_t maxLines=0, bool preserveNewlines = false);
// Function to get an entry from the list based on the index
@@ -89,7 +89,7 @@ namespace ult {
// Function to read file into a set of strings
std::unordered_set<std::string> readSetFromFile(const std::string& filePath);
std::unordered_set<std::string> readSetFromFile(const std::string& filePath, const std::string& packagePath = "");
// Function to write a set to a file

2
Source/sys-clk/overlay/lib/libultrahand/libultra/include/mod_funcs.hpp
View File

@@ -13,7 +13,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2024-2025 ppkantorski
********************************************************************************/
#pragma once

17
Source/sys-clk/overlay/lib/libultrahand/libultra/include/path_funcs.hpp
View File

@@ -14,7 +14,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once
@@ -36,6 +36,7 @@
#include "get_funcs.hpp"
#include <queue>
#include <mutex>
#include <unordered_set>
namespace ult {
@@ -143,7 +144,7 @@ namespace ult {
*
* @param pathPattern The pattern used to match and delete files or directories.
*/
void deleteFileOrDirectoryByPattern(const std::string& pathPattern, const std::string& logSource = "");
void deleteFileOrDirectoryByPattern(const std::string& pathPattern, const std::string& logSourc = "", const std::unordered_set<std::string>* filterSet = nullptr);
void moveDirectory(const std::string& sourcePath, const std::string& destinationPath,
@@ -176,12 +177,16 @@ namespace ult {
*
* This function identifies files or directories that match the `sourcePathPattern` and moves them to the `destinationPath`.
* It processes each matching entry in the source directory pattern and moves them to the specified destination.
* Files/directories in the filterSet will be skipped.
*
* @param sourcePathPattern The pattern used to match files or directories to be moved.
* @param destinationPath The destination directory where matching files or directories will be moved.
* @param logSource Optional log source identifier.
* @param logDestination Optional log destination identifier.
* @param filterSet Optional set of paths to exclude from moving (nullptr to move all).
*/
void moveFilesOrDirectoriesByPattern(const std::string& sourcePathPattern, const std::string& destinationPath,
const std::string& logSource = "", const std::string& logDestination = "");
const std::string& logSource = "", const std::string& logDestination = "", const std::unordered_set<std::string>* filterSet = nullptr);
@@ -227,12 +232,16 @@ namespace ult {
*
* This function identifies files or directories that match the `sourcePathPattern` and copies them to the `toDirectory`.
* It processes each matching entry in the source directory pattern and copies them to the specified destination.
* Files/directories in the filterSet will be skipped.
*
* @param sourcePathPattern The pattern used to match files or directories to be copied.
* @param toDirectory The destination directory where matching files or directories will be copied.
* @param logSource Optional log source identifier.
* @param logDestination Optional log destination identifier.
* @param filterSet Optional set of paths to exclude from copying (nullptr to copy all).
*/
void copyFileOrDirectoryByPattern(const std::string& sourcePathPattern, const std::string& toDirectory,
const std::string& logSource = "", const std::string& logDestination = "");
const std::string& logSource = "", const std::string& logDestination = "", const std::unordered_set<std::string>* filterSet = nullptr);

6
Source/sys-clk/overlay/lib/libultrahand/libultra/include/string_funcs.hpp
View File

@@ -14,7 +14,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#pragma once
@@ -40,7 +40,7 @@ namespace ult {
extern int stoi(const std::string& str, std::size_t* pos = nullptr, int base = 10);
extern float stof(const std::string& str);
extern bool canConvertToInt(const std::string& str);
//extern bool canConvertToInt(const std::string& str);
/**
* @brief A lightweight string stream class that mimics basic functionality of std::istringstream.
@@ -144,7 +144,7 @@ namespace ult {
* @param input The input string to process.
* @return The string with multiple slashes replaced.
*/
std::string replaceMultipleSlashes(const std::string& input);
//std::string replaceMultipleSlashes(const std::string& input);
void resolveDirectoryTraversal(std::string& path);

177
Source/sys-clk/overlay/lib/libultrahand/libultra/include/tsl_utils.hpp
View File

@@ -18,7 +18,7 @@
* altered or removed.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
@@ -54,39 +54,39 @@
#include <map>
#include <barrier>
#ifndef APPROXIMATE_cos
// Approximation for cos(x) using Taylor series around 0
#define APPROXIMATE_cos(x) (1 - (x) * (x) / 2 + (x) * (x) * (x) * (x) / 24) // valid for small x
#endif
#ifndef APPROXIMATE_ifloor
#define APPROXIMATE_ifloor(x) ((int)((x) >= 0 ? (x) : (x) - 1)) // truncate toward negative infinity
#define APPROXIMATE_iceil(x) ((int)((x) == (int)(x) ? (x) : ((x) > 0 ? (int)(x) + 1 : (int)(x)))) // truncate toward positive infinity
#endif
#ifndef APPROXIMATE_sqrt
// Fast approximation for sqrt using Newton's method
#define APPROXIMATE_sqrt(x) ((x) <= 0 ? 0 : (x) / 2.0 * (3.0 - ((x) * (x) * 0.5))) // Approximation for x close to 1
#define APPROXIMATE_pow(x, y) ((y) == 0 ? 1 : ((y) == 1 ? (x) : APPROXIMATE_sqrt(x))) // limited to approximate sqrt if y=0.5
#endif
#ifndef APPROXIMATE_fmod
#define APPROXIMATE_fmod(x, y) ((x) - ((int)((x) / (y)) * (y))) // equivalent to x - floor(x/y) * y
#endif
#ifndef APPROXIMATE_cos
// Approximation for cos(x) using Taylor series around 0
#define APPROXIMATE_cos(x) (1 - (x) * (x) / 2 + (x) * (x) * (x) * (x) / 24) // valid for small x
#endif
#ifndef APPROXIMATE_acos
#define APPROXIMATE_acos(x) (1.5708 - (x) - (x)*(x)*(x) / 6) // limited approximation for acos in range [-1, 1]
#endif
#ifndef APPROXIMATE_fabs
#define APPROXIMATE_fabs(x) ((x) < 0 ? -(x) : (x))
#endif
//#ifndef APPROXIMATE_cos
//// Approximation for cos(x) using Taylor series around 0
//#define APPROXIMATE_cos(x) (1 - (x) * (x) / 2 + (x) * (x) * (x) * (x) / 24) // valid for small x
//#endif
//
//
//#ifndef APPROXIMATE_ifloor
//#define APPROXIMATE_ifloor(x) ((int)((x) >= 0 ? (x) : (x) - 1)) // truncate toward negative infinity
//#define APPROXIMATE_iceil(x) ((int)((x) == (int)(x) ? (x) : ((x) > 0 ? (int)(x) + 1 : (int)(x)))) // truncate toward positive infinity
//#endif
//
//#ifndef APPROXIMATE_sqrt
//// Fast approximation for sqrt using Newton's method
//#define APPROXIMATE_sqrt(x) ((x) <= 0 ? 0 : (x) / 2.0 * (3.0 - ((x) * (x) * 0.5))) // Approximation for x close to 1
//#define APPROXIMATE_pow(x, y) ((y) == 0 ? 1 : ((y) == 1 ? (x) : APPROXIMATE_sqrt(x))) // limited to approximate sqrt if y=0.5
//#endif
//
//#ifndef APPROXIMATE_fmod
//#define APPROXIMATE_fmod(x, y) ((x) - ((int)((x) / (y)) * (y))) // equivalent to x - floor(x/y) * y
//#endif
//
//#ifndef APPROXIMATE_cos
//// Approximation for cos(x) using Taylor series around 0
//#define APPROXIMATE_cos(x) (1 - (x) * (x) / 2 + (x) * (x) * (x) * (x) / 24) // valid for small x
//#endif
//
//#ifndef APPROXIMATE_acos
//#define APPROXIMATE_acos(x) (1.5708 - (x) - (x)*(x)*(x) / 6) // limited approximation for acos in range [-1, 1]
//#endif
//
//#ifndef APPROXIMATE_fabs
//#define APPROXIMATE_fabs(x) ((x) < 0 ? -(x) : (x))
//#endif
struct OverlayCombo {
std::string path; // full overlay path
@@ -99,6 +99,35 @@ struct SwapDepth {
};
namespace ult {
// math funcs
inline double cos(double x) {
static constexpr double PI = 3.14159265358979323846;
static constexpr double TWO_PI = 6.28318530717958647692;
static constexpr double HALF_PI = 1.57079632679489661923;
// Fast normalization using multiply instead of divide when possible
x = x - TWO_PI * static_cast<int>(x * 0.159154943091895); // 1/(2π)
if (x < 0) x += TWO_PI;
// Use symmetry to reduce range
int sign = 1;
if (x > PI) {
x -= PI;
sign = -1;
}
if (x > HALF_PI) {
x = PI - x;
sign = -sign;
}
// Horner's method for faster polynomial evaluation (fewer operations)
// 5-term minimax polynomial for [0, π/2] - accurate to ~10^-8
const double x2 = x * x;
return sign * (1.0 + x2 * (-0.5 + x2 * (0.04166666666666666 + x2 * (-0.001388888888888889 + x2 * (0.0000248015873015873 - x2 * 0.0000002755731922398589)))));
}
extern bool correctFrameSize; // for detecting the correct Overlay display size
extern u16 DefaultFramebufferWidth; ///< Width of the framebuffer
@@ -182,6 +211,9 @@ namespace ult {
extern std::atomic<float> selectWidth;
extern std::atomic<float> nextPageWidth;
extern std::atomic<bool> inMainMenu;
extern std::atomic<bool> inHiddenMode;
extern std::atomic<bool> inSettingsMenu;
extern std::atomic<bool> inSubSettingsMenu;
extern std::atomic<bool> inOverlaysPage;
extern std::atomic<bool> inPackagesPage;
@@ -200,7 +232,7 @@ namespace ult {
//bool progressAnimation = false;
extern bool disableTransparency;
//bool useCustomWallpaper = false;
extern bool useMemoryExpansion;
//extern bool useMemoryExpansion;
extern bool useOpaqueScreenshots;
extern std::atomic<bool> onTrackBar;
@@ -344,6 +376,7 @@ namespace ult {
extern std::string HIDE_OVERLAY;
extern std::string HIDE_PACKAGE;
extern std::string LAUNCH_ARGUMENTS;
extern std::string FORCE_AMS110_SUPPORT;
extern std::string QUICK_LAUNCH;
extern std::string BOOT_COMMANDS;
extern std::string EXIT_COMMANDS;
@@ -371,6 +404,8 @@ namespace ult {
extern std::string USER_GUIDE;
extern std::string SHOW_HIDDEN;
extern std::string SHOW_DELETE;
extern std::string SHOW_UNSUPPORTED;
extern std::string PAGE_SWAP;
extern std::string RIGHT_SIDE_MODE;
extern std::string OVERLAY_VERSIONS;
@@ -379,7 +414,7 @@ namespace ult {
//extern std::string VERSION_LABELS;
extern std::string KEY_COMBO;
extern std::string MODE;
extern std::string MODES;
extern std::string LAUNCH_MODES;
extern std::string LANGUAGE;
extern std::string OVERLAY_INFO;
extern std::string SOFTWARE_UPDATE;
@@ -394,11 +429,19 @@ namespace ult {
extern std::string VENDOR;
extern std::string MODEL;
extern std::string STORAGE;
extern std::string NOTICE;
extern std::string UTILIZES;
//extern std::string NOTICE;
//extern std::string UTILIZES;
extern std::string MEMORY_EXPANSION;
extern std::string REBOOT_REQUIRED;
extern std::string OVERLAY_MEMORY;
extern std::string NOT_ENOUGH_MEMORY;
extern std::string WALLPAPER_SUPPORT_DISABLED;
extern std::string SOUND_SUPPORT_DISABLED;
extern std::string WALLPAPER_SUPPORT_ENABLED;
extern std::string SOUND_SUPPORT_ENABLED;
extern std::string EXIT_OVERLAY_SYSTEM;
//extern std::string MEMORY_EXPANSION;
//extern std::string REBOOT_REQUIRED;
extern std::string LOCAL_IP;
extern std::string WALLPAPER;
extern std::string THEME;
@@ -443,9 +486,16 @@ namespace ult {
extern std::string ULTRAHAND_HAS_STARTED;
extern std::string NEW_UPDATE_IS_AVAILABLE;
extern std::string REBOOT_IS_REQUIRED;
extern std::string HOLD_A_TO_DELETE;
//extern std::string REBOOT_IS_REQUIRED;
//extern std::string HOLD_A_TO_DELETE;
extern std::string DELETE_PACKAGE;
extern std::string DELETE_OVERLAY;
extern std::string SELECTION_IS_EMPTY;
extern std::string FORCED_SUPPORT_WARNING;
extern std::string TASK_IS_COMPLETE;
extern std::string TASK_HAS_FAILED;
//extern std::string PACKAGE_VERSIONS;
//extern std::string PROGRESS_ANIMATION;
@@ -456,6 +506,8 @@ namespace ult {
extern std::string BOOT_ENTRY;
#endif
extern std::string INCOMPATIBLE_WARNING;
extern std::string SYSTEM_RAM;
extern std::string FREE;
extern std::string DEFAULT_CHAR_WIDTH;
@@ -567,7 +619,7 @@ namespace ult {
float calculateAmplitude(float x, float peakDurationFactor = 0.25f);
//float calculateAmplitude(float x, float peakDurationFactor = 0.25f);
extern std::atomic<bool> refreshWallpaperNow;
@@ -685,9 +737,44 @@ namespace ult {
extern bool cleanVersionLabels, hideOverlayVersions, hidePackageVersions, useLibultrahandTitles, useLibultrahandVersions, usePackageTitles, usePackageVersions;
// nx-ovlloader settings
enum class OverlayHeapSize : u64 {
Size_4MB = 0x400000,
Size_6MB = 0x600000,
Size_8MB = 0x800000
};
// Static cache
static struct {
bool initialized = false;
OverlayHeapSize cachedSize = OverlayHeapSize::Size_6MB;
u64 customSizeMB = 0; // NEW: store custom size in MB
} heapSizeCache;
// Helper function to convert MB to bytes
extern u64 mbToBytes(u32 mb);
// Helper function to convert bytes to MB
extern u32 bytesToMB(u64 bytes);
// Implementation
OverlayHeapSize getCurrentHeapSize();
extern OverlayHeapSize currentHeapSize;
bool setOverlayHeapSize(OverlayHeapSize heapSize);
// Implementation
bool requestOverlayExit();
extern const std::string loaderInfo;
extern const std::string loaderTitle;
extern const bool expandedMemory;
extern std::string loaderTitle;
extern bool expandedMemory;
extern bool furtherExpandedMemory;
extern bool limitedMemory;
extern std::string versionLabel;

4
Source/sys-clk/overlay/lib/libultrahand/libultra/include/ultra.hpp
View File

@@ -19,7 +19,7 @@
* altered or removed.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2024-2025 ppkantorski
********************************************************************************/
#pragma once
@@ -43,7 +43,7 @@
#include "download_funcs.hpp"
#include "mod_funcs.hpp"
#include "tsl_utils.hpp"
#include "audio_player.hpp"
#include "audio.hpp"
#include "haptics.hpp"
#endif // ULTRA_HPP

60
Source/sys-clk/overlay/lib/libultrahand/libultra/source/audio_player.cpp → Source/sys-clk/overlay/lib/libultrahand/libultra/source/audio.cpp
View File

@@ -1,5 +1,5 @@
/********************************************************************************
* File: audio_player.cpp
* File: audio.cpp
* Author: ppkantorski
* Description:
* Memory-optimized version with reduced allocation overhead and chunked I/O.
@@ -19,17 +19,17 @@
* Copyright (c) 2025 ppkantorski
********************************************************************************/
#include "audio_player.hpp"
#include "audio.hpp"
namespace ult {
bool AudioPlayer::m_initialized = false;
std::atomic<bool> AudioPlayer::m_enabled{true};
float AudioPlayer::m_masterVolume = 0.6f;
bool AudioPlayer::m_lastDockedState = false;
std::vector<AudioPlayer::CachedSound> AudioPlayer::m_cachedSounds;
std::mutex AudioPlayer::m_audioMutex;
bool Audio::m_initialized = false;
std::atomic<bool> Audio::m_enabled{true};
float Audio::m_masterVolume = 0.6f;
bool Audio::m_lastDockedState = false;
std::vector<Audio::CachedSound> Audio::m_cachedSounds;
std::mutex Audio::m_audioMutex;
bool AudioPlayer::initialize() {
bool Audio::initialize() {
std::lock_guard<std::mutex> lock(m_audioMutex);
if (m_initialized) return true;
@@ -41,13 +41,13 @@ namespace ult {
m_initialized = true;
m_cachedSounds.resize(static_cast<uint32_t>(SoundType::Count));
m_lastDockedState = isDocked();
m_lastDockedState = ult::consoleIsDocked();
reloadAllSounds();
return true;
}
void AudioPlayer::exit() {
void Audio::exit() {
std::lock_guard<std::mutex> lock(m_audioMutex);
// Free all cached sound buffers
@@ -67,13 +67,13 @@ namespace ult {
}
}
void AudioPlayer::reloadAllSounds() {
void Audio::reloadAllSounds() {
for (uint32_t i = 0; i < static_cast<uint32_t>(SoundType::Count); ++i) {
loadSoundFromWav(static_cast<SoundType>(i), m_soundPaths[i]);
}
}
void AudioPlayer::unloadAllSounds(const std::initializer_list<SoundType>& excludeSounds) {
void Audio::unloadAllSounds(const std::initializer_list<SoundType>& excludeSounds) {
std::lock_guard<std::mutex> lock(m_audioMutex);
if (!m_initialized) return;
@@ -95,10 +95,10 @@ namespace ult {
}
}
bool AudioPlayer::reloadIfDockedChanged() {
bool Audio::reloadIfDockedChanged() {
if (!m_initialized) return false;
const bool currentDocked = isDocked();
const bool currentDocked = ult::consoleIsDocked();
if (currentDocked == m_lastDockedState) return false;
std::lock_guard<std::mutex> lock(m_audioMutex);
@@ -108,7 +108,7 @@ namespace ult {
return true;
}
bool AudioPlayer::loadSoundFromWav(SoundType type, const char* path) {
bool Audio::loadSoundFromWav(SoundType type, const char* path) {
const uint32_t idx = static_cast<uint32_t>(type);
if (!m_initialized || idx >= static_cast<uint32_t>(SoundType::Count)) return false;
@@ -253,7 +253,7 @@ namespace ult {
return true;
}
void AudioPlayer::playSound(SoundType type) {
void Audio::playSound(SoundType type) {
// Lock-free check - SAFE with atomic
if (!m_enabled.load(std::memory_order_relaxed)) return;
@@ -286,27 +286,27 @@ namespace ult {
audoutPlayBuffer(&audioBuffer, &rel);
}
void AudioPlayer::setMasterVolume(float v) {
void Audio::setMasterVolume(float v) {
std::lock_guard<std::mutex> lock(m_audioMutex);
m_masterVolume = std::clamp(v, 0.0f, 1.0f);
}
void AudioPlayer::setEnabled(bool e) {
void Audio::setEnabled(bool e) {
m_enabled.store(e, std::memory_order_relaxed);
}
bool AudioPlayer::isEnabled() {
bool Audio::isEnabled() {
return m_enabled.load(std::memory_order_relaxed);
}
bool AudioPlayer::isDocked() {
Result rc = apmInitialize();
if (R_FAILED(rc)) return false;
ApmPerformanceMode perfMode = ApmPerformanceMode_Invalid;
rc = apmGetPerformanceMode(&perfMode);
apmExit();
return R_SUCCEEDED(rc) && (perfMode == ApmPerformanceMode_Boost);
}
//bool Audio::isDocked() {
// Result rc = apmInitialize();
// if (R_FAILED(rc)) return false;
//
// ApmPerformanceMode perfMode = ApmPerformanceMode_Invalid;
// rc = apmGetPerformanceMode(&perfMode);
// apmExit();
//
// return R_SUCCEEDED(rc) && (perfMode == ApmPerformanceMode_Boost);
//}
}

9
Source/sys-clk/overlay/lib/libultrahand/libultra/source/debug_funcs.cpp
View File

@@ -4,6 +4,15 @@
* Description:
* This source file contains the implementation of debugging functions for the
* Ultrahand Overlay project.
*
* For the latest updates and contributions, visit the project's GitHub repository.
* (GitHub Repository: https://github.com/ppkantorski/Ultrahand-Overlay)
*
* Note: Please be aware that this notice cannot be altered or removed. It is a part
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include "debug_funcs.hpp"

46
Source/sys-clk/overlay/lib/libultrahand/libultra/source/download_funcs.cpp
View File

@@ -14,7 +14,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include "download_funcs.hpp"
@@ -23,8 +23,8 @@
namespace ult {
// Base loader definitions
size_t DOWNLOAD_READ_BUFFER = 8*1024;//64 * 1024;//4096*10;
size_t DOWNLOAD_WRITE_BUFFER = 8*1024;//64 * 1024;
size_t DOWNLOAD_READ_BUFFER = 32*1024;//64 * 1024;//4096*10;
size_t DOWNLOAD_WRITE_BUFFER = 16*1024;//64 * 1024;
size_t UNZIP_READ_BUFFER = 32*1024;//131072*2;//4096*4;
size_t UNZIP_WRITE_BUFFER = 16*1024;//131072*2;//4096*4;
@@ -131,7 +131,7 @@ int progressCallback(void *ptr, curl_off_t totalToDownload, curl_off_t nowDownlo
// }
//}
std::unique_ptr<char[]> globalWriteBuffer;
//std::unique_ptr<char[]> writeBuffer;
/**
* @brief Downloads a file from a URL to a specified destination.
@@ -192,12 +192,12 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool
}
// ADD THIS: Set up write buffer for better performance
//std::unique_ptr<char[]> globalWriteBuffer;
std::unique_ptr<char[]> writeBuffer;
if (DOWNLOAD_WRITE_BUFFER > 0) {
//if (!globalWriteBuffer)
globalWriteBuffer = std::make_unique<char[]>(DOWNLOAD_WRITE_BUFFER);
//if (!writeBuffer)
writeBuffer = std::make_unique<char[]>(DOWNLOAD_WRITE_BUFFER);
// _IOFBF = full buffering, _IOLBF = line buffering, _IONBF = no buffering
setvbuf(file.get(), globalWriteBuffer.get(), _IOFBF, DOWNLOAD_WRITE_BUFFER);
setvbuf(file.get(), writeBuffer.get(), _IOFBF, DOWNLOAD_WRITE_BUFFER);
}
//setvbuf(file.get(), NULL, _IOFBF, DOWNLOAD_WRITE_BUFFER);
@@ -224,7 +224,7 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool
file.close();
#else
file.reset();
globalWriteBuffer.reset();
writeBuffer.reset();
#endif
return false;
}
@@ -277,12 +277,15 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool
//const bool wasAborted = (result == CURLE_ABORTED_BY_CALLBACK ||
// abortDownload.load(std::memory_order_acquire));
// Check HTTP response code BEFORE closing file/curl
long http_code = 0;
curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &http_code);
#if USING_FSTREAM_DIRECTIVE
file.close();
#else
file.reset();
globalWriteBuffer.reset();
writeBuffer.reset();
#endif
curl.reset();
@@ -310,6 +313,20 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool
//socketExit();
// Check for HTTP errors (404, 500, etc.)
if (result == CURLE_OK && (http_code < 200 || http_code >= 300)) {
#if USING_LOGGING_DIRECTIVE
if (!disableLogging)
logMessage("HTTP error " + std::to_string(http_code) + " downloading: " + url);
#endif
deleteFileOrDirectory(tempFilePath);
if (!noPercentagePolling) {
downloadPercentage.store(-1, std::memory_order_release);
}
return false;
}
if (result != CURLE_OK) {
#if USING_LOGGING_DIRECTIVE
if (result == CURLE_ABORTED_BY_CALLBACK) {
@@ -382,6 +399,7 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool
}
moveFile(tempFilePath, destination);
return true;
}
@@ -622,7 +640,7 @@ bool unzipFile(const std::string& zipFilePath, const std::string& toDestination)
const size_t bufferSize = UNZIP_WRITE_BUFFER;
//std::unique_ptr<char[]> buffer = std::make_unique<char[]>(bufferSize);
globalWriteBuffer = std::make_unique<char[]>(bufferSize);
std::unique_ptr<char[]> writeBuffer = std::make_unique<char[]>(bufferSize);
char filenameBuffer[512]; // Stack allocated for filename reading
@@ -758,14 +776,14 @@ bool unzipFile(const std::string& zipFilePath, const std::string& toDestination)
fileBytesProcessed = 0;
while ((bytesRead = unzReadCurrentFile(zipFile, globalWriteBuffer.get(), bufferSize)) > 0) {
while ((bytesRead = unzReadCurrentFile(zipFile, writeBuffer.get(), bufferSize)) > 0) {
if (abortUnzip.load(std::memory_order_relaxed)) {
extractSuccess = false;
break; // RAII will handle cleanup
}
// Write data to file
if (outputFile.write(globalWriteBuffer.get(), bytesRead) != static_cast<size_t>(bytesRead)) {
if (outputFile.write(writeBuffer.get(), bytesRead) != static_cast<size_t>(bytesRead)) {
extractSuccess = false;
break;
}
@@ -845,7 +863,7 @@ bool unzipFile(const std::string& zipFilePath, const std::string& toDestination)
result = unzGoToNextFile(zipFile);
}
globalWriteBuffer.reset();
writeBuffer.reset();
// Check final abort state
if (abortUnzip.load(std::memory_order_relaxed)) {

2
Source/sys-clk/overlay/lib/libultrahand/libultra/source/get_funcs.cpp
View File

@@ -15,7 +15,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include "get_funcs.hpp"

20
Source/sys-clk/overlay/lib/libultrahand/libultra/source/global_vars.cpp
View File

@@ -13,7 +13,7 @@
* altered or removed.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include "global_vars.hpp"
@@ -26,6 +26,10 @@ namespace ult {
const std::string TESLA_CONFIG_PATH = ROOT_PATH + "config/tesla/";
const std::string SWITCH_PATH = ROOT_PATH + "switch/";
const std::string NX_OVLLOADER_PATH = ROOT_PATH + "config/nx-ovlloader/";
const std::string OVL_HEAP_CONFIG_PATH = NX_OVLLOADER_PATH + "heap_size.bin";
const std::string OVL_EXIT_FLAG_PATH = NX_OVLLOADER_PATH + "exit_flag.bin";
// Filenames
CONSTEXPR_STRING std::string CONFIG_FILENAME = "config.ini";
const std::string BOOT_PACKAGE_FILENAME = "boot_package.ini";
@@ -59,7 +63,8 @@ namespace ult {
std::string THEME_CONFIG_INI_PATH = BASE_CONFIG_PATH + THEME_FILENAME;
std::string WALLPAPER_PATH = BASE_CONFIG_PATH + WALLPAPER_FILENAME;
const std::string DOWNLOADS_PATH = BASE_CONFIG_PATH + "downloads/";
const std::string EXPANSION_PATH = BASE_CONFIG_PATH + "expansion/";
//const std::string EXPANSION_PATH = BASE_CONFIG_PATH + "expansion/";
const std::string FUSE_DATA_INI_PATH = BASE_CONFIG_PATH + FUSE_FILENAME;
const std::string PACKAGE_PATH = SWITCH_PATH + ".packages/";
const std::string OVERLAY_PATH = SWITCH_PATH + ".overlays/";
@@ -79,12 +84,13 @@ namespace ult {
const std::string ULTRAHAND_REPO_URL = GITHUB_BASE_URL + "Ultrahand-Overlay/";
const std::string INCLUDED_THEME_FOLDER_URL = GITHUB_RAW_BASE_URL + "Ultrahand-Overlay/main/themes/";
const std::string LATEST_RELEASE_INFO_URL = GITHUB_RAW_BASE_URL + "Ultrahand-Overlay/main/RELEASE.ini";
const std::string NX_OVLLOADER_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/latest/download/nx-ovlloader.zip";
const std::string NX_OVLLOADER_PLUS_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/latest/download/nx-ovlloader+.zip";
const std::string LATEST_UPDATER_INI_URL = ULTRAHAND_REPO_URL + "releases/latest/download/update.ini";
//const std::string NX_OVLLOADER_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/latest/download/nx-ovlloader.zip";
//const std::string NX_OVLLOADER_PLUS_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/latest/download/nx-ovlloader+.zip";
const std::string OLD_NX_OVLLOADER_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/download/v1.0.8/nx-ovlloader.zip";
const std::string OLD_NX_OVLLOADER_PLUS_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/download/v1.0.8/nx-ovlloader+.zip";
//const std::string OLD_NX_OVLLOADER_PLUS_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/download/v1.0.8/nx-ovlloader+.zip";
const std::string UPDATER_PAYLOAD_URL = GITHUB_RAW_BASE_URL + "Ultrahand-Overlay/main/payloads/ultrahand_updater.bin";
const std::string SOUND_EFFECTS_URL = GITHUB_RAW_BASE_URL + "Ultrahand-Overlay/main/sounds/sounds.zip";
//const std::string SOUND_EFFECTS_URL = GITHUB_RAW_BASE_URL + "Ultrahand-Overlay/main/sounds/sounds.zip";
// Launch options
const std::string LAUNCH_ARGS_STR = "launch_args";
@@ -140,6 +146,7 @@ namespace ult {
CONSTEXPR_STRING std::string FALSE_STR = "false";
CONSTEXPR_STRING std::string GLOBAL_STR = "global";
CONSTEXPR_STRING std::string DEFAULT_STR = "default";
CONSTEXPR_STRING std::string HOLD_STR = "hold";
CONSTEXPR_STRING std::string SLOT_STR = "slot";
CONSTEXPR_STRING std::string OPTION_STR = "option";
CONSTEXPR_STRING std::string FORWARDER_STR = "forwarder";
@@ -164,6 +171,7 @@ namespace ult {
CONSTEXPR_STRING std::string INPROGRESS_SYMBOL = "\u25CF";
CONSTEXPR_STRING std::string STAR_SYMBOL = "\u2605";
CONSTEXPR_STRING std::string DIVIDER_SYMBOL = "";
CONSTEXPR_STRING std::string NOTIFY_HEADER = "";
const std::vector<std::string> THROBBER_SYMBOLS = {"", "", "", "", "", "", "", ""};

207
Source/sys-clk/overlay/lib/libultrahand/libultra/source/haptics.cpp
View File

@@ -32,8 +32,11 @@ namespace ult {
static u64 doubleClickTick = 0;
static u8 doubleClickPulse = 0;
static u32 cachedHandheldStyle = 0;
static u32 cachedPlayer1Style = 0;
// ===== Shared flags (accessible globally) =====
std::atomic<bool> rumbleActive{false};
std::atomic<bool> clickActive{false};
std::atomic<bool> doubleClickActive{false};
// ===== Constants =====
@@ -41,144 +44,182 @@ namespace ult {
static constexpr u64 DOUBLE_CLICK_PULSE_DURATION_NS = 30'000'000ULL;
static constexpr u64 DOUBLE_CLICK_GAP_NS = 100'000'000ULL;
static constexpr HidVibrationValue clickDocked = {
//static constexpr HidVibrationValue clickDocked = {
// .amp_low = 0.20f,
// .freq_low = 100.0f,
// .amp_high = 0.80f,
// .freq_high = 300.0f
//};
//
//static constexpr HidVibrationValue clickHandheld = {
// .amp_low = 0.20f,
// .freq_low = 100.0f,
// .amp_high = 0.80f,
// .freq_high = 300.0f
//};
static constexpr HidVibrationValue hapticsPreset = {
.amp_low = 0.20f,
.freq_low = 100.0f,
.amp_high = 0.80f,
.freq_high = 300.0f
};
static constexpr HidVibrationValue clickHandheld = {
.amp_low = 0.25f,
.freq_low = 100.0f,
.amp_high = 1.0f,
.freq_high = 300.0f
};
static constexpr HidVibrationValue vibrationStop{0};
// ===== Internal helpers =====
static void initController(HidNpadIdType npad, HidVibrationDeviceHandle* handles, int count) {
const u32 styleMask = hidGetNpadStyleSet(npad);
if (styleMask)
hidInitializeVibrationDevices(handles, count, npad, static_cast<HidNpadStyleTag>(styleMask));
}
static void sendVibration(const HidVibrationValue* value) {
if (hidGetNpadStyleSet(HidNpadIdType_Handheld))
static inline void sendVibration(const HidVibrationValue* value) {
if (cachedHandheldStyle)
hidSendVibrationValue(vibHandheld, value);
if (hidGetNpadStyleSet(HidNpadIdType_No1)) {
if (cachedPlayer1Style) {
hidSendVibrationValue(vibPlayer1Left, value);
hidSendVibrationValue(vibPlayer1Right, value);
}
}
// ===== Public API =====
void initRumble() {
//if (rumbleInitialized) return;
// Try to initialize whatever is available
// Don't check if controllers exist - let initController handle it
initController(HidNpadIdType_Handheld, &vibHandheld, 1);
HidVibrationDeviceHandle handles[2];
initController(HidNpadIdType_No1, handles, 2);
vibPlayer1Left = handles[0];
vibPlayer1Right = handles[1];
// Only mark as initialized if at least one controller was found
hidGetNpadStyleSet(HidNpadIdType_Handheld);
hidGetNpadStyleSet(HidNpadIdType_No1);
//rumbleInitialized = (handheldStyle || player1Style);
// If neither exist, stay uninitialized so we retry later
static inline void sendVibration2x(const HidVibrationValue* value) {
sendVibration(value);
sendVibration(value);
}
//void deinitRumble() {
// ===== Public API =====
void initHaptics() {
const u32 handheldStyle = hidGetNpadStyleSet(HidNpadIdType_Handheld);
const u32 player1Style = hidGetNpadStyleSet(HidNpadIdType_No1);
// Clear previous handles to avoid using stale handles if controllers were removed
vibHandheld = (HidVibrationDeviceHandle)0;
vibPlayer1Left = (HidVibrationDeviceHandle)0;
vibPlayer1Right = (HidVibrationDeviceHandle)0;
// Handheld
if (handheldStyle) {
hidInitializeVibrationDevices(&vibHandheld, 1,
HidNpadIdType_Handheld,
(HidNpadStyleTag)handheldStyle);
}
// Player 1 (left + right Joy-Con or Pro Controller)
if (player1Style) {
HidVibrationDeviceHandle tmp[2] = { (HidVibrationDeviceHandle)0, (HidVibrationDeviceHandle)0 };
hidInitializeVibrationDevices(tmp, 2,
HidNpadIdType_No1,
(HidNpadStyleTag)player1Style);
vibPlayer1Left = tmp[0];
vibPlayer1Right = tmp[1];
}
// Ensure cache is valid immediately after initHaptics()
cachedHandheldStyle = handheldStyle;
cachedPlayer1Style = player1Style;
}
//void deinitHaptics() {
// rumbleInitialized = false;
//}
void checkAndReinitRumble() {
void checkAndReinitHaptics() {
static u32 lastHandheldStyle = 0;
static u32 lastPlayer1Style = 0;
const u32 currentHandheldStyle = hidGetNpadStyleSet(HidNpadIdType_Handheld);
const u32 currentPlayer1Style = hidGetNpadStyleSet(HidNpadIdType_No1);
// If not initialized but controllers exist, try to init
// This handles the boot race condition where HID reports controllers
// but vibration subsystem isn't ready yet
//if (!rumbleInitialized && (currentHandheldStyle || currentPlayer1Style)) {
// initRumble();
//}
// Reinitialize only if something changed (appearance/disappearance or style change)
//const bool changed =
// (currentHandheldStyle != lastHandheldStyle) || (currentPlayer1Style != lastPlayer1Style);
// Reinit if controller configuration changed
if (currentHandheldStyle != lastHandheldStyle || currentPlayer1Style != lastPlayer1Style) {
//rumbleInitialized = false;
initRumble();
if ((currentHandheldStyle != lastHandheldStyle) || (currentPlayer1Style != lastPlayer1Style)) {
initHaptics();
}
// Update last style tracking regardless
// Update last-known styles for change detection
lastHandheldStyle = currentHandheldStyle;
lastPlayer1Style = currentPlayer1Style;
// Update cached styles used by sendVibration()/rumble paths
cachedHandheldStyle = currentHandheldStyle;
cachedPlayer1Style = currentPlayer1Style;
}
void rumbleClick() {
//if (!rumbleInitialized) {
// initRumble();
// if (!rumbleInitialized) return;
//}
sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked);
rumbleActive.store(true, std::memory_order_release);
void rumbleClick() {
// Use cached style bit instead of querying hid each call
//const HidVibrationValue* pattern = cachedHandheldStyle ? &clickHandheld : &clickDocked;
sendVibration(&vibrationStop);
//if (cachedHandheldStyle) {
// sendVibration(&clickHandheld);
// sendVibration(&clickHandheld);
//} else {
// sendVibration(&clickDocked);
// sendVibration(&clickDocked);
//}
sendVibration2x(&hapticsPreset);
clickActive.store(true, std::memory_order_release);
rumbleStartTick = armGetSystemTick();
}
void rumbleDoubleClick() {
//if (!rumbleInitialized) {
// initRumble();
// if (!rumbleInitialized) return;
//onst HidVibrationValue* pattern = cachedHandheldStyle ? &clickHandheld : &clickDocked;
sendVibration(&vibrationStop);
//if (cachedHandheldStyle) {
// sendVibration(&clickHandheld);
// sendVibration(&clickHandheld);
//} else {
// sendVibration(&clickDocked);
// sendVibration(&clickDocked);
//}
sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked);
sendVibration2x(&hapticsPreset);
doubleClickActive.store(true, std::memory_order_release);
doubleClickPulse = 1;
doubleClickTick = armGetSystemTick();
doubleClickTick = armGetSystemTick(); // Set ONCE
}
void processRumbleStop(u64 nowNs) {
if (rumbleActive.load(std::memory_order_acquire) &&
if (clickActive.load(std::memory_order_acquire) &&
nowNs - armTicksToNs(rumbleStartTick) >= RUMBLE_DURATION_NS) {
sendVibration(&vibrationStop);
rumbleActive.store(false, std::memory_order_release);
clickActive.store(false, std::memory_order_release);
}
}
void processRumbleDoubleClick(u64 nowNs) {
if (!doubleClickActive.load(std::memory_order_acquire)) return;
const u64 elapsed = nowNs - armTicksToNs(doubleClickTick);
const u64 elapsed = nowNs - armTicksToNs(doubleClickTick); // Always from original start
switch (doubleClickPulse) {
case 1:
if (elapsed >= DOUBLE_CLICK_PULSE_DURATION_NS) {
sendVibration(&vibrationStop);
doubleClickPulse = 2;
doubleClickTick = armGetSystemTick();
// Don't reset tick!
}
break;
case 2:
if (elapsed >= DOUBLE_CLICK_GAP_NS) {
sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked);
if (elapsed >= DOUBLE_CLICK_PULSE_DURATION_NS + DOUBLE_CLICK_GAP_NS) {
// Use cached style here too
//if (cachedHandheldStyle) {
// sendVibration(&clickHandheld);
// sendVibration(&clickHandheld);
//} else {
// sendVibration(&clickDocked);
// sendVibration(&clickDocked);
//}
sendVibration2x(&hapticsPreset);
doubleClickPulse = 3;
doubleClickTick = armGetSystemTick();
// Don't reset tick!
}
break;
case 3:
if (elapsed >= DOUBLE_CLICK_PULSE_DURATION_NS) {
if (elapsed >= (DOUBLE_CLICK_PULSE_DURATION_NS * 2) + DOUBLE_CLICK_GAP_NS) {
sendVibration(&vibrationStop);
doubleClickActive.store(false, std::memory_order_release);
doubleClickPulse = 0;
@@ -187,14 +228,32 @@ namespace ult {
}
}
void rumbleDoubleClickStandalone() {
sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked);
// Standalone uses sleeps, but still use cached style for decision
//const HidVibrationValue* pattern = cachedHandheldStyle ? &clickHandheld : &clickDocked;
sendVibration(&vibrationStop);
//if (cachedHandheldStyle) {
// sendVibration(&clickHandheld);
// sendVibration(&clickHandheld);
//} else {
// sendVibration(&clickDocked);
// sendVibration(&clickDocked);
//}
sendVibration2x(&hapticsPreset);
svcSleepThread(DOUBLE_CLICK_PULSE_DURATION_NS);
sendVibration(&vibrationStop);
svcSleepThread(DOUBLE_CLICK_GAP_NS);
sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked);
//if (cachedHandheldStyle) {
// sendVibration(&clickHandheld);
// sendVibration(&clickHandheld);
//} else {
// sendVibration(&clickDocked);
// sendVibration(&clickDocked);
//}
sendVibration2x(&hapticsPreset);
svcSleepThread(DOUBLE_CLICK_PULSE_DURATION_NS);
sendVibration(&vibrationStop);

255
Source/sys-clk/overlay/lib/libultrahand/libultra/source/hex_funcs.cpp
View File

@@ -15,7 +15,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include "hex_funcs.hpp"
@@ -229,15 +229,16 @@ namespace ult {
const size_t fileSize = ftell(file);
fseek(file, 0, SEEK_SET);
std::vector<unsigned char> binaryData;
if (hexData.length() % 2 != 0) {
fclose(file);
return offsets;
}
const size_t hexLen = hexData.length();
binaryData.resize(hexLen / 2);
const size_t patternLen = hexLen / 2;
// Use heap allocation for the buffer to avoid stack overflow with large buffer sizes
std::unique_ptr<unsigned char[]> binaryData(new unsigned char[patternLen]);
const unsigned char* hexPtr = reinterpret_cast<const unsigned char*>(hexData.c_str());
// Unrolled hex conversion loop
@@ -252,17 +253,17 @@ namespace ult {
}
// Optimized search variables
const unsigned char* patternPtr = binaryData.data();
const size_t patternLen = binaryData.size();
const unsigned char* patternPtr = binaryData.get();
const unsigned char firstByte = patternPtr[0];
std::vector<unsigned char> buffer(HEX_BUFFER_SIZE);
// Use heap allocation for the buffer to avoid stack overflow with large buffer sizes
std::unique_ptr<unsigned char[]> buffer(new unsigned char[HEX_BUFFER_SIZE]);
size_t bytesRead = 0;
size_t offset = 0;
while ((bytesRead = fread(buffer.data(), 1, HEX_BUFFER_SIZE, file)) > 0) {
const unsigned char* bufPtr = buffer.data();
while ((bytesRead = fread(buffer.get(), 1, HEX_BUFFER_SIZE, file)) > 0) {
const unsigned char* bufPtr = buffer.get();
// Optimized search with first-byte filtering and loop unrolling
i = 0;
@@ -322,15 +323,16 @@ namespace ult {
const size_t fileSize = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<unsigned char> binaryData;
if (hexData.length() % 2 != 0) {
file.close();
return offsets;
}
const size_t hexLen = hexData.length();
binaryData.resize(hexLen / 2);
const size_t patternLen = hexLen / 2;
// Use heap allocation for the buffer to avoid stack overflow with large buffer sizes
std::unique_ptr<unsigned char[]> binaryData(new unsigned char[patternLen]);
const unsigned char* hexPtr = reinterpret_cast<const unsigned char*>(hexData.c_str());
size_t i = 0;
@@ -342,17 +344,17 @@ namespace ult {
binaryData[i/2] = (hexTable[hexPtr[i]] << 4) | hexTable[hexPtr[i + 1]];
}
const unsigned char* patternPtr = binaryData.data();
const size_t patternLen = binaryData.size();
const unsigned char* patternPtr = binaryData.get();
const unsigned char firstByte = patternPtr[0];
std::vector<unsigned char> buffer(HEX_BUFFER_SIZE);
// Use heap allocation for the buffer to avoid stack overflow with large buffer sizes
std::unique_ptr<unsigned char[]> buffer(new unsigned char[HEX_BUFFER_SIZE]);
size_t bytesRead = 0;
size_t offset = 0;
while (file.read(reinterpret_cast<char*>(buffer.data()), HEX_BUFFER_SIZE) || file.gcount() > 0) {
while (file.read(reinterpret_cast<char*>(buffer.get()), HEX_BUFFER_SIZE) || file.gcount() > 0) {
bytesRead = file.gcount();
const unsigned char* bufPtr = buffer.data();
const unsigned char* bufPtr = buffer.get();
// Same optimized search as FILE* version
i = 0;
@@ -418,7 +420,6 @@ namespace ult {
void hexEditByOffset(const std::string& filePath, const std::string& offsetStr, const std::string& hexData) {
// Lock file writes to prevent concurrent modifications to the same file
std::lock_guard<std::mutex> fileWriteLock(fileWriteMutex);
const std::streampos offset = std::stoll(offsetStr);
#if !USING_FSTREAM_DIRECTIVE
@@ -435,7 +436,6 @@ namespace ult {
// Retrieve the file size
fseek(file, 0, SEEK_END);
const std::streampos fileSize = ftell(file);
fseek(file, 0, SEEK_SET);
if (offset >= fileSize) {
#if USING_LOGGING_DIRECTIVE
@@ -446,18 +446,37 @@ namespace ult {
return;
}
// Convert the hex string to binary data
std::vector<unsigned char> binaryData(hexData.length() / 2);
std::string byteString;
for (size_t i = 0, j = 0; i < hexData.length(); i += 2, ++j) {
byteString = hexData.substr(i, 2);
binaryData[j] = static_cast<unsigned char>(ult::stoi(byteString, nullptr, 16));
// Validate hex data length
const size_t hexLen = hexData.length();
if (hexLen % 2 != 0) {
#if USING_LOGGING_DIRECTIVE
if (!disableLogging)
logMessage("Invalid hex data length.");
#endif
fclose(file);
return;
}
// Convert the hex string to binary data using optimized lookup table
const size_t dataLen = hexLen / 2;
std::unique_ptr<unsigned char[]> binaryData(new unsigned char[dataLen]);
const unsigned char* hexPtr = reinterpret_cast<const unsigned char*>(hexData.c_str());
// Unrolled hex conversion loop (same as findHexDataOffsets)
size_t i = 0;
for (; i + 4 <= hexLen; i += 4) {
binaryData[i/2] = (hexTable[hexPtr[i]] << 4) | hexTable[hexPtr[i + 1]];
binaryData[i/2 + 1] = (hexTable[hexPtr[i + 2]] << 4) | hexTable[hexPtr[i + 3]];
}
// Handle remaining bytes
for (; i < hexLen; i += 2) {
binaryData[i/2] = (hexTable[hexPtr[i]] << 4) | hexTable[hexPtr[i + 1]];
}
// Move to the specified offset and write the binary data directly to the file
fseek(file, offset, SEEK_SET);
const size_t bytesWritten = fwrite(binaryData.data(), sizeof(unsigned char), binaryData.size(), file);
if (bytesWritten != binaryData.size()) {
const size_t bytesWritten = fwrite(binaryData.get(), sizeof(unsigned char), dataLen, file);
if (bytesWritten != dataLen) {
#if USING_LOGGING_DIRECTIVE
if (!disableLogging)
logMessage("Failed to write data to the file.");
@@ -481,7 +500,6 @@ namespace ult {
// Retrieve the file size
file.seekg(0, std::ios::end);
const std::streampos fileSize = file.tellg();
file.seekg(0, std::ios::beg);
if (offset >= fileSize) {
#if USING_LOGGING_DIRECTIVE
@@ -491,17 +509,34 @@ namespace ult {
return;
}
// Convert the hex string to binary data
std::vector<unsigned char> binaryData(hexData.length() / 2);
std::string byteString;
for (size_t i = 0, j = 0; i < hexData.length(); i += 2, ++j) {
byteString = hexData.substr(i, 2);
binaryData[j] = static_cast<unsigned char>(ult::stoi(byteString, nullptr, 16));
// Validate hex data length
const size_t hexLen = hexData.length();
if (hexLen % 2 != 0) {
#if USING_LOGGING_DIRECTIVE
if (!disableLogging)
logMessage("Invalid hex data length.");
#endif
return;
}
// Convert the hex string to binary data using optimized lookup table
const size_t dataLen = hexLen / 2;
std::unique_ptr<unsigned char[]> binaryData(new unsigned char[dataLen]);
const unsigned char* hexPtr = reinterpret_cast<const unsigned char*>(hexData.c_str());
// Unrolled hex conversion loop
size_t i = 0;
for (; i + 4 <= hexLen; i += 4) {
binaryData[i/2] = (hexTable[hexPtr[i]] << 4) | hexTable[hexPtr[i + 1]];
binaryData[i/2 + 1] = (hexTable[hexPtr[i + 2]] << 4) | hexTable[hexPtr[i + 3]];
}
for (; i < hexLen; i += 2) {
binaryData[i/2] = (hexTable[hexPtr[i]] << 4) | hexTable[hexPtr[i + 1]];
}
// Move to the specified offset and write the binary data directly to the file
file.seekp(offset);
file.write(reinterpret_cast<const char*>(binaryData.data()), binaryData.size());
file.write(reinterpret_cast<const char*>(binaryData.get()), dataLen);
if (!file) {
#if USING_LOGGING_DIRECTIVE
if (!disableLogging)
@@ -676,8 +711,10 @@ namespace ult {
}
const std::streampos totalOffset = hexSum + std::stoll(offsetStr);
std::vector<char> hexBuffer(length);
std::vector<char> hexStream(length * 2);
// Pre-allocate final string size to avoid reallocation
std::string result;
result.reserve(length * 2);
#if !USING_FSTREAM_DIRECTIVE
FILE* file = fopen(filePath.c_str(), "rb");
@@ -698,23 +735,41 @@ namespace ult {
return "";
}
const size_t bytesRead = fread(hexBuffer.data(), sizeof(char), length, file);
if (bytesRead == length) {
static constexpr char hexDigits[] = "0123456789ABCDEF";
for (size_t i = 0; i < length; ++i) {
hexStream[i * 2] = hexDigits[(hexBuffer[i] >> 4) & 0xF];
hexStream[i * 2 + 1] = hexDigits[hexBuffer[i] & 0xF];
}
} else {
// Use heap allocation for the buffer to avoid stack overflow with large buffer sizes
std::unique_ptr<unsigned char[]> buffer(new unsigned char[length]);
const size_t bytesRead = fread(buffer.get(), 1, length, file);
fclose(file);
if (bytesRead != length) {
#if USING_LOGGING_DIRECTIVE
if (!disableLogging)
logMessage("Error reading data from file or end of file reached.");
#endif
fclose(file);
return "";
}
fclose(file);
// Optimized hex conversion - directly build uppercase string
static constexpr char hexDigits[] = "0123456789ABCDEF";
result.resize(length * 2);
// Unrolled loop for better performance
size_t i = 0;
for (; i + 4 <= length; i += 4) {
result[i * 2] = hexDigits[(buffer[i] >> 4) & 0xF];
result[i * 2 + 1] = hexDigits[buffer[i] & 0xF];
result[i * 2 + 2] = hexDigits[(buffer[i + 1] >> 4) & 0xF];
result[i * 2 + 3] = hexDigits[buffer[i + 1] & 0xF];
result[i * 2 + 4] = hexDigits[(buffer[i + 2] >> 4) & 0xF];
result[i * 2 + 5] = hexDigits[buffer[i + 2] & 0xF];
result[i * 2 + 6] = hexDigits[(buffer[i + 3] >> 4) & 0xF];
result[i * 2 + 7] = hexDigits[buffer[i + 3] & 0xF];
}
// Handle remaining bytes
for (; i < length; ++i) {
result[i * 2] = hexDigits[(buffer[i] >> 4) & 0xF];
result[i * 2 + 1] = hexDigits[buffer[i] & 0xF];
}
#else
std::ifstream file(filePath, std::ios::binary);
if (!file) {
@@ -734,14 +789,12 @@ namespace ult {
return "";
}
file.read(hexBuffer.data(), length);
if (file.gcount() == static_cast<std::streamsize>(length)) {
static constexpr char hexDigits[] = "0123456789ABCDEF";
for (size_t i = 0; i < length; ++i) {
hexStream[i * 2] = hexDigits[(hexBuffer[i] >> 4) & 0xF];
hexStream[i * 2 + 1] = hexDigits[hexBuffer[i] & 0xF];
}
} else {
// Use heap allocation for the buffer to avoid stack overflow with large buffer sizes
std::unique_ptr<unsigned char[]> buffer(new unsigned char[length]);
file.read(reinterpret_cast<char*>(buffer.get()), length);
file.close();
if (file.gcount() != static_cast<std::streamsize>(length)) {
#if USING_LOGGING_DIRECTIVE
if (!disableLogging)
logMessage("Error reading data from file or end of file reached.");
@@ -749,11 +802,28 @@ namespace ult {
return "";
}
file.close();
#endif
// Optimized hex conversion - directly build uppercase string
static constexpr char hexDigits[] = "0123456789ABCDEF";
result.resize(length * 2);
std::string result(hexStream.begin(), hexStream.end());
result = stringToUppercase(result);
// Unrolled loop for better performance
size_t i = 0;
for (; i + 4 <= length; i += 4) {
result[i * 2] = hexDigits[(buffer[i] >> 4) & 0xF];
result[i * 2 + 1] = hexDigits[buffer[i] & 0xF];
result[i * 2 + 2] = hexDigits[(buffer[i + 1] >> 4) & 0xF];
result[i * 2 + 3] = hexDigits[buffer[i + 1] & 0xF];
result[i * 2 + 4] = hexDigits[(buffer[i + 2] >> 4) & 0xF];
result[i * 2 + 5] = hexDigits[buffer[i + 2] & 0xF];
result[i * 2 + 6] = hexDigits[(buffer[i + 3] >> 4) & 0xF];
result[i * 2 + 7] = hexDigits[buffer[i + 3] & 0xF];
}
// Handle remaining bytes
for (; i < length; ++i) {
result[i * 2] = hexDigits[(buffer[i] >> 4) & 0xF];
result[i * 2 + 1] = hexDigits[buffer[i] & 0xF];
}
#endif
return result;
}
@@ -878,4 +948,71 @@ namespace ult {
return ""; // Return empty string if no match is found
}
// 1. Table optimization: Mark as constexpr for compile-time evaluation
static constexpr uint8_t b64_table[256] = {
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,62, 0xFF,0xFF,0xFF,63,
52,53,54,55,56,57,58,59,60,61,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
};
// 2. Optimized decode: Pre-calculate output size, reduce bounds checking
static size_t base64_decode(const char* src, uint8_t* out) {
size_t outLen = 0;
const char* p = src;
// Process 4 chars at a time (unrolled loop for better instruction pipelining)
while (*p) {
uint8_t a = b64_table[static_cast<uint8_t>(*p++)];
if (a == 0xFF) break;
uint8_t b = b64_table[static_cast<uint8_t>(*p++)];
if (b == 0xFF) break;
out[outLen++] = (a << 2) | (b >> 4);
uint8_t cChar = *p++;
if (cChar == '=' || cChar == '\0') break;
uint8_t c = b64_table[cChar];
if (c == 0xFF) break;
out[outLen++] = (b << 4) | (c >> 2);
uint8_t dChar = *p++;
if (dChar == '=' || dChar == '\0') break;
uint8_t d = b64_table[dChar];
if (d == 0xFF) break;
out[outLen++] = (c << 6) | d;
}
return outLen;
}
// 3. Optimized wrapper: Pre-calculate exact output size, avoid vector overhead
std::string decodeBase64ToString(const std::string& b64) {
// Base64 decodes to ~3/4 original size
const size_t maxOutSize = (b64.size() * 3) / 4 + 3;
std::string result(maxOutSize, '\0');
const size_t len = base64_decode(b64.c_str(), reinterpret_cast<uint8_t*>(result.data()));
result.resize(len);
return result;
}
}

1094
Source/sys-clk/overlay/lib/libultrahand/libultra/source/ini_funcs.cpp
View File

File diff suppressed because it is too large Load Diff

2
Source/sys-clk/overlay/lib/libultrahand/libultra/source/json_funcs.cpp
View File

@@ -12,7 +12,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include "json_funcs.hpp"

33
Source/sys-clk/overlay/lib/libultrahand/libultra/source/list_funcs.cpp
View File

@@ -14,7 +14,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include <list_funcs.hpp>
@@ -85,8 +85,8 @@ namespace ult {
}
// Function to read file into a vector of strings with optional cap
std::vector<std::string> readListFromFile(const std::string& filePath, size_t maxLines) {
// Function to read file into a vector of strings with optional cap and newline preservation
std::vector<std::string> readListFromFile(const std::string& filePath, size_t maxLines, bool preserveNewlines) {
std::lock_guard<std::mutex> lock(file_access_mutex);
std::vector<std::string> lines;
@@ -109,7 +109,11 @@ namespace ult {
break;
}
// More efficient newline removal
if (preserveNewlines) {
// Keep the line as-is, including newlines
lines.emplace_back(buffer);
} else {
// Remove newlines
len = strlen(buffer);
if (len > 0 && buffer[len - 1] == '\n') {
buffer[len - 1] = '\0';
@@ -119,9 +123,9 @@ namespace ult {
buffer[len - 1] = '\0';
}
}
lines.emplace_back(buffer);
}
}
fclose(file);
#else
@@ -140,13 +144,18 @@ namespace ult {
break;
}
if (preserveNewlines) {
// Add back the newline that getline removed
line += '\n';
lines.emplace_back(std::move(line));
} else {
// Remove carriage return if present (getline removes \n but not \r)
if (!line.empty() && line.back() == '\r') {
line.pop_back();
}
lines.emplace_back(std::move(line));
}
}
file.close();
#endif
@@ -282,7 +291,7 @@ namespace ult {
// Function to read file into a set of strings
std::unordered_set<std::string> readSetFromFile(const std::string& filePath) {
std::unordered_set<std::string> readSetFromFile(const std::string& filePath, const std::string& packagePath) {
std::lock_guard<std::mutex> lock(file_access_mutex);
std::unordered_set<std::string> lines;
@@ -304,7 +313,12 @@ namespace ult {
if (len > 0 && buffer[len - 1] == '\n') {
buffer[len - 1] = '\0';
}
lines.insert(buffer);
std::string line = buffer;
if (!packagePath.empty()) {
preprocessPath(line, packagePath);
}
lines.insert(std::move(line));
}
fclose(file);
@@ -319,6 +333,9 @@ namespace ult {
std::string line;
while (std::getline(file, line)) {
if (!packagePath.empty()) {
preprocessPath(line, packagePath);
}
lines.insert(std::move(line));
}

2
Source/sys-clk/overlay/lib/libultrahand/libultra/source/mod_funcs.cpp
View File

@@ -14,7 +14,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2024-2025 ppkantorski
********************************************************************************/
#include <mod_funcs.hpp>

731
Source/sys-clk/overlay/lib/libultrahand/libultra/source/path_funcs.cpp
View File

File diff suppressed because it is too large Load Diff

61
Source/sys-clk/overlay/lib/libultrahand/libultra/source/string_funcs.cpp
View File

@@ -15,7 +15,7 @@
* of the project's documentation and must remain intact.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include "string_funcs.hpp"
@@ -226,12 +226,14 @@ namespace ult {
* @return The string with quotes removed.
*/
void removeQuotes(std::string& str) {
if (str.size() >= 2) {
const size_t len = str.size();
if (len >= 2) {
const char front = str[0];
const char back = str[str.size() - 1];
const char back = str[len - 1];
if ((front == '\'' && back == '\'') || (front == '"' && back == '"')) {
str.erase(0, 1);
str.pop_back();
std::memmove(&str[0], &str[1], len - 2);
str.resize(len - 2);
}
}
}
@@ -245,25 +247,25 @@ namespace ult {
* @param input The input string to process.
* @return The string with multiple slashes replaced.
*/
std::string replaceMultipleSlashes(const std::string& input) {
std::string output;
output.reserve(input.size()); // Reserve space for the output string
bool previousSlash = false;
for (char c : input) {
if (c == '/') {
if (!previousSlash) {
output.push_back(c);
}
previousSlash = true;
} else {
output.push_back(c);
previousSlash = false;
}
}
return output;
}
//std::string replaceMultipleSlashes(const std::string& input) {
// std::string output;
// output.reserve(input.size()); // Reserve space for the output string
//
// bool previousSlash = false;
// for (char c : input) {
// if (c == '/') {
// if (!previousSlash) {
// output.push_back(c);
// }
// previousSlash = true;
// } else {
// output.push_back(c);
// previousSlash = false;
// }
// }
//
// return output;
//}
@@ -366,7 +368,7 @@ namespace ult {
* @param filename The input filename from which to drop the extension, passed by reference and modified in-place.
*/
void dropExtension(std::string& filename) {
const size_t lastDotPos = filename.find_last_of('.'); // Single char instead of string
const size_t lastDotPos = filename.rfind('.');
if (lastDotPos != std::string::npos) {
filename.resize(lastDotPos);
}
@@ -510,9 +512,12 @@ namespace ult {
* @param input The input string from which to remove the tag, passed by reference and modified in-place.
*/
void removeTag(std::string &input) {
const size_t pos = input.find('?');
if (pos != std::string::npos) {
input.resize(pos); // Modify the string in-place to remove everything after the '?'
const char* pos = static_cast<const char*>(
std::memchr(input.data(), '?', input.size())
);
if (pos) {
input.resize(pos - input.data());
}
}

499
Source/sys-clk/overlay/lib/libultrahand/libultra/source/tsl_utils.cpp
View File

@@ -15,7 +15,7 @@
* altered or removed.
*
* Licensed under both GPLv2 and CC-BY-4.0
* Copyright (c) 2024 ppkantorski
* Copyright (c) 2023-2025 ppkantorski
********************************************************************************/
#include <tsl_utils.hpp>
@@ -28,6 +28,7 @@ extern "C" { // assertion override
}
namespace ult {
bool correctFrameSize; // for detecting the correct Overlay display size
u16 DefaultFramebufferWidth = 448; ///< Width of the framebuffer
@@ -100,7 +101,7 @@ namespace ult {
value = content.substr(valueStart + 1, valueEnd - valueStart - 1);
// 🔹 Convert escaped newlines (\\n) into real ones
// Convert escaped newlines (\\n) into real ones
normalizeNewlines(key);
normalizeNewlines(value);
@@ -132,29 +133,14 @@ namespace ult {
u16 activeHeaderHeight = 97;
bool consoleIsDocked() {
Result rc;
Result rc = apmInitialize();
if (R_FAILED(rc)) return false;
ApmPerformanceMode perfMode = ApmPerformanceMode_Invalid;
// Initialize the APM service
rc = apmInitialize();
if (R_FAILED(rc)) {
return false; // Fail early if initialization fails
}
// Get the current performance mode
rc = apmGetPerformanceMode(&perfMode);
apmExit(); // Clean up the APM service
apmExit();
if (R_FAILED(rc)) {
return false; // Fail early if performance mode check fails
}
// Check if the performance mode indicates docked state
if (perfMode == ApmPerformanceMode_Boost) {
return true; // System is docked (boost mode active)
}
return false; // Not docked (normal mode or handheld)
return R_SUCCEEDED(rc) && (perfMode == ApmPerformanceMode_Boost);
}
//static bool pminfoInitialized = false;
@@ -314,6 +300,9 @@ namespace ult {
std::atomic<float> selectWidth;
std::atomic<float> nextPageWidth;
std::atomic<bool> inMainMenu{false};
std::atomic<bool> inHiddenMode{false};
std::atomic<bool> inSettingsMenu{false};
std::atomic<bool> inSubSettingsMenu{false};
std::atomic<bool> inOverlaysPage{false};
std::atomic<bool> inPackagesPage{false};
@@ -332,7 +321,7 @@ namespace ult {
//bool progressAnimation = false;
bool disableTransparency = false;
//bool useCustomWallpaper = false;
bool useMemoryExpansion = false;
//bool useMemoryExpansion = false;
bool useOpaqueScreenshots = false;
std::atomic<bool> onTrackBar(false);
@@ -468,6 +457,7 @@ namespace ult {
std::string HIDE_OVERLAY = "Hide Overlay";
std::string HIDE_PACKAGE = "Hide Package";
std::string LAUNCH_ARGUMENTS = "Launch Arguments";
std::string FORCE_AMS110_SUPPORT = "Force AMS110+ Support";
std::string QUICK_LAUNCH = "Quick Launch";
std::string BOOT_COMMANDS = "Boot Commands";
std::string EXIT_COMMANDS = "Exit Commands";
@@ -495,6 +485,7 @@ namespace ult {
std::string USER_GUIDE = "User Guide";
std::string SHOW_HIDDEN = "Show Hidden";
std::string SHOW_DELETE = "Show Delete";
std::string SHOW_UNSUPPORTED = "Show Unsupported";
std::string PAGE_SWAP = "Page Swap";
std::string RIGHT_SIDE_MODE = "Right-side Mode";
std::string OVERLAY_VERSIONS = "Overlay Versions";
@@ -503,7 +494,7 @@ namespace ult {
//std::string VERSION_LABELS = "Version Labels";
std::string KEY_COMBO = "Key Combo";
std::string MODE = "Mode";
std::string MODES = "Modes";
std::string LAUNCH_MODES = "Launch Modes";
std::string LANGUAGE = "Language";
std::string OVERLAY_INFO = "Overlay Info";
std::string SOFTWARE_UPDATE = "Software Update";
@@ -518,11 +509,20 @@ namespace ult {
std::string VENDOR = "Vendor";
std::string MODEL = "Model";
std::string STORAGE = "Storage";
std::string NOTICE = "Notice";
std::string UTILIZES = "Utilizes";
//std::string NOTICE = "Notice";
//std::string UTILIZES = "Utilizes";
std::string MEMORY_EXPANSION = "Memory Expansion";
std::string REBOOT_REQUIRED = "*Reboot required.";
std::string OVERLAY_MEMORY = "Overlay Memory";
std::string NOT_ENOUGH_MEMORY = "Not enough memory.";
std::string WALLPAPER_SUPPORT_DISABLED = "Wallpaper support disabled.";
std::string SOUND_SUPPORT_DISABLED = "Sound support disabled.";
std::string WALLPAPER_SUPPORT_ENABLED = "Wallpaper support enabled.";
std::string SOUND_SUPPORT_ENABLED = "Sound support enabled.";
std::string EXIT_OVERLAY_SYSTEM = "Exit Overlay System";
//std::string MEMORY_EXPANSION = "Memory Expansion";
//std::string REBOOT_REQUIRED = "*Reboot required.";
std::string LOCAL_IP = "Local IP";
std::string WALLPAPER = "Wallpaper";
std::string THEME = "Theme";
@@ -566,10 +566,15 @@ namespace ult {
std::string ULTRAHAND_HAS_STARTED = "Ultrahand has started.";
std::string NEW_UPDATE_IS_AVAILABLE = "New update is available!";
std::string REBOOT_IS_REQUIRED = "Reboot is required.";
std::string HOLD_A_TO_DELETE = "Hold \uE0E0 to Delete";
//std::string REBOOT_IS_REQUIRED = "Reboot is required.";
//std::string HOLD_A_TO_DELETE = "Hold \uE0E0 to Delete";
std::string DELETE_PACKAGE = "Delete Package";
std::string DELETE_OVERLAY = "Delete Overlay";
std::string SELECTION_IS_EMPTY = "Selection is empty!";
std::string FORCED_SUPPORT_WARNING = "Forcing support can be dangerous.";
std::string TASK_IS_COMPLETE = "Task is complete!";
std::string TASK_HAS_FAILED = "Task has failed.";
//std::string PACKAGE_VERSIONS = "Package Versions";
@@ -581,6 +586,8 @@ namespace ult {
std::string BOOT_ENTRY = "Boot Entry";
#endif
std::string INCOMPATIBLE_WARNING = "Incompatible on AMS v1.10+";
std::string SYSTEM_RAM = "System RAM";
std::string FREE = "free";
std::string DEFAULT_CHAR_WIDTH = "0.33";
@@ -678,6 +685,7 @@ namespace ult {
HIDE_OVERLAY = "Hide Overlay";
HIDE_PACKAGE = "Hide Package";
LAUNCH_ARGUMENTS = "Launch Arguments";
FORCE_AMS110_SUPPORT = "Force AMS110+ Support";
QUICK_LAUNCH = "Quick Launch";
BOOT_COMMANDS = "Boot Commands";
EXIT_COMMANDS = "Exit Commands";
@@ -704,6 +712,7 @@ namespace ult {
USER_GUIDE = "User Guide";
SHOW_HIDDEN = "Show Hidden";
SHOW_DELETE = "Show Delete";
SHOW_UNSUPPORTED = "Show Unsupported";
PAGE_SWAP = "Page Swap";
RIGHT_SIDE_MODE = "Right-side Mode";
OVERLAY_VERSIONS = "Overlay Versions";
@@ -712,7 +721,7 @@ namespace ult {
//VERSION_LABELS = "Version Labels";
KEY_COMBO = "Key Combo";
MODE = "Mode";
MODES = "Modes";
LAUNCH_MODES = "Launch Modes";
LANGUAGE = "Language";
OVERLAY_INFO = "Overlay Info";
SOFTWARE_UPDATE = "Software Update";
@@ -727,11 +736,21 @@ namespace ult {
VENDOR = "Vendor";
MODEL = "Model";
STORAGE = "Storage";
NOTICE = "Notice";
UTILIZES = "Utilizes";
//NOTICE = "Notice";
//UTILIZES = "Utilizes";
SYSTEM_RAM = "System RAM";
FREE = "free";
MEMORY_EXPANSION = "Memory Expansion";
REBOOT_REQUIRED = "*Reboot required.";
OVERLAY_MEMORY = "Overlay Memory";
NOT_ENOUGH_MEMORY = "Not enough memory.";
WALLPAPER_SUPPORT_DISABLED = "Wallpaper support disabled.";
SOUND_SUPPORT_DISABLED = "Sound support disabled.";
WALLPAPER_SUPPORT_ENABLED = "Wallpaper support enabled.";
SOUND_SUPPORT_ENABLED = "Sound support enabled.";
EXIT_OVERLAY_SYSTEM = "Exit Overlay System";
//MEMORY_EXPANSION = "Memory Expansion";
//REBOOT_REQUIRED = "*Reboot required.";
LOCAL_IP = "Local IP";
WALLPAPER = "Wallpaper";
THEME = "Theme";
@@ -790,9 +809,15 @@ namespace ult {
ULTRAHAND_HAS_STARTED = "Ultrahand has started.";
NEW_UPDATE_IS_AVAILABLE = "New update is available!";
REBOOT_IS_REQUIRED = "Reboot is required.";
HOLD_A_TO_DELETE = "Hold  to Delete";
//REBOOT_IS_REQUIRED = "Reboot is required.";
//HOLD_A_TO_DELETE = "Hold  to Delete";
DELETE_PACKAGE = "Delete Package";
DELETE_OVERLAY = "Delete Overlay";
SELECTION_IS_EMPTY = "Selection is empty!";
FORCED_SUPPORT_WARNING = "Forcing support can be dangerous.";
INCOMPATIBLE_WARNING = "Incompatible on AMS v1.10+";
TASK_IS_COMPLETE = "Task is complete!";
TASK_HAS_FAILED = "Task has failed.";
//EMPTY = "Empty";
@@ -860,7 +885,7 @@ namespace ult {
}
static std::unordered_map<std::string, std::string*> configMap = {
std::unordered_map<std::string, std::string*> configMap = {
#if IS_LAUNCHER_DIRECTIVE
{"ENGLISH", &ENGLISH},
{"SPANISH", &SPANISH},
@@ -887,6 +912,7 @@ namespace ult {
{"HIDE_PACKAGE", &HIDE_PACKAGE},
{"HIDE_OVERLAY", &HIDE_OVERLAY},
{"LAUNCH_ARGUMENTS", &LAUNCH_ARGUMENTS},
{"FORCE_AMS110_SUPPORT", &FORCE_AMS110_SUPPORT},
{"QUICK_LAUNCH", &QUICK_LAUNCH},
{"BOOT_COMMANDS", &BOOT_COMMANDS},
{"EXIT_COMMANDS", &EXIT_COMMANDS},
@@ -914,6 +940,7 @@ namespace ult {
{"USER_GUIDE", &USER_GUIDE},
{"SHOW_HIDDEN", &SHOW_HIDDEN},
{"SHOW_DELETE", &SHOW_DELETE},
{"SHOW_UNSUPPORTED", &SHOW_UNSUPPORTED},
{"PAGE_SWAP", &PAGE_SWAP},
{"RIGHT_SIDE_MODE", &RIGHT_SIDE_MODE},
{"OVERLAY_VERSIONS", &OVERLAY_VERSIONS},
@@ -922,7 +949,7 @@ namespace ult {
//{"VERSION_LABELS", &VERSION_LABELS},
{"KEY_COMBO", &KEY_COMBO},
{"MODE", &MODE},
{"MODES", &MODES},
{"LAUNCH_MODES", &LAUNCH_MODES},
{"LANGUAGE", &LANGUAGE},
{"OVERLAY_INFO", &OVERLAY_INFO},
{"SOFTWARE_UPDATE", &SOFTWARE_UPDATE},
@@ -937,11 +964,19 @@ namespace ult {
{"VENDOR", &VENDOR},
{"MODEL", &MODEL},
{"STORAGE", &STORAGE},
{"NOTICE", &NOTICE},
{"UTILIZES", &UTILIZES},
//{"NOTICE", &NOTICE},
//{"UTILIZES", &UTILIZES},
{"MEMORY_EXPANSION", &MEMORY_EXPANSION},
{"REBOOT_REQUIRED", &REBOOT_REQUIRED},
{"OVERLAY_MEMORY", &OVERLAY_MEMORY},
{"NOT_ENOUGH_MEMORY", &NOT_ENOUGH_MEMORY},
{"WALLPAPER_SUPPORT_DISABLED", &WALLPAPER_SUPPORT_DISABLED},
{"SOUND_SUPPORT_DISABLED", &SOUND_SUPPORT_DISABLED},
{"WALLPAPER_SUPPORT_ENABLED", &WALLPAPER_SUPPORT_ENABLED},
{"SOUND_SUPPORT_ENABLED", &SOUND_SUPPORT_ENABLED},
{"EXIT_OVERLAY_SYSTEM", &EXIT_OVERLAY_SYSTEM},
//{"MEMORY_EXPANSION", &MEMORY_EXPANSION},
//{"REBOOT_REQUIRED", &REBOOT_REQUIRED},
{"LOCAL_IP", &LOCAL_IP},
{"WALLPAPER", &WALLPAPER},
{"THEME", &THEME},
@@ -986,9 +1021,15 @@ namespace ult {
{"ULTRAHAND_HAS_STARTED", &ULTRAHAND_HAS_STARTED},
{"NEW_UPDATE_IS_AVAILABLE", &NEW_UPDATE_IS_AVAILABLE},
{"REBOOT_IS_REQUIRED", &REBOOT_IS_REQUIRED},
{"HOLD_A_TO_DELETE", &HOLD_A_TO_DELETE},
//{"REBOOT_IS_REQUIRED", &REBOOT_IS_REQUIRED},
//{"HOLD_A_TO_DELETE", &HOLD_A_TO_DELETE},
{"DELETE_PACKAGE", &DELETE_PACKAGE},
{"DELETE_OVERLAY", &DELETE_OVERLAY},
{"SELECTION_IS_EMPTY", &SELECTION_IS_EMPTY},
{"FORCED_SUPPORT_WARNING", &FORCED_SUPPORT_WARNING},
{"INCOMPATIBLE_WARNING", &INCOMPATIBLE_WARNING},
{"TASK_IS_COMPLETE", &TASK_IS_COMPLETE},
{"TASK_HAS_FAILED", &TASK_HAS_FAILED},
//{"PACKAGE_VERSIONS", &PACKAGE_VERSIONS},
//{"PROGRESS_ANIMATION", &PROGRESS_ANIMATION},
@@ -999,6 +1040,7 @@ namespace ult {
{"BOOT_ENTRY", &BOOT_ENTRY},
#endif
{"SYSTEM_RAM", &SYSTEM_RAM},
{"FREE", &FREE},
{"DEFAULT_CHAR_WIDTH", &DEFAULT_CHAR_WIDTH},
@@ -1144,41 +1186,47 @@ namespace ult {
// Unified function to apply replacements
void applyLangReplacements(std::string& text, bool isValue) {
// Static maps for replacements
#if IS_LAUNCHER_DIRECTIVE
const std::unordered_map<std::string, std::string*> launcherReplacements = {
{"Reboot To", &REBOOT_TO},
{"Boot Entry", &BOOT_ENTRY},
{"Reboot", &REBOOT},
{"Shutdown", &SHUTDOWN}
};
#endif
const std::unordered_map<std::string, std::string*> valueReplacements = {
{"On", &ON},
{"Off", &OFF}
};
// Determine which map to use
const std::unordered_map<std::string, std::string*>* replacements = nullptr;
if (!isValue) {
#if IS_LAUNCHER_DIRECTIVE
replacements = &launcherReplacements;
#else
if (isValue) {
// Direct comparison for value replacements
if (text.length() == 2) {
if (text[0] == 'O') {
if (text[1] == 'n') {
text = ON;
return;
} else if (text[1] == 'f' && text == "Off") {
text = OFF;
return;
}
}
}
}
#if IS_LAUNCHER_DIRECTIVE
else {
// Direct comparison for launcher replacements
switch (text.length()) {
case 6:
if (text == "Reboot") {
text = REBOOT;
}
break;
case 8:
if (text == "Shutdown") {
text = SHUTDOWN;
}
break;
case 9:
if (text == "Reboot To") {
text = REBOOT_TO;
}
break;
case 10:
if (text == "Boot Entry") {
text = BOOT_ENTRY;
}
break;
}
}
#endif
} else {
replacements = &valueReplacements;
}
// Perform the direct replacement
if (replacements) {
auto it = replacements->find(text);
if (it != replacements->end()) {
text = *(it->second);
}
}
}
@@ -1252,7 +1300,8 @@ namespace ult {
{"selection_value_text_color", "FF7777"},
{"selection_bg_color", blackColor},
{"selection_bg_alpha", "11"},
{"trackbar_color", "555555"},
{"scrollbar_color", "555555"},
{"scrollbar_wall_color", "AAAAAA"},
{"highlight_color_1", "2288CC"},
{"highlight_color_2", "88FFFF"},
{"highlight_color_3", "FFFF45"},
@@ -1292,23 +1341,6 @@ namespace ult {
}
float calculateAmplitude(float x, float peakDurationFactor) {
//const float phasePeriod = 360.0f * peakDurationFactor; // One full phase period
// Convert x from radians to degrees and calculate phase within the period
const int phase = static_cast<int>(x * RAD_TO_DEG) % static_cast<int>(360.0f * peakDurationFactor);
// Check if the phase is odd using bitwise operation
if (phase & 1) {
return 1.0f; // Flat amplitude (maximum positive)
} else {
// Calculate the sinusoidal amplitude for the remaining period
return (APPROXIMATE_cos(x) + 1.0f) / 2.0f; // Cosine function expects radians
}
}
std::atomic<bool> refreshWallpaperNow(false);
std::atomic<bool> refreshWallpaper(false);
std::vector<u8> wallpaperData;
@@ -1318,125 +1350,6 @@ namespace ult {
std::condition_variable cv;
// Function to load the RGBA file into memory and modify wallpaperData directly
//void loadWallpaperFile(const std::string& filePath, s32 width, s32 height) {
// const size_t originalDataSize = width * height * 4; // Original size in bytes (4 bytes per pixel)
// const size_t compressedDataSize = originalDataSize / 2; // RGBA4444 uses half the space
//
// wallpaperData.resize(compressedDataSize);
//
// if (!isFileOrDirectory(filePath)) {
// wallpaperData.clear();
// return;
// }
//
// #if !USING_FSTREAM_DIRECTIVE
// FILE* file = fopen(filePath.c_str(), "rb");
// if (!file) {
// wallpaperData.clear();
// return;
// }
//
// std::vector<uint8_t> buffer;
// //if (reducedMemory) {
// // // Reuse wallpaperData to avoid double allocation
// // buffer.swap(wallpaperData);
// // buffer.resize(originalDataSize);
// //} else {
// buffer.resize(originalDataSize);
// //}
//
// const size_t bytesRead = fread(buffer.data(), 1, originalDataSize, file);
// fclose(file);
//
// if (bytesRead != originalDataSize) {
// wallpaperData.clear();
// return;
// }
//
// #else
// std::ifstream file(filePath, std::ios::binary);
// if (!file) {
// wallpaperData.clear();
// return;
// }
//
// std::vector<uint8_t> buffer;
// //if (reducedMemory) {
// // buffer.swap(wallpaperData);
// // buffer.resize(originalDataSize);
// //} else {
// buffer.resize(originalDataSize);
// //}
//
// file.read(reinterpret_cast<char*>(buffer.data()), originalDataSize);
// if (!file) {
// wallpaperData.clear();
// return;
// }
// #endif
//
// // Compress RGBA8888 to RGBA4444
// //if (reducedMemory) {
// // // In-place compression to save memory
// // size_t writeIndex = 0;
// // for (size_t i = 0; i < originalDataSize; i += 8, writeIndex += 4) {
// // uint8_t r1 = buffer[i] >> 4;
// // uint8_t g1 = buffer[i + 1] >> 4;
// // uint8_t b1 = buffer[i + 2] >> 4;
// // uint8_t a1 = buffer[i + 3] >> 4;
// //
// // uint8_t r2 = buffer[i + 4] >> 4;
// // uint8_t g2 = buffer[i + 5] >> 4;
// // uint8_t b2 = buffer[i + 6] >> 4;
// // uint8_t a2 = buffer[i + 7] >> 4;
// //
// // buffer[writeIndex] = (r1 << 4) | g1;
// // buffer[writeIndex + 1] = (b1 << 4) | a1;
// // buffer[writeIndex + 2] = (r2 << 4) | g2;
// // buffer[writeIndex + 3] = (b2 << 4) | a2;
// // }
// // buffer.resize(compressedDataSize);
// // wallpaperData.swap(buffer);
// //} else {
// uint8_t* input = buffer.data();
// uint8_t* output = wallpaperData.data();
// //uint8_t r1, g1, b1, a1;
// //uint8_t r2, g2, b2, a2;
//
// //for (size_t i = 0, j = 0; i < originalDataSize; i += 8, j += 4) {
// // // Read 2 RGBA pixels (8 bytes)
// // const uint8_t r1 = input[i] >> 4;
// // const uint8_t g1 = input[i + 1] >> 4;
// // const uint8_t b1 = input[i + 2] >> 4;
// // const uint8_t a1 = input[i + 3] >> 4;
// //
// // const uint8_t r2 = input[i + 4] >> 4;
// // const uint8_t g2 = input[i + 5] >> 4;
// // const uint8_t b2 = input[i + 6] >> 4;
// // const uint8_t a2 = input[i + 7] >> 4;
// //
// // // Pack them into 4 bytes (2 bytes per pixel)
// // output[j] = (r1 << 4) | g1;
// // output[j + 1] = (b1 << 4) | a1;
// // output[j + 2] = (r2 << 4) | g2;
// // output[j + 3] = (b2 << 4) | a2;
// //}
//
// for (size_t i = 0, j = 0; i < originalDataSize; i += 16, j += 8) {
// output[j] = ((input[i] >> 4) << 4) | (input[i + 1] >> 4);
// output[j + 1] = ((input[i + 2] >> 4) << 4) | (input[i + 3] >> 4);
// output[j + 2] = ((input[i + 4] >> 4) << 4) | (input[i + 5] >> 4);
// output[j + 3] = ((input[i + 6] >> 4) << 4) | (input[i + 7] >> 4);
// output[j + 4] = ((input[i + 8] >> 4) << 4) | (input[i + 9] >> 4);
// output[j + 5] = ((input[i + 10] >> 4) << 4) | (input[i + 11] >> 4);
// output[j + 6] = ((input[i + 12] >> 4) << 4) | (input[i + 13] >> 4);
// output[j + 7] = ((input[i + 14] >> 4) << 4) | (input[i + 15] >> 4);
// }
// //}
//}
void loadWallpaperFile(const std::string& filePath, s32 width, s32 height) {
const size_t originalDataSize = width * height * 4;
const size_t compressedDataSize = originalDataSize / 2;
@@ -1454,32 +1367,40 @@ namespace ult {
return;
}
constexpr size_t chunkBytes = 64 * 1024; // 64 KB chunks
setvbuf(file, nullptr, _IOFBF, 256 * 1024);
constexpr size_t chunkBytes = 128 * 1024;
uint8_t chunkBuffer[chunkBytes];
size_t totalRead = 0;
size_t writeIndex = 0;
size_t remaining, toRead, bytesRead;
uint8_t* dst = wallpaperData.data();
const uint8x8_t mask = vdup_n_u8(0xF0);
while (totalRead < originalDataSize) {
// Determine how much to read this iteration
remaining = originalDataSize - totalRead;
toRead = remaining < chunkBytes ? remaining : chunkBytes;
const size_t remaining = originalDataSize - totalRead;
const size_t toRead = remaining < chunkBytes ? remaining : chunkBytes;
bytesRead = fread(chunkBuffer, 1, toRead, file);
if (bytesRead == 0 || bytesRead % 8 != 0) { // must be multiple of 2 pixels
const size_t bytesRead = fread(chunkBuffer, 1, toRead, file);
if (bytesRead == 0) {
fclose(file);
wallpaperData.clear();
return;
}
// Compress each 2-pixel group in the chunk
for (size_t i = 0; i < bytesRead; i += 8, writeIndex += 4) {
wallpaperData[writeIndex] = (chunkBuffer[i] & 0xF0) | (chunkBuffer[i + 1] >> 4);
wallpaperData[writeIndex + 1] = (chunkBuffer[i + 2] & 0xF0) | (chunkBuffer[i + 3] >> 4);
wallpaperData[writeIndex + 2] = (chunkBuffer[i + 4] & 0xF0) | (chunkBuffer[i + 5] >> 4);
wallpaperData[writeIndex + 3] = (chunkBuffer[i + 6] & 0xF0) | (chunkBuffer[i + 7] >> 4);
const uint8_t* src = chunkBuffer;
size_t i = 0;
// NEON: Process 16 bytes -> 8 bytes
for (; i + 16 <= bytesRead; i += 16) {
uint8x16_t data = vld1q_u8(src + i);
uint8x8x2_t sep = vuzp_u8(vget_low_u8(data), vget_high_u8(data));
vst1_u8(dst, vorr_u8(vand_u8(sep.val[0], mask), vshr_n_u8(sep.val[1], 4)));
dst += 8;
}
// Scalar fallback
for (; i + 1 < bytesRead; i += 2) {
*dst++ = (src[i] & 0xF0) | (src[i + 1] >> 4);
}
totalRead += bytesRead;
@@ -1762,8 +1683,8 @@ namespace ult {
// Time implementation
CONSTEXPR_STRING std::string DEFAULT_DT_FORMAT = "'%a %T'";
std::string datetimeFormat = "%a %T";
CONSTEXPR_STRING std::string DEFAULT_DT_FORMAT = "%a %T";
std::string datetimeFormat = DEFAULT_DT_FORMAT;
// Widget settings
@@ -1798,9 +1719,114 @@ namespace ult {
bool cleanVersionLabels, hideOverlayVersions, hidePackageVersions, useLibultrahandTitles, useLibultrahandVersions, usePackageTitles, usePackageVersions;
// Helper function to convert MB to bytes
u64 mbToBytes(u32 mb) {
return static_cast<u64>(mb) * 0x100000;
}
// Helper function to convert bytes to MB
u32 bytesToMB(u64 bytes) {
return static_cast<u32>(bytes / 0x100000);
}
// Helper function to get version-appropriate default heap size
static OverlayHeapSize getDefaultHeapSize() {
if (hosversionAtLeast(21, 0, 0)) {
return OverlayHeapSize::Size_4MB; // HOS 21.0.0+
} else if (hosversionAtLeast(20, 0, 0)) {
return OverlayHeapSize::Size_6MB; // HOS 20.0.0+
} else {
return OverlayHeapSize::Size_8MB; // Older versions
}
}
// Implementation
OverlayHeapSize getCurrentHeapSize() {
// Fast path: return cached value if already loaded
if (heapSizeCache.initialized) {
return heapSizeCache.cachedSize;
}
// Slow path: read from file (only happens once)
FILE* f = fopen(ult::OVL_HEAP_CONFIG_PATH.c_str(), "rb");
if (!f) {
// No config file - use version-specific default
heapSizeCache.cachedSize = getDefaultHeapSize();
heapSizeCache.initialized = true;
return heapSizeCache.cachedSize;
}
u64 size;
if (fread(&size, sizeof(size), 1, f) == 1) {
constexpr u64 twoMB = 0x200000;
// Only accept multiples of 2MB, excluding 2MB itself
if (size != twoMB && size % twoMB == 0) {
heapSizeCache.cachedSize = static_cast<OverlayHeapSize>(size);
fclose(f);
heapSizeCache.initialized = true;
return heapSizeCache.cachedSize;
}
}
// Invalid or no data in config - use version-specific default
fclose(f);
heapSizeCache.cachedSize = getDefaultHeapSize();
heapSizeCache.initialized = true;
return heapSizeCache.cachedSize;
}
// Update the global default too
OverlayHeapSize currentHeapSize = getDefaultHeapSize();
bool setOverlayHeapSize(OverlayHeapSize heapSize) {
ult::createDirectory(ult::NX_OVLLOADER_PATH);
FILE* f = fopen(ult::OVL_HEAP_CONFIG_PATH.c_str(), "wb");
if (!f) return false;
const u64 size = static_cast<u64>(heapSize);
const bool success = (fwrite(&size, sizeof(size), 1, f) == 1);
fclose(f);
// Update cache on successful write
if (success) {
heapSizeCache.cachedSize = heapSize;
heapSizeCache.initialized = true;
}
return success;
}
// Implementation
bool requestOverlayExit() {
ult::createDirectory(ult::NX_OVLLOADER_PATH);
FILE* f = fopen(ult::OVL_EXIT_FLAG_PATH.c_str(), "wb");
if (!f) return false;
// Write a single byte (flag file just needs to exist)
u8 flag = 1;
bool success = (fwrite(&flag, 1, 1, f) == 1);
fclose(f);
deleteFileOrDirectory(NOTIFICATIONS_FLAG_FILEPATH);
return success;
}
const std::string loaderInfo = envGetLoaderInfo();
const std::string loaderTitle = extractTitle(loaderInfo);
const bool expandedMemory = (loaderTitle == "nx-ovlloader+");
std::string loaderTitle = extractTitle(loaderInfo);
bool expandedMemory = false;
bool furtherExpandedMemory = false;
bool limitedMemory = false;
std::string versionLabel;
@@ -1834,9 +1860,10 @@ namespace ult {
// Number of renderer threads to use
const unsigned numThreads = expandedMemory ? 4 : 0;
const unsigned numThreads = 4;//expandedMemory ? 4 : 0;
std::vector<std::thread> renderThreads(numThreads);
const s32 bmpChunkSize = (numThreads > 0) ? ((720 + numThreads - 1) / numThreads) : 0;
const s32 bmpChunkSize = ((720 + numThreads - 1) / numThreads);
std::atomic<s32> currentRow;
//std::atomic<unsigned int> barrierCounter{0};

21
Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp
View File

@@ -97,12 +97,33 @@ void AppProfileGui::addModuleListItem(SysClkProfile profile, SysClkModule module
this->listElement->addItem(listItem);
}
void AppProfileGui::addModuleListItemToggle(SysClkProfile profile, SysClkModule module)
{
const char* moduleName = sysclkFormatModule(module, true);
std::uint32_t currentValue = this->profileList->mhzMap[profile][module];
tsl::elm::ToggleListItem* toggle = new tsl::elm::ToggleListItem(moduleName, currentValue != 0);
toggle->setStateChangedListener([this, profile, module](bool state) {
this->profileList->mhzMap[profile][module] = state ? 1 : 0;
Result rc = sysclkIpcSetProfiles(this->applicationId, this->profileList);
if(R_FAILED(rc))
{
FatalGui::openWithResultCode("sysclkIpcSetProfiles", rc);
}
});
this->listElement->addItem(toggle);
}
void AppProfileGui::addProfileUI(SysClkProfile profile)
{
this->listElement->addItem(new tsl::elm::CategoryHeader(sysclkFormatProfile(profile, true) + std::string(" ") + ult::DIVIDER_SYMBOL + "  Reset"));
this->addModuleListItem(profile, SysClkModule_CPU);
this->addModuleListItem(profile, SysClkModule_GPU);
this->addModuleListItem(profile, SysClkModule_MEM);
this->addModuleListItemToggle(profile, HorizonOCModule_Governor);
}
void AppProfileGui::listUI()

1
Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h
View File

@@ -40,6 +40,7 @@ class AppProfileGui : public BaseMenuGui
void openFreqChoiceGui(tsl::elm::ListItem* listItem, SysClkProfile profile, SysClkModule module);
void addModuleListItem(SysClkProfile profile, SysClkModule module);
void addModuleListItemToggle(SysClkProfile profile, SysClkModule module);
void addProfileUI(SysClkProfile profile);
public:

1
Source/sys-clk/overlay/src/ui/gui/base_gui.cpp
View File

@@ -27,7 +27,6 @@
#include "base_gui.h"
#include "../elements/base_frame.h"
#include "logo_rgba_bin.h"
#include <tesla.hpp>
#include <math.h>

26
Source/sys-clk/overlay/src/ui/gui/global_override_gui.cpp
View File

@@ -96,16 +96,40 @@ void GlobalOverrideGui::addModuleListItem(SysClkModule module)
}
return false;
});
this->listElement->addItem(listItem);
this->listItems[module] = listItem;
}
void GlobalOverrideGui::addModuleToggleItem(SysClkModule module)
{
const char* moduleName = sysclkFormatModule(module, true);
bool isOn = this->listHz[module];
// Create a ToggleListItem
tsl::elm::ToggleListItem* toggle = new tsl::elm::ToggleListItem(moduleName, isOn);
toggle->setStateChangedListener([this, module, toggle](bool state) {
Result rc = sysclkIpcSetOverride(module, state ? 1 : 0);
if(R_FAILED(rc))
{
FatalGui::openWithResultCode("sysclkIpcSetProfiles", rc);
}
});
// Add to list and track
this->listElement->addItem(toggle);
this->listItems[module] = toggle;
}
void GlobalOverrideGui::listUI()
{
this->listElement->addItem(new tsl::elm::CategoryHeader("Temporary Overrides " + ult::DIVIDER_SYMBOL + "  Reset"));
this->addModuleListItem(SysClkModule_CPU);
this->addModuleListItem(SysClkModule_GPU);
this->addModuleListItem(SysClkModule_MEM);
this->addModuleToggleItem(HorizonOCModule_Governor);
}
void GlobalOverrideGui::refresh()
@@ -115,6 +139,8 @@ void GlobalOverrideGui::refresh()
{
for(std::uint16_t m = 0; m < SysClkModule_EnumMax; m++)
{
if(m > SysClkModule_MEM)
continue;
if(this->listItems[m] != nullptr && this->listHz[m] != this->context->overrideFreqs[m])
{
this->listItems[m]->setValue(formatListFreqHz(this->context->overrideFreqs[m]));

2
Source/sys-clk/overlay/src/ui/gui/global_override_gui.h
View File

@@ -39,7 +39,7 @@ class GlobalOverrideGui : public BaseMenuGui
void openFreqChoiceGui(SysClkModule module);
void addModuleListItem(SysClkModule module);
void addModuleToggleItem(SysClkModule module);
public:
GlobalOverrideGui();
~GlobalOverrideGui() {}

2
Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp
View File

@@ -399,8 +399,6 @@ void MiscGui::listUI()
chargerCurrents,
false
);
addConfigToggle(HocClkConfigValue_HandheldGovernor, nullptr);
}

BIN
Source/sys-clk/sys-clk.zip Normal file
View File

Binary file not shown.

48
Source/sys-clk/sysmodule/src/clock_manager.cpp
View File

@@ -37,7 +37,9 @@
#include "notification.h"
#define HOSPPC_HAS_BOOST (hosversionAtLeast(7,0,0))
bool isGovernorEnabled = false; // to avoid thread messes
bool lastGovernorState = false;
bool hasChanged = true;
ClockManager *ClockManager::instance = NULL;
Thread governorTHREAD;
@@ -276,7 +278,7 @@ void ClockManager::GovernorThread(void* arg)
std::scoped_lock lock{mgr->contextMutex};
if (!mgr->config->GetConfigValue(HocClkConfigValue_HandheldGovernor))
if (!isGovernorEnabled)
{
svcSleepThread(50'000'000);
continue;
@@ -388,7 +390,6 @@ void ClockManager::Tick()
}
}
if(((tmp451TempSoc() / 1000) > (int)this->config->GetConfigValue(HocClkConfigValue_ThermalThrottleThreshold)) && this->config->GetConfigValue(HocClkConfigValue_ThermalThrottle)) {
ResetToStockClocks();
return;
@@ -406,15 +407,9 @@ void ClockManager::Tick()
ResetToStockClocks();
return;
}
for (unsigned int module = 0; module < SysClkModule_EnumMax; module++)
{
if(this->config->GetConfigValue(HocClkConfigValue_HandheldGovernor)) {
noGPU = true;
} else {
noGPU = false;
}
if(noGPU && module == SysClkModule_GPU)
continue;
targetHz = this->context->overrideFreqs[module];
if (!targetHz)
{
@@ -423,26 +418,51 @@ void ClockManager::Tick()
targetHz = this->config->GetAutoClockHz(GLOBAL_PROFILE_ID, (SysClkModule)module, this->context->profile);
}
if(module == HorizonOCModule_Governor) {
bool newGovernorState = targetHz;
if(newGovernorState != lastGovernorState) {
FileUtils::LogLine("[mgr] Governor state changed: %s", newGovernorState ? "enabled" : "disabled");
lastGovernorState = newGovernorState;
// Force a "context refresh" like on app/profile change
hasChanged = true;
this->context->enabled = this->GetConfig()->Enabled();
Board::ResetToStock(); // optional: reset clocks before re-applying
}
isGovernorEnabled = newGovernorState;
}
// Skip GPU if governor handles it
if(module > SysClkModule_MEM) {
continue;
}
if(isGovernorEnabled) {
noGPU = true;
} else {
noGPU = false;
}
if(noGPU && module == SysClkModule_GPU)
continue;
if (targetHz)
{
maxHz = this->GetMaxAllowedHz((SysClkModule)module, this->context->profile);
nearestHz = this->GetNearestHz((SysClkModule)module, targetHz, maxHz);
if (nearestHz != this->context->freqs[module] && this->context->enabled) {
FileUtils::LogLine(
"[mgr] %s clock set : %u.%u MHz (target = %u.%u MHz)",
Board::GetModuleName((SysClkModule)module, true),
nearestHz / 1000000, nearestHz / 100000 - nearestHz / 1000000 * 10,
targetHz / 1000000, targetHz / 100000 - targetHz / 1000000 * 10);
targetHz / 1000000, targetHz / 100000 - targetHz / 1000000 * 10
);
Board::SetHz((SysClkModule)module, nearestHz);
this->context->freqs[module] = nearestHz;
}
}
}
}
}
void ClockManager::ResetToStockClocks() {

BIN
dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp vendored
View File

Binary file not shown.