vector_math: Remove unimplemented function prototypes

externals/mbedtls: Update to mbedtls v2.12.0

externals/CMakeLists.txt

@@ -36,7 +36,7 @@ add_subdirectory(lz4/contrib/cmake_unofficial)
 target_include_directories(lz4_static INTERFACE ./lz4/lib)
 
 # mbedtls
-add_subdirectory(mbedtls)
+add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
 target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 
 # MicroProfile
@@ -62,5 +62,5 @@ target_include_directories(opus INTERFACE ./opus/include)
 # Cubeb
 if(ENABLE_CUBEB)
     set(BUILD_TESTS OFF CACHE BOOL "")
-    add_subdirectory(cubeb)
+    add_subdirectory(cubeb EXCLUDE_FROM_ALL)
 endif()

src/audio_core/CMakeLists.txt

@@ -4,8 +4,6 @@ add_library(audio_core STATIC
     audio_renderer.cpp
     audio_renderer.h
     buffer.h
-    cubeb_sink.cpp
-    cubeb_sink.h
     codec.cpp
     codec.h
     null_sink.h
@@ -15,6 +13,8 @@ add_library(audio_core STATIC
     sink_details.cpp
     sink_details.h
     sink_stream.h
+
+    $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
 )
 
 create_target_directory_groups(audio_core)

src/common/logging/backend.cpp

@@ -200,6 +200,7 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, SPL)                                                                              \
     SUB(Service, SSL)                                                                              \
     SUB(Service, Time)                                                                             \
+    SUB(Service, USB)                                                                              \
     SUB(Service, VI)                                                                               \
     SUB(Service, WLAN)                                                                             \
     CLS(HW)                                                                                        \

src/common/logging/log.h

