Merge branch 'ribbitvulkanadditions' of https://git.eden-emu.dev/Ribbit/ribbitvulkanadditions into ribbitvulkanadditions
Some checks failed
eden-license / license-header (pull_request) Failing after 19s
Some checks failed
eden-license / license-header (pull_request) Failing after 19s
This commit is contained in:
Ribbit
commit
77584eb628
21 changed files with 292 additions and 521 deletions
|
|
@ -166,7 +166,7 @@ ENUM(ResolutionSetup,
|
|||
Res7X,
|
||||
Res8X);
|
||||
|
||||
ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, ScaleForce, Fsr, Area, MaxEnum);
|
||||
ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Spline1, Gaussian, Lanczos, ScaleForce, Fsr, Area, MaxEnum);
|
||||
|
||||
ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
|
||||
|
||||
|
|
|
|||
|
|
@ -45,13 +45,6 @@ constexpr u64 CURRENT_CRYPTO_REVISION = 0x5;
|
|||
|
||||
using Common::AsArray;
|
||||
|
||||
// clang-format off
|
||||
constexpr std::array eticket_source_hashes{
|
||||
AsArray("B71DB271DC338DF380AA2C4335EF8873B1AFD408E80B3582D8719FC81C5E511C"), // eticket_rsa_kek_source
|
||||
AsArray("E8965A187D30E57869F562D04383C996DE487BBA5761363D2D4D32391866A85C"), // eticket_rsa_kekek_source
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
constexpr std::array<std::pair<std::string_view, KeyIndex<S128KeyType>>, 30> s128_file_id{{
|
||||
{"eticket_rsa_kek", {S128KeyType::ETicketRSAKek, 0, 0}},
|
||||
{"eticket_rsa_kek_source",
|
||||
|
|
@ -1117,81 +1110,25 @@ void KeyManager::DeriveBase() {
|
|||
|
||||
void KeyManager::DeriveETicket(PartitionDataManager& data,
|
||||
const FileSys::ContentProvider& provider) {
|
||||
// ETicket keys
|
||||
const auto es = provider.GetEntry(0x0100000000000033, FileSys::ContentRecordType::Program);
|
||||
|
||||
if (es == nullptr) {
|
||||
// The emulator no longer derives the ETicket RSA Kek.
|
||||
// It is now required for the user to provide this key in their keys file.
|
||||
if (!HasKey(S128KeyType::ETicketRSAKek)) {
|
||||
LOG_WARNING(Crypto, "ETicket RSA Kek not found, skipping eTicket parsing.");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto exefs = es->GetExeFS();
|
||||
if (exefs == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
const auto main = exefs->GetFile("main");
|
||||
if (main == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
const auto bytes = main->ReadAllBytes();
|
||||
|
||||
const auto eticket_kek = FindKeyFromHex16(bytes, eticket_source_hashes[0]);
|
||||
const auto eticket_kekek = FindKeyFromHex16(bytes, eticket_source_hashes[1]);
|
||||
|
||||
const auto seed3 = data.GetRSAKekSeed3();
|
||||
const auto mask0 = data.GetRSAKekMask0();
|
||||
|
||||
if (eticket_kek != Key128{}) {
|
||||
SetKey(S128KeyType::Source, eticket_kek, static_cast<size_t>(SourceKeyType::ETicketKek));
|
||||
}
|
||||
if (eticket_kekek != Key128{}) {
|
||||
SetKey(S128KeyType::Source, eticket_kekek,
|
||||
static_cast<size_t>(SourceKeyType::ETicketKekek));
|
||||
}
|
||||
if (seed3 != Key128{}) {
|
||||
SetKey(S128KeyType::RSAKek, seed3, static_cast<size_t>(RSAKekType::Seed3));
|
||||
}
|
||||
if (mask0 != Key128{}) {
|
||||
SetKey(S128KeyType::RSAKek, mask0, static_cast<size_t>(RSAKekType::Mask0));
|
||||
}
|
||||
if (eticket_kek == Key128{} || eticket_kekek == Key128{} || seed3 == Key128{} ||
|
||||
mask0 == Key128{}) {
|
||||
return;
|
||||
}
|
||||
|
||||
const Key128 rsa_oaep_kek = seed3 ^ mask0;
|
||||
if (rsa_oaep_kek == Key128{}) {
|
||||
return;
|
||||
}
|
||||
|
||||
SetKey(S128KeyType::Source, rsa_oaep_kek,
|
||||
static_cast<u64>(SourceKeyType::RSAOaepKekGeneration));
|
||||
|
||||
Key128 temp_kek{};
|
||||
Key128 temp_kekek{};
|
||||
Key128 eticket_final{};
|
||||
|
||||
// Derive ETicket RSA Kek
|
||||
AESCipher<Key128> es_master(GetKey(S128KeyType::Master), Mode::ECB);
|
||||
es_master.Transcode(rsa_oaep_kek.data(), rsa_oaep_kek.size(), temp_kek.data(), Op::Decrypt);
|
||||
AESCipher<Key128> es_kekek(temp_kek, Mode::ECB);
|
||||
es_kekek.Transcode(eticket_kekek.data(), eticket_kekek.size(), temp_kekek.data(), Op::Decrypt);
|
||||
AESCipher<Key128> es_kek(temp_kekek, Mode::ECB);
|
||||
es_kek.Transcode(eticket_kek.data(), eticket_kek.size(), eticket_final.data(), Op::Decrypt);
|
||||
|
||||
if (eticket_final == Key128{}) {
|
||||
return;
|
||||
}
|
||||
|
||||
SetKey(S128KeyType::ETicketRSAKek, eticket_final);
|
||||
|
||||
// Titlekeys
|
||||
// Decrypt PRODINFO to get the extended kek needed for the RSA keypair.
|
||||
data.DecryptProdInfo(GetBISKey(0));
|
||||
|
||||
// The extended kek is read from the decrypted PRODINFO.
|
||||
eticket_extended_kek = data.GetETicketExtendedKek();
|
||||
WriteKeyToFile(KeyCategory::Console, "eticket_extended_kek", eticket_extended_kek);
|
||||
|
||||
// Derive the final RSA keypair using the user-provided ETicketRSAKek
|
||||
// and the extended kek from PRODINFO.
|
||||
DeriveETicketRSAKey();
|
||||
|
||||
// Load personalized tickets from the NAND.
|
||||
PopulateTickets();
|
||||
}
|
||||
|
||||
|
|
@ -1272,22 +1209,6 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) {
|
|||
encrypted_keyblobs[i]);
|
||||
}
|
||||
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetPackage2KeySource(),
|
||||
static_cast<u64>(SourceKeyType::Package2));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetAESKekGenerationSource(),
|
||||
static_cast<u64>(SourceKeyType::AESKekGeneration));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetTitlekekSource(),
|
||||
static_cast<u64>(SourceKeyType::Titlekek));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetMasterKeySource(),
|
||||
static_cast<u64>(SourceKeyType::Master));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetKeyblobMACKeySource(),
|
||||
static_cast<u64>(SourceKeyType::KeyblobMAC));
|
||||
|
||||
for (size_t i = 0; i < PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH; ++i) {
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetKeyblobKeySource(i),
|
||||
static_cast<u64>(SourceKeyType::Keyblob), i);
|
||||
}
|
||||
|
||||
if (data.HasFuses()) {
|
||||
SetKeyWrapped(S128KeyType::SecureBoot, data.GetSecureBootKey());
|
||||
}
|
||||
|
|
@ -1302,13 +1223,6 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) {
|
|||
}
|
||||
}
|
||||
|
||||
const auto masters = data.GetTZMasterKeys(latest_master);
|
||||
for (size_t i = 0; i < masters.size(); ++i) {
|
||||
if (masters[i] != Key128{} && !HasKey(S128KeyType::Master, i)) {
|
||||
SetKey(S128KeyType::Master, masters[i], i);
|
||||
}
|
||||
}
|
||||
|
||||
DeriveBase();
|
||||
|
||||
if (!data.HasPackage2())
|
||||
|
|
@ -1322,27 +1236,6 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) {
|
|||
}
|
||||
data.DecryptPackage2(package2_keys, Package2Type::NormalMain);
|
||||
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeyApplicationSource(),
|
||||
static_cast<u64>(SourceKeyType::KeyAreaKey),
|
||||
static_cast<u64>(KeyAreaKeyType::Application));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeyOceanSource(),
|
||||
static_cast<u64>(SourceKeyType::KeyAreaKey),
|
||||
static_cast<u64>(KeyAreaKeyType::Ocean));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeySystemSource(),
|
||||
static_cast<u64>(SourceKeyType::KeyAreaKey),
|
||||
static_cast<u64>(KeyAreaKeyType::System));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetSDKekSource(),
|
||||
static_cast<u64>(SourceKeyType::SDKek));
|
||||
SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDSaveKeySource(),
|
||||
static_cast<u64>(SDKeyType::Save));
|
||||
SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDNCAKeySource(),
|
||||
static_cast<u64>(SDKeyType::NCA));
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetHeaderKekSource(),
|
||||
static_cast<u64>(SourceKeyType::HeaderKek));
|
||||
SetKeyWrapped(S256KeyType::HeaderSource, data.GetHeaderKeySource());
|
||||
SetKeyWrapped(S128KeyType::Source, data.GetAESKeyGenerationSource(),
|
||||
static_cast<u64>(SourceKeyType::AESKeyGeneration));
|
||||
|
||||
DeriveBase();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,11 +4,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
// NOTE TO FUTURE MAINTAINERS:
|
||||
// When a new version of switch cryptography is released,
|
||||
// hash the new keyblob source and master key and add the hashes to
|
||||
// the arrays below.
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cctype>
|
||||
|
|
@ -49,178 +44,7 @@ struct Package2Header {
|
|||
};
|
||||
static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect size.");
|
||||
|
||||
// clang-format off
|
||||
constexpr std::array source_hashes{
|
||||
AsArray("B24BD293259DBC7AC5D63F88E60C59792498E6FC5443402C7FFE87EE8B61A3F0"), // keyblob_mac_key_source
|
||||
AsArray("7944862A3A5C31C6720595EFD302245ABD1B54CCDCF33000557681E65C5664A4"), // master_key_source
|
||||
AsArray("21E2DF100FC9E094DB51B47B9B1D6E94ED379DB8B547955BEF8FE08D8DD35603"), // package2_key_source
|
||||
AsArray("FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"), // aes_kek_generation_source
|
||||
AsArray("FBD10056999EDC7ACDB96098E47E2C3606230270D23281E671F0F389FC5BC585"), // aes_key_generation_source
|
||||
AsArray("C48B619827986C7F4E3081D59DB2B460C84312650E9A8E6B458E53E8CBCA4E87"), // titlekek_source
|
||||
AsArray("04AD66143C726B2A139FB6B21128B46F56C553B2B3887110304298D8D0092D9E"), // key_area_key_application_source
|
||||
AsArray("FD434000C8FF2B26F8E9A9D2D2C12F6BE5773CBB9DC86300E1BD99F8EA33A417"), // key_area_key_ocean_source
|
||||
AsArray("1F17B1FD51AD1C2379B58F152CA4912EC2106441E51722F38700D5937A1162F7"), // key_area_key_system_source
|
||||
AsArray("6B2ED877C2C52334AC51E59ABFA7EC457F4A7D01E46291E9F2EAA45F011D24B7"), // sd_card_kek_source
|
||||
AsArray("D482743563D3EA5DCDC3B74E97C9AC8A342164FA041A1DC80F17F6D31E4BC01C"), // sd_card_save_key_source
|
||||
AsArray("2E751CECF7D93A2B957BD5FFCB082FD038CC2853219DD3092C6DAB9838F5A7CC"), // sd_card_nca_key_source
|
||||
AsArray("1888CAED5551B3EDE01499E87CE0D86827F80820EFB275921055AA4E2ABDFFC2"), // header_kek_source
|
||||
AsArray("8F783E46852DF6BE0BA4E19273C4ADBAEE16380043E1B8C418C4089A8BD64AA6"), // header_key_source
|
||||
AsArray("D1757E52F1AE55FA882EC690BC6F954AC46A83DC22F277F8806BD55577C6EED7"), // rsa_kek_seed3
|
||||
AsArray("FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"), // rsa_kek_mask0
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
// clang-format off
|
||||
constexpr std::array keyblob_source_hashes{
|
||||
AsArray("8A06FE274AC491436791FDB388BCDD3AB9943BD4DEF8094418CDAC150FD73786"), // keyblob_key_source_00
|
||||
AsArray("2D5CAEB2521FEF70B47E17D6D0F11F8CE2C1E442A979AD8035832C4E9FBCCC4B"), // keyblob_key_source_01
|
||||
AsArray("61C5005E713BAE780641683AF43E5F5C0E03671117F702F401282847D2FC6064"), // keyblob_key_source_02
|
||||
AsArray("8E9795928E1C4428E1B78F0BE724D7294D6934689C11B190943923B9D5B85903"), // keyblob_key_source_03
|
||||
AsArray("95FA33AF95AFF9D9B61D164655B32710ED8D615D46C7D6CC3CC70481B686B402"), // keyblob_key_source_04
|
||||
AsArray("3F5BE7B3C8B1ABD8C10B4B703D44766BA08730562C172A4FE0D6B866B3E2DB3E"), // keyblob_key_source_05
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_06
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_07
|
||||
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_08
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_09
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0A
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0B
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0C
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0D
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0E
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0F
|
||||
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_10
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_11
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_12
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_13
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_14
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_15
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_16
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_17
|
||||
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_18
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_19
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1A
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1B
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1C
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1D
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1E
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1F
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
// clang-format off
|
||||
constexpr std::array master_key_hashes{
|
||||
AsArray("0EE359BE3C864BB0782E1D70A718A0342C551EED28C369754F9C4F691BECF7CA"), // master_key_00
|
||||
AsArray("4FE707B7E4ABDAF727C894AAF13B1351BFE2AC90D875F73B2E20FA94B9CC661E"), // master_key_01
|
||||
AsArray("79277C0237A2252EC3DFAC1F7C359C2B3D121E9DB15BB9AB4C2B4408D2F3AE09"), // master_key_02
|
||||
AsArray("4F36C565D13325F65EE134073C6A578FFCB0008E02D69400836844EAB7432754"), // master_key_03
|
||||
AsArray("75FF1D95D26113550EE6FCC20ACB58E97EDEB3A2FF52543ED5AEC63BDCC3DA50"), // master_key_04
|
||||
AsArray("EBE2BCD6704673EC0F88A187BB2AD9F1CC82B718C389425941BDC194DC46B0DD"), // master_key_05
|
||||
AsArray("9497E6779F5D840F2BBA1DE4E95BA1D6F21EFC94717D5AE5CA37D7EC5BD37A19"), // master_key_06
|
||||
AsArray("4EC96B8CB01B8DCE382149443430B2B6EBCB2983348AFA04A25E53609DABEDF6"), // master_key_07
|
||||
|
||||
AsArray("2998E2E23609BC2675FF062A2D64AF5B1B78DFF463B24119D64A1B64F01B2D51"), // master_key_08
|
||||
AsArray("9D486A98067C44B37CF173D3BF577891EB6081FF6B4A166347D9DBBF7025076B"), // master_key_09
|
||||
AsArray("4EC5A237A75A083A9C5F6CF615601522A7F822D06BD4BA32612C9CEBBB29BD45"), // master_key_0A
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0B
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0C
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0D
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0E
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0F
|
||||
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_10
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_11
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_12
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_13
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_14
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_15
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_16
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_17
|
||||
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_18
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_19
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1A
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1B
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1C
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1D
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1E
|
||||
AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1F
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
static constexpr u8 CalculateMaxKeyblobSourceHash() {
|
||||
const auto is_zero = [](const auto& data) {
|
||||
// TODO: Replace with std::all_of whenever mingw decides to update their
|
||||
// libraries to include the constexpr variant of it.
|
||||
for (const auto element : data) {
|
||||
if (element != 0) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
||||
for (s8 i = 0x1F; i >= 0; --i) {
|
||||
if (!is_zero(keyblob_source_hashes[i])) {
|
||||
return static_cast<u8>(i + 1);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = CalculateMaxKeyblobSourceHash();
|
||||
|
||||
template <size_t key_size = 0x10>
|
||||
std::array<u8, key_size> FindKeyFromHex(const std::vector<u8>& binary,
|
||||
const std::array<u8, 0x20>& hash) {
|
||||
if (binary.size() < key_size)
|
||||
return {};
|
||||
|
||||
std::array<u8, 0x20> temp{};
|
||||
for (size_t i = 0; i < binary.size() - key_size; ++i) {
|
||||
mbedtls_sha256(binary.data() + i, key_size, temp.data(), 0);
|
||||
|
||||
if (temp != hash)
|
||||
continue;
|
||||
|
||||
std::array<u8, key_size> out{};
|
||||
std::memcpy(out.data(), binary.data() + i, key_size);
|
||||
return out;
|
||||
}
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
std::array<u8, 16> FindKeyFromHex16(const std::vector<u8>& binary, std::array<u8, 32> hash) {
|
||||
return FindKeyFromHex<0x10>(binary, hash);
|
||||
}
|
||||
|
||||
static std::array<Key128, 0x20> FindEncryptedMasterKeyFromHex(const std::vector<u8>& binary,
|
||||
const Key128& key) {
|
||||
if (binary.size() < 0x10)
|
||||
return {};
|
||||
|
||||
SHA256Hash temp{};
|
||||
Key128 dec_temp{};
|
||||
std::array<Key128, 0x20> out{};
|
||||
AESCipher<Key128> cipher(key, Mode::ECB);
|
||||
for (size_t i = 0; i < binary.size() - 0x10; ++i) {
|
||||
cipher.Transcode(binary.data() + i, dec_temp.size(), dec_temp.data(), Op::Decrypt);
|
||||
mbedtls_sha256(dec_temp.data(), dec_temp.size(), temp.data(), 0);
|
||||
|
||||
for (size_t k = 0; k < out.size(); ++k) {
|
||||
if (temp == master_key_hashes[k]) {
|
||||
out[k] = dec_temp;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = 32;
|
||||
|
||||
static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir,
|
||||
const std::string& name) {
|
||||
|
|
@ -287,52 +111,10 @@ std::vector<u8> PartitionDataManager::GetSecureMonitor() const {
|
|||
return secure_monitor_bytes;
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetPackage2KeySource() const {
|
||||
return FindKeyFromHex(secure_monitor_bytes, source_hashes[2]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetAESKekGenerationSource() const {
|
||||
return FindKeyFromHex(secure_monitor_bytes, source_hashes[3]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetTitlekekSource() const {
|
||||
return FindKeyFromHex(secure_monitor_bytes, source_hashes[5]);
|
||||
}
|
||||
|
||||
std::array<std::array<u8, 16>, 32> PartitionDataManager::GetTZMasterKeys(
|
||||
std::array<u8, 0x10> master_key) const {
|
||||
return FindEncryptedMasterKeyFromHex(secure_monitor_bytes, master_key);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetRSAKekSeed3() const {
|
||||
return FindKeyFromHex(secure_monitor_bytes, source_hashes[14]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetRSAKekMask0() const {
|
||||
return FindKeyFromHex(secure_monitor_bytes, source_hashes[15]);
|
||||
}
|
||||
|
||||
std::vector<u8> PartitionDataManager::GetPackage1Decrypted() const {
|
||||
return package1_decrypted_bytes;
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetMasterKeySource() const {
|
||||
return FindKeyFromHex(package1_decrypted_bytes, source_hashes[1]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetKeyblobMACKeySource() const {
|
||||
return FindKeyFromHex(package1_decrypted_bytes, source_hashes[0]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetKeyblobKeySource(std::size_t revision) const {
|
||||
if (keyblob_source_hashes[revision] == SHA256Hash{}) {
|
||||
LOG_WARNING(Crypto,
|
||||
"No keyblob source hash for crypto revision {:02X}! Cannot derive keys...",
|
||||
revision);
|
||||
}
|
||||
return FindKeyFromHex(package1_decrypted_bytes, keyblob_source_hashes[revision]);
|
||||
}
|
||||
|
||||
bool PartitionDataManager::HasFuses() const {
|
||||
return fuses != nullptr;
|
||||
}
|
||||
|
|
@ -444,46 +226,10 @@ const std::vector<u8>& PartitionDataManager::GetPackage2FSDecompressed(Package2T
|
|||
return package2_fs.at(static_cast<size_t>(type));
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetKeyAreaKeyApplicationSource(Package2Type type) const {
|
||||
return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[6]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetKeyAreaKeyOceanSource(Package2Type type) const {
|
||||
return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[7]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetKeyAreaKeySystemSource(Package2Type type) const {
|
||||
return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[8]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetSDKekSource(Package2Type type) const {
|
||||
return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[9]);
|
||||
}
|
||||
|
||||
std::array<u8, 32> PartitionDataManager::GetSDSaveKeySource(Package2Type type) const {
|
||||
return FindKeyFromHex<0x20>(package2_fs.at(static_cast<size_t>(type)), source_hashes[10]);
|
||||
}
|
||||
|
||||
std::array<u8, 32> PartitionDataManager::GetSDNCAKeySource(Package2Type type) const {
|
||||
return FindKeyFromHex<0x20>(package2_fs.at(static_cast<size_t>(type)), source_hashes[11]);
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetHeaderKekSource(Package2Type type) const {
|
||||
return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[12]);
|
||||
}
|
||||
|
||||
std::array<u8, 32> PartitionDataManager::GetHeaderKeySource(Package2Type type) const {
|
||||
return FindKeyFromHex<0x20>(package2_fs.at(static_cast<size_t>(type)), source_hashes[13]);
|
||||
}
|
||||
|
||||
const std::vector<u8>& PartitionDataManager::GetPackage2SPLDecompressed(Package2Type type) const {
|
||||
return package2_spl.at(static_cast<size_t>(type));
|
||||
}
|
||||
|
||||
std::array<u8, 16> PartitionDataManager::GetAESKeyGenerationSource(Package2Type type) const {
|
||||
return FindKeyFromHex(package2_spl.at(static_cast<size_t>(type)), source_hashes[4]);
|
||||
}
|
||||
|
||||
bool PartitionDataManager::HasProdInfo() const {
|
||||
return prodinfo != nullptr;
|
||||
}
|
||||
|
|
@ -509,4 +255,4 @@ std::array<u8, 576> PartitionDataManager::GetETicketExtendedKek() const {
|
|||
prodinfo_decrypted->Read(out.data(), out.size(), 0x3890);
|
||||
return out;
|
||||
}
|
||||
} // namespace Core::Crypto
|
||||
} // namespace Core::Crypto
|
||||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -36,16 +39,7 @@ public:
|
|||
EncryptedKeyBlob GetEncryptedKeyblob(std::size_t index) const;
|
||||
EncryptedKeyBlobs GetEncryptedKeyblobs() const;
|
||||
std::vector<u8> GetSecureMonitor() const;
|
||||
std::array<u8, 0x10> GetPackage2KeySource() const;
|
||||
std::array<u8, 0x10> GetAESKekGenerationSource() const;
|
||||
std::array<u8, 0x10> GetTitlekekSource() const;
|
||||
std::array<std::array<u8, 0x10>, 0x20> GetTZMasterKeys(std::array<u8, 0x10> master_key) const;
|
||||
std::array<u8, 0x10> GetRSAKekSeed3() const;
|
||||
std::array<u8, 0x10> GetRSAKekMask0() const;
|
||||
std::vector<u8> GetPackage1Decrypted() const;
|
||||
std::array<u8, 0x10> GetMasterKeySource() const;
|
||||
std::array<u8, 0x10> GetKeyblobMACKeySource() const;
|
||||
std::array<u8, 0x10> GetKeyblobKeySource(std::size_t revision) const;
|
||||
|
||||
// Fuses
|
||||
bool HasFuses() const;
|
||||
|
|
@ -63,21 +57,8 @@ public:
|
|||
Package2Type type);
|
||||
const std::vector<u8>& GetPackage2FSDecompressed(
|
||||
Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x10> GetKeyAreaKeyApplicationSource(
|
||||
Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x10> GetKeyAreaKeyOceanSource(
|
||||
Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x10> GetKeyAreaKeySystemSource(
|
||||
Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x10> GetSDKekSource(Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x20> GetSDSaveKeySource(Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x20> GetSDNCAKeySource(Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x10> GetHeaderKekSource(Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x20> GetHeaderKeySource(Package2Type type = Package2Type::NormalMain) const;
|
||||
const std::vector<u8>& GetPackage2SPLDecompressed(
|
||||
Package2Type type = Package2Type::NormalMain) const;
|
||||
std::array<u8, 0x10> GetAESKeyGenerationSource(
|
||||
Package2Type type = Package2Type::NormalMain) const;
|
||||
|
||||
// PRODINFO
|
||||
bool HasProdInfo() const;
|
||||
|
|
@ -104,6 +85,4 @@ private:
|
|||
std::array<std::vector<u8>, 6> package2_spl;
|
||||
};
|
||||
|
||||
std::array<u8, 0x10> FindKeyFromHex16(const std::vector<u8>& binary, std::array<u8, 0x20> hash);
|
||||
|
||||
} // namespace Core::Crypto
|
||||
} // namespace Core::Crypto
|
||||
|
|
@ -381,7 +381,7 @@ public:
|
|||
|
||||
private:
|
||||
void Submit(HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_NIFM, "(STUBBED) called");
|
||||
LOG_DEBUG(Service_NIFM, "(STUBBED) called");
|
||||
|
||||
if (state == RequestState::NotSubmitted) {
|
||||
UpdateState(RequestState::OnHold);
|
||||
|
|
@ -392,7 +392,7 @@ private:
|
|||
}
|
||||
|
||||
void GetRequestState(HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_NIFM, "(STUBBED) called");
|
||||
LOG_DEBUG(Service_NIFM, "(STUBBED) called");
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 3};
|
||||
rb.Push(ResultSuccess);
|
||||
|
|
@ -424,7 +424,7 @@ private:
|
|||
}
|
||||
|
||||
void GetResult(HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_NIFM, "(STUBBED) called");
|
||||
LOG_DEBUG(Service_NIFM, "(STUBBED) called");
|
||||
|
||||
const auto result = [this] {
|
||||
const auto has_connection = Network::GetHostIPv4Address().has_value() &&
|
||||
|
|
@ -486,7 +486,7 @@ private:
|
|||
}
|
||||
|
||||
void UpdateState(RequestState new_state) {
|
||||
LOG_WARNING(Service_NIFM, "(STUBBED) called");
|
||||
LOG_DEBUG(Service_NIFM, "(STUBBED) called");
|
||||
state = new_state;
|
||||
event1->Signal();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -572,7 +572,9 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent)
|
|||
PAIR(ScalingFilter, NearestNeighbor, tr("Nearest Neighbor")),
|
||||
PAIR(ScalingFilter, Bilinear, tr("Bilinear")),
|
||||
PAIR(ScalingFilter, Bicubic, tr("Bicubic")),
|
||||
PAIR(ScalingFilter, Spline1, tr("Spline-1")),
|
||||
PAIR(ScalingFilter, Gaussian, tr("Gaussian")),
|
||||
PAIR(ScalingFilter, Lanczos, tr("Lanczos")),
|
||||
PAIR(ScalingFilter, ScaleForce, tr("ScaleForce")),
|
||||
PAIR(ScalingFilter, Fsr, tr("AMD FidelityFX™️ Super Resolution")),
|
||||
PAIR(ScalingFilter, Area, tr("Area")),
|
||||
|
|
|
|||
|
|
@ -38,8 +38,12 @@ static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map
|
|||
{Settings::ScalingFilter::Bilinear,
|
||||
QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bilinear"))},
|
||||
{Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bicubic"))},
|
||||
{Settings::ScalingFilter::Spline1,
|
||||
QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Spline-1"))},
|
||||
{Settings::ScalingFilter::Gaussian,
|
||||
QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Gaussian"))},
|
||||
{Settings::ScalingFilter::Lanczos,
|
||||
QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Lanczos"))},
|
||||
{Settings::ScalingFilter::ScaleForce,
|
||||
QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "ScaleForce"))},
|
||||
{Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FSR"))},
|
||||
|
|
|
|||
|
|
@ -271,40 +271,4 @@ void TranslatorVisitor::ResetOFlag() {
|
|||
SetOFlag(ir.Imm1(false));
|
||||
}
|
||||
|
||||
IR::U32 TranslatorVisitor::apply_ISBERD_shift(IR::U32 result, Isberd::Shift shift_value) {
|
||||
if (shift_value != Isberd::Shift::Default) {
|
||||
return ir.ShiftLeftLogical(result, ir.Imm32(1));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
IR::U32 TranslatorVisitor::apply_ISBERD_size_read(IR::U32 address, Isberd::SZ sz) {
|
||||
switch (sz) {
|
||||
case Isberd::SZ::U8:
|
||||
return ir.LoadGlobalU8(ir.UConvert(64, address));
|
||||
case Isberd::SZ::U16:
|
||||
return ir.LoadGlobalU16(ir.UConvert(64, address));
|
||||
case Isberd::SZ::U32:
|
||||
case Isberd::SZ::F32:
|
||||
return ir.LoadGlobal32(ir.UConvert(64, address));
|
||||
default:
|
||||
UNREACHABLE();
|
||||
}
|
||||
}
|
||||
|
||||
IR::U32 TranslatorVisitor::compute_ISBERD_address(IR::Reg src_reg, u32 src_reg_num, u32 imm, u64 skew_value) {
|
||||
IR::U32 address{};
|
||||
if (src_reg_num == 0xFF) {
|
||||
address = ir.Imm32(imm);
|
||||
} else {
|
||||
auto offset = ir.Imm32(imm);
|
||||
address = ir.IAdd(X(src_reg), offset);
|
||||
if (skew_value != 0) {
|
||||
address = ir.IAdd(address, ir.LaneId());
|
||||
}
|
||||
}
|
||||
|
||||
return address;
|
||||
};
|
||||
|
||||
} // namespace Shader::Maxwell
|
||||
|
|
|
|||
|
|
@ -56,30 +56,6 @@ enum class FPCompareOp : u64 {
|
|||
T,
|
||||
};
|
||||
|
||||
namespace Isberd {
|
||||
enum class Mode : u64 {
|
||||
Default,
|
||||
Patch,
|
||||
Prim,
|
||||
Attr,
|
||||
};
|
||||
|
||||
enum class Shift : u64 {
|
||||
Default,
|
||||
U16,
|
||||
B32,
|
||||
};
|
||||
|
||||
enum class SZ : u64 {
|
||||
U8,
|
||||
U16,
|
||||
U32,
|
||||
F32,
|
||||
};
|
||||
|
||||
} // namespace Isberd
|
||||
|
||||
|
||||
class TranslatorVisitor {
|
||||
public:
|
||||
explicit TranslatorVisitor(Environment& env_, IR::Block& block) : env{env_}, ir(block) {}
|
||||
|
|
@ -408,12 +384,6 @@ public:
|
|||
void ResetSFlag();
|
||||
void ResetCFlag();
|
||||
void ResetOFlag();
|
||||
|
||||
private:
|
||||
// Helper functions for various translator visitors
|
||||
IR::U32 apply_ISBERD_shift(IR::U32 result, Isberd::Shift shift_value);
|
||||
IR::U32 apply_ISBERD_size_read(IR::U32 address, Isberd::SZ sz_value);
|
||||
IR::U32 compute_ISBERD_address(IR::Reg src_reg, u32 src_reg_num, u32 imm, u64 skew_value);
|
||||
};
|
||||
|
||||
} // namespace Shader::Maxwell
|
||||
|
|
|
|||
|
|
@ -9,9 +9,52 @@
|
|||
#include "shader_recompiler/frontend/maxwell/translate/impl/impl.h"
|
||||
|
||||
namespace Shader::Maxwell {
|
||||
namespace {
|
||||
enum class Mode : u64 {
|
||||
Default,
|
||||
Patch,
|
||||
Prim,
|
||||
Attr,
|
||||
};
|
||||
|
||||
enum class SZ : u64 {
|
||||
U8,
|
||||
U16,
|
||||
U32,
|
||||
F32
|
||||
};
|
||||
|
||||
enum class Shift : u64 {
|
||||
Default,
|
||||
U16,
|
||||
B32,
|
||||
};
|
||||
|
||||
IR::U32 scaleIndex(IR::IREmitter& ir, IR::U32 index, Shift shift) {
|
||||
switch (shift) {
|
||||
case Shift::Default: return index;
|
||||
case Shift::U16: return ir.ShiftLeftLogical(index, ir.Imm32(1));
|
||||
case Shift::B32: return ir.ShiftLeftLogical(index, ir.Imm32(2));
|
||||
default: UNREACHABLE();
|
||||
}
|
||||
}
|
||||
|
||||
IR::U32 skewBytes(IR::IREmitter& ir, SZ sizeRead) {
|
||||
const IR::U32 lane = ir.LaneId();
|
||||
switch (sizeRead) {
|
||||
case SZ::U8: return lane;
|
||||
case SZ::U16: return ir.ShiftLeftLogical(lane, ir.Imm32(1));
|
||||
case SZ::U32:
|
||||
case SZ::F32: return ir.ShiftLeftLogical(lane, ir.Imm32(2));
|
||||
default: UNREACHABLE();
|
||||
}
|
||||
}
|
||||
|
||||
} // Anonymous namespace
|
||||
|
||||
// Valid only for GS, TI, VS and trap
|
||||
void TranslatorVisitor::ISBERD(u64 insn) {
|
||||
LOG_DEBUG(Shader, "called with insn={:#X}", insn);
|
||||
|
||||
union {
|
||||
u64 raw;
|
||||
BitField<0, 8, IR::Reg> dest_reg;
|
||||
|
|
@ -20,49 +63,66 @@ void TranslatorVisitor::ISBERD(u64 insn) {
|
|||
BitField<24, 8, u32> imm;
|
||||
BitField<31, 1, u64> skew;
|
||||
BitField<32, 1, u64> o;
|
||||
BitField<33, 2, Isberd::Mode> mode;
|
||||
BitField<36, 4, Isberd::SZ> sz;
|
||||
BitField<47, 2, Isberd::Shift> shift;
|
||||
BitField<33, 2, Mode> mode;
|
||||
BitField<36, 4, SZ> sz;
|
||||
BitField<47, 2, Shift> shift;
|
||||
} const isberd{insn};
|
||||
|
||||
auto address = compute_ISBERD_address(isberd.src_reg, isberd.src_reg_num, isberd.imm, isberd.skew);
|
||||
if (isberd.o != 0) {
|
||||
auto result = apply_ISBERD_size_read(address, isberd.sz.Value());
|
||||
X(isberd.dest_reg, apply_ISBERD_shift(result, isberd.shift.Value()));
|
||||
|
||||
return;
|
||||
IR::U32 index{};
|
||||
if (isberd.src_reg_num.Value() == 0xFF) {
|
||||
index = ir.Imm32(isberd.imm.Value());
|
||||
} else {
|
||||
const IR::U32 scaledIndex = scaleIndex(ir, X(isberd.src_reg.Value()), isberd.shift.Value());
|
||||
index = ir.IAdd(scaledIndex, ir.Imm32(isberd.imm.Value()));
|
||||
}
|
||||
|
||||
if (isberd.mode != Isberd::Mode::Default) {
|
||||
IR::F32 result_f32{};
|
||||
switch (isberd.mode.Value()) {
|
||||
case Isberd::Mode::Patch:
|
||||
result_f32 = ir.GetPatch(address.Patch());
|
||||
break;
|
||||
case Isberd::Mode::Prim:
|
||||
result_f32 = ir.GetAttribute(address.Attribute());
|
||||
break;
|
||||
case Isberd::Mode::Attr:
|
||||
result_f32 = ir.GetAttributeIndexed(address);
|
||||
break;
|
||||
default:
|
||||
UNREACHABLE();
|
||||
if (isberd.o.Value()) {
|
||||
if (isberd.skew.Value()) {
|
||||
index = ir.IAdd(index, skewBytes(ir, isberd.sz.Value()));
|
||||
}
|
||||
|
||||
auto result_u32 = ir.BitCast<IR::U32>(result_f32);
|
||||
X(isberd.dest_reg, apply_ISBERD_shift(result_u32, isberd.shift.Value()));
|
||||
return;
|
||||
}
|
||||
|
||||
if (isberd.skew != 0) {
|
||||
auto result = ir.IAdd(X(isberd.src_reg), ir.LaneId());
|
||||
X(isberd.dest_reg, result);
|
||||
const IR::U64 index64 = ir.UConvert(64, index);
|
||||
IR::U32 globalLoaded{};
|
||||
switch (isberd.sz.Value()) {
|
||||
case SZ::U8: globalLoaded = ir.LoadGlobalU8 (index64); break;
|
||||
case SZ::U16: globalLoaded = ir.LoadGlobalU16(index64); break;
|
||||
case SZ::U32:
|
||||
case SZ::F32: globalLoaded = ir.LoadGlobal32(index64); break;
|
||||
default: UNREACHABLE();
|
||||
}
|
||||
X(isberd.dest_reg.Value(), globalLoaded);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// Fallback if nothing else applies
|
||||
X(isberd.dest_reg, X(isberd.src_reg));
|
||||
if (isberd.mode.Value() != Mode::Default) {
|
||||
if (isberd.skew.Value()) {
|
||||
index = ir.IAdd(index, skewBytes(ir, SZ::U32));
|
||||
}
|
||||
|
||||
IR::F32 float_index{};
|
||||
switch (isberd.mode.Value()) {
|
||||
case Mode::Patch: float_index = ir.GetPatch(index.Patch());
|
||||
break;
|
||||
case Mode::Prim: float_index = ir.GetAttribute(index.Attribute());
|
||||
break;
|
||||
case Mode::Attr: float_index = ir.GetAttributeIndexed(index);
|
||||
break;
|
||||
default: UNREACHABLE();
|
||||
}
|
||||
X(isberd.dest_reg.Value(), ir.BitCast<IR::U32>(float_index));
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (isberd.skew.Value()) {
|
||||
X(isberd.dest_reg.Value(), ir.IAdd(X(isberd.src_reg.Value()), ir.LaneId()));
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// Fallback copy
|
||||
X(isberd.dest_reg.Value(), X(isberd.src_reg.Value()));
|
||||
}
|
||||
|
||||
} // namespace Shader::Maxwell
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
# SPDX-FileCopyrightText: 2018 yuzu Emulator Project
|
||||
# SPDX-License-Identifier: GPL-2.0-or-later
|
||||
# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
# SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
set(FIDELITYFX_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/externals/FidelityFX-FSR/ffx-fsr)
|
||||
|
||||
|
|
@ -45,6 +45,8 @@ set(SHADER_FILES
|
|||
present_area.frag
|
||||
present_bicubic.frag
|
||||
present_gaussian.frag
|
||||
present_lanczos.frag
|
||||
present_spline1.frag
|
||||
queries_prefix_scan_sum.comp
|
||||
queries_prefix_scan_sum_nosubgroups.comp
|
||||
resolve_conditional_render.comp
|
||||
|
|
|
|||
40
src/video_core/host_shaders/present_lanczos.frag
Normal file
40
src/video_core/host_shaders/present_lanczos.frag
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// https://en.wikipedia.org/wiki/Lanczos_resampling
|
||||
|
||||
#version 460 core
|
||||
|
||||
layout (location = 0) in vec2 frag_tex_coord;
|
||||
layout (location = 0) out vec4 color;
|
||||
layout (binding = 0) uniform sampler2D color_texture;
|
||||
|
||||
#define PI 3.1415926535897932384626433
|
||||
float sinc(float x) {
|
||||
return x == 0.0f ? 1.0f : sin(PI * x) / (PI * x);
|
||||
}
|
||||
float lanczos(vec2 v, float a) {
|
||||
float d = length(v);
|
||||
return sinc(d) / sinc(d / a);
|
||||
}
|
||||
vec4 textureLanczos(sampler2D textureSampler, vec2 p) {
|
||||
vec3 c_sum = vec3(0.0f);
|
||||
float w_sum = 0.0f;
|
||||
vec2 res = vec2(textureSize(textureSampler, 0));
|
||||
vec2 cc = floor(p * res) / res;
|
||||
// kernel size = (2r + 1)^2
|
||||
const int r = 3; //radius (1 = 3 steps)
|
||||
for (int x = -r; x <= r; x++)
|
||||
for (int y = -r; y <= r; y++) {
|
||||
vec2 kp = 0.5f * (vec2(x, y) / res); // 0.5 = half-pixel level resampling
|
||||
vec2 uv = cc + kp;
|
||||
float w = lanczos(kp, float(r));
|
||||
c_sum += w * texture(textureSampler, p + kp).rgb;
|
||||
w_sum += w;
|
||||
}
|
||||
return vec4(c_sum / w_sum, 1.0f);
|
||||
}
|
||||
|
||||
void main() {
|
||||
color = textureLanczos(color_texture, frag_tex_coord);
|
||||
}
|
||||
24
src/video_core/host_shaders/present_spline1.frag
Normal file
24
src/video_core/host_shaders/present_spline1.frag
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// Spline (smooth linear inerpolation) with 1 texel fetch (needs bilinear to work)
|
||||
// Emulates bicubic without actually doing bicubic
|
||||
// See https://iquilezles.org/articles/texture, unfortunely there are issues with the original
|
||||
// where smoothstep "expansion" actually results in worse codegen (SPIRV-Opt does a direct conv to smoothstep)
|
||||
// TODO: Numerical analysis - fract is sawtooth func and floor, reuse params? Perhaps - no need for precision
|
||||
|
||||
#version 460 core
|
||||
|
||||
layout (location = 0) in vec2 frag_tex_coord;
|
||||
layout (location = 0) out vec4 color;
|
||||
layout (binding = 0) uniform sampler2D color_texture;
|
||||
|
||||
vec4 textureSpline1(sampler2D sam, vec2 uv) {
|
||||
float r = float(textureSize(sam, 0).x);
|
||||
vec2 x = fract(uv * r + 0.5);
|
||||
return texture(sam, (floor(uv * r + 0.5) + smoothstep(0.0, 1.0, x) - 0.5) / r);
|
||||
}
|
||||
|
||||
void main() {
|
||||
color = textureSpline1(color_texture, frag_tex_coord);
|
||||
}
|
||||
|
|
@ -89,6 +89,12 @@ void BlitScreen::CreateWindowAdapt() {
|
|||
case Settings::ScalingFilter::Gaussian:
|
||||
window_adapt = MakeGaussian(device);
|
||||
break;
|
||||
case Settings::ScalingFilter::Spline1:
|
||||
window_adapt = MakeSpline1(device);
|
||||
break;
|
||||
case Settings::ScalingFilter::Lanczos:
|
||||
window_adapt = MakeLanczos(device);
|
||||
break;
|
||||
case Settings::ScalingFilter::ScaleForce:
|
||||
window_adapt = MakeScaleForce(device);
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -12,6 +12,8 @@
|
|||
#include "video_core/host_shaders/present_area_frag.h"
|
||||
#include "video_core/host_shaders/present_bicubic_frag.h"
|
||||
#include "video_core/host_shaders/present_gaussian_frag.h"
|
||||
#include "video_core/host_shaders/present_lanczos_frag.h"
|
||||
#include "video_core/host_shaders/present_spline1_frag.h"
|
||||
#include "video_core/renderer_opengl/present/filters.h"
|
||||
#include "video_core/renderer_opengl/present/util.h"
|
||||
|
||||
|
|
@ -27,6 +29,11 @@ std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device) {
|
|||
HostShaders::OPENGL_PRESENT_FRAG);
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device) {
|
||||
return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
|
||||
HostShaders::PRESENT_SPLINE1_FRAG);
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device) {
|
||||
return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
|
||||
HostShaders::PRESENT_BICUBIC_FRAG);
|
||||
|
|
@ -37,6 +44,11 @@ std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device) {
|
|||
HostShaders::PRESENT_GAUSSIAN_FRAG);
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device) {
|
||||
return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
|
||||
HostShaders::PRESENT_LANCZOS_FRAG);
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device) {
|
||||
return std::make_unique<WindowAdaptPass>(
|
||||
device, CreateBilinearSampler(),
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@ std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device);
|
|||
std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device);
|
||||
std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device);
|
||||
std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device);
|
||||
std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device);
|
||||
std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device);
|
||||
std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device);
|
||||
std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device);
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,8 @@
|
|||
#include "video_core/host_shaders/present_area_frag_spv.h"
|
||||
#include "video_core/host_shaders/present_bicubic_frag_spv.h"
|
||||
#include "video_core/host_shaders/present_gaussian_frag_spv.h"
|
||||
#include "video_core/host_shaders/present_lanczos_frag_spv.h"
|
||||
#include "video_core/host_shaders/present_spline1_frag_spv.h"
|
||||
#include "video_core/host_shaders/vulkan_present_frag_spv.h"
|
||||
#include "video_core/host_shaders/vulkan_present_scaleforce_fp16_frag_spv.h"
|
||||
#include "video_core/host_shaders/vulkan_present_scaleforce_fp32_frag_spv.h"
|
||||
|
|
@ -45,6 +47,11 @@ std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device, VkFormat fra
|
|||
BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat frame_format) {
|
||||
return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
|
||||
BuildShader(device, PRESENT_SPLINE1_FRAG_SPV));
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format) {
|
||||
// No need for handrolled shader -- if the VK impl can do it for us ;)
|
||||
if (device.IsExtFilterCubicSupported())
|
||||
|
|
@ -59,6 +66,11 @@ std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat fra
|
|||
BuildShader(device, PRESENT_GAUSSIAN_FRAG_SPV));
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device, VkFormat frame_format) {
|
||||
return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
|
||||
BuildShader(device, PRESENT_LANCZOS_FRAG_SPV));
|
||||
}
|
||||
|
||||
std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device, VkFormat frame_format) {
|
||||
return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
|
||||
SelectScaleForceShader(device));
|
||||
|
|
|
|||
|
|
@ -18,7 +18,9 @@ class MemoryAllocator;
|
|||
std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device, VkFormat frame_format);
|
||||
std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device, VkFormat frame_format);
|
||||
std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format);
|
||||
std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat frame_format);
|
||||
std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat frame_format);
|
||||
std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device, VkFormat frame_format);
|
||||
std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device, VkFormat frame_format);
|
||||
std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device, VkFormat frame_format);
|
||||
|
||||
|
|
|
|||
|
|
@ -43,9 +43,15 @@ void BlitScreen::SetWindowAdaptPass() {
|
|||
case Settings::ScalingFilter::Bicubic:
|
||||
window_adapt = MakeBicubic(device, swapchain_view_format);
|
||||
break;
|
||||
case Settings::ScalingFilter::Spline1:
|
||||
window_adapt = MakeSpline1(device, swapchain_view_format);
|
||||
break;
|
||||
case Settings::ScalingFilter::Gaussian:
|
||||
window_adapt = MakeGaussian(device, swapchain_view_format);
|
||||
break;
|
||||
case Settings::ScalingFilter::Lanczos:
|
||||
window_adapt = MakeLanczos(device, swapchain_view_format);
|
||||
break;
|
||||
case Settings::ScalingFilter::ScaleForce:
|
||||
window_adapt = MakeScaleForce(device, swapchain_view_format);
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -1590,10 +1590,10 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
|
|||
since tropic didn't want to touch it for a long time, so it needs a rewrite from someone
|
||||
better than me at vulkan. */
|
||||
// CHANGE: Gate the MSAA path more strictly and only use it for color, when the pass and device
|
||||
// support are available. Avoid running the MSAA path when prerequisites aren't met, preventing
|
||||
// validation and runtime issues.
|
||||
// support are available. Avoid running the MSAA path when prerequisites aren't met,
|
||||
// preventing validation and runtime issues.
|
||||
const bool wants_msaa_upload = info.num_samples > 1 &&
|
||||
aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT &&
|
||||
(aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0 &&
|
||||
runtime->CanUploadMSAA() && runtime->msaa_copy_pass != nullptr &&
|
||||
runtime->device.IsStorageImageMultisampleSupported();
|
||||
|
||||
|
|
@ -1603,7 +1603,8 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
|
|||
temp_info.num_samples = 1;
|
||||
|
||||
// CHANGE: Build a fresh VkImageCreateInfo with robust usage flags for the temp image.
|
||||
// Using the target image's usage as-is could miss STORAGE/TRANSFER bits and trigger validation errors.
|
||||
// Using the target image's usage as-is could miss STORAGE/TRANSFER bits and trigger
|
||||
// validation errors.
|
||||
VkImageCreateInfo image_ci = MakeImageCreateInfo(runtime->device, temp_info);
|
||||
image_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
|
||||
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
|
||||
|
|
@ -1613,7 +1614,7 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
|
|||
auto temp_wrapper = std::make_shared<Image>(*runtime, temp_info, 0, 0);
|
||||
temp_wrapper->original_image = runtime->memory_allocator.CreateImage(image_ci);
|
||||
temp_wrapper->current_image = &Image::original_image;
|
||||
temp_wrapper->aspect_mask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
temp_wrapper->aspect_mask = aspect_mask;
|
||||
temp_wrapper->initialized = true;
|
||||
|
||||
// Upload to the temporary non-MSAA image
|
||||
|
|
@ -1622,18 +1623,17 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
|
|||
const VkBuffer src_buffer = buffer;
|
||||
const VkImage temp_vk_image = *temp_wrapper->original_image;
|
||||
const VkImageAspectFlags vk_aspect_mask = temp_wrapper->aspect_mask;
|
||||
|
||||
scheduler->Record([src_buffer, temp_vk_image, vk_aspect_mask, vk_copies,
|
||||
// CHANGE: capture shared_ptr to pin lifetime through submission
|
||||
keep = temp_wrapper](vk::CommandBuffer cmdbuf) {
|
||||
CopyBufferToImage(cmdbuf, src_buffer, temp_vk_image, vk_aspect_mask, false, vk_copies);
|
||||
});
|
||||
|
||||
// Use MSAACopyPass to convert from non-MSAA to MSAA
|
||||
// CHANGE: only lifetime and usage were fixed.
|
||||
std::vector<VideoCommon::ImageCopy> image_copies;
|
||||
image_copies.reserve(copies.size());
|
||||
for (const auto& copy : copies) {
|
||||
VideoCommon::ImageCopy image_copy;
|
||||
VideoCommon::ImageCopy image_copy{};
|
||||
image_copy.src_offset = {0, 0, 0}; // Use zero offset for source
|
||||
image_copy.dst_offset = copy.image_offset;
|
||||
image_copy.src_subresource = copy.image_subresource;
|
||||
|
|
@ -1646,11 +1646,9 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
|
|||
/*msaa_to_non_msaa=*/false);
|
||||
std::exchange(initialized, true);
|
||||
|
||||
// CHANGE: Add a no-op recording that captures temp_wrapper to ensure it stays alive
|
||||
// at least until commands are submitted/recorded.
|
||||
scheduler->Record([keep = std::move(temp_wrapper)](vk::CommandBuffer) {});
|
||||
const u64 tick = scheduler->Flush();
|
||||
scheduler->Wait(tick);
|
||||
|
||||
// CHANGE: Restore scaling before returning from the MSAA path.
|
||||
if (is_rescaled) {
|
||||
ScaleUp();
|
||||
}
|
||||
|
|
@ -1663,10 +1661,11 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
|
|||
const VkBuffer src_buffer = buffer;
|
||||
const VkImage vk_image = *original_image;
|
||||
const VkImageAspectFlags vk_aspect_mask = aspect_mask;
|
||||
const bool is_initialized = std::exchange(initialized, true);
|
||||
scheduler->Record([src_buffer, vk_image, vk_aspect_mask, is_initialized,
|
||||
const bool was_initialized = std::exchange(initialized, true);
|
||||
|
||||
scheduler->Record([src_buffer, vk_image, vk_aspect_mask, was_initialized,
|
||||
vk_copies](vk::CommandBuffer cmdbuf) {
|
||||
CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, is_initialized, vk_copies);
|
||||
CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, was_initialized, vk_copies);
|
||||
});
|
||||
|
||||
if (is_rescaled) {
|
||||
|
|
|
|||
48
tools/lanczos_gen.c
Normal file
48
tools/lanczos_gen.c
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// clang -lm tools/lanczos_gen.c -o tools/lanczos_gen && ./tools/lanczos_gen
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
double sinc(double x) {
|
||||
return x == 0.0f ? 1.0f : sin(M_PI * x) / (M_PI * x);
|
||||
}
|
||||
|
||||
typedef struct vec2 {
|
||||
double x;
|
||||
double y;
|
||||
} vec2;
|
||||
|
||||
double lanczos(vec2 v, float a) {
|
||||
double d = sqrt(v.x * v.x + v.y * v.y);
|
||||
return sinc(d) / sinc(d / a);
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
const int r = 3; //radius (1 = 3 steps)
|
||||
const int k_size = (r * 2 + 1) * (r * 2 + 1);
|
||||
double w_sum = 0.0f;
|
||||
// kernel size = (r * 2 + 1) ^ 2
|
||||
printf("const float w_kernel[%i] = float[] (\n ", k_size);
|
||||
double factor = 1.0f / ((double)r + 1.0f);
|
||||
for (int x = -r; x <= r; x++)
|
||||
for (int y = -r; y <= r; y++) {
|
||||
double w = lanczos((vec2){ .x = x, .y = y }, (double)r);
|
||||
printf("%lff, ", w);
|
||||
w_sum += w;
|
||||
}
|
||||
printf("\n);\n");
|
||||
printf("const vec2 w_pos[%i] = vec2[] (\n ", k_size);
|
||||
for (int x = -r; x <= r; x++)
|
||||
for (int y = -r; y <= r; y++) {
|
||||
vec2 kp = (vec2){
|
||||
.x = x * factor,
|
||||
.y = y * factor
|
||||
};
|
||||
printf("vec2(%lff, %lff), ", kp.x, kp.y);
|
||||
}
|
||||
printf("\n);\n");
|
||||
printf("const float w_sum = %lff;\n", w_sum);
|
||||
return 0;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue