diff --git a/src/common/settings_enums.h b/src/common/settings_enums.h index 41133a7819..ebfa4ceb9e 100644 --- a/src/common/settings_enums.h +++ b/src/common/settings_enums.h @@ -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); diff --git a/src/core/crypto/key_manager.cpp b/src/core/crypto/key_manager.cpp index 6d0b32ba70..50945eee91 100644 --- a/src/core/crypto/key_manager.cpp +++ b/src/core/crypto/key_manager.cpp @@ -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>, 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(SourceKeyType::ETicketKek)); - } - if (eticket_kekek != Key128{}) { - SetKey(S128KeyType::Source, eticket_kekek, - static_cast(SourceKeyType::ETicketKekek)); - } - if (seed3 != Key128{}) { - SetKey(S128KeyType::RSAKek, seed3, static_cast(RSAKekType::Seed3)); - } - if (mask0 != Key128{}) { - SetKey(S128KeyType::RSAKek, mask0, static_cast(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(SourceKeyType::RSAOaepKekGeneration)); - - Key128 temp_kek{}; - Key128 temp_kekek{}; - Key128 eticket_final{}; - - // Derive ETicket RSA Kek - AESCipher es_master(GetKey(S128KeyType::Master), Mode::ECB); - es_master.Transcode(rsa_oaep_kek.data(), rsa_oaep_kek.size(), temp_kek.data(), Op::Decrypt); - AESCipher es_kekek(temp_kek, Mode::ECB); - es_kekek.Transcode(eticket_kekek.data(), eticket_kekek.size(), temp_kekek.data(), Op::Decrypt); - AESCipher 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(SourceKeyType::Package2)); - SetKeyWrapped(S128KeyType::Source, data.GetAESKekGenerationSource(), - static_cast(SourceKeyType::AESKekGeneration)); - SetKeyWrapped(S128KeyType::Source, data.GetTitlekekSource(), - static_cast(SourceKeyType::Titlekek)); - SetKeyWrapped(S128KeyType::Source, data.GetMasterKeySource(), - static_cast(SourceKeyType::Master)); - SetKeyWrapped(S128KeyType::Source, data.GetKeyblobMACKeySource(), - static_cast(SourceKeyType::KeyblobMAC)); - - for (size_t i = 0; i < PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH; ++i) { - SetKeyWrapped(S128KeyType::Source, data.GetKeyblobKeySource(i), - static_cast(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(SourceKeyType::KeyAreaKey), - static_cast(KeyAreaKeyType::Application)); - SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeyOceanSource(), - static_cast(SourceKeyType::KeyAreaKey), - static_cast(KeyAreaKeyType::Ocean)); - SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeySystemSource(), - static_cast(SourceKeyType::KeyAreaKey), - static_cast(KeyAreaKeyType::System)); - SetKeyWrapped(S128KeyType::Source, data.GetSDKekSource(), - static_cast(SourceKeyType::SDKek)); - SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDSaveKeySource(), - static_cast(SDKeyType::Save)); - SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDNCAKeySource(), - static_cast(SDKeyType::NCA)); - SetKeyWrapped(S128KeyType::Source, data.GetHeaderKekSource(), - static_cast(SourceKeyType::HeaderKek)); - SetKeyWrapped(S256KeyType::HeaderSource, data.GetHeaderKeySource()); - SetKeyWrapped(S128KeyType::Source, data.GetAESKeyGenerationSource(), - static_cast(SourceKeyType::AESKeyGeneration)); - DeriveBase(); } diff --git a/src/core/crypto/partition_data_manager.cpp b/src/core/crypto/partition_data_manager.cpp index 8e4fc2e595..e185838e57 100644 --- a/src/core/crypto/partition_data_manager.cpp +++ b/src/core/crypto/partition_data_manager.cpp @@ -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 #include #include @@ -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(i + 1); - } - } - - return 0; -} - -const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = CalculateMaxKeyblobSourceHash(); - -template -std::array FindKeyFromHex(const std::vector& binary, - const std::array& hash) { - if (binary.size() < key_size) - return {}; - - std::array 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 out{}; - std::memcpy(out.data(), binary.data() + i, key_size); - return out; - } - - return {}; -} - -std::array FindKeyFromHex16(const std::vector& binary, std::array hash) { - return FindKeyFromHex<0x10>(binary, hash); -} - -static std::array FindEncryptedMasterKeyFromHex(const std::vector& binary, - const Key128& key) { - if (binary.size() < 0x10) - return {}; - - SHA256Hash temp{}; - Key128 dec_temp{}; - std::array out{}; - AESCipher 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 PartitionDataManager::GetSecureMonitor() const { return secure_monitor_bytes; } -std::array PartitionDataManager::GetPackage2KeySource() const { - return FindKeyFromHex(secure_monitor_bytes, source_hashes[2]); -} - -std::array PartitionDataManager::GetAESKekGenerationSource() const { - return FindKeyFromHex(secure_monitor_bytes, source_hashes[3]); -} - -std::array PartitionDataManager::GetTitlekekSource() const { - return FindKeyFromHex(secure_monitor_bytes, source_hashes[5]); -} - -std::array, 32> PartitionDataManager::GetTZMasterKeys( - std::array master_key) const { - return FindEncryptedMasterKeyFromHex(secure_monitor_bytes, master_key); -} - -std::array PartitionDataManager::GetRSAKekSeed3() const { - return FindKeyFromHex(secure_monitor_bytes, source_hashes[14]); -} - -std::array PartitionDataManager::GetRSAKekMask0() const { - return FindKeyFromHex(secure_monitor_bytes, source_hashes[15]); -} - std::vector PartitionDataManager::GetPackage1Decrypted() const { return package1_decrypted_bytes; } -std::array PartitionDataManager::GetMasterKeySource() const { - return FindKeyFromHex(package1_decrypted_bytes, source_hashes[1]); -} - -std::array PartitionDataManager::GetKeyblobMACKeySource() const { - return FindKeyFromHex(package1_decrypted_bytes, source_hashes[0]); -} - -std::array 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& PartitionDataManager::GetPackage2FSDecompressed(Package2T return package2_fs.at(static_cast(type)); } -std::array PartitionDataManager::GetKeyAreaKeyApplicationSource(Package2Type type) const { - return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[6]); -} - -std::array PartitionDataManager::GetKeyAreaKeyOceanSource(Package2Type type) const { - return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[7]); -} - -std::array PartitionDataManager::GetKeyAreaKeySystemSource(Package2Type type) const { - return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[8]); -} - -std::array PartitionDataManager::GetSDKekSource(Package2Type type) const { - return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[9]); -} - -std::array PartitionDataManager::GetSDSaveKeySource(Package2Type type) const { - return FindKeyFromHex<0x20>(package2_fs.at(static_cast(type)), source_hashes[10]); -} - -std::array PartitionDataManager::GetSDNCAKeySource(Package2Type type) const { - return FindKeyFromHex<0x20>(package2_fs.at(static_cast(type)), source_hashes[11]); -} - -std::array PartitionDataManager::GetHeaderKekSource(Package2Type type) const { - return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[12]); -} - -std::array PartitionDataManager::GetHeaderKeySource(Package2Type type) const { - return FindKeyFromHex<0x20>(package2_fs.at(static_cast(type)), source_hashes[13]); -} - const std::vector& PartitionDataManager::GetPackage2SPLDecompressed(Package2Type type) const { return package2_spl.at(static_cast(type)); } -std::array PartitionDataManager::GetAESKeyGenerationSource(Package2Type type) const { - return FindKeyFromHex(package2_spl.at(static_cast(type)), source_hashes[4]); -} - bool PartitionDataManager::HasProdInfo() const { return prodinfo != nullptr; } @@ -509,4 +255,4 @@ std::array PartitionDataManager::GetETicketExtendedKek() const { prodinfo_decrypted->Read(out.data(), out.size(), 0x3890); return out; } -} // namespace Core::Crypto +} // namespace Core::Crypto \ No newline at end of file diff --git a/src/core/crypto/partition_data_manager.h b/src/core/crypto/partition_data_manager.h index 4354a21e6a..2a01aed228 100644 --- a/src/core/crypto/partition_data_manager.h +++ b/src/core/crypto/partition_data_manager.h @@ -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 GetSecureMonitor() const; - std::array GetPackage2KeySource() const; - std::array GetAESKekGenerationSource() const; - std::array GetTitlekekSource() const; - std::array, 0x20> GetTZMasterKeys(std::array master_key) const; - std::array GetRSAKekSeed3() const; - std::array GetRSAKekMask0() const; std::vector GetPackage1Decrypted() const; - std::array GetMasterKeySource() const; - std::array GetKeyblobMACKeySource() const; - std::array GetKeyblobKeySource(std::size_t revision) const; // Fuses bool HasFuses() const; @@ -63,21 +57,8 @@ public: Package2Type type); const std::vector& GetPackage2FSDecompressed( Package2Type type = Package2Type::NormalMain) const; - std::array GetKeyAreaKeyApplicationSource( - Package2Type type = Package2Type::NormalMain) const; - std::array GetKeyAreaKeyOceanSource( - Package2Type type = Package2Type::NormalMain) const; - std::array GetKeyAreaKeySystemSource( - Package2Type type = Package2Type::NormalMain) const; - std::array GetSDKekSource(Package2Type type = Package2Type::NormalMain) const; - std::array GetSDSaveKeySource(Package2Type type = Package2Type::NormalMain) const; - std::array GetSDNCAKeySource(Package2Type type = Package2Type::NormalMain) const; - std::array GetHeaderKekSource(Package2Type type = Package2Type::NormalMain) const; - std::array GetHeaderKeySource(Package2Type type = Package2Type::NormalMain) const; const std::vector& GetPackage2SPLDecompressed( Package2Type type = Package2Type::NormalMain) const; - std::array GetAESKeyGenerationSource( - Package2Type type = Package2Type::NormalMain) const; // PRODINFO bool HasProdInfo() const; @@ -104,6 +85,4 @@ private: std::array, 6> package2_spl; }; -std::array FindKeyFromHex16(const std::vector& binary, std::array hash); - -} // namespace Core::Crypto +} // namespace Core::Crypto \ No newline at end of file diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp index 7d43677c6f..b486e56d68 100644 --- a/src/core/hle/service/nifm/nifm.cpp +++ b/src/core/hle/service/nifm/nifm.cpp @@ -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(); } diff --git a/src/qt_common/shared_translation.cpp b/src/qt_common/shared_translation.cpp index eb413f28e9..4254253c2f 100644 --- a/src/qt_common/shared_translation.cpp +++ b/src/qt_common/shared_translation.cpp @@ -572,7 +572,9 @@ std::unique_ptr 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")), diff --git a/src/qt_common/shared_translation.h b/src/qt_common/shared_translation.h index 48a2cb5205..c9216c2daa 100644 --- a/src/qt_common/shared_translation.h +++ b/src/qt_common/shared_translation.h @@ -38,8 +38,12 @@ static const std::map 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"))}, diff --git a/src/shader_recompiler/frontend/maxwell/translate/impl/impl.cpp b/src/shader_recompiler/frontend/maxwell/translate/impl/impl.cpp index 157e5dfaaf..8b5a103006 100644 --- a/src/shader_recompiler/frontend/maxwell/translate/impl/impl.cpp +++ b/src/shader_recompiler/frontend/maxwell/translate/impl/impl.cpp @@ -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 diff --git a/src/shader_recompiler/frontend/maxwell/translate/impl/impl.h b/src/shader_recompiler/frontend/maxwell/translate/impl/impl.h index 1b2547a1bd..37963dc777 100644 --- a/src/shader_recompiler/frontend/maxwell/translate/impl/impl.h +++ b/src/shader_recompiler/frontend/maxwell/translate/impl/impl.h @@ -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 diff --git a/src/shader_recompiler/frontend/maxwell/translate/impl/internal_stage_buffer_entry_read.cpp b/src/shader_recompiler/frontend/maxwell/translate/impl/internal_stage_buffer_entry_read.cpp index 2aaf85772d..e6345de65e 100644 --- a/src/shader_recompiler/frontend/maxwell/translate/impl/internal_stage_buffer_entry_read.cpp +++ b/src/shader_recompiler/frontend/maxwell/translate/impl/internal_stage_buffer_entry_read.cpp @@ -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(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(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 diff --git a/src/video_core/host_shaders/CMakeLists.txt b/src/video_core/host_shaders/CMakeLists.txt index 688e10d2e4..c14b44a45a 100644 --- a/src/video_core/host_shaders/CMakeLists.txt +++ b/src/video_core/host_shaders/CMakeLists.txt @@ -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 diff --git a/src/video_core/host_shaders/present_lanczos.frag b/src/video_core/host_shaders/present_lanczos.frag new file mode 100644 index 0000000000..b69b329c1b --- /dev/null +++ b/src/video_core/host_shaders/present_lanczos.frag @@ -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); +} diff --git a/src/video_core/host_shaders/present_spline1.frag b/src/video_core/host_shaders/present_spline1.frag new file mode 100644 index 0000000000..871b47586b --- /dev/null +++ b/src/video_core/host_shaders/present_spline1.frag @@ -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); +} diff --git a/src/video_core/renderer_opengl/gl_blit_screen.cpp b/src/video_core/renderer_opengl/gl_blit_screen.cpp index 2071fe8d15..65670fcad8 100644 --- a/src/video_core/renderer_opengl/gl_blit_screen.cpp +++ b/src/video_core/renderer_opengl/gl_blit_screen.cpp @@ -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; diff --git a/src/video_core/renderer_opengl/present/filters.cpp b/src/video_core/renderer_opengl/present/filters.cpp index c5ac8e7823..5e3d1538c6 100644 --- a/src/video_core/renderer_opengl/present/filters.cpp +++ b/src/video_core/renderer_opengl/present/filters.cpp @@ -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 MakeBilinear(const Device& device) { HostShaders::OPENGL_PRESENT_FRAG); } +std::unique_ptr MakeSpline1(const Device& device) { + return std::make_unique(device, CreateBilinearSampler(), + HostShaders::PRESENT_SPLINE1_FRAG); +} + std::unique_ptr MakeBicubic(const Device& device) { return std::make_unique(device, CreateBilinearSampler(), HostShaders::PRESENT_BICUBIC_FRAG); @@ -37,6 +44,11 @@ std::unique_ptr MakeGaussian(const Device& device) { HostShaders::PRESENT_GAUSSIAN_FRAG); } +std::unique_ptr MakeLanczos(const Device& device) { + return std::make_unique(device, CreateBilinearSampler(), + HostShaders::PRESENT_LANCZOS_FRAG); +} + std::unique_ptr MakeScaleForce(const Device& device) { return std::make_unique( device, CreateBilinearSampler(), diff --git a/src/video_core/renderer_opengl/present/filters.h b/src/video_core/renderer_opengl/present/filters.h index be2ce24842..7b38ac56bc 100644 --- a/src/video_core/renderer_opengl/present/filters.h +++ b/src/video_core/renderer_opengl/present/filters.h @@ -18,6 +18,8 @@ std::unique_ptr MakeNearestNeighbor(const Device& device); std::unique_ptr MakeBilinear(const Device& device); std::unique_ptr MakeBicubic(const Device& device); std::unique_ptr MakeGaussian(const Device& device); +std::unique_ptr MakeSpline1(const Device& device); +std::unique_ptr MakeLanczos(const Device& device); std::unique_ptr MakeScaleForce(const Device& device); std::unique_ptr MakeArea(const Device& device); diff --git a/src/video_core/renderer_vulkan/present/filters.cpp b/src/video_core/renderer_vulkan/present/filters.cpp index 7843f38d2c..e0f2b26f84 100644 --- a/src/video_core/renderer_vulkan/present/filters.cpp +++ b/src/video_core/renderer_vulkan/present/filters.cpp @@ -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 MakeBilinear(const Device& device, VkFormat fra BuildShader(device, VULKAN_PRESENT_FRAG_SPV)); } +std::unique_ptr MakeSpline1(const Device& device, VkFormat frame_format) { + return std::make_unique(device, frame_format, CreateBilinearSampler(device), + BuildShader(device, PRESENT_SPLINE1_FRAG_SPV)); +} + std::unique_ptr 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 MakeGaussian(const Device& device, VkFormat fra BuildShader(device, PRESENT_GAUSSIAN_FRAG_SPV)); } +std::unique_ptr MakeLanczos(const Device& device, VkFormat frame_format) { + return std::make_unique(device, frame_format, CreateBilinearSampler(device), + BuildShader(device, PRESENT_LANCZOS_FRAG_SPV)); +} + std::unique_ptr MakeScaleForce(const Device& device, VkFormat frame_format) { return std::make_unique(device, frame_format, CreateBilinearSampler(device), SelectScaleForceShader(device)); diff --git a/src/video_core/renderer_vulkan/present/filters.h b/src/video_core/renderer_vulkan/present/filters.h index c8259487f8..015bffc8a5 100644 --- a/src/video_core/renderer_vulkan/present/filters.h +++ b/src/video_core/renderer_vulkan/present/filters.h @@ -18,7 +18,9 @@ class MemoryAllocator; std::unique_ptr MakeNearestNeighbor(const Device& device, VkFormat frame_format); std::unique_ptr MakeBilinear(const Device& device, VkFormat frame_format); std::unique_ptr MakeBicubic(const Device& device, VkFormat frame_format); +std::unique_ptr MakeSpline1(const Device& device, VkFormat frame_format); std::unique_ptr MakeGaussian(const Device& device, VkFormat frame_format); +std::unique_ptr MakeLanczos(const Device& device, VkFormat frame_format); std::unique_ptr MakeScaleForce(const Device& device, VkFormat frame_format); std::unique_ptr MakeArea(const Device& device, VkFormat frame_format); diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp index 39f07b966d..b720bcded3 100644 --- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp +++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp @@ -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; diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp index 82dc961cc4..e4fef2998e 100644 --- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp @@ -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(*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 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) { diff --git a/tools/lanczos_gen.c b/tools/lanczos_gen.c new file mode 100644 index 0000000000..6d7be3cb0e --- /dev/null +++ b/tools/lanczos_gen.c @@ -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 +#include + +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; +}