@@ -87,6 +87,7 @@ enum class Class : ClassType {
     Service_SPL,       ///< The SPL service
     Service_SSL,       ///< The SSL service
     Service_Time,      ///< The time service
+    Service_USB,       ///< The USB (Universal Serial Bus) service
     Service_VI,        ///< The VI (Video interface) service
     Service_WLAN,      ///< The WLAN (Wireless local area network) service
     HW,                ///< Low-level hardware emulation

src/common/vector_math.h

@@ -42,140 +42,136 @@ class Vec3;
 template <typename T>
 class Vec4;
 
-template <typename T>
-static inline Vec2<T> MakeVec(const T& x, const T& y);
-template <typename T>
-static inline Vec3<T> MakeVec(const T& x, const T& y, const T& z);
-template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w);
-
 template <typename T>
 class Vec2 {
 public:
     T x{};
     T y{};
 
-    Vec2() = default;
-    Vec2(const T& _x, const T& _y) : x(_x), y(_y) {}
+    constexpr Vec2() = default;
+    constexpr Vec2(const T& x_, const T& y_) : x(x_), y(y_) {}
 
     template <typename T2>
-    Vec2<T2> Cast() const {
-        return Vec2<T2>((T2)x, (T2)y);
+    constexpr Vec2<T2> Cast() const {
+        return Vec2<T2>(static_cast<T2>(x), static_cast<T2>(y));
     }
 
-    static Vec2 AssignToAll(const T& f) {
-        return Vec2<T>(f, f);
+    static constexpr Vec2 AssignToAll(const T& f) {
+        return Vec2{f, f};
     }
 
-    Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
-        return MakeVec(x + other.x, y + other.y);
+    constexpr Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
+        return {x + other.x, y + other.y};
     }
-    void operator+=(const Vec2& other) {
+    constexpr Vec2& operator+=(const Vec2& other) {
         x += other.x;
         y += other.y;
+        return *this;
     }
-    Vec2<decltype(T{} - T{})> operator-(const Vec2& other) const {
-        return MakeVec(x - other.x, y - other.y);
+    constexpr Vec2<decltype(T{} - T{})> operator-(const Vec2& other) const {
+        return {x - other.x, y - other.y};
     }
-    void operator-=(const Vec2& other) {
+    constexpr Vec2& operator-=(const Vec2& other) {
         x -= other.x;
         y -= other.y;
+        return *this;
     }
 
     template <typename U = T>
-    Vec2<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
-        return MakeVec(-x, -y);
+    constexpr Vec2<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
+        return {-x, -y};
     }
-    Vec2<decltype(T{} * T{})> operator*(const Vec2& other) const {
-        return MakeVec(x * other.x, y * other.y);
-    }
-    template <typename V>
-    Vec2<decltype(T{} * V{})> operator*(const V& f) const {
-        return MakeVec(x * f, y * f);
-    }
-    template <typename V>
-    void operator*=(const V& f) {
-        *this = *this * f;
-    }
-    template <typename V>
-    Vec2<decltype(T{} / V{})> operator/(const V& f) const {
-        return MakeVec(x / f, y / f);
-    }
-    template <typename V>
-    void operator/=(const V& f) {
-        *this = *this / f;
+    constexpr Vec2<decltype(T{} * T{})> operator*(const Vec2& other) const {
+        return {x * other.x, y * other.y};
     }
 
-    T Length2() const {
+    template <typename V>
+    constexpr Vec2<decltype(T{} * V{})> operator*(const V& f) const {
+        return {x * f, y * f};
+    }
+
+    template <typename V>
+    constexpr Vec2& operator*=(const V& f) {
+        *this = *this * f;
+        return *this;
+    }
+
+    template <typename V>
+    constexpr Vec2<decltype(T{} / V{})> operator/(const V& f) const {
+        return {x / f, y / f};
+    }
+
+    template <typename V>
+    constexpr Vec2& operator/=(const V& f) {
+        *this = *this / f;
+        return *this;
+    }
+
+    constexpr T Length2() const {
         return x * x + y * y;
     }
 
     // Only implemented for T=float
     float Length() const;
-    void SetLength(const float l);
-    Vec2 WithLength(const float l) const;
-    float Distance2To(Vec2& other);
-    Vec2 Normalized() const;
     float Normalize(); // returns the previous length, which is often useful
 
-    T& operator[](int i) // allow vector[1] = 3   (vector.y=3)
-    {
+    constexpr T& operator[](std::size_t i) {
         return *((&x) + i);
     }
-    T operator[](const int i) const {
+    constexpr const T& operator[](std::size_t i) const {
         return *((&x) + i);
     }
 
-    void SetZero() {
+    constexpr void SetZero() {
         x = 0;
         y = 0;
     }
 
     // Common aliases: UV (texel coordinates), ST (texture coordinates)
-    T& u() {
+    constexpr T& u() {
         return x;
     }
-    T& v() {
+    constexpr T& v() {
         return y;
     }
-    T& s() {
+    constexpr T& s() {
         return x;
     }
-    T& t() {
+    constexpr T& t() {
         return y;
     }
 
-    const T& u() const {
+    constexpr const T& u() const {
         return x;
     }
-    const T& v() const {
+    constexpr const T& v() const {
         return y;
     }
-    const T& s() const {
+    constexpr const T& s() const {
         return x;
     }
-    const T& t() const {
+    constexpr const T& t() const {
         return y;
     }
 
     // swizzlers - create a subvector of specific components
-    const Vec2 yx() const {
+    constexpr Vec2 yx() const {
         return Vec2(y, x);
     }
-    const Vec2 vu() const {
+    constexpr Vec2 vu() const {
         return Vec2(y, x);
     }
-    const Vec2 ts() const {
+    constexpr Vec2 ts() const {
         return Vec2(y, x);
     }
 };
 
 template <typename T, typename V>
-Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
+constexpr Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
     return Vec2<T>(f * vec.x, f * vec.y);
 }
 
-typedef Vec2<float> Vec2f;
+using Vec2f = Vec2<float>;
 
 template <>
 inline float Vec2<float>::Length() const {
@@ -196,147 +192,151 @@ public:
     T y{};
     T z{};
 
-    Vec3() = default;
-    Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) {}
+    constexpr Vec3() = default;
+    constexpr Vec3(const T& x_, const T& y_, const T& z_) : x(x_), y(y_), z(z_) {}
 
     template <typename T2>
-    Vec3<T2> Cast() const {
-        return MakeVec<T2>((T2)x, (T2)y, (T2)z);
+    constexpr Vec3<T2> Cast() const {
+        return Vec3<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z));
     }
 
-    // Only implemented for T=int and T=float
-    static Vec3 FromRGB(unsigned int rgb);
-    unsigned int ToRGB() const; // alpha bits set to zero
-
-    static Vec3 AssignToAll(const T& f) {
-        return MakeVec(f, f, f);
+    static constexpr Vec3 AssignToAll(const T& f) {
+        return Vec3(f, f, f);
     }
 
-    Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
-        return MakeVec(x + other.x, y + other.y, z + other.z);
+    constexpr Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
+        return {x + other.x, y + other.y, z + other.z};
     }
-    void operator+=(const Vec3& other) {
+
+    constexpr Vec3& operator+=(const Vec3& other) {
         x += other.x;
         y += other.y;
         z += other.z;
+        return *this;
     }
-    Vec3<decltype(T{} - T{})> operator-(const Vec3& other) const {
-        return MakeVec(x - other.x, y - other.y, z - other.z);
+
+    constexpr Vec3<decltype(T{} - T{})> operator-(const Vec3& other) const {
+        return {x - other.x, y - other.y, z - other.z};
     }
-    void operator-=(const Vec3& other) {
+
+    constexpr Vec3& operator-=(const Vec3& other) {
         x -= other.x;
         y -= other.y;
         z -= other.z;
+        return *this;
     }
 
     template <typename U = T>
-    Vec3<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
-        return MakeVec(-x, -y, -z);
-    }
-    Vec3<decltype(T{} * T{})> operator*(const Vec3& other) const {
-        return MakeVec(x * other.x, y * other.y, z * other.z);
-    }
-    template <typename V>
-    Vec3<decltype(T{} * V{})> operator*(const V& f) const {
-        return MakeVec(x * f, y * f, z * f);
-    }
-    template <typename V>
-    void operator*=(const V& f) {
-        *this = *this * f;
-    }
-    template <typename V>
-    Vec3<decltype(T{} / V{})> operator/(const V& f) const {
-        return MakeVec(x / f, y / f, z / f);
-    }
-    template <typename V>
-    void operator/=(const V& f) {
-        *this = *this / f;
+    constexpr Vec3<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
+        return {-x, -y, -z};
     }
 
-    T Length2() const {
+    constexpr Vec3<decltype(T{} * T{})> operator*(const Vec3& other) const {
+        return {x * other.x, y * other.y, z * other.z};
+    }
+
+    template <typename V>
+    constexpr Vec3<decltype(T{} * V{})> operator*(const V& f) const {
+        return {x * f, y * f, z * f};
+    }
+
+    template <typename V>
+    constexpr Vec3& operator*=(const V& f) {
+        *this = *this * f;
+        return *this;
+    }
+    template <typename V>
+    constexpr Vec3<decltype(T{} / V{})> operator/(const V& f) const {
+        return {x / f, y / f, z / f};
+    }
+
+    template <typename V>
+    constexpr Vec3& operator/=(const V& f) {
+        *this = *this / f;
+        return *this;
+    }
+
+    constexpr T Length2() const {
         return x * x + y * y + z * z;
     }
 
     // Only implemented for T=float
     float Length() const;
-    void SetLength(const float l);
-    Vec3 WithLength(const float l) const;
-    float Distance2To(Vec3& other);
     Vec3 Normalized() const;
     float Normalize(); // returns the previous length, which is often useful
 
-    T& operator[](int i) // allow vector[2] = 3   (vector.z=3)
-    {
-        return *((&x) + i);
-    }
-    T operator[](const int i) const {
+    constexpr T& operator[](std::size_t i) {
         return *((&x) + i);
     }
 
-    void SetZero() {
+    constexpr const T& operator[](std::size_t i) const {
+        return *((&x) + i);
+    }
+
+    constexpr void SetZero() {
         x = 0;
         y = 0;
         z = 0;
     }
 
     // Common aliases: UVW (texel coordinates), RGB (colors), STQ (texture coordinates)
-    T& u() {
+    constexpr T& u() {
         return x;
     }
-    T& v() {
+    constexpr T& v() {
         return y;
     }
-    T& w() {
+    constexpr T& w() {
         return z;
     }
 
-    T& r() {
+    constexpr T& r() {
         return x;
     }
-    T& g() {
+    constexpr T& g() {
         return y;
     }
-    T& b() {
+    constexpr T& b() {
         return z;
     }
 
-    T& s() {
+    constexpr T& s() {
         return x;
     }
-    T& t() {
+    constexpr T& t() {
         return y;
     }
-    T& q() {
+    constexpr T& q() {
         return z;
     }
 
-    const T& u() const {
+    constexpr const T& u() const {
         return x;
     }
-    const T& v() const {
+    constexpr const T& v() const {
         return y;
     }
-    const T& w() const {
+    constexpr const T& w() const {
         return z;
     }
 
-    const T& r() const {
+    constexpr const T& r() const {
         return x;
     }
-    const T& g() const {
+    constexpr const T& g() const {
         return y;
     }
-    const T& b() const {
+    constexpr const T& b() const {
         return z;
     }
 
-    const T& s() const {
+    constexpr const T& s() const {
         return x;
     }
-    const T& t() const {
+    constexpr const T& t() const {
         return y;
     }
-    const T& q() const {
+    constexpr const T& q() const {
         return z;
     }
 
@@ -345,7 +345,7 @@ public:
 // _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
 // component names (x<->r) and permutations (xy<->yx)
 #define _DEFINE_SWIZZLER2(a, b, name)                                                              \
-    const Vec2<T> name() const {                                                                   \
+    constexpr Vec2<T> name() const {                                                               \
         return Vec2<T>(a, b);                                                                      \
     }
 #define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4)                                             \
@@ -366,7 +366,7 @@ public:
 };
 
 template <typename T, typename V>
-Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
+constexpr Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
     return Vec3<T>(f * vec.x, f * vec.y, f * vec.z);
 }
 
@@ -387,7 +387,7 @@ inline float Vec3<float>::Normalize() {
     return length;
 }
 
-typedef Vec3<float> Vec3f;
+using Vec3f = Vec3<float>;
 
 template <typename T>
 class Vec4 {
@@ -397,86 +397,88 @@ public:
     T z{};
     T w{};
 
-    Vec4() = default;
-    Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) {}
+    constexpr Vec4() = default;
+    constexpr Vec4(const T& x_, const T& y_, const T& z_, const T& w_)
+        : x(x_), y(y_), z(z_), w(w_) {}
 
     template <typename T2>
-    Vec4<T2> Cast() const {
-        return Vec4<T2>((T2)x, (T2)y, (T2)z, (T2)w);
+    constexpr Vec4<T2> Cast() const {
+        return Vec4<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z),
+                        static_cast<T2>(w));
     }
 
-    // Only implemented for T=int and T=float
-    static Vec4 FromRGBA(unsigned int rgba);
-    unsigned int ToRGBA() const;
-
-    static Vec4 AssignToAll(const T& f) {
-        return Vec4<T>(f, f, f, f);
+    static constexpr Vec4 AssignToAll(const T& f) {
+        return Vec4(f, f, f, f);
     }
 
-    Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
-        return MakeVec(x + other.x, y + other.y, z + other.z, w + other.w);
+    constexpr Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
+        return {x + other.x, y + other.y, z + other.z, w + other.w};
     }
-    void operator+=(const Vec4& other) {
+
+    constexpr Vec4& operator+=(const Vec4& other) {
         x += other.x;
         y += other.y;
         z += other.z;
         w += other.w;
+        return *this;
     }
-    Vec4<decltype(T{} - T{})> operator-(const Vec4& other) const {
-        return MakeVec(x - other.x, y - other.y, z - other.z, w - other.w);
+
+    constexpr Vec4<decltype(T{} - T{})> operator-(const Vec4& other) const {
+        return {x - other.x, y - other.y, z - other.z, w - other.w};
     }
-    void operator-=(const Vec4& other) {
+
+    constexpr Vec4& operator-=(const Vec4& other) {
         x -= other.x;
         y -= other.y;
         z -= other.z;
         w -= other.w;
+        return *this;
     }
 
     template <typename U = T>
-    Vec4<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
-        return MakeVec(-x, -y, -z, -w);
-    }
-    Vec4<decltype(T{} * T{})> operator*(const Vec4& other) const {
-        return MakeVec(x * other.x, y * other.y, z * other.z, w * other.w);
-    }
-    template <typename V>
-    Vec4<decltype(T{} * V{})> operator*(const V& f) const {
-        return MakeVec(x * f, y * f, z * f, w * f);
-    }
-    template <typename V>
-    void operator*=(const V& f) {
-        *this = *this * f;
-    }
-    template <typename V>
-    Vec4<decltype(T{} / V{})> operator/(const V& f) const {
-        return MakeVec(x / f, y / f, z / f, w / f);
-    }
-    template <typename V>
-    void operator/=(const V& f) {
-        *this = *this / f;
+    constexpr Vec4<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
+        return {-x, -y, -z, -w};
     }
 
-    T Length2() const {
+    constexpr Vec4<decltype(T{} * T{})> operator*(const Vec4& other) const {
+        return {x * other.x, y * other.y, z * other.z, w * other.w};
+    }
+
+    template <typename V>
+    constexpr Vec4<decltype(T{} * V{})> operator*(const V& f) const {
+        return {x * f, y * f, z * f, w * f};
+    }
+
+    template <typename V>
+    constexpr Vec4& operator*=(const V& f) {
+        *this = *this * f;
+        return *this;
+    }
+
+    template <typename V>
+    constexpr Vec4<decltype(T{} / V{})> operator/(const V& f) const {
+        return {x / f, y / f, z / f, w / f};
+    }
+
+    template <typename V>
+    constexpr Vec4& operator/=(const V& f) {
+        *this = *this / f;
+        return *this;
+    }
+
+    constexpr T Length2() const {
         return x * x + y * y + z * z + w * w;
     }
 
-    // Only implemented for T=float
-    float Length() const;
-    void SetLength(const float l);
-    Vec4 WithLength(const float l) const;
-    float Distance2To(Vec4& other);
-    Vec4 Normalized() const;
-    float Normalize(); // returns the previous length, which is often useful
-
-    T& operator[](int i) // allow vector[2] = 3   (vector.z=3)
-    {
-        return *((&x) + i);
-    }
-    T operator[](const int i) const {
+    constexpr T& operator[](std::size_t i) {
         return *((&x) + i);
     }
 
-    void SetZero() {
+    constexpr const T& operator[](std::size_t i) const {
+        return *((&x) + i);
+    }
+
+    constexpr void SetZero() {
         x = 0;
         y = 0;
         z = 0;
@@ -484,29 +486,29 @@ public:
     }
 
     // Common alias: RGBA (colors)
-    T& r() {
+    constexpr T& r() {
         return x;
     }
-    T& g() {
+    constexpr T& g() {
         return y;
     }
-    T& b() {
+    constexpr T& b() {
         return z;
     }
-    T& a() {
+    constexpr T& a() {
         return w;
     }
 
-    const T& r() const {
+    constexpr const T& r() const {
         return x;
     }
-    const T& g() const {
+    constexpr const T& g() const {
         return y;
     }
-    const T& b() const {
+    constexpr const T& b() const {
         return z;
     }
-    const T& a() const {
+    constexpr const T& a() const {
         return w;
     }
 
@@ -518,7 +520,7 @@ public:
 // DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
 // permutations (xy<->yx)
 #define _DEFINE_SWIZZLER2(a, b, name)                                                              \
-    const Vec2<T> name() const {                                                                   \
+    constexpr Vec2<T> name() const {                                                               \
         return Vec2<T>(a, b);                                                                      \
     }
 #define DEFINE_SWIZZLER2_COMP1(a, a2)                                                              \
@@ -545,7 +547,7 @@ public:
 #undef _DEFINE_SWIZZLER2
 
 #define _DEFINE_SWIZZLER3(a, b, c, name)                                                           \
-    const Vec3<T> name() const {                                                                   \
+    constexpr Vec3<T> name() const {                                                               \
         return Vec3<T>(a, b, c);                                                                   \
     }
 #define DEFINE_SWIZZLER3_COMP1(a, a2)                                                              \
@@ -579,51 +581,51 @@ public:
 };
 
 template <typename T, typename V>
-Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
-    return MakeVec(f * vec.x, f * vec.y, f * vec.z, f * vec.w);
+constexpr Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
+    return {f * vec.x, f * vec.y, f * vec.z, f * vec.w};
 }
 
-typedef Vec4<float> Vec4f;
+using Vec4f = Vec4<float>;
 
 template <typename T>
-static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec2<T>& a, const Vec2<T>& b) {
+constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec2<T>& a, const Vec2<T>& b) {
     return a.x * b.x + a.y * b.y;
 }
 
 template <typename T>
-static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec3<T>& a, const Vec3<T>& b) {
+constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec3<T>& a, const Vec3<T>& b) {
     return a.x * b.x + a.y * b.y + a.z * b.z;
 }
 
 template <typename T>
-static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec4<T>& a, const Vec4<T>& b) {
+constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec4<T>& a, const Vec4<T>& b) {
     return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
 }
 
 template <typename T>
-static inline Vec3<decltype(T{} * T{} - T{} * T{})> Cross(const Vec3<T>& a, const Vec3<T>& b) {
-    return MakeVec(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+constexpr Vec3<decltype(T{} * T{} - T{} * T{})> Cross(const Vec3<T>& a, const Vec3<T>& b) {
+    return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
 }
 
 // linear interpolation via float: 0.0=begin, 1.0=end
 template <typename X>
-static inline decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
-                                                           const float t) {
+constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
+                                                       const float t) {
     return begin * (1.f - t) + end * t;
 }
 
 // linear interpolation via int: 0=begin, base=end
 template <typename X, int base>
-static inline decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin, const X& end,
-                                                                   const int t) {
+constexpr decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin, const X& end,
+                                                               const int t) {
     return (begin * (base - t) + end * t) / base;
 }
 
 // bilinear interpolation. s is for interpolating x00-x01 and x10-x11, and t is for the second
 // interpolation.
 template <typename X>
-inline auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x11, const float s,
-                           const float t) {
+constexpr auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x11, const float s,
+                              const float t) {
     auto y0 = Lerp(x00, x01, s);
     auto y1 = Lerp(x10, x11, s);
     return Lerp(y0, y1, t);
@@ -631,42 +633,42 @@ inline auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x1
 
 // Utility vector factories
 template <typename T>
-static inline Vec2<T> MakeVec(const T& x, const T& y) {
+constexpr Vec2<T> MakeVec(const T& x, const T& y) {
     return Vec2<T>{x, y};
 }
 
 template <typename T>
-static inline Vec3<T> MakeVec(const T& x, const T& y, const T& z) {
+constexpr Vec3<T> MakeVec(const T& x, const T& y, const T& z) {
     return Vec3<T>{x, y, z};
 }
 
 template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const T& y, const Vec2<T>& zw) {
+constexpr Vec4<T> MakeVec(const T& x, const T& y, const Vec2<T>& zw) {
     return MakeVec(x, y, zw[0], zw[1]);
 }
 
 template <typename T>
-static inline Vec3<T> MakeVec(const Vec2<T>& xy, const T& z) {
+constexpr Vec3<T> MakeVec(const Vec2<T>& xy, const T& z) {
     return MakeVec(xy[0], xy[1], z);
 }
 
 template <typename T>
-static inline Vec3<T> MakeVec(const T& x, const Vec2<T>& yz) {
+constexpr Vec3<T> MakeVec(const T& x, const Vec2<T>& yz) {
     return MakeVec(x, yz[0], yz[1]);
 }
 
 template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w) {
+constexpr Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w) {
     return Vec4<T>{x, y, z, w};
 }
 
 template <typename T>
-static inline Vec4<T> MakeVec(const Vec2<T>& xy, const T& z, const T& w) {
+constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const T& z, const T& w) {
     return MakeVec(xy[0], xy[1], z, w);
 }
 
 template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
+constexpr Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
     return MakeVec(x, yz[0], yz[1], w);
 }
 
@@ -674,17 +676,17 @@ static inline Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
 //       Even if someone wanted to use an odd object like Vec2<Vec2<T>>, the compiler would error
 //       out soon enough due to misuse of the returned structure.
 template <typename T>
-static inline Vec4<T> MakeVec(const Vec2<T>& xy, const Vec2<T>& zw) {
+constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const Vec2<T>& zw) {
     return MakeVec(xy[0], xy[1], zw[0], zw[1]);
 }
 
 template <typename T>
-static inline Vec4<T> MakeVec(const Vec3<T>& xyz, const T& w) {
+constexpr Vec4<T> MakeVec(const Vec3<T>& xyz, const T& w) {
     return MakeVec(xyz[0], xyz[1], xyz[2], w);
 }
 
 template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
+constexpr Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
     return MakeVec(x, yzw[0], yzw[1], yzw[2]);
 }
 

src/core/CMakeLists.txt

@@ -315,6 +315,8 @@ add_library(core STATIC
     hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
+    hle/service/usb/usb.cpp
+    hle/service/usb/usb.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp

src/core/file_sys/content_archive.cpp

@@ -76,12 +76,17 @@ bool IsValidNCA(const NCAHeader& header) {
     return header.magic == Common::MakeMagic('N', 'C', 'A', '3');
 }
 
-boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
+u8 NCA::GetCryptoRevision() const {
     u8 master_key_id = header.crypto_type;
     if (header.crypto_type_2 > master_key_id)
         master_key_id = header.crypto_type_2;
     if (master_key_id > 0)
         --master_key_id;
+    return master_key_id;
+}
+
+boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
+    const auto master_key_id = GetCryptoRevision();
 
     if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
         return boost::none;
@@ -108,33 +113,58 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
     return out;
 }
 
-VirtualFile NCA::Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const {
+boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() const {
+    const auto master_key_id = GetCryptoRevision();
+
+    u128 rights_id{};
+    memcpy(rights_id.data(), header.rights_id.data(), 16);
+    if (rights_id == u128{})
+        return boost::none;
+
+    auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
+    if (titlekey == Core::Crypto::Key128{})
+        return boost::none;
+    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
+        keys.GetKey(Core::Crypto::S128KeyType::Titlekek, master_key_id), Core::Crypto::Mode::ECB);
+    cipher.Transcode(titlekey.data(), titlekey.size(), titlekey.data(), Core::Crypto::Op::Decrypt);
+
+    return titlekey;
+}
+
+VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) const {
     if (!encrypted)
         return in;
 
-    switch (header.raw.header.crypto_type) {
+    switch (s_header.raw.header.crypto_type) {
     case NCASectionCryptoType::NONE:
         LOG_DEBUG(Crypto, "called with mode=NONE");
         return in;
     case NCASectionCryptoType::CTR:
         LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
-            const auto key = GetKeyAreaKey(NCASectionCryptoType::CTR);
+            boost::optional<Core::Crypto::Key128> key = boost::none;
+            if (std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
+                                 [](char c) { return c == 0; }) == header.rights_id.end()) {
+                key = GetKeyAreaKey(NCASectionCryptoType::CTR);
+            } else {
+                key = GetTitlekey();
+            }
+
             if (key == boost::none)
                 return nullptr;
             auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(
                 std::move(in), key.value(), starting_offset);
             std::vector<u8> iv(16);
             for (u8 i = 0; i < 8; ++i)
-                iv[i] = header.raw.section_ctr[0x8 - i - 1];
+                iv[i] = s_header.raw.section_ctr[0x8 - i - 1];
             out->SetIV(iv);
             return std::static_pointer_cast<VfsFile>(out);
         }
     case NCASectionCryptoType::XTS:
-        // TODO(DarkLordZach): Implement XTSEncryptionLayer and title key encryption.
+        // TODO(DarkLordZach): Implement XTSEncryptionLayer.
     default:
         LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
-                  static_cast<u8>(header.raw.header.crypto_type));
+                  static_cast<u8>(s_header.raw.header.crypto_type));
         return nullptr;
     }
 }

src/core/file_sys/content_archive.h

@@ -95,7 +95,9 @@ protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
+    u8 GetCryptoRevision() const;
     boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
+    boost::optional<Core::Crypto::Key128> GetTitlekey() const;
     VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset) const;
 
     std::vector<VirtualDir> dirs;

src/core/hle/kernel/client_port.cpp

@@ -14,8 +14,8 @@
 
 namespace Kernel {
 
-ClientPort::ClientPort() {}
-ClientPort::~ClientPort() {}
+ClientPort::ClientPort() = default;
+ClientPort::~ClientPort() = default;
 
 ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     // Note: Threads do not wait for the server endpoint to call
@@ -40,4 +40,12 @@ ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     return MakeResult(std::get<SharedPtr<ClientSession>>(sessions));
 }
 
+void ClientPort::ConnectionClosed() {
+    if (active_sessions == 0) {
+        return;
+    }
+
+    --active_sessions;
+}
+
 } // namespace Kernel

src/core/hle/kernel/client_port.h

@@ -37,14 +37,20 @@ public:
      */
     ResultVal<SharedPtr<ClientSession>> Connect();
 
-    SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.
-    u32 max_sessions;    ///< Maximum number of simultaneous sessions the port can have
-    u32 active_sessions; ///< Number of currently open sessions to this port
-    std::string name;    ///< Name of client port (optional)
+    /**
+     * Signifies that a previously active connection has been closed,
+     * decreasing the total number of active connections to this port.
+     */
+    void ConnectionClosed();
 
 private:
     ClientPort();
     ~ClientPort() override;
+
+    SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.
+    u32 max_sessions = 0;    ///< Maximum number of simultaneous sessions the port can have
+    u32 active_sessions = 0; ///< Number of currently open sessions to this port
+    std::string name;        ///< Name of client port (optional)
 };
 
 } // namespace Kernel

src/core/hle/kernel/server_session.cpp

@@ -27,7 +27,7 @@ ServerSession::~ServerSession() {
 
     // Decrease the port's connection count.
     if (parent->port)
-        parent->port->active_sessions--;
+        parent->port->ConnectionClosed();
 
     // TODO(Subv): Wake up all the ClientSession's waiting threads and set
     // the SendSyncRequest result to 0xC920181A.

src/core/hle/service/apm/apm.cpp

@@ -13,6 +13,7 @@ void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module_ = std::make_shared<Module>();
     std::make_shared<APM>(module_, "apm")->InstallAsService(service_manager);
     std::make_shared<APM>(module_, "apm:p")->InstallAsService(service_manager);
+    std::make_shared<APM_Sys>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/interface.cpp

@@ -74,6 +74,31 @@ void APM::OpenSession(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
     rb.PushIpcInterface<ISession>();
+
+    LOG_DEBUG(Service_APM, "called");
+}
+
+APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "RequestPerformanceMode"},
+        {1, &APM_Sys::GetPerformanceEvent, "GetPerformanceEvent"},
+        {2, nullptr, "GetThrottlingState"},
+        {3, nullptr, "GetLastThrottlingState"},
+        {4, nullptr, "ClearLastThrottlingState"},
+        {5, nullptr, "LoadAndApplySettings"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+void APM_Sys::GetPerformanceEvent(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<ISession>();
+
+    LOG_DEBUG(Service_APM, "called");
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/interface.h

@@ -19,4 +19,12 @@ private:
     std::shared_ptr<Module> apm;
 };
 
+class APM_Sys final : public ServiceFramework<APM_Sys> {
+public:
+    explicit APM_Sys();
+
+private:
+    void GetPerformanceEvent(Kernel::HLERequestContext& ctx);
+};
+
 } // namespace Service::APM

src/core/hle/service/hid/hid.cpp

@@ -337,6 +337,7 @@ public:
              "AcquireNpadStyleSetUpdateEventHandle"},
             {107, nullptr, "DisconnectNpad"},
             {108, &Hid::GetPlayerLedPattern, "GetPlayerLedPattern"},
+            {109, nullptr, "ActivateNpadWithRevision"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
             {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -7,8 +7,8 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
+#include "video_core/gpu.h"
 #include "video_core/renderer_base.h"
-#include "video_core/video_core.h"
 
 namespace Service::Nvidia::Devices {
 

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -2,14 +2,15 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
+#include <cstring>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_as_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
+#include "video_core/memory_manager.h"
+#include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
-#include "video_core/video_core.h"
 
 namespace Service::Nvidia::Devices {
 

src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cstdlib>
+#include <cstring>
+
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl.h"

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -5,8 +5,6 @@
 #pragma once
 
 #include <array>
-#include <cstdlib>
-#include <cstring>
 #include <vector>
 #include "common/common_types.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
+#include <cstring>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -2,12 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
-#include <map>
+#include <cstring>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
+#include "core/memory.h"
+#include "video_core/gpu.h"
+#include "video_core/memory_manager.h"
 
 namespace Service::Nvidia::Devices {
 

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -6,6 +6,7 @@
 
 #include <memory>
 #include <vector>
+#include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cstring>
+
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"

src/core/hle/service/nvdrv/devices/nvhost_nvdec.h

@@ -4,11 +4,9 @@
 
 #pragma once
 
-#include <array>
-#include <cstdlib>
-#include <cstring>
 #include <vector>
 #include "common/common_types.h"
+#include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
 
 namespace Service::Nvidia::Devices {

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -3,7 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cinttypes>
+#include <cstring>
 
 #include "common/assert.h"
 #include "common/logging/log.h"

src/core/hle/service/nvdrv/interface.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <string>
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/service.h"

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -54,7 +54,7 @@ u32 Module::Open(const std::string& device_name) {
     return fd;
 }
 
-u32 Module::Ioctl(u32 fd, u32_le command, const std::vector<u8>& input, std::vector<u8>& output) {
+u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
     auto itr = open_files.find(fd);
     ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
 

src/core/hle/service/nvdrv/nvmemp.cpp

@@ -4,8 +4,6 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvdrv/nvmemp.h"
 
 namespace Service::Nvidia {

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -3,8 +3,11 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <boost/optional.hpp>
 
 #include "common/alignment.h"
+#include "common/assert.h"
+#include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
@@ -31,7 +34,7 @@ NVFlinger::NVFlinger() {
 
     // Schedule the screen composition events
     composition_event =
-        CoreTiming::RegisterEvent("ScreenCompositioin", [this](u64 userdata, int cycles_late) {
+        CoreTiming::RegisterEvent("ScreenComposition", [this](u64 userdata, int cycles_late) {
             Compose();
             CoreTiming::ScheduleEvent(frame_ticks - cycles_late, composition_event);
         });
@@ -43,7 +46,7 @@ NVFlinger::~NVFlinger() {
     CoreTiming::UnscheduleEvent(composition_event, 0);
 }
 
-u64 NVFlinger::OpenDisplay(const std::string& name) {
+u64 NVFlinger::OpenDisplay(std::string_view name) {
     LOG_WARNING(Service, "Opening display {}", name);
 
     // TODO(Subv): Currently we only support the Default display.

src/core/hle/service/nvflinger/nvflinger.h

@@ -5,7 +5,11 @@
 #pragma once
 
 #include <memory>
-#include <boost/optional.hpp>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "common/common_types.h"
 #include "core/hle/kernel/event.h"
 
 namespace CoreTiming {
@@ -41,7 +45,7 @@ public:
     ~NVFlinger();
 
     /// Opens the specified display and returns the id.
-    u64 OpenDisplay(const std::string& name);
+    u64 OpenDisplay(std::string_view name);
 
     /// Creates a layer on the specified display and returns the layer id.
     u64 CreateLayer(u64 display_id);

src/core/hle/service/service.cpp

@@ -63,6 +63,7 @@
 #include "core/hle/service/spl/module.h"
 #include "core/hle/service/ssl/ssl.h"
 #include "core/hle/service/time/time.h"
+#include "core/hle/service/usb/usb.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/hle/service/wlan/wlan.h"
 
@@ -249,6 +250,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm) {
     SPL::InstallInterfaces(*sm);
     SSL::InstallInterfaces(*sm);
     Time::InstallInterfaces(*sm);
+    USB::InstallInterfaces(*sm);
     VI::InstallInterfaces(*sm, nv_flinger);
     WLAN::InstallInterfaces(*sm);
 

src/core/hle/service/time/time.cpp

@@ -80,8 +80,8 @@ public:
             {5, nullptr, "GetTimeZoneRuleVersion"},
             {100, &ITimeZoneService::ToCalendarTime, "ToCalendarTime"},
             {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
-            {200, nullptr, "ToPosixTime"},
-            {201, nullptr, "ToPosixTimeWithMyRule"},
+            {201, nullptr, "ToPosixTime"},
+            {202, nullptr, "ToPosixTimeWithMyRule"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/usb/usb.cpp

@@ -0,0 +1,238 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+#include "core/hle/service/usb/usb.h"
+
+namespace Service::USB {
+
+class IDsInterface final : public ServiceFramework<IDsInterface> {
+public:
+    explicit IDsInterface() : ServiceFramework{"IDsInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetDsEndpoint"},
+            {1, nullptr, "GetSetupEvent"},
+            {2, nullptr, "Unknown"},
+            {3, nullptr, "EnableInterface"},
+            {4, nullptr, "DisableInterface"},
+            {5, nullptr, "CtrlInPostBufferAsync"},
+            {6, nullptr, "CtrlOutPostBufferAsync"},
+            {7, nullptr, "GetCtrlInCompletionEvent"},
+            {8, nullptr, "GetCtrlInReportData"},
+            {9, nullptr, "GetCtrlOutCompletionEvent"},
+            {10, nullptr, "GetCtrlOutReportData"},
+            {11, nullptr, "StallCtrl"},
+            {12, nullptr, "AppendConfigurationData"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class USB_DS final : public ServiceFramework<USB_DS> {
+public:
+    explicit USB_DS() : ServiceFramework{"usb:ds"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "BindDevice"},
+            {1, nullptr, "BindClientProcess"},
+            {2, nullptr, "GetDsInterface"},
+            {3, nullptr, "GetStateChangeEvent"},
+            {4, nullptr, "GetState"},
+            {5, nullptr, "ClearDeviceData"},
+            {6, nullptr, "AddUsbStringDescriptor"},
+            {7, nullptr, "DeleteUsbStringDescriptor"},
+            {8, nullptr, "SetUsbDeviceDescriptor"},
+            {9, nullptr, "SetBinaryObjectStore"},
+            {10, nullptr, "Enable"},
+            {11, nullptr, "Disable"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class IClientEpSession final : public ServiceFramework<IClientEpSession> {
+public:
+    explicit IClientEpSession() : ServiceFramework{"IClientEpSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
+            {4, nullptr, "PostBufferAsync"},
+            {5, nullptr, "Unknown5"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class IClientIfSession final : public ServiceFramework<IClientIfSession> {
+public:
+    explicit IClientIfSession() : ServiceFramework{"IClientIfSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
+            {4, nullptr, "Unknown5"},
+            {5, nullptr, "CtrlXferAsync"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "GetCtrlXferReport"},
+            {8, nullptr, "Unknown7"},
+            {9, nullptr, "GetClientEpSession"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class USB_HS final : public ServiceFramework<USB_HS> {
+public:
+    explicit USB_HS() : ServiceFramework{"usb:hs"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "BindClientProcess"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
+            {6, nullptr, "GetInterfaceStateChangeEvent"},
+            {7, nullptr, "GetClientIfSession"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class IPdSession final : public ServiceFramework<IPdSession> {
+public:
+    explicit IPdSession() : ServiceFramework{"IPdSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "BindNoticeEvent"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "GetStatus"},
+            {3, nullptr, "GetNotice"},
+            {4, nullptr, "Unknown2"},
+            {5, nullptr, "Unknown3"},
+            {6, nullptr, "ReplyPowerRequest"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class USB_PD final : public ServiceFramework<USB_PD> {
+public:
+    explicit USB_PD() : ServiceFramework{"usb:pd"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &USB_PD::GetPdSession, "GetPdSession"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetPdSession(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IPdSession>();
+
+        LOG_DEBUG(Service_USB, "called");
+    }
+};
+
+class IPdCradleSession final : public ServiceFramework<IPdCradleSession> {
+public:
+    explicit IPdCradleSession() : ServiceFramework{"IPdCradleSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "VdmUserWrite"},
+            {1, nullptr, "VdmUserRead"},
+            {2, nullptr, "Vdm20Init"},
+            {3, nullptr, "GetFwType"},
+            {4, nullptr, "GetFwRevision"},
+            {5, nullptr, "GetManufacturerId"},
+            {6, nullptr, "GetDeviceId"},
+            {7, nullptr, "Unknown1"},
+            {8, nullptr, "Unknown2"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class USB_PD_C final : public ServiceFramework<USB_PD_C> {
+public:
+    explicit USB_PD_C() : ServiceFramework{"usb:pd:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &USB_PD_C::GetPdCradleSession, "GetPdCradleSession"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetPdCradleSession(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IPdCradleSession>();
+
+        LOG_DEBUG(Service_USB, "called");
+    }
+};
+
+class USB_PM final : public ServiceFramework<USB_PM> {
+public:
+    explicit USB_PM() : ServiceFramework{"usb:pm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
+            {4, nullptr, "Unknown5"},
+            {5, nullptr, "Unknown6"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<USB_DS>()->InstallAsService(sm);
+    std::make_shared<USB_HS>()->InstallAsService(sm);
+    std::make_shared<USB_PD>()->InstallAsService(sm);
+    std::make_shared<USB_PD_C>()->InstallAsService(sm);
+    std::make_shared<USB_PM>()->InstallAsService(sm);
+}
+
+} // namespace Service::USB

src/core/hle/service/usb/usb.h

@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::USB {
+
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::USB

src/core/loader/deconstructed_rom_directory.cpp

@@ -41,7 +41,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
     if (dir == nullptr) {
         if (file == nullptr)
             return ResultStatus::ErrorInvalidFormat;
-        const FileSys::VirtualDir dir = file->GetContainingDirectory();
+        dir = file->GetContainingDirectory();
     }
 
     const FileSys::VirtualFile npdm = dir->GetFile("main.npdm");

src/video_core/command_processor.cpp

@@ -29,10 +29,10 @@ enum class BufferMethods {
 };
 
 void GPU::WriteReg(u32 method, u32 subchannel, u32 value, u32 remaining_params) {
-    LOG_WARNING(HW_GPU,
-                "Processing method {:08X} on subchannel {} value "
-                "{:08X} remaining params {}",
-                method, subchannel, value, remaining_params);
+    LOG_TRACE(HW_GPU,
+              "Processing method {:08X} on subchannel {} value "
+              "{:08X} remaining params {}",
+              method, subchannel, value, remaining_params);
 
     if (method == static_cast<u32>(BufferMethods::BindObject)) {
         // Bind the current subchannel to the desired engine id.

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -204,8 +204,9 @@ struct SurfaceParams {
 
     static PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
         switch (format) {
+        // TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
+        // gamma.
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
-            return PixelFormat::SRGBA8;
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
             return PixelFormat::ABGR8;
         case Tegra::RenderTargetFormat::BGRA8_UNORM: