early-access version 1310

This commit is contained in:
pineappleEA 2021-01-12 10:22:33 +01:00
parent ebc2449a41
commit 4219fd41b9
49 changed files with 308 additions and 342 deletions

View File

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 1298. This is the source code for early-access 1310.
## Legal Notice ## Legal Notice

View File

@ -1,31 +1,31 @@
diff --git a/CMakeModules/GenerateSCMRev.cmake b/CMakeModules/GenerateSCMRev.cmake diff --git a/CMakeModules/GenerateSCMRev.cmake b/CMakeModules/GenerateSCMRev.cmake
index 311ba1c2e..79315b198 100644
--- a/CMakeModules/GenerateSCMRev.cmake --- a/CMakeModules/GenerateSCMRev.cmake
+++ b/CMakeModules/GenerateSCMRev.cmake +++ b/CMakeModules/GenerateSCMRev.cmake
@@ -11,9 +11,9 @@ find_package(Git QUIET PATHS "${GIT_EXECUTABLE}") @@ -11,10 +11,10 @@
# generate git/build information # generate git/build information
include(GetGitRevisionDescription) include(GetGitRevisionDescription)
-get_git_head_revision(GIT_REF_SPEC GIT_REV) -get_git_head_revision(GIT_REF_SPEC GIT_REV)
-git_describe(GIT_DESC --always --long --dirty) -git_describe(GIT_DESC --always --long --dirty)
-git_branch_name(GIT_BRANCH) -git_branch_name(GIT_BRANCH)
-get_timestamp(BUILD_DATE)
+#get_git_head_revision(GIT_REF_SPEC GIT_REV) +#get_git_head_revision(GIT_REF_SPEC GIT_REV)
+#git_describe(GIT_DESC --always --long --dirty) +#git_describe(GIT_DESC --always --long --dirty)
+#git_branch_name(GIT_BRANCH) +#git_branch_name(GIT_BRANCH)
get_timestamp(BUILD_DATE) +#get_timestamp(BUILD_DATE)
# Generate cpp with Git revision from template # Generate cpp with Git revision from template
@@ -113,4 +113,5 @@ foreach (F IN LISTS HASH_FILES) # Also if this is a CI build, add the build name (ie: Nightly, Canary) to the scm_rev file as well
@@ -113,4 +113,5 @@
set(COMBINED "${COMBINED}${TMP}") set(COMBINED "${COMBINED}${TMP}")
endforeach() endforeach()
string(MD5 SHADER_CACHE_VERSION "${COMBINED}") string(MD5 SHADER_CACHE_VERSION "${COMBINED}")
+set(BUILD_FULLNAME "${BUILD_FULLNAME} ") +set(BUILD_FULLNAME "${BUILD_FULLNAME} ")
configure_file("${SRC_DIR}/src/common/scm_rev.cpp.in" "scm_rev.cpp" @ONLY) configure_file("${SRC_DIR}/src/common/scm_rev.cpp.in" "scm_rev.cpp" @ONLY)
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index d120c8d3d..bf3dcdbf6 100644
--- a/src/common/CMakeLists.txt --- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt
@@ -28,6 +28,11 @@ add_custom_command(OUTPUT scm_rev.cpp @@ -28,6 +28,12 @@
-DBUILD_TAG="${BUILD_TAG}" -DBUILD_TAG="${BUILD_TAG}"
-DBUILD_ID="${DISPLAY_VERSION}" -DBUILD_ID="${DISPLAY_VERSION}"
-DGIT_EXECUTABLE="${GIT_EXECUTABLE}" -DGIT_EXECUTABLE="${GIT_EXECUTABLE}"
@ -34,6 +34,7 @@ index d120c8d3d..bf3dcdbf6 100644
+ -DGIT_DESC="${GIT_DESC}" + -DGIT_DESC="${GIT_DESC}"
+ -DGIT_BRANCH="${GIT_BRANCH}" + -DGIT_BRANCH="${GIT_BRANCH}"
+ -DBUILD_FULLNAME="${BUILD_FULLNAME}" + -DBUILD_FULLNAME="${BUILD_FULLNAME}"
+ -DBUILD_DATE="${BUILD_DATE}"
-P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake" -P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
DEPENDS DEPENDS
# WARNING! It was too much work to try and make a common location for this list, # WARNING! It was too much work to try and make a common location for this list,

View File

@ -45,10 +45,15 @@ if (MSVC)
# Warnings # Warnings
/W3 /W3
/we4062 # enumerator 'identifier' in a switch of enum 'enumeration' is not handled
/we4101 # 'identifier': unreferenced local variable
/we4265 # 'class': class has virtual functions, but destructor is not virtual
/we4388 # signed/unsigned mismatch
/we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect /we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect
/we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'? /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
/we4555 # Expression has no effect; expected expression with side-effect /we4555 # Expression has no effect; expected expression with side-effect
/we4834 # Discarding return value of function with 'nodiscard' attribute /we4834 # Discarding return value of function with 'nodiscard' attribute
/we5038 # data member 'member1' will be initialized after data member 'member2'
) )
# /GS- - No stack buffer overflow checks # /GS- - No stack buffer overflow checks

View File

@ -11,16 +11,16 @@ namespace Common {
/// Ceiled integer division. /// Ceiled integer division.
template <typename N, typename D> template <typename N, typename D>
requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr auto DivCeil( requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeil(N number,
N number, D divisor) { D divisor) {
return (static_cast<D>(number) + divisor - 1) / divisor; return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
} }
/// Ceiled integer division with logarithmic divisor in base 2 /// Ceiled integer division with logarithmic divisor in base 2
template <typename N, typename D> template <typename N, typename D>
requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr auto DivCeilLog2( requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeilLog2(
N value, D alignment_log2) { N value, D alignment_log2) {
return (static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2; return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
} }
} // namespace Common } // namespace Common

View File

@ -1,18 +1,6 @@
/* // Copyright 2021 yuzu Emulator Project
* Copyright (c) 2018-2020 Atmosphère-NX // Licensed under GPLv2 or any later version
* // Refer to the license.txt file included.
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
@ -30,7 +18,7 @@ class IntrusiveRedBlackTreeImpl;
struct IntrusiveRedBlackTreeNode { struct IntrusiveRedBlackTreeNode {
private: private:
RB_ENTRY(IntrusiveRedBlackTreeNode) entry; RB_ENTRY(IntrusiveRedBlackTreeNode) entry{};
friend class impl::IntrusiveRedBlackTreeImpl; friend class impl::IntrusiveRedBlackTreeImpl;
@ -38,8 +26,7 @@ private:
friend class IntrusiveRedBlackTree; friend class IntrusiveRedBlackTree;
public: public:
constexpr IntrusiveRedBlackTreeNode() : entry() { /* ... */ constexpr IntrusiveRedBlackTreeNode() = default;
}
}; };
template <class T, class Traits, class Comparator> template <class T, class Traits, class Comparator>
@ -80,18 +67,16 @@ public:
using iterator_category = std::bidirectional_iterator_tag; using iterator_category = std::bidirectional_iterator_tag;
using value_type = typename IntrusiveRedBlackTreeImpl::value_type; using value_type = typename IntrusiveRedBlackTreeImpl::value_type;
using difference_type = typename IntrusiveRedBlackTreeImpl::difference_type; using difference_type = typename IntrusiveRedBlackTreeImpl::difference_type;
using pointer = typename std::conditional<Const, IntrusiveRedBlackTreeImpl::const_pointer, using pointer = std::conditional_t<Const, IntrusiveRedBlackTreeImpl::const_pointer,
IntrusiveRedBlackTreeImpl::pointer>::type; IntrusiveRedBlackTreeImpl::pointer>;
using reference = using reference = std::conditional_t<Const, IntrusiveRedBlackTreeImpl::const_reference,
typename std::conditional<Const, IntrusiveRedBlackTreeImpl::const_reference, IntrusiveRedBlackTreeImpl::reference>;
IntrusiveRedBlackTreeImpl::reference>::type;
private: private:
pointer node; pointer node;
public: public:
explicit Iterator(pointer n) : node(n) { /* ... */ explicit Iterator(pointer n) : node(n) {}
}
bool operator==(const Iterator& rhs) const { bool operator==(const Iterator& rhs) const {
return this->node == rhs.node; return this->node == rhs.node;
@ -137,12 +122,11 @@ public:
}; };
protected: protected:
/* Generate static implementations for non-comparison operations for IntrusiveRedBlackTreeRoot. // Generate static implementations for non-comparison operations for IntrusiveRedBlackTreeRoot.
*/
RB_GENERATE_WITHOUT_COMPARE_STATIC(IntrusiveRedBlackTreeRoot, IntrusiveRedBlackTreeNode, entry); RB_GENERATE_WITHOUT_COMPARE_STATIC(IntrusiveRedBlackTreeRoot, IntrusiveRedBlackTreeNode, entry);
private: private:
/* Define accessors using RB_* functions. */ // Define accessors using RB_* functions.
constexpr void InitializeImpl() { constexpr void InitializeImpl() {
RB_INIT(&this->root); RB_INIT(&this->root);
} }
@ -174,12 +158,12 @@ public:
return RB_PREV(IntrusiveRedBlackTreeRoot, nullptr, node); return RB_PREV(IntrusiveRedBlackTreeRoot, nullptr, node);
} }
static IntrusiveRedBlackTreeNode const* GetNext(IntrusiveRedBlackTreeNode const* node) { static IntrusiveRedBlackTreeNode const* GetNext(const IntrusiveRedBlackTreeNode* node) {
return static_cast<const IntrusiveRedBlackTreeNode*>( return static_cast<const IntrusiveRedBlackTreeNode*>(
GetNext(const_cast<IntrusiveRedBlackTreeNode*>(node))); GetNext(const_cast<IntrusiveRedBlackTreeNode*>(node)));
} }
static IntrusiveRedBlackTreeNode const* GetPrev(IntrusiveRedBlackTreeNode const* node) { static IntrusiveRedBlackTreeNode const* GetPrev(const IntrusiveRedBlackTreeNode* node) {
return static_cast<const IntrusiveRedBlackTreeNode*>( return static_cast<const IntrusiveRedBlackTreeNode*>(
GetPrev(const_cast<IntrusiveRedBlackTreeNode*>(node))); GetPrev(const_cast<IntrusiveRedBlackTreeNode*>(node)));
} }
@ -189,7 +173,7 @@ public:
this->InitializeImpl(); this->InitializeImpl();
} }
/* Iterator accessors. */ // Iterator accessors.
iterator begin() { iterator begin() {
return iterator(this->GetMinImpl()); return iterator(this->GetMinImpl());
} }
@ -222,7 +206,7 @@ public:
return const_iterator(&ref); return const_iterator(&ref);
} }
/* Content management. */ // Content management.
bool empty() const { bool empty() const {
return this->EmptyImpl(); return this->EmptyImpl();
} }
@ -273,8 +257,7 @@ consteval auto* GetLightCompareType() {
} // namespace impl } // namespace impl
template <typename T, typename Default> template <typename T, typename Default>
using LightCompareType = using LightCompareType = std::remove_pointer_t<decltype(impl::GetLightCompareType<T, Default>())>;
typename std::remove_pointer<decltype(impl::GetLightCompareType<T, Default>())>::type;
template <class T, class Traits, class Comparator> template <class T, class Traits, class Comparator>
class IntrusiveRedBlackTree { class IntrusiveRedBlackTree {
@ -283,7 +266,7 @@ public:
using ImplType = impl::IntrusiveRedBlackTreeImpl; using ImplType = impl::IntrusiveRedBlackTreeImpl;
private: private:
ImplType impl; ImplType impl{};
public: public:
struct IntrusiveRedBlackTreeRootWithCompare : ImplType::IntrusiveRedBlackTreeRoot {}; struct IntrusiveRedBlackTreeRootWithCompare : ImplType::IntrusiveRedBlackTreeRoot {};
@ -311,27 +294,25 @@ public:
friend class IntrusiveRedBlackTree<T, Traits, Comparator>; friend class IntrusiveRedBlackTree<T, Traits, Comparator>;
using ImplIterator = using ImplIterator =
typename std::conditional<Const, ImplType::const_iterator, ImplType::iterator>::type; std::conditional_t<Const, ImplType::const_iterator, ImplType::iterator>;
using iterator_category = std::bidirectional_iterator_tag; using iterator_category = std::bidirectional_iterator_tag;
using value_type = typename IntrusiveRedBlackTree::value_type; using value_type = typename IntrusiveRedBlackTree::value_type;
using difference_type = typename IntrusiveRedBlackTree::difference_type; using difference_type = typename IntrusiveRedBlackTree::difference_type;
using pointer = typename std::conditional<Const, IntrusiveRedBlackTree::const_pointer, using pointer = std::conditional_t<Const, IntrusiveRedBlackTree::const_pointer,
IntrusiveRedBlackTree::pointer>::type; IntrusiveRedBlackTree::pointer>;
using reference = typename std::conditional<Const, IntrusiveRedBlackTree::const_reference, using reference = std::conditional_t<Const, IntrusiveRedBlackTree::const_reference,
IntrusiveRedBlackTree::reference>::type; IntrusiveRedBlackTree::reference>;
private: private:
ImplIterator iterator; ImplIterator iterator;
private: private:
explicit Iterator(ImplIterator it) : iterator(it) { /* ... */ explicit Iterator(ImplIterator it) : iterator(it) {}
}
explicit Iterator(typename std::conditional<Const, ImplType::const_iterator, explicit Iterator(typename std::conditional<Const, ImplType::const_iterator,
ImplType::iterator>::type::pointer ptr) ImplType::iterator>::type::pointer ptr)
: iterator(ptr) { /* ... */ : iterator(ptr) {}
}
ImplIterator GetImplIterator() const { ImplIterator GetImplIterator() const {
return this->iterator; return this->iterator;
@ -382,7 +363,7 @@ public:
}; };
private: private:
/* Generate static implementations for comparison operations for IntrusiveRedBlackTreeRoot. */ // Generate static implementations for comparison operations for IntrusiveRedBlackTreeRoot.
RB_GENERATE_WITH_COMPARE_STATIC(IntrusiveRedBlackTreeRootWithCompare, IntrusiveRedBlackTreeNode, RB_GENERATE_WITH_COMPARE_STATIC(IntrusiveRedBlackTreeRootWithCompare, IntrusiveRedBlackTreeNode,
entry, CompareImpl, LightCompareImpl); entry, CompareImpl, LightCompareImpl);
@ -396,14 +377,14 @@ private:
return Comparator::Compare(*static_cast<const_light_pointer>(elm), *Traits::GetParent(rhs)); return Comparator::Compare(*static_cast<const_light_pointer>(elm), *Traits::GetParent(rhs));
} }
/* Define accessors using RB_* functions. */ // Define accessors using RB_* functions.
IntrusiveRedBlackTreeNode* InsertImpl(IntrusiveRedBlackTreeNode* node) { IntrusiveRedBlackTreeNode* InsertImpl(IntrusiveRedBlackTreeNode* node) {
return RB_INSERT(IntrusiveRedBlackTreeRootWithCompare, return RB_INSERT(IntrusiveRedBlackTreeRootWithCompare,
static_cast<IntrusiveRedBlackTreeRootWithCompare*>(&this->impl.root), static_cast<IntrusiveRedBlackTreeRootWithCompare*>(&this->impl.root),
node); node);
} }
IntrusiveRedBlackTreeNode* FindImpl(IntrusiveRedBlackTreeNode const* node) const { IntrusiveRedBlackTreeNode* FindImpl(const IntrusiveRedBlackTreeNode* node) const {
return RB_FIND( return RB_FIND(
IntrusiveRedBlackTreeRootWithCompare, IntrusiveRedBlackTreeRootWithCompare,
const_cast<IntrusiveRedBlackTreeRootWithCompare*>( const_cast<IntrusiveRedBlackTreeRootWithCompare*>(
@ -411,7 +392,7 @@ private:
const_cast<IntrusiveRedBlackTreeNode*>(node)); const_cast<IntrusiveRedBlackTreeNode*>(node));
} }
IntrusiveRedBlackTreeNode* NFindImpl(IntrusiveRedBlackTreeNode const* node) const { IntrusiveRedBlackTreeNode* NFindImpl(const IntrusiveRedBlackTreeNode* node) const {
return RB_NFIND( return RB_NFIND(
IntrusiveRedBlackTreeRootWithCompare, IntrusiveRedBlackTreeRootWithCompare,
const_cast<IntrusiveRedBlackTreeRootWithCompare*>( const_cast<IntrusiveRedBlackTreeRootWithCompare*>(
@ -436,10 +417,9 @@ private:
} }
public: public:
constexpr IntrusiveRedBlackTree() : impl() { /* ... */ constexpr IntrusiveRedBlackTree() = default;
}
/* Iterator accessors. */ // Iterator accessors.
iterator begin() { iterator begin() {
return iterator(this->impl.begin()); return iterator(this->impl.begin());
} }
@ -472,7 +452,7 @@ public:
return const_iterator(this->impl.iterator_to(*Traits::GetNode(std::addressof(ref)))); return const_iterator(this->impl.iterator_to(*Traits::GetNode(std::addressof(ref))));
} }
/* Content management. */ // Content management.
bool empty() const { bool empty() const {
return this->impl.empty(); return this->impl.empty();
} }
@ -548,12 +528,12 @@ private:
return GetParentPointer<Member, Derived>(node); return GetParentPointer<Member, Derived>(node);
} }
static constexpr Derived const* GetParent(IntrusiveRedBlackTreeNode const* node) { static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
return GetParentPointer<Member, Derived>(node); return GetParentPointer<Member, Derived>(node);
} }
private: private:
static constexpr TYPED_STORAGE(Derived) DerivedStorage = {}; static constexpr TypedStorage<Derived> DerivedStorage = {};
static_assert(GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage)); static_assert(GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage));
}; };
@ -569,7 +549,7 @@ public:
using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl; using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl;
static constexpr bool IsValid() { static constexpr bool IsValid() {
TYPED_STORAGE(Derived) DerivedStorage = {}; TypedStorage<Derived> DerivedStorage = {};
return GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage); return GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage);
} }
@ -591,7 +571,7 @@ private:
return GetParentPointer<Member, Derived>(node); return GetParentPointer<Member, Derived>(node);
} }
static constexpr Derived const* GetParent(IntrusiveRedBlackTreeNode const* node) { static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
return GetParentPointer<Member, Derived>(node); return GetParentPointer<Member, Derived>(node);
} }
}; };
@ -639,7 +619,7 @@ private:
return static_cast<Derived*>(node); return static_cast<Derived*>(node);
} }
static constexpr Derived const* GetParent(IntrusiveRedBlackTreeNode const* node) { static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
return static_cast<const Derived*>(node); return static_cast<const Derived*>(node);
} }
}; };

View File

@ -1,18 +1,6 @@
/* // Copyright 2021 yuzu Emulator Project
* Copyright (c) 2018-2020 Atmosphère-NX // Licensed under GPLv2 or any later version
* // Refer to the license.txt file included.
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
@ -22,22 +10,24 @@
#include "common/common_types.h" #include "common/common_types.h"
namespace Common { namespace Common {
namespace detail {
template <typename T, size_t Size, size_t Align> template <typename T, size_t Size, size_t Align>
struct TypedStorage { struct TypedStorageImpl {
typename std::aligned_storage<Size, Align>::type _storage; std::aligned_storage_t<Size, Align> storage_;
}; };
} // namespace detail
#define TYPED_STORAGE(...) TypedStorage<__VA_ARGS__, sizeof(__VA_ARGS__), alignof(__VA_ARGS__)>
template <typename T> template <typename T>
static constexpr T* GetPointer(TYPED_STORAGE(T) & ts) { using TypedStorage = detail::TypedStorageImpl<T, sizeof(T), alignof(T)>;
return static_cast<T*>(static_cast<void*>(std::addressof(ts._storage)));
template <typename T>
static constexpr T* GetPointer(TypedStorage<T>& ts) {
return static_cast<T*>(static_cast<void*>(std::addressof(ts.storage_)));
} }
template <typename T> template <typename T>
static constexpr const T* GetPointer(const TYPED_STORAGE(T) & ts) { static constexpr const T* GetPointer(const TypedStorage<T>& ts) {
return static_cast<const T*>(static_cast<const void*>(std::addressof(ts._storage))); return static_cast<const T*>(static_cast<const void*>(std::addressof(ts.storage_)));
} }
namespace impl { namespace impl {
@ -73,8 +63,7 @@ struct OffsetOfUnionHolder {
}; };
template <typename ParentType, typename MemberType> template <typename ParentType, typename MemberType>
union UnionImpl<ParentType, MemberType, MaxDepth> { /* Empty ... */ union UnionImpl<ParentType, MemberType, MaxDepth> {};
};
}; };
template <typename ParentType, typename MemberType> template <typename ParentType, typename MemberType>
@ -83,13 +72,11 @@ struct OffsetOfCalculator {
typename OffsetOfUnionHolder<sizeof(MemberType)>::template UnionImpl<ParentType, MemberType, typename OffsetOfUnionHolder<sizeof(MemberType)>::template UnionImpl<ParentType, MemberType,
0>; 0>;
union Union { union Union {
char c; char c{};
UnionHolder first_union; UnionHolder first_union;
TYPED_STORAGE(ParentType) parent; TypedStorage<ParentType> parent;
/* This coerces the active member to be c. */ constexpr Union() : c() {}
constexpr Union() : c() { /* ... */
}
}; };
static constexpr Union U = {}; static constexpr Union U = {};

View File

@ -71,15 +71,8 @@ public:
} }
void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override { void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
switch (exception) {
case Dynarmic::A32::Exception::UndefinedInstruction:
case Dynarmic::A32::Exception::UnpredictableInstruction:
break;
case Dynarmic::A32::Exception::Breakpoint:
break;
}
LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})", LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
static_cast<std::size_t>(exception), pc, MemoryReadCode(pc)); exception, pc, MemoryReadCode(pc));
UNIMPLEMENTED(); UNIMPLEMENTED();
} }

View File

@ -67,18 +67,18 @@ public:
virtual void Refresh() = 0; virtual void Refresh() = 0;
virtual bool HasEntry(u64 title_id, ContentRecordType type) const = 0; virtual bool HasEntry(u64 title_id, ContentRecordType type) const = 0;
virtual bool HasEntry(ContentProviderEntry entry) const; bool HasEntry(ContentProviderEntry entry) const;
virtual std::optional<u32> GetEntryVersion(u64 title_id) const = 0; virtual std::optional<u32> GetEntryVersion(u64 title_id) const = 0;
virtual VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const = 0; virtual VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const = 0;
virtual VirtualFile GetEntryUnparsed(ContentProviderEntry entry) const; VirtualFile GetEntryUnparsed(ContentProviderEntry entry) const;
virtual VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const = 0; virtual VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const = 0;
virtual VirtualFile GetEntryRaw(ContentProviderEntry entry) const; VirtualFile GetEntryRaw(ContentProviderEntry entry) const;
virtual std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const = 0; virtual std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const = 0;
virtual std::unique_ptr<NCA> GetEntry(ContentProviderEntry entry) const; std::unique_ptr<NCA> GetEntry(ContentProviderEntry entry) const;
virtual std::vector<ContentProviderEntry> ListEntries() const; virtual std::vector<ContentProviderEntry> ListEntries() const;

View File

@ -1,10 +1,7 @@
// Copyright 2020 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
// This file references various implementation details from Atmosphere, an open-source firmware for
// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
#include "core/arm/exclusive_monitor.h" #include "core/arm/exclusive_monitor.h"
#include "core/core.h" #include "core/core.h"
#include "core/hle/kernel/k_address_arbiter.h" #include "core/hle/kernel/k_address_arbiter.h"
@ -18,7 +15,8 @@
namespace Kernel { namespace Kernel {
KAddressArbiter::KAddressArbiter(Core::System& system) : system{system}, kernel{system.Kernel()} {} KAddressArbiter::KAddressArbiter(Core::System& system_)
: system{system_}, kernel{system.Kernel()} {}
KAddressArbiter::~KAddressArbiter() = default; KAddressArbiter::~KAddressArbiter() = default;
namespace { namespace {
@ -278,6 +276,7 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
cur_thread->SetAddressArbiter(std::addressof(thread_tree), addr); cur_thread->SetAddressArbiter(std::addressof(thread_tree), addr);
thread_tree.insert(*cur_thread); thread_tree.insert(*cur_thread);
cur_thread->SetState(ThreadState::Waiting); cur_thread->SetState(ThreadState::Waiting);
cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Arbitration);
} }
// Cancel the timer wait. // Cancel the timer wait.
@ -341,6 +340,7 @@ ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
cur_thread->SetAddressArbiter(std::addressof(thread_tree), addr); cur_thread->SetAddressArbiter(std::addressof(thread_tree), addr);
thread_tree.insert(*cur_thread); thread_tree.insert(*cur_thread);
cur_thread->SetState(ThreadState::Waiting); cur_thread->SetState(ThreadState::Waiting);
cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Arbitration);
} }
// Cancel the timer wait. // Cancel the timer wait.

View File

@ -1,10 +1,7 @@
// Copyright 2020 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
// This file references various implementation details from Atmosphere, an open-source firmware for
// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
#pragma once #pragma once
#include "common/assert.h" #include "common/assert.h"
@ -26,7 +23,7 @@ class KAddressArbiter {
public: public:
using ThreadTree = KConditionVariable::ThreadTree; using ThreadTree = KConditionVariable::ThreadTree;
explicit KAddressArbiter(Core::System& system); explicit KAddressArbiter(Core::System& system_);
~KAddressArbiter(); ~KAddressArbiter();
[[nodiscard]] ResultCode SignalToAddress(VAddr addr, Svc::SignalType type, s32 value, [[nodiscard]] ResultCode SignalToAddress(VAddr addr, Svc::SignalType type, s32 value,

View File

@ -1,10 +1,7 @@
// Copyright 2020 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
// This file references various implementation details from Atmosphere, an open-source firmware for
// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
#include <vector> #include <vector>
#include "core/arm/exclusive_monitor.h" #include "core/arm/exclusive_monitor.h"
@ -63,8 +60,8 @@ bool UpdateLockAtomic(Core::System& system, u32* out, VAddr address, u32 if_zero
} // namespace } // namespace
KConditionVariable::KConditionVariable(Core::System& system) KConditionVariable::KConditionVariable(Core::System& system_)
: system{system}, kernel{system.Kernel()} {} : system{system_}, kernel{system.Kernel()} {}
KConditionVariable::~KConditionVariable() = default; KConditionVariable::~KConditionVariable() = default;
@ -136,6 +133,7 @@ ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 val
cur_thread->SetAddressKey(addr, value); cur_thread->SetAddressKey(addr, value);
owner_thread->AddWaiter(cur_thread); owner_thread->AddWaiter(cur_thread);
cur_thread->SetState(ThreadState::Waiting); cur_thread->SetState(ThreadState::Waiting);
cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::ConditionVar);
cur_thread->SetMutexWaitAddressForDebugging(addr); cur_thread->SetMutexWaitAddressForDebugging(addr);
} }
} }
@ -318,6 +316,7 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
// If the timeout is non-zero, set the thread as waiting. // If the timeout is non-zero, set the thread as waiting.
if (timeout != 0) { if (timeout != 0) {
cur_thread->SetState(ThreadState::Waiting); cur_thread->SetState(ThreadState::Waiting);
cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::ConditionVar);
cur_thread->SetMutexWaitAddressForDebugging(addr); cur_thread->SetMutexWaitAddressForDebugging(addr);
} }
} }

View File

@ -1,10 +1,7 @@
// Copyright 2020 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
// This file references various implementation details from Atmosphere, an open-source firmware for
// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
#pragma once #pragma once
#include "common/assert.h" #include "common/assert.h"
@ -25,7 +22,7 @@ class KConditionVariable {
public: public:
using ThreadTree = typename Thread::ConditionVariableThreadTreeType; using ThreadTree = typename Thread::ConditionVariableThreadTreeType;
explicit KConditionVariable(Core::System& system); explicit KConditionVariable(Core::System& system_);
~KConditionVariable(); ~KConditionVariable();
// Arbitration // Arbitration

View File

@ -1,10 +1,7 @@
// Copyright 2020 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
// This file references various implementation details from Atmosphere, an open-source firmware for
// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
#include "common/assert.h" #include "common/assert.h"
#include "common/common_types.h" #include "common/common_types.h"
#include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/k_scheduler.h"
@ -75,12 +72,13 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,
} }
// For debugging only // For debugging only
thread->SetWaitObjectsForDebugging(objects, num_objects); thread->SetWaitObjectsForDebugging({objects, static_cast<std::size_t>(num_objects)});
// Mark the thread as waiting. // Mark the thread as waiting.
thread->SetCancellable(); thread->SetCancellable();
thread->SetSyncedObject(nullptr, Svc::ResultTimedOut); thread->SetSyncedObject(nullptr, Svc::ResultTimedOut);
thread->SetState(ThreadState::Waiting); thread->SetState(ThreadState::Waiting);
thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Synchronization);
} }
// The lock/sleep is done, so we should be able to get our result. // The lock/sleep is done, so we should be able to get our result.
@ -89,7 +87,7 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,
thread->ClearCancellable(); thread->ClearCancellable();
// For debugging only // For debugging only
thread->SetWaitObjectsForDebugging(nullptr, 0); thread->SetWaitObjectsForDebugging({});
// Cancel the timer as needed. // Cancel the timer as needed.
if (timer != InvalidHandle) { if (timer != InvalidHandle) {

View File

@ -1,10 +1,7 @@
// Copyright 2020 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
// This file references various implementation details from Atmosphere, an open-source firmware for
// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
#pragma once #pragma once
#include <vector> #include <vector>

View File

@ -605,6 +605,8 @@ void KernelCore::Suspend(bool in_suspention) {
const auto state = should_suspend ? ThreadState::Runnable : ThreadState::Waiting; const auto state = should_suspend ? ThreadState::Runnable : ThreadState::Waiting;
for (std::size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { for (std::size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
impl->suspend_threads[i]->SetState(state); impl->suspend_threads[i]->SetState(state);
impl->suspend_threads[i]->SetWaitReasonForDebugging(
ThreadWaitReasonForDebugging::Suspended);
} }
} }
} }

View File

@ -301,7 +301,7 @@ public:
void LoadModule(CodeSet code_set, VAddr base_addr); void LoadModule(CodeSet code_set, VAddr base_addr);
virtual bool IsSignaled() const override; bool IsSignaled() const override;
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
// Thread-local storage management // Thread-local storage management

View File

@ -45,7 +45,7 @@ public:
void Signal(); void Signal();
virtual bool IsSignaled() const override; bool IsSignaled() const override;
private: private:
explicit ReadableEvent(KernelCore& kernel); explicit ReadableEvent(KernelCore& kernel);

View File

@ -79,7 +79,7 @@ public:
/// waiting to be accepted by this port. /// waiting to be accepted by this port.
void AppendPendingSession(std::shared_ptr<ServerSession> pending_session); void AppendPendingSession(std::shared_ptr<ServerSession> pending_session);
virtual bool IsSignaled() const override; bool IsSignaled() const override;
private: private:
/// ServerSessions waiting to be accepted by the port /// ServerSessions waiting to be accepted by the port

View File

@ -124,7 +124,7 @@ public:
convert_to_domain = true; convert_to_domain = true;
} }
virtual bool IsSignaled() const override; bool IsSignaled() const override;
private: private:
/// Queues a sync request from the emulated application. /// Queues a sync request from the emulated application.

View File

@ -347,6 +347,7 @@ static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
{ {
KScopedSchedulerLock lock(kernel); KScopedSchedulerLock lock(kernel);
thread->SetState(ThreadState::Waiting); thread->SetState(ThreadState::Waiting);
thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);
session->SendSyncRequest(SharedFrom(thread), system.Memory(), system.CoreTiming()); session->SendSyncRequest(SharedFrom(thread), system.Memory(), system.CoreTiming());
} }

View File

@ -215,7 +215,10 @@ VAddr Thread::GetCommandBufferAddress() const {
void Thread::SetState(ThreadState state) { void Thread::SetState(ThreadState state) {
KScopedSchedulerLock sl(kernel); KScopedSchedulerLock sl(kernel);
SetMutexWaitAddressForDebugging(0); // Clear debugging state
SetMutexWaitAddressForDebugging({});
SetWaitReasonForDebugging({});
const ThreadState old_state = thread_state; const ThreadState old_state = thread_state;
thread_state = thread_state =
static_cast<ThreadState>((old_state & ~ThreadState::Mask) | (state & ThreadState::Mask)); static_cast<ThreadState>((old_state & ~ThreadState::Mask) | (state & ThreadState::Mask));
@ -386,6 +389,7 @@ ResultCode Thread::Sleep(s64 nanoseconds) {
{ {
KScopedSchedulerLockAndSleep lock(kernel, event_handle, this, nanoseconds); KScopedSchedulerLockAndSleep lock(kernel, event_handle, this, nanoseconds);
SetState(ThreadState::Waiting); SetState(ThreadState::Waiting);
SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Sleep);
} }
if (event_handle != InvalidHandle) { if (event_handle != InvalidHandle) {

View File

@ -6,6 +6,7 @@
#include <array> #include <array>
#include <functional> #include <functional>
#include <span>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
@ -113,6 +114,16 @@ enum class ThreadSchedFlags : u32 {
KernelInitPauseFlag = 1 << 8, KernelInitPauseFlag = 1 << 8,
}; };
enum class ThreadWaitReasonForDebugging : u32 {
None, ///< Thread is not waiting
Sleep, ///< Thread is waiting due to a SleepThread SVC
IPC, ///< Thread is waiting for the reply from an IPC request
Synchronization, ///< Thread is waiting due to a WaitSynchronization SVC
ConditionVar, ///< Thread is waiting due to a WaitProcessWideKey SVC
Arbitration, ///< Thread is waiting due to a SignalToAddress/WaitForAddress SVC
Suspended, ///< Thread is waiting due to process suspension
};
class Thread final : public KSynchronizationObject, public boost::intrusive::list_base_hook<> { class Thread final : public KSynchronizationObject, public boost::intrusive::list_base_hook<> {
friend class KScheduler; friend class KScheduler;
friend class Process; friend class Process;
@ -514,11 +525,19 @@ public:
disable_count--; disable_count--;
} }
void SetWaitObjectsForDebugging(KSynchronizationObject** objects, s32 num_objects) { void SetWaitReasonForDebugging(ThreadWaitReasonForDebugging reason) {
wait_reason_for_debugging = reason;
}
[[nodiscard]] ThreadWaitReasonForDebugging GetWaitReasonForDebugging() const {
return wait_reason_for_debugging;
}
void SetWaitObjectsForDebugging(const std::span<KSynchronizationObject*>& objects) {
wait_objects_for_debugging.clear(); wait_objects_for_debugging.clear();
wait_objects_for_debugging.reserve(num_objects); wait_objects_for_debugging.reserve(objects.size());
for (auto i = 0; i < num_objects; ++i) { for (const auto& object : objects) {
wait_objects_for_debugging.emplace_back(objects[i]); wait_objects_for_debugging.emplace_back(object);
} }
} }
@ -548,11 +567,11 @@ public:
return address_key_value; return address_key_value;
} }
[[nodiscard]] void SetAddressKey(VAddr key) { void SetAddressKey(VAddr key) {
address_key = key; address_key = key;
} }
[[nodiscard]] void SetAddressKey(VAddr key, u32 val) { void SetAddressKey(VAddr key, u32 val) {
address_key = key; address_key = key;
address_key_value = val; address_key_value = val;
} }
@ -560,11 +579,11 @@ public:
private: private:
static constexpr size_t PriorityInheritanceCountMax = 10; static constexpr size_t PriorityInheritanceCountMax = 10;
union SyncObjectBuffer { union SyncObjectBuffer {
std::array<KSynchronizationObject*, Svc::ArgumentHandleCountMax> sync_objects; std::array<KSynchronizationObject*, Svc::ArgumentHandleCountMax> sync_objects{};
std::array<Handle, std::array<Handle,
Svc::ArgumentHandleCountMax*(sizeof(KSynchronizationObject*) / sizeof(Handle))> Svc::ArgumentHandleCountMax*(sizeof(KSynchronizationObject*) / sizeof(Handle))>
handles; handles;
constexpr SyncObjectBuffer() : sync_objects() {} constexpr SyncObjectBuffer() {}
}; };
static_assert(sizeof(SyncObjectBuffer::sync_objects) == sizeof(SyncObjectBuffer::handles)); static_assert(sizeof(SyncObjectBuffer::sync_objects) == sizeof(SyncObjectBuffer::handles));
@ -707,6 +726,9 @@ private:
/// The current mutex wait address. This is used for debugging only. /// The current mutex wait address. This is used for debugging only.
VAddr mutex_wait_address_for_debugging{}; VAddr mutex_wait_address_for_debugging{};
/// The reason the thread is waiting. This is used for debugging only.
ThreadWaitReasonForDebugging wait_reason_for_debugging{};
KSynchronizationObject* signaling_object; KSynchronizationObject* signaling_object;
ResultCode signaling_result{RESULT_SUCCESS}; ResultCode signaling_result{RESULT_SUCCESS};

View File

@ -56,7 +56,7 @@ APM::APM(Core::System& system_, std::shared_ptr<Module> apm_, Controller& contro
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &APM::OpenSession, "OpenSession"}, {0, &APM::OpenSession, "OpenSession"},
{1, &APM::GetPerformanceMode, "GetPerformanceMode"}, {1, &APM::GetPerformanceMode, "GetPerformanceMode"},
{6, nullptr, "IsCpuOverclockEnabled"}, {6, &APM::IsCpuOverclockEnabled, "IsCpuOverclockEnabled"},
}; };
RegisterHandlers(functions); RegisterHandlers(functions);
} }
@ -78,6 +78,14 @@ void APM::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
rb.PushEnum(controller.GetCurrentPerformanceMode()); rb.PushEnum(controller.GetCurrentPerformanceMode());
} }
void APM::IsCpuOverclockEnabled(Kernel::HLERequestContext& ctx) {
LOG_WARNING(Service_APM, "(STUBBED) called");
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(RESULT_SUCCESS);
rb.Push(false);
}
APM_Sys::APM_Sys(Core::System& system_, Controller& controller_) APM_Sys::APM_Sys(Core::System& system_, Controller& controller_)
: ServiceFramework{system_, "apm:sys"}, controller{controller_} { : ServiceFramework{system_, "apm:sys"}, controller{controller_} {
// clang-format off // clang-format off

View File

@ -20,6 +20,7 @@ public:
private: private:
void OpenSession(Kernel::HLERequestContext& ctx); void OpenSession(Kernel::HLERequestContext& ctx);
void GetPerformanceMode(Kernel::HLERequestContext& ctx); void GetPerformanceMode(Kernel::HLERequestContext& ctx);
void IsCpuOverclockEnabled(Kernel::HLERequestContext& ctx);
std::shared_ptr<Module> apm; std::shared_ptr<Module> apm;
Controller& controller; Controller& controller;

View File

@ -34,8 +34,7 @@ NvResult nvhost_nvdec::Ioctl1(Ioctl command, const std::vector<u8>& input,
case 0xa: { case 0xa: {
if (command.length == 0x1c) { if (command.length == 0x1c) {
LOG_INFO(Service_NVDRV, "NVDEC video stream ended"); LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
Tegra::ChCommandHeaderList cmdlist(1); Tegra::ChCommandHeaderList cmdlist{{0xDEADB33F}};
cmdlist[0] = Tegra::ChCommandHeader{0xDEADB33F};
system.GPU().PushCommandBuffer(cmdlist); system.GPU().PushCommandBuffer(cmdlist);
system.GPU().MemoryManager().InvalidateQueuedCaches(); system.GPU().MemoryManager().InvalidateQueuedCaches();
} }

View File

@ -29,8 +29,13 @@ NvResult nvhost_vic::Ioctl1(Ioctl command, const std::vector<u8>& input, std::ve
return GetWaitbase(input, output); return GetWaitbase(input, output);
case 0x9: case 0x9:
return MapBuffer(input, output); return MapBuffer(input, output);
case 0xa: case 0xa: {
if (command.length == 0x1c) {
Tegra::ChCommandHeaderList cmdlist{{0xDEADB33F}};
system.GPU().PushCommandBuffer(cmdlist);
}
return UnmapBuffer(input, output); return UnmapBuffer(input, output);
}
default: default:
break; break;
} }

View File

@ -180,9 +180,11 @@ u32 BufferQueue::Query(QueryType type) {
switch (type) { switch (type) {
case QueryType::NativeWindowFormat: case QueryType::NativeWindowFormat:
return static_cast<u32>(PixelFormat::RGBA8888); return static_cast<u32>(PixelFormat::RGBA8888);
case QueryType::NativeWindowWidth:
case QueryType::NativeWindowHeight:
break;
} }
UNIMPLEMENTED_MSG("Unimplemented query type={}", type);
UNIMPLEMENTED();
return 0; return 0;
} }

View File

@ -6,7 +6,6 @@ add_executable(tests
common/ring_buffer.cpp common/ring_buffer.cpp
core/core_timing.cpp core/core_timing.cpp
tests.cpp tests.cpp
video_core/buffer_base.cpp
) )
create_target_directory_groups(tests) create_target_directory_groups(tests)

View File

@ -20,60 +20,60 @@ TEST_CASE("RingBuffer: Basic Tests", "[common]") {
for (std::size_t i = 0; i < 4; i++) { for (std::size_t i = 0; i < 4; i++) {
const char elem = static_cast<char>(i); const char elem = static_cast<char>(i);
const std::size_t count = buf.Push(&elem, 1); const std::size_t count = buf.Push(&elem, 1);
REQUIRE(count == 1); REQUIRE(count == 1U);
} }
REQUIRE(buf.Size() == 4); REQUIRE(buf.Size() == 4U);
// Pushing values into a full ring buffer should fail. // Pushing values into a full ring buffer should fail.
{ {
const char elem = static_cast<char>(42); const char elem = static_cast<char>(42);
const std::size_t count = buf.Push(&elem, 1); const std::size_t count = buf.Push(&elem, 1);
REQUIRE(count == 0); REQUIRE(count == 0U);
} }
REQUIRE(buf.Size() == 4); REQUIRE(buf.Size() == 4U);
// Popping multiple values from a ring buffer with values should succeed. // Popping multiple values from a ring buffer with values should succeed.
{ {
const std::vector<char> popped = buf.Pop(2); const std::vector<char> popped = buf.Pop(2);
REQUIRE(popped.size() == 2); REQUIRE(popped.size() == 2U);
REQUIRE(popped[0] == 0); REQUIRE(popped[0] == 0);
REQUIRE(popped[1] == 1); REQUIRE(popped[1] == 1);
} }
REQUIRE(buf.Size() == 2); REQUIRE(buf.Size() == 2U);
// Popping a single value from a ring buffer with values should succeed. // Popping a single value from a ring buffer with values should succeed.
{ {
const std::vector<char> popped = buf.Pop(1); const std::vector<char> popped = buf.Pop(1);
REQUIRE(popped.size() == 1); REQUIRE(popped.size() == 1U);
REQUIRE(popped[0] == 2); REQUIRE(popped[0] == 2);
} }
REQUIRE(buf.Size() == 1); REQUIRE(buf.Size() == 1U);
// Pushing more values than space available should partially suceed. // Pushing more values than space available should partially suceed.
{ {
std::vector<char> to_push(6); std::vector<char> to_push(6);
std::iota(to_push.begin(), to_push.end(), 88); std::iota(to_push.begin(), to_push.end(), 88);
const std::size_t count = buf.Push(to_push); const std::size_t count = buf.Push(to_push);
REQUIRE(count == 3); REQUIRE(count == 3U);
} }
REQUIRE(buf.Size() == 4); REQUIRE(buf.Size() == 4U);
// Doing an unlimited pop should pop all values. // Doing an unlimited pop should pop all values.
{ {
const std::vector<char> popped = buf.Pop(); const std::vector<char> popped = buf.Pop();
REQUIRE(popped.size() == 4); REQUIRE(popped.size() == 4U);
REQUIRE(popped[0] == 3); REQUIRE(popped[0] == 3);
REQUIRE(popped[1] == 88); REQUIRE(popped[1] == 88);
REQUIRE(popped[2] == 89); REQUIRE(popped[2] == 89);
REQUIRE(popped[3] == 90); REQUIRE(popped[3] == 90);
} }
REQUIRE(buf.Size() == 0); REQUIRE(buf.Size() == 0U);
} }
TEST_CASE("RingBuffer: Threaded Test", "[common]") { TEST_CASE("RingBuffer: Threaded Test", "[common]") {
@ -93,7 +93,7 @@ TEST_CASE("RingBuffer: Threaded Test", "[common]") {
std::size_t i = 0; std::size_t i = 0;
while (i < count) { while (i < count) {
if (const std::size_t c = buf.Push(&value[0], 1); c > 0) { if (const std::size_t c = buf.Push(&value[0], 1); c > 0) {
REQUIRE(c == 1); REQUIRE(c == 1U);
i++; i++;
next_value(value); next_value(value);
} else { } else {
@ -108,7 +108,7 @@ TEST_CASE("RingBuffer: Threaded Test", "[common]") {
std::size_t i = 0; std::size_t i = 0;
while (i < count) { while (i < count) {
if (const std::vector<char> v = buf.Pop(1); v.size() > 0) { if (const std::vector<char> v = buf.Pop(1); v.size() > 0) {
REQUIRE(v.size() == 2); REQUIRE(v.size() == 2U);
REQUIRE(v[0] == value[0]); REQUIRE(v[0] == value[0]);
REQUIRE(v[1] == value[1]); REQUIRE(v[1] == value[1]);
i++; i++;
@ -123,7 +123,7 @@ TEST_CASE("RingBuffer: Threaded Test", "[common]") {
producer.join(); producer.join();
consumer.join(); consumer.join();
REQUIRE(buf.Size() == 0); REQUIRE(buf.Size() == 0U);
printf("RingBuffer: Threaded Test: full: %zu, empty: %zu\n", full, empty); printf("RingBuffer: Threaded Test: full: %zu, empty: %zu\n", full, empty);
} }

View File

@ -1,7 +1,6 @@
add_subdirectory(host_shaders) add_subdirectory(host_shaders)
add_library(video_core STATIC add_library(video_core STATIC
buffer_cache/buffer_base.h
buffer_cache/buffer_block.h buffer_cache/buffer_block.h
buffer_cache/buffer_cache.h buffer_cache/buffer_cache.h
buffer_cache/map_interval.cpp buffer_cache/map_interval.cpp

View File

@ -37,59 +37,43 @@ CDmaPusher::CDmaPusher(GPU& gpu_)
CDmaPusher::~CDmaPusher() = default; CDmaPusher::~CDmaPusher() = default;
void CDmaPusher::Push(ChCommandHeaderList&& entries) { void CDmaPusher::ProcessEntries(ChCommandHeaderList&& entries) {
cdma_queue.push(std::move(entries)); for (const auto& value : entries) {
}
void CDmaPusher::DispatchCalls() {
while (!cdma_queue.empty()) {
Step();
}
}
void CDmaPusher::Step() {
const auto entries{cdma_queue.front()};
cdma_queue.pop();
std::vector<u32> values(entries.size());
std::memcpy(values.data(), entries.data(), entries.size() * sizeof(u32));
for (const u32 value : values) {
if (mask != 0) { if (mask != 0) {
const u32 lbs = Common::CountTrailingZeroes32(mask); const u32 lbs = Common::CountTrailingZeroes32(mask);
mask &= ~(1U << lbs); mask &= ~(1U << lbs);
ExecuteCommand(static_cast<u32>(offset + lbs), value); ExecuteCommand(offset + lbs, value.raw);
continue; continue;
} else if (count != 0) { } else if (count != 0) {
--count; --count;
ExecuteCommand(static_cast<u32>(offset), value); ExecuteCommand(offset, value.raw);
if (incrementing) { if (incrementing) {
++offset; ++offset;
} }
continue; continue;
} }
const auto mode = static_cast<ChSubmissionMode>((value >> 28) & 0xf); const auto mode = value.submission_mode.Value();
switch (mode) { switch (mode) {
case ChSubmissionMode::SetClass: { case ChSubmissionMode::SetClass: {
mask = value & 0x3f; mask = value.value & 0x3f;
offset = (value >> 16) & 0xfff; offset = value.method_offset;
current_class = static_cast<ChClassId>((value >> 6) & 0x3ff); current_class = static_cast<ChClassId>((value.value >> 6) & 0x3ff);
break; break;
} }
case ChSubmissionMode::Incrementing: case ChSubmissionMode::Incrementing:
case ChSubmissionMode::NonIncrementing: case ChSubmissionMode::NonIncrementing:
count = value & 0xffff; count = value.value;
offset = (value >> 16) & 0xfff; offset = value.method_offset;
incrementing = mode == ChSubmissionMode::Incrementing; incrementing = mode == ChSubmissionMode::Incrementing;
break; break;
case ChSubmissionMode::Mask: case ChSubmissionMode::Mask:
mask = value & 0xffff; mask = value.value;
offset = (value >> 16) & 0xfff; offset = value.method_offset;
break; break;
case ChSubmissionMode::Immediate: { case ChSubmissionMode::Immediate: {
const u32 data = value & 0xfff; const u32 data = value.value & 0xfff;
offset = (value >> 16) & 0xfff; offset = value.method_offset;
ExecuteCommand(static_cast<u32>(offset), data); ExecuteCommand(offset, data);
break; break;
} }
default: default:
@ -102,8 +86,8 @@ void CDmaPusher::Step() {
void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) { void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
switch (current_class) { switch (current_class) {
case ChClassId::NvDec: case ChClassId::NvDec:
ThiStateWrite(nvdec_thi_state, state_offset, {data}); ThiStateWrite(nvdec_thi_state, offset, data);
switch (static_cast<ThiMethod>(state_offset)) { switch (static_cast<ThiMethod>(offset)) {
case ThiMethod::IncSyncpt: { case ThiMethod::IncSyncpt: {
LOG_DEBUG(Service_NVDRV, "NVDEC Class IncSyncpt Method"); LOG_DEBUG(Service_NVDRV, "NVDEC Class IncSyncpt Method");
const auto syncpoint_id = static_cast<u32>(data & 0xFF); const auto syncpoint_id = static_cast<u32>(data & 0xFF);
@ -120,7 +104,7 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
LOG_DEBUG(Service_NVDRV, "NVDEC method 0x{:X}", LOG_DEBUG(Service_NVDRV, "NVDEC method 0x{:X}",
static_cast<u32>(nvdec_thi_state.method_0)); static_cast<u32>(nvdec_thi_state.method_0));
nvdec_processor->ProcessMethod(static_cast<Nvdec::Method>(nvdec_thi_state.method_0), nvdec_processor->ProcessMethod(static_cast<Nvdec::Method>(nvdec_thi_state.method_0),
{data}); data);
break; break;
default: default:
break; break;
@ -144,7 +128,7 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
case ThiMethod::SetMethod1: case ThiMethod::SetMethod1:
LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})", LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})",
static_cast<u32>(vic_thi_state.method_0), data); static_cast<u32>(vic_thi_state.method_0), data);
vic_processor->ProcessMethod(static_cast<Vic::Method>(vic_thi_state.method_0), {data}); vic_processor->ProcessMethod(static_cast<Vic::Method>(vic_thi_state.method_0), data);
break; break;
default: default:
break; break;
@ -153,7 +137,7 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
case ChClassId::Host1x: case ChClassId::Host1x:
// This device is mainly for syncpoint synchronization // This device is mainly for syncpoint synchronization
LOG_DEBUG(Service_NVDRV, "Host1X Class Method"); LOG_DEBUG(Service_NVDRV, "Host1X Class Method");
host1x_processor->ProcessMethod(static_cast<Host1x::Method>(state_offset), {data}); host1x_processor->ProcessMethod(static_cast<Host1x::Method>(offset), data);
break; break;
default: default:
UNIMPLEMENTED_MSG("Current class not implemented {:X}", static_cast<u32>(current_class)); UNIMPLEMENTED_MSG("Current class not implemented {:X}", static_cast<u32>(current_class));
@ -161,10 +145,9 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
} }
} }
void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 state_offset, void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 state_offset, u32 argument) {
const std::vector<u32>& arguments) { u8* const offset_ptr = reinterpret_cast<u8*>(&state) + sizeof(u32) * state_offset;
u8* const state_offset_ptr = reinterpret_cast<u8*>(&state) + sizeof(u32) * state_offset; std::memcpy(offset_ptr, &argument, sizeof(u32));
std::memcpy(state_offset_ptr, arguments.data(), sizeof(u32) * arguments.size());
} }
} // namespace Tegra } // namespace Tegra

View File

@ -5,9 +5,7 @@
#pragma once #pragma once
#include <memory> #include <memory>
#include <unordered_map>
#include <vector> #include <vector>
#include <queue>
#include "common/bit_field.h" #include "common/bit_field.h"
#include "common/common_types.h" #include "common/common_types.h"
@ -16,9 +14,9 @@
namespace Tegra { namespace Tegra {
class GPU; class GPU;
class Host1x;
class Nvdec; class Nvdec;
class Vic; class Vic;
class Host1x;
enum class ChSubmissionMode : u32 { enum class ChSubmissionMode : u32 {
SetClass = 0, SetClass = 0,
@ -48,16 +46,10 @@ enum class ChClassId : u32 {
NvDec = 0xf0 NvDec = 0xf0
}; };
enum class ChMethod : u32 {
Empty = 0,
SetMethod = 0x10,
SetData = 0x11,
};
union ChCommandHeader { union ChCommandHeader {
u32 raw; u32 raw;
BitField<0, 16, u32> value; BitField<0, 16, u32> value;
BitField<16, 12, ChMethod> method_offset; BitField<16, 12, u32> method_offset;
BitField<28, 4, ChSubmissionMode> submission_mode; BitField<28, 4, ChSubmissionMode> submission_mode;
}; };
static_assert(sizeof(ChCommandHeader) == sizeof(u32), "ChCommand header is an invalid size"); static_assert(sizeof(ChCommandHeader) == sizeof(u32), "ChCommand header is an invalid size");
@ -99,21 +91,15 @@ public:
explicit CDmaPusher(GPU& gpu_); explicit CDmaPusher(GPU& gpu_);
~CDmaPusher(); ~CDmaPusher();
/// Push NVDEC command buffer entries into queue /// Process the command entry
void Push(ChCommandHeaderList&& entries); void ProcessEntries(ChCommandHeaderList&& entries);
/// Process queued command buffer entries
void DispatchCalls();
/// Process one queue element
void Step();
private:
/// Invoke command class devices to execute the command based on the current state /// Invoke command class devices to execute the command based on the current state
void ExecuteCommand(u32 state_offset, u32 data); void ExecuteCommand(u32 state_offset, u32 data);
private:
/// Write arguments value to the ThiRegisters member at the specified offset /// Write arguments value to the ThiRegisters member at the specified offset
void ThiStateWrite(ThiRegisters& state, u32 state_offset, const std::vector<u32>& arguments); void ThiStateWrite(ThiRegisters& state, u32 offset, u32 argument);
GPU& gpu; GPU& gpu;
std::shared_ptr<Tegra::Nvdec> nvdec_processor; std::shared_ptr<Tegra::Nvdec> nvdec_processor;
@ -124,13 +110,10 @@ private:
ThiRegisters vic_thi_state{}; ThiRegisters vic_thi_state{};
ThiRegisters nvdec_thi_state{}; ThiRegisters nvdec_thi_state{};
s32 count{}; u32 count{};
s32 offset{}; u32 offset{};
s32 mask{}; u32 mask{};
bool incrementing{}; bool incrementing{};
// Queue of command lists to be processed
std::queue<ChCommandHeaderList> cdma_queue;
}; };
} // namespace Tegra } // namespace Tegra

View File

@ -44,8 +44,10 @@ Codec::~Codec() {
} }
void Codec::SetTargetCodec(NvdecCommon::VideoCodec codec) { void Codec::SetTargetCodec(NvdecCommon::VideoCodec codec) {
LOG_INFO(Service_NVDRV, "NVDEC video codec initialized to {}", codec); if (current_codec != codec) {
current_codec = codec; LOG_INFO(Service_NVDRV, "NVDEC video codec initialized to {}", static_cast<u32>(codec));
current_codec = codec;
}
} }
void Codec::StateWrite(u32 offset, u64 arguments) { void Codec::StateWrite(u32 offset, u64 arguments) {
@ -55,7 +57,6 @@ void Codec::StateWrite(u32 offset, u64 arguments) {
void Codec::Decode() { void Codec::Decode() {
bool is_first_frame = false; bool is_first_frame = false;
if (!initialized) { if (!initialized) {
if (current_codec == NvdecCommon::VideoCodec::H264) { if (current_codec == NvdecCommon::VideoCodec::H264) {
av_codec = avcodec_find_decoder(AV_CODEC_ID_H264); av_codec = avcodec_find_decoder(AV_CODEC_ID_H264);

View File

@ -12,16 +12,16 @@ Nvdec::Nvdec(GPU& gpu_) : gpu(gpu_), codec(std::make_unique<Codec>(gpu)) {}
Nvdec::~Nvdec() = default; Nvdec::~Nvdec() = default;
void Nvdec::ProcessMethod(Method method, const std::vector<u32>& arguments) { void Nvdec::ProcessMethod(Method method, u32 argument) {
if (method == Method::SetVideoCodec) { if (method == Method::SetVideoCodec) {
codec->StateWrite(static_cast<u32>(method), arguments[0]); codec->StateWrite(static_cast<u32>(method), argument);
} else { } else {
codec->StateWrite(static_cast<u32>(method), static_cast<u64>(arguments[0]) << 8); codec->StateWrite(static_cast<u32>(method), static_cast<u64>(argument) << 8);
} }
switch (method) { switch (method) {
case Method::SetVideoCodec: case Method::SetVideoCodec:
codec->SetTargetCodec(static_cast<NvdecCommon::VideoCodec>(arguments[0])); codec->SetTargetCodec(static_cast<NvdecCommon::VideoCodec>(argument));
break; break;
case Method::Execute: case Method::Execute:
Execute(); Execute();

View File

@ -23,7 +23,7 @@ public:
~Nvdec(); ~Nvdec();
/// Writes the method into the state, Invoke Execute() if encountered /// Writes the method into the state, Invoke Execute() if encountered
void ProcessMethod(Method method, const std::vector<u32>& arguments); void ProcessMethod(Method method, u32 argument);
/// Return most recently decoded frame /// Return most recently decoded frame
[[nodiscard]] AVFramePtr GetFrame(); [[nodiscard]] AVFramePtr GetFrame();

View File

@ -18,18 +18,14 @@ extern "C" {
namespace Tegra { namespace Tegra {
Vic::Vic(GPU& gpu_, std::shared_ptr<Nvdec> nvdec_processor_) Vic::Vic(GPU& gpu_, std::shared_ptr<Nvdec> nvdec_processor_)
: gpu(gpu_), nvdec_processor(std::move(nvdec_processor_)) {} : gpu(gpu_),
nvdec_processor(std::move(nvdec_processor_)), converted_frame_buffer{nullptr, av_free} {}
Vic::~Vic() = default; Vic::~Vic() = default;
void Vic::VicStateWrite(u32 offset, u32 arguments) { void Vic::ProcessMethod(Method method, u32 argument) {
u8* const state_offset = reinterpret_cast<u8*>(&vic_state) + offset * sizeof(u32); LOG_DEBUG(HW_GPU, "Vic method 0x{:X}", static_cast<u32>(method));
std::memcpy(state_offset, &arguments, sizeof(u32)); const u64 arg = static_cast<u64>(argument) << 8;
}
void Vic::ProcessMethod(Method method, const std::vector<u32>& arguments) {
LOG_DEBUG(HW_GPU, "Vic method 0x{:X}", method);
VicStateWrite(static_cast<u32>(method), arguments[0]);
const u64 arg = static_cast<u64>(arguments[0]) << 8;
switch (method) { switch (method) {
case Method::Execute: case Method::Execute:
Execute(); Execute();
@ -53,8 +49,7 @@ void Vic::ProcessMethod(Method method, const std::vector<u32>& arguments) {
void Vic::Execute() { void Vic::Execute() {
if (output_surface_luma_address == 0) { if (output_surface_luma_address == 0) {
LOG_ERROR(Service_NVDRV, "VIC Luma address not set. Received 0x{:X}", LOG_ERROR(Service_NVDRV, "VIC Luma address not set.");
vic_state.output_surface.luma_offset);
return; return;
} }
const VicConfig config{gpu.MemoryManager().Read<u64>(config_struct_address + 0x20)}; const VicConfig config{gpu.MemoryManager().Read<u64>(config_struct_address + 0x20)};
@ -89,8 +84,10 @@ void Vic::Execute() {
// Get Converted frame // Get Converted frame
const std::size_t linear_size = frame->width * frame->height * 4; const std::size_t linear_size = frame->width * frame->height * 4;
using AVMallocPtr = std::unique_ptr<u8, decltype(&av_free)>; // Only allocate frame_buffer once per stream, as the size is not expected to change
AVMallocPtr converted_frame_buffer{static_cast<u8*>(av_malloc(linear_size)), av_free}; if (!converted_frame_buffer) {
converted_frame_buffer = AVMallocPtr{static_cast<u8*>(av_malloc(linear_size)), av_free};
}
const int converted_stride{frame->width * 4}; const int converted_stride{frame->width * 4};
u8* const converted_frame_buf_addr{converted_frame_buffer.get()}; u8* const converted_frame_buf_addr{converted_frame_buffer.get()};
@ -104,12 +101,12 @@ void Vic::Execute() {
const u32 block_height = static_cast<u32>(config.block_linear_height_log2); const u32 block_height = static_cast<u32>(config.block_linear_height_log2);
const auto size = Tegra::Texture::CalculateSize(true, 4, frame->width, frame->height, 1, const auto size = Tegra::Texture::CalculateSize(true, 4, frame->width, frame->height, 1,
block_height, 0); block_height, 0);
std::vector<u8> swizzled_data(size); luma_buffer.resize(size);
Tegra::Texture::SwizzleSubrect(frame->width, frame->height, frame->width * 4, Tegra::Texture::SwizzleSubrect(frame->width, frame->height, frame->width * 4,
frame->width, 4, swizzled_data.data(), frame->width, 4, luma_buffer.data(),
converted_frame_buffer.get(), block_height, 0, 0); converted_frame_buffer.get(), block_height, 0, 0);
gpu.MemoryManager().WriteBlock(output_surface_luma_address, swizzled_data.data(), size); gpu.MemoryManager().WriteBlock(output_surface_luma_address, luma_buffer.data(), size);
gpu.Maxwell3D().OnMemoryWrite(); gpu.Maxwell3D().OnMemoryWrite();
} else { } else {
// send pitch linear frame // send pitch linear frame
@ -134,15 +131,15 @@ void Vic::Execute() {
const auto stride = frame->linesize[0]; const auto stride = frame->linesize[0];
const auto half_stride = frame->linesize[1]; const auto half_stride = frame->linesize[1];
std::vector<u8> luma_buffer(aligned_width * surface_height); luma_buffer.resize(aligned_width * surface_height);
std::vector<u8> chroma_buffer(aligned_width * half_height); chroma_buffer.resize(aligned_width * half_height);
// Populate luma buffer // Populate luma buffer
for (std::size_t y = 0; y < surface_height - 1; ++y) { for (std::size_t y = 0; y < surface_height - 1; ++y) {
std::size_t src = y * stride; const std::size_t src = y * stride;
std::size_t dst = y * aligned_width; const std::size_t dst = y * aligned_width;
std::size_t size = surface_width; const std::size_t size = surface_width;
for (std::size_t offset = 0; offset < size; ++offset) { for (std::size_t offset = 0; offset < size; ++offset) {
luma_buffer[dst + offset] = luma_ptr[src + offset]; luma_buffer[dst + offset] = luma_ptr[src + offset];
@ -153,8 +150,8 @@ void Vic::Execute() {
// Populate chroma buffer from both channels with interleaving. // Populate chroma buffer from both channels with interleaving.
for (std::size_t y = 0; y < half_height; ++y) { for (std::size_t y = 0; y < half_height; ++y) {
std::size_t src = y * half_stride; const std::size_t src = y * half_stride;
std::size_t dst = y * aligned_width; const std::size_t dst = y * aligned_width;
for (std::size_t x = 0; x < half_width; ++x) { for (std::size_t x = 0; x < half_width; ++x) {
chroma_buffer[dst + x * 2] = chroma_b_ptr[src + x]; chroma_buffer[dst + x * 2] = chroma_b_ptr[src + x];

View File

@ -15,43 +15,6 @@ namespace Tegra {
class GPU; class GPU;
class Nvdec; class Nvdec;
struct PlaneOffsets {
u32 luma_offset{};
u32 chroma_u_offset{};
u32 chroma_v_offset{};
};
struct VicRegisters {
INSERT_PADDING_WORDS(64);
u32 nop{};
INSERT_PADDING_WORDS(15);
u32 pm_trigger{};
INSERT_PADDING_WORDS(47);
u32 set_application_id{};
u32 set_watchdog_timer{};
INSERT_PADDING_WORDS(17);
u32 context_save_area{};
u32 context_switch{};
INSERT_PADDING_WORDS(43);
u32 execute{};
INSERT_PADDING_WORDS(63);
std::array<std::array<PlaneOffsets, 8>, 8> surfacex_slots{};
u32 picture_index{};
u32 control_params{};
u32 config_struct_offset{};
u32 filter_struct_offset{};
u32 palette_offset{};
u32 hist_offset{};
u32 context_id{};
u32 fce_ucode_size{};
PlaneOffsets output_surface{};
u32 fce_ucode_offset{};
INSERT_PADDING_WORDS(4);
std::array<u32, 8> slot_context_id{};
INSERT_PADDING_WORDS(16);
};
static_assert(sizeof(VicRegisters) == 0x7A0, "VicRegisters is an invalid size");
class Vic { class Vic {
public: public:
enum class Method : u32 { enum class Method : u32 {
@ -67,14 +30,11 @@ public:
~Vic(); ~Vic();
/// Write to the device state. /// Write to the device state.
void ProcessMethod(Method method, const std::vector<u32>& arguments); void ProcessMethod(Method method, u32 argument);
private: private:
void Execute(); void Execute();
void VicStateWrite(u32 offset, u32 arguments);
VicRegisters vic_state{};
enum class VideoPixelFormat : u64_le { enum class VideoPixelFormat : u64_le {
RGBA8 = 0x1f, RGBA8 = 0x1f,
BGRA8 = 0x20, BGRA8 = 0x20,
@ -88,8 +48,6 @@ private:
BitField<9, 2, u64_le> chroma_loc_vert; BitField<9, 2, u64_le> chroma_loc_vert;
BitField<11, 4, u64_le> block_linear_kind; BitField<11, 4, u64_le> block_linear_kind;
BitField<15, 4, u64_le> block_linear_height_log2; BitField<15, 4, u64_le> block_linear_height_log2;
BitField<19, 3, u64_le> reserved0;
BitField<22, 10, u64_le> reserved1;
BitField<32, 14, u64_le> surface_width_minus1; BitField<32, 14, u64_le> surface_width_minus1;
BitField<46, 14, u64_le> surface_height_minus1; BitField<46, 14, u64_le> surface_height_minus1;
}; };
@ -97,6 +55,13 @@ private:
GPU& gpu; GPU& gpu;
std::shared_ptr<Tegra::Nvdec> nvdec_processor; std::shared_ptr<Tegra::Nvdec> nvdec_processor;
/// Avoid reallocation of the following buffers every frame, as their
/// size does not change during a stream
using AVMallocPtr = std::unique_ptr<u8, decltype(&av_free)>;
AVMallocPtr converted_frame_buffer;
std::vector<u8> luma_buffer;
std::vector<u8> chroma_buffer;
GPUVAddr config_struct_address{}; GPUVAddr config_struct_address{};
GPUVAddr output_surface_luma_address{}; GPUVAddr output_surface_luma_address{};
GPUVAddr output_surface_chroma_u_address{}; GPUVAddr output_surface_chroma_u_address{};

View File

@ -30,8 +30,7 @@ MICROPROFILE_DEFINE(GPU_wait, "GPU", "Wait for the GPU", MP_RGB(128, 128, 192));
GPU::GPU(Core::System& system_, bool is_async_, bool use_nvdec_) GPU::GPU(Core::System& system_, bool is_async_, bool use_nvdec_)
: system{system_}, memory_manager{std::make_unique<Tegra::MemoryManager>(system)}, : system{system_}, memory_manager{std::make_unique<Tegra::MemoryManager>(system)},
dma_pusher{std::make_unique<Tegra::DmaPusher>(system, *this)}, dma_pusher{std::make_unique<Tegra::DmaPusher>(system, *this)}, use_nvdec{use_nvdec_},
cdma_pusher{std::make_unique<Tegra::CDmaPusher>(*this)}, use_nvdec{use_nvdec_},
maxwell_3d{std::make_unique<Engines::Maxwell3D>(system, *memory_manager)}, maxwell_3d{std::make_unique<Engines::Maxwell3D>(system, *memory_manager)},
fermi_2d{std::make_unique<Engines::Fermi2D>()}, fermi_2d{std::make_unique<Engines::Fermi2D>()},
kepler_compute{std::make_unique<Engines::KeplerCompute>(system, *memory_manager)}, kepler_compute{std::make_unique<Engines::KeplerCompute>(system, *memory_manager)},
@ -494,8 +493,7 @@ void GPU::PushCommandBuffer(Tegra::ChCommandHeaderList& entries) {
// TODO(ameerj): RE proper async nvdec operation // TODO(ameerj): RE proper async nvdec operation
// gpu_thread.SubmitCommandBuffer(std::move(entries)); // gpu_thread.SubmitCommandBuffer(std::move(entries));
cdma_pusher->Push(std::move(entries)); cdma_pusher->ProcessEntries(std::move(entries));
cdma_pusher->DispatchCalls();
} }
void GPU::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) { void GPU::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {

View File

@ -47,8 +47,7 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
dma_pusher.DispatchCalls(); dma_pusher.DispatchCalls();
} else if (auto* command_list = std::get_if<SubmitChCommandEntries>(&next.data)) { } else if (auto* command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
// NVDEC // NVDEC
cdma_pusher.Push(std::move(command_list->entries)); cdma_pusher.ProcessEntries(std::move(command_list->entries));
cdma_pusher.DispatchCalls();
} else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) { } else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr); renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
} else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) { } else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {

View File

@ -475,7 +475,7 @@ bool GRenderWindow::TouchStart(const QTouchEvent::TouchPoint& touch_point) {
bool GRenderWindow::TouchUpdate(const QTouchEvent::TouchPoint& touch_point) { bool GRenderWindow::TouchUpdate(const QTouchEvent::TouchPoint& touch_point) {
for (std::size_t id = 0; id < touch_ids.size(); ++id) { for (std::size_t id = 0; id < touch_ids.size(); ++id) {
if (touch_ids[id] == touch_point.id() + 1) { if (touch_ids[id] == static_cast<std::size_t>(touch_point.id() + 1)) {
const auto [x, y] = ScaleTouch(touch_point.pos()); const auto [x, y] = ScaleTouch(touch_point.pos());
this->TouchMoved(x, y, id + 1); this->TouchMoved(x, y, id + 1);
return true; return true;
@ -486,8 +486,9 @@ bool GRenderWindow::TouchUpdate(const QTouchEvent::TouchPoint& touch_point) {
bool GRenderWindow::TouchExist(std::size_t id, bool GRenderWindow::TouchExist(std::size_t id,
const QList<QTouchEvent::TouchPoint>& touch_points) const { const QList<QTouchEvent::TouchPoint>& touch_points) const {
return std::any_of(touch_points.begin(), touch_points.end(), return std::any_of(touch_points.begin(), touch_points.end(), [id](const auto& point) {
[id](const auto& point) { return id == point.id() + 1; }); return id == static_cast<std::size_t>(point.id() + 1);
});
} }
bool GRenderWindow::event(QEvent* event) { bool GRenderWindow::event(QEvent* event) {

View File

@ -508,7 +508,7 @@ void Config::ReadControlValues() {
Settings::values.emulate_analog_keyboard = Settings::values.emulate_analog_keyboard =
ReadSetting(QStringLiteral("emulate_analog_keyboard"), false).toBool(); ReadSetting(QStringLiteral("emulate_analog_keyboard"), false).toBool();
ReadSettingGlobal(Settings::values.use_docked_mode, QStringLiteral("use_docked_mode"), false); ReadSettingGlobal(Settings::values.use_docked_mode, QStringLiteral("use_docked_mode"), true);
ReadSettingGlobal(Settings::values.vibration_enabled, QStringLiteral("vibration_enabled"), ReadSettingGlobal(Settings::values.vibration_enabled, QStringLiteral("vibration_enabled"),
true); true);
ReadSettingGlobal(Settings::values.enable_accurate_vibrations, ReadSettingGlobal(Settings::values.enable_accurate_vibrations,
@ -1168,7 +1168,7 @@ void Config::SaveControlValues() {
SaveTouchscreenValues(); SaveTouchscreenValues();
SaveMotionTouchValues(); SaveMotionTouchValues();
WriteSettingGlobal(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode, false); WriteSettingGlobal(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode, true);
WriteSettingGlobal(QStringLiteral("vibration_enabled"), Settings::values.vibration_enabled, WriteSettingGlobal(QStringLiteral("vibration_enabled"), Settings::values.vibration_enabled,
true); true);
WriteSettingGlobal(QStringLiteral("enable_accurate_vibrations"), WriteSettingGlobal(QStringLiteral("enable_accurate_vibrations"),

View File

@ -51,6 +51,8 @@ CalibrationConfigurationDialog::CalibrationConfigurationDialog(QWidget* parent,
case CalibrationConfigurationJob::Status::Completed: case CalibrationConfigurationJob::Status::Completed:
text = tr("Configuration completed!"); text = tr("Configuration completed!");
break; break;
default:
break;
} }
QMetaObject::invokeMethod(this, "UpdateLabelText", Q_ARG(QString, text)); QMetaObject::invokeMethod(this, "UpdateLabelText", Q_ARG(QString, text));
if (status == CalibrationConfigurationJob::Status::Completed) { if (status == CalibrationConfigurationJob::Status::Completed) {
@ -163,8 +165,9 @@ void ConfigureMotionTouch::ConnectEvents() {
} }
void ConfigureMotionTouch::OnUDPAddServer() { void ConfigureMotionTouch::OnUDPAddServer() {
QRegExp re(tr(R"re(^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4]" // Validator for IP address
"[0-9]|[01]?[0-9][0-9]?)$)re")); // a valid ip address QRegExp re(QStringLiteral(
R"re(^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$)re"));
bool ok; bool ok;
QString port_text = ui->udp_port->text(); QString port_text = ui->udp_port->text();
QString server_text = ui->udp_server->text(); QString server_text = ui->udp_server->text();

View File

@ -251,7 +251,29 @@ QString WaitTreeThread::GetText() const {
} }
break; break;
case Kernel::ThreadState::Waiting: case Kernel::ThreadState::Waiting:
status = tr("waiting"); switch (thread.GetWaitReasonForDebugging()) {
case Kernel::ThreadWaitReasonForDebugging::Sleep:
status = tr("sleeping");
break;
case Kernel::ThreadWaitReasonForDebugging::IPC:
status = tr("waiting for IPC reply");
break;
case Kernel::ThreadWaitReasonForDebugging::Synchronization:
status = tr("waiting for objects");
break;
case Kernel::ThreadWaitReasonForDebugging::ConditionVar:
status = tr("waiting for condition variable");
break;
case Kernel::ThreadWaitReasonForDebugging::Arbitration:
status = tr("waiting for address arbiter");
break;
case Kernel::ThreadWaitReasonForDebugging::Suspended:
status = tr("waiting for suspend resume");
break;
default:
status = tr("waiting");
break;
}
break; break;
case Kernel::ThreadState::Initialized: case Kernel::ThreadState::Initialized:
status = tr("initialized"); status = tr("initialized");
@ -259,6 +281,9 @@ QString WaitTreeThread::GetText() const {
case Kernel::ThreadState::Terminated: case Kernel::ThreadState::Terminated:
status = tr("terminated"); status = tr("terminated");
break; break;
default:
status = tr("unknown");
break;
} }
const auto& context = thread.GetContext64(); const auto& context = thread.GetContext64();
@ -285,7 +310,20 @@ QColor WaitTreeThread::GetColor() const {
return QColor(WaitTreeColors[2][color_index]); return QColor(WaitTreeColors[2][color_index]);
} }
case Kernel::ThreadState::Waiting: case Kernel::ThreadState::Waiting:
return QColor(WaitTreeColors[3][color_index]); switch (thread.GetWaitReasonForDebugging()) {
case Kernel::ThreadWaitReasonForDebugging::IPC:
return QColor(WaitTreeColors[4][color_index]);
case Kernel::ThreadWaitReasonForDebugging::Sleep:
return QColor(WaitTreeColors[5][color_index]);
case Kernel::ThreadWaitReasonForDebugging::Synchronization:
case Kernel::ThreadWaitReasonForDebugging::ConditionVar:
case Kernel::ThreadWaitReasonForDebugging::Arbitration:
case Kernel::ThreadWaitReasonForDebugging::Suspended:
return QColor(WaitTreeColors[6][color_index]);
break;
default:
return QColor(WaitTreeColors[3][color_index]);
}
case Kernel::ThreadState::Initialized: case Kernel::ThreadState::Initialized:
return QColor(WaitTreeColors[7][color_index]); return QColor(WaitTreeColors[7][color_index]);
case Kernel::ThreadState::Terminated: case Kernel::ThreadState::Terminated:
@ -336,7 +374,9 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
list.push_back(std::make_unique<WaitTreeText>(tr("not waiting for mutex"))); list.push_back(std::make_unique<WaitTreeText>(tr("not waiting for mutex")));
} }
if (thread.GetState() == Kernel::ThreadState::Waiting) { if (thread.GetState() == Kernel::ThreadState::Waiting &&
thread.GetWaitReasonForDebugging() ==
Kernel::ThreadWaitReasonForDebugging::Synchronization) {
list.push_back(std::make_unique<WaitTreeObjectList>(thread.GetWaitObjectsForDebugging(), list.push_back(std::make_unique<WaitTreeObjectList>(thread.GetWaitObjectsForDebugging(),
thread.IsCancellable())); thread.IsCancellable()));
} }

View File

@ -22,6 +22,8 @@ void UrlRequestInterceptor::interceptRequest(QWebEngineUrlRequestInfo& info) {
case QWebEngineUrlRequestInfo::ResourceTypeXhr: case QWebEngineUrlRequestInfo::ResourceTypeXhr:
emit FrameChanged(); emit FrameChanged();
break; break;
default:
break;
} }
} }

View File

@ -340,7 +340,7 @@ void Config::ReadValues() {
// System // System
Settings::values.use_docked_mode.SetValue( Settings::values.use_docked_mode.SetValue(
sdl2_config->GetBoolean("System", "use_docked_mode", false)); sdl2_config->GetBoolean("System", "use_docked_mode", true));
Settings::values.current_user = std::clamp<int>( Settings::values.current_user = std::clamp<int>(
sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1); sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);

View File

@ -274,7 +274,7 @@ gamecard_path =
[System] [System]
# Whether the system is docked # Whether the system is docked
# 1: Yes, 0 (default): No # 1 (default): Yes, 0: No
use_docked_mode = use_docked_mode =
# Allow the use of NFC in games # Allow the use of NFC in games

View File

@ -95,8 +95,6 @@ int main(int argc, char** argv) {
int option_index = 0; int option_index = 0;
InitializeLogging(); InitializeLogging();
char* endarg;
#ifdef _WIN32 #ifdef _WIN32
int argc_w; int argc_w;
auto argv_w = CommandLineToArgvW(GetCommandLineW(), &argc_w); auto argv_w = CommandLineToArgvW(GetCommandLineW(), &argc_w);

View File

@ -84,7 +84,7 @@ void Config::ReadValues() {
Settings::values.touchscreen.diameter_y = 15; Settings::values.touchscreen.diameter_y = 15;
Settings::values.use_docked_mode.SetValue( Settings::values.use_docked_mode.SetValue(
sdl2_config->GetBoolean("Controls", "use_docked_mode", false)); sdl2_config->GetBoolean("Controls", "use_docked_mode", true));
// Data Storage // Data Storage
Settings::values.use_virtual_sd = Settings::values.use_virtual_sd =

View File

@ -116,7 +116,7 @@ use_virtual_sd =
[System] [System]
# Whether the system is docked # Whether the system is docked
# 1: Yes, 0 (default): No # 1 (default): Yes, 0: No
use_docked_mode = use_docked_mode =
# Allow the use of NFC in games # Allow the use of NFC in games