maxwell_to_gl: Properly handle UnsignedInt/SignedInt sizes.

audout_u: Correct IAudioOut initializer list order

src/audio_core/CMakeLists.txt

@@ -1,4 +1,8 @@
 add_library(audio_core STATIC
+    algorithm/filter.cpp
+    algorithm/filter.h
+    algorithm/interpolate.cpp
+    algorithm/interpolate.h
     audio_out.cpp
     audio_out.h
     audio_renderer.cpp
@@ -7,12 +11,12 @@ add_library(audio_core STATIC
     codec.cpp
     codec.h
     null_sink.h
-    stream.cpp
-    stream.h
     sink.h
     sink_details.cpp
     sink_details.h
     sink_stream.h
+    stream.cpp
+    stream.h
 
     $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
 )

src/audio_core/algorithm/filter.cpp

@@ -0,0 +1,79 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#define _USE_MATH_DEFINES
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <vector>
+#include "audio_core/algorithm/filter.h"
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+Filter Filter::LowPass(double cutoff, double Q) {
+    const double w0 = 2.0 * M_PI * cutoff;
+    const double sin_w0 = std::sin(w0);
+    const double cos_w0 = std::cos(w0);
+    const double alpha = sin_w0 / (2 * Q);
+
+    const double a0 = 1 + alpha;
+    const double a1 = -2.0 * cos_w0;
+    const double a2 = 1 - alpha;
+    const double b0 = 0.5 * (1 - cos_w0);
+    const double b1 = 1.0 * (1 - cos_w0);
+    const double b2 = 0.5 * (1 - cos_w0);
+
+    return {a0, a1, a2, b0, b1, b2};
+}
+
+Filter::Filter() : Filter(1.0, 0.0, 0.0, 1.0, 0.0, 0.0) {}
+
+Filter::Filter(double a0, double a1, double a2, double b0, double b1, double b2)
+    : a1(a1 / a0), a2(a2 / a0), b0(b0 / a0), b1(b1 / a0), b2(b2 / a0) {}
+
+void Filter::Process(std::vector<s16>& signal) {
+    const size_t num_frames = signal.size() / 2;
+    for (size_t i = 0; i < num_frames; i++) {
+        std::rotate(in.begin(), in.end() - 1, in.end());
+        std::rotate(out.begin(), out.end() - 1, out.end());
+
+        for (size_t ch = 0; ch < channel_count; ch++) {
+            in[0][ch] = signal[i * channel_count + ch];
+
+            out[0][ch] = b0 * in[0][ch] + b1 * in[1][ch] + b2 * in[2][ch] - a1 * out[1][ch] -
+                         a2 * out[2][ch];
+
+            signal[i * 2 + ch] = std::clamp(out[0][ch], -32768.0, 32767.0);
+        }
+    }
+}
+
+/// Calculates the appropriate Q for each biquad in a cascading filter.
+/// @param total_count The total number of biquads to be cascaded.
+/// @param index 0-index of the biquad to calculate the Q value for.
+static double CascadingBiquadQ(size_t total_count, size_t index) {
+    const double pole = M_PI * (2 * index + 1) / (4.0 * total_count);
+    return 1.0 / (2.0 * std::cos(pole));
+}
+
+CascadingFilter CascadingFilter::LowPass(double cutoff, size_t cascade_size) {
+    std::vector<Filter> cascade(cascade_size);
+    for (size_t i = 0; i < cascade_size; i++) {
+        cascade[i] = Filter::LowPass(cutoff, CascadingBiquadQ(cascade_size, i));
+    }
+    return CascadingFilter{std::move(cascade)};
+}
+
+CascadingFilter::CascadingFilter() = default;
+CascadingFilter::CascadingFilter(std::vector<Filter> filters) : filters(std::move(filters)) {}
+
+void CascadingFilter::Process(std::vector<s16>& signal) {
+    for (auto& filter : filters) {
+        filter.Process(signal);
+    }
+}
+
+} // namespace AudioCore

src/audio_core/algorithm/filter.h

@@ -0,0 +1,62 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <vector>
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+/// Digital biquad filter:
+///
+///          b0 + b1 z^-1 + b2 z^-2
+///  H(z) = ------------------------
+///          a0 + a1 z^-1 + b2 z^-2
+class Filter {
+public:
+    /// Creates a low-pass filter.
+    /// @param cutoff Determines the cutoff frequency. A value from 0.0 to 1.0.
+    /// @param Q Determines the quality factor of this filter.
+    static Filter LowPass(double cutoff, double Q = 0.7071);
+
+    /// Passthrough filter.
+    Filter();
+
+    Filter(double a0, double a1, double a2, double b0, double b1, double b2);
+
+    void Process(std::vector<s16>& signal);
+
+private:
+    static constexpr size_t channel_count = 2;
+
+    /// Coefficients are in normalized form (a0 = 1.0).
+    double a1, a2, b0, b1, b2;
+    /// Input History
+    std::array<std::array<double, channel_count>, 3> in;
+    /// Output History
+    std::array<std::array<double, channel_count>, 3> out;
+};
+
+/// Cascade filters to build up higher-order filters from lower-order ones.
+class CascadingFilter {
+public:
+    /// Creates a cascading low-pass filter.
+    /// @param cutoff Determines the cutoff frequency. A value from 0.0 to 1.0.
+    /// @param cascade_size Number of biquads in cascade.
+    static CascadingFilter LowPass(double cutoff, size_t cascade_size);
+
+    /// Passthrough.
+    CascadingFilter();
+
+    explicit CascadingFilter(std::vector<Filter> filters);
+
+    void Process(std::vector<s16>& signal);
+
+private:
+    std::vector<Filter> filters;
+};
+
+} // namespace AudioCore

src/audio_core/algorithm/interpolate.cpp

@@ -0,0 +1,71 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#define _USE_MATH_DEFINES
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include "audio_core/algorithm/interpolate.h"
+#include "common/common_types.h"
+#include "common/logging/log.h"
+
+namespace AudioCore {
+
+/// The Lanczos kernel
+static double Lanczos(size_t a, double x) {
+    if (x == 0.0)
+        return 1.0;
+    const double px = M_PI * x;
+    return a * std::sin(px) * std::sin(px / a) / (px * px);
+}
+
+std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input, double ratio) {
+    if (input.size() < 2)
+        return {};
+
+    if (ratio <= 0) {
+        LOG_CRITICAL(Audio, "Nonsensical interpolation ratio {}", ratio);
+        ratio = 1.0;
+    }
+
+    if (ratio != state.current_ratio) {
+        const double cutoff_frequency = std::min(0.5 / ratio, 0.5 * ratio);
+        state.nyquist = CascadingFilter::LowPass(std::clamp(cutoff_frequency, 0.0, 0.4), 3);
+        state.current_ratio = ratio;
+    }
+    state.nyquist.Process(input);
+
+    constexpr size_t taps = InterpolationState::lanczos_taps;
+    const size_t num_frames = input.size() / 2;
+
+    std::vector<s16> output;
+    output.reserve(static_cast<size_t>(input.size() / ratio + 4));
+
+    double& pos = state.position;
+    auto& h = state.history;
+    for (size_t i = 0; i < num_frames; ++i) {
+        std::rotate(h.begin(), h.end() - 1, h.end());
+        h[0][0] = input[i * 2 + 0];
+        h[0][1] = input[i * 2 + 1];
+
+        while (pos <= 1.0) {
+            double l = 0.0;
+            double r = 0.0;
+            for (size_t j = 0; j < h.size(); j++) {
+                l += Lanczos(taps, pos + j - taps + 1) * h[j][0];
+                r += Lanczos(taps, pos + j - taps + 1) * h[j][1];
+            }
+            output.emplace_back(static_cast<s16>(std::clamp(l, -32768.0, 32767.0)));
+            output.emplace_back(static_cast<s16>(std::clamp(r, -32768.0, 32767.0)));
+
+            pos += ratio;
+        }
+        pos -= 1.0;
+    }
+
+    return output;
+}
+
+} // namespace AudioCore

src/audio_core/algorithm/interpolate.h

@@ -0,0 +1,43 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <vector>
+#include "audio_core/algorithm/filter.h"
+#include "common/common_types.h"
+
+namespace AudioCore {
+
+struct InterpolationState {
+    static constexpr size_t lanczos_taps = 4;
+    static constexpr size_t history_size = lanczos_taps * 2 - 1;
+
+    double current_ratio = 0.0;
+    CascadingFilter nyquist;
+    std::array<std::array<s16, 2>, history_size> history = {};
+    double position = 0;
+};
+
+/// Interpolates input signal to produce output signal.
+/// @param input The signal to interpolate.
+/// @param ratio Interpolation ratio.
+///              ratio > 1.0 results in fewer output samples.
+///              ratio < 1.0 results in more output samples.
+/// @returns Output signal.
+std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input, double ratio);
+
+/// Interpolates input signal to produce output signal.
+/// @param input The signal to interpolate.
+/// @param input_rate The sample rate of input.
+/// @param output_rate The desired sample rate of the output.
+/// @returns Output signal.
+inline std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
+                                    u32 input_rate, u32 output_rate) {
+    const double ratio = static_cast<double>(input_rate) / static_cast<double>(output_rate);
+    return Interpolate(state, std::move(input), ratio);
+}
+
+} // namespace AudioCore

src/audio_core/audio_renderer.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_renderer.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
@@ -199,6 +200,8 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
         break;
     }
 
+    samples = Interpolate(interp_state, std::move(samples), Info().sample_rate, STREAM_SAMPLE_RATE);
+
     is_refresh_pending = false;
 }
 
@@ -224,7 +227,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                 break;
             }
 
-            samples_remaining -= samples.size();
+            samples_remaining -= samples.size() / stream->GetNumChannels();
 
             for (const auto& sample : samples) {
                 const s32 buffer_sample{buffer[offset]};

src/audio_core/audio_renderer.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_out.h"
 #include "audio_core/codec.h"
 #include "audio_core/stream.h"
@@ -194,6 +195,7 @@ private:
         size_t wave_index{};
         size_t offset{};
         Codec::ADPCMState adpcm_state{};
+        InterpolationState interp_state{};
         std::vector<s16> samples;
         VoiceOutStatus out_status{};
         VoiceInfo info{};

src/common/logging/backend.cpp

@@ -302,13 +302,14 @@ Backend* GetBackend(std::string_view backend_name) {
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                        unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
-    auto filter = Impl::Instance().GetGlobalFilter();
+    auto& instance = Impl::Instance();
+    const auto& filter = instance.GetGlobalFilter();
     if (!filter.CheckMessage(log_class, log_level))
         return;
 
     Entry entry =
         CreateEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
 
-    Impl::Instance().PushEntry(std::move(entry));
+    instance.PushEntry(std::move(entry));
 }
 } // namespace Log

src/core/CMakeLists.txt

@@ -249,6 +249,10 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_gpu.h
     hle/service/nvdrv/devices/nvhost_nvdec.cpp
     hle/service/nvdrv/devices/nvhost_nvdec.h
+    hle/service/nvdrv/devices/nvhost_nvjpg.cpp
+    hle/service/nvdrv/devices/nvhost_nvjpg.h
+    hle/service/nvdrv/devices/nvhost_vic.cpp
+    hle/service/nvdrv/devices/nvhost_vic.h
     hle/service/nvdrv/devices/nvmap.cpp
     hle/service/nvdrv/devices/nvmap.h
     hle/service/nvdrv/interface.cpp

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -243,9 +243,7 @@ void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
-    if (jit->IsExecuting()) {
-        jit->HaltExecution();
-    }
+    jit->HaltExecution();
 }
 
 void ARM_Dynarmic::ClearInstructionCache() {

src/core/hle/service/audio/audout_u.cpp

@@ -28,7 +28,7 @@ constexpr int DefaultSampleRate{48000};
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
     IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core)
-        : ServiceFramework("IAudioOut"), audio_params(audio_params), audio_core(audio_core) {
+        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params) {
 
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},

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

@@ -0,0 +1,34 @@
+// Copyright 2018 yuzu emulator team
+// 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_nvjpg.h"
+
+namespace Service::Nvidia::Devices {
+
+u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocSetNVMAPfdCommand:
+        return SetNVMAPfd(input, output);
+    }
+
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
+}
+
+u32 nvhost_nvjpg::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlSetNvmapFD params{};
+    std::memcpy(&params, input.data(), input.size());
+    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
+    nvmap_fd = params.nvmap_fd;
+    return 0;
+}
+
+} // namespace Service::Nvidia::Devices

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

@@ -0,0 +1,36 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/nvdrv/devices/nvdevice.h"
+
+namespace Service::Nvidia::Devices {
+
+class nvhost_nvjpg final : public nvdevice {
+public:
+    nvhost_nvjpg() = default;
+    ~nvhost_nvjpg() override = default;
+
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+
+private:
+    enum class IoctlCommand : u32_le {
+        IocSetNVMAPfdCommand = 0x40044801,
+    };
+
+    struct IoctlSetNvmapFD {
+        u32_le nvmap_fd;
+    };
+    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
+
+    u32_le nvmap_fd{};
+
+    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
+};
+
+} // namespace Service::Nvidia::Devices

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

@@ -0,0 +1,34 @@
+// Copyright 2018 yuzu emulator team
+// 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_vic.h"
+
+namespace Service::Nvidia::Devices {
+
+u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+    LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
+              command.raw, input.size(), output.size());
+
+    switch (static_cast<IoctlCommand>(command.raw)) {
+    case IoctlCommand::IocSetNVMAPfdCommand:
+        return SetNVMAPfd(input, output);
+    }
+
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
+}
+
+u32 nvhost_vic::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlSetNvmapFD params{};
+    std::memcpy(&params, input.data(), input.size());
+    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
+    nvmap_fd = params.nvmap_fd;
+    return 0;
+}
+
+} // namespace Service::Nvidia::Devices

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

@@ -0,0 +1,36 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/nvdrv/devices/nvdevice.h"
+
+namespace Service::Nvidia::Devices {
+
+class nvhost_vic final : public nvdevice {
+public:
+    nvhost_vic() = default;
+    ~nvhost_vic() override = default;
+
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+
+private:
+    enum class IoctlCommand : u32_le {
+        IocSetNVMAPfdCommand = 0x40044801,
+    };
+
+    struct IoctlSetNvmapFD {
+        u32_le nvmap_fd;
+    };
+    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
+
+    u32_le nvmap_fd{};
+
+    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
+};
+
+} // namespace Service::Nvidia::Devices

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

@@ -12,6 +12,8 @@
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
+#include "core/hle/service/nvdrv/devices/nvhost_nvjpg.h"
+#include "core/hle/service/nvdrv/devices/nvhost_vic.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
 #include "core/hle/service/nvdrv/interface.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
@@ -39,6 +41,8 @@ Module::Module() {
     devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(nvmap_dev);
     devices["/dev/nvhost-ctrl"] = std::make_shared<Devices::nvhost_ctrl>();
     devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>();
+    devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>();
+    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>();
 }
 
 u32 Module::Open(const std::string& device_name) {

src/video_core/gpu.cpp

@@ -47,6 +47,7 @@ u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
     case RenderTargetFormat::RGBA32_UINT:
         return 16;
     case RenderTargetFormat::RGBA16_UINT:
+    case RenderTargetFormat::RGBA16_UNORM:
     case RenderTargetFormat::RGBA16_FLOAT:
     case RenderTargetFormat::RG32_FLOAT:
     case RenderTargetFormat::RG32_UINT:

src/video_core/gpu.h

@@ -20,6 +20,7 @@ enum class RenderTargetFormat : u32 {
     NONE = 0x0,
     RGBA32_FLOAT = 0xC0,
     RGBA32_UINT = 0xC2,
+    RGBA16_UNORM = 0xC6,
     RGBA16_UINT = 0xC9,
     RGBA16_FLOAT = 0xCA,
     RG32_FLOAT = 0xCB,

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -101,6 +101,7 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_R8, GL_RED, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                    // R8
     {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, ComponentType::UInt, false},           // R8UI
     {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, ComponentType::Float, false},                 // RGBA16F
+    {GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},              // RGBA16U
     {GL_RGBA16UI, GL_RGBA, GL_UNSIGNED_SHORT, ComponentType::UInt, false},             // RGBA16UI
     {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, ComponentType::Float,
      false},                                                                     // R11FG11FB10F
@@ -115,7 +116,7 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true},                                                                     // DXN2UNORM
     {GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_INT, ComponentType::SNorm, true}, // DXN2SNORM
-    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true},                                                                    // BC7U
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_4X4
     {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8
@@ -247,6 +248,7 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<true, PixelFormat::R8>,
         MortonCopy<true, PixelFormat::R8UI>,
         MortonCopy<true, PixelFormat::RGBA16F>,
+        MortonCopy<true, PixelFormat::RGBA16U>,
         MortonCopy<true, PixelFormat::RGBA16UI>,
         MortonCopy<true, PixelFormat::R11FG11FB10F>,
         MortonCopy<true, PixelFormat::RGBA32UI>,
@@ -299,6 +301,7 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<false, PixelFormat::R8>,
         MortonCopy<false, PixelFormat::R8UI>,
         MortonCopy<false, PixelFormat::RGBA16F>,
+        MortonCopy<false, PixelFormat::RGBA16U>,
         MortonCopy<false, PixelFormat::RGBA16UI>,
         MortonCopy<false, PixelFormat::R11FG11FB10F>,
         MortonCopy<false, PixelFormat::RGBA32UI>,

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -31,47 +31,48 @@ struct SurfaceParams {
         R8 = 5,
         R8UI = 6,
         RGBA16F = 7,
-        RGBA16UI = 8,
-        R11FG11FB10F = 9,
-        RGBA32UI = 10,
-        DXT1 = 11,
-        DXT23 = 12,
-        DXT45 = 13,
-        DXN1 = 14, // This is also known as BC4
-        DXN2UNORM = 15,
-        DXN2SNORM = 16,
-        BC7U = 17,
-        ASTC_2D_4X4 = 18,
-        G8R8 = 19,
-        BGRA8 = 20,
-        RGBA32F = 21,
-        RG32F = 22,
-        R32F = 23,
-        R16F = 24,
-        R16UNORM = 25,
-        R16S = 26,
-        R16UI = 27,
-        R16I = 28,
-        RG16 = 29,
-        RG16F = 30,
-        RG16UI = 31,
-        RG16I = 32,
-        RG16S = 33,
-        RGB32F = 34,
-        SRGBA8 = 35,
-        RG8U = 36,
-        RG8S = 37,
-        RG32UI = 38,
-        R32UI = 39,
+        RGBA16U = 8,
+        RGBA16UI = 9,
+        R11FG11FB10F = 10,
+        RGBA32UI = 11,
+        DXT1 = 12,
+        DXT23 = 13,
+        DXT45 = 14,
+        DXN1 = 15, // This is also known as BC4
+        DXN2UNORM = 16,
+        DXN2SNORM = 17,
+        BC7U = 18,
+        ASTC_2D_4X4 = 19,
+        G8R8 = 20,
+        BGRA8 = 21,
+        RGBA32F = 22,
+        RG32F = 23,
+        R32F = 24,
+        R16F = 25,
+        R16UNORM = 26,
+        R16S = 27,
+        R16UI = 28,
+        R16I = 29,
+        RG16 = 30,
+        RG16F = 31,
+        RG16UI = 32,
+        RG16I = 33,
+        RG16S = 34,
+        RGB32F = 35,
+        SRGBA8 = 36,
+        RG8U = 37,
+        RG8S = 38,
+        RG32UI = 39,
+        R32UI = 40,
 
         MaxColorFormat,
 
         // DepthStencil formats
-        Z24S8 = 40,
-        S8Z24 = 41,
-        Z32F = 42,
-        Z16 = 43,
-        Z32FS8 = 44,
+        Z24S8 = 41,
+        S8Z24 = 42,
+        Z32F = 43,
+        Z16 = 44,
+        Z32FS8 = 45,
 
         MaxDepthStencilFormat,
 
@@ -117,6 +118,7 @@ struct SurfaceParams {
             1, // R8
             1, // R8UI
             1, // RGBA16F
+            1, // RGBA16U
             1, // RGBA16UI
             1, // R11FG11FB10F
             1, // RGBA32UI
@@ -173,6 +175,7 @@ struct SurfaceParams {
             8,   // R8
             8,   // R8UI
             64,  // RGBA16F
+            64,  // RGBA16U
             64,  // RGBA16UI
             32,  // R11FG11FB10F
             128, // RGBA32UI
@@ -253,6 +256,8 @@ struct SurfaceParams {
             return PixelFormat::A2B10G10R10;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
             return PixelFormat::RGBA16F;
+        case Tegra::RenderTargetFormat::RGBA16_UNORM:
+            return PixelFormat::RGBA16U;
         case Tegra::RenderTargetFormat::RGBA16_UINT:
             return PixelFormat::RGBA16UI;
         case Tegra::RenderTargetFormat::RGBA32_FLOAT:
@@ -469,6 +474,7 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::R16_UNORM:
         case Tegra::RenderTargetFormat::B5G6R5_UNORM:
         case Tegra::RenderTargetFormat::RG8_UNORM:
+        case Tegra::RenderTargetFormat::RGBA16_UNORM:
             return ComponentType::UNorm;
         case Tegra::RenderTargetFormat::RGBA8_SNORM:
         case Tegra::RenderTargetFormat::RG16_SNORM:

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -24,15 +24,25 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
 inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
     switch (attrib.type) {
+    case Maxwell::VertexAttribute::Type::UnsignedInt:
     case Maxwell::VertexAttribute::Type::UnsignedNorm: {
 
         switch (attrib.size) {
+        case Maxwell::VertexAttribute::Size::Size_8:
         case Maxwell::VertexAttribute::Size::Size_8_8:
+        case Maxwell::VertexAttribute::Size::Size_8_8_8:
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return GL_UNSIGNED_BYTE;
+        case Maxwell::VertexAttribute::Size::Size_16:
         case Maxwell::VertexAttribute::Size::Size_16_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16_16:
         case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
             return GL_UNSIGNED_SHORT;
+        case Maxwell::VertexAttribute::Size::Size_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
+            return GL_UNSIGNED_INT;
         case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
             return GL_UNSIGNED_INT_2_10_10_10_REV;
         }
@@ -42,16 +52,25 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
+    case Maxwell::VertexAttribute::Type::SignedInt:
     case Maxwell::VertexAttribute::Type::SignedNorm: {
 
         switch (attrib.size) {
-        case Maxwell::VertexAttribute::Size::Size_32_32_32:
-            return GL_INT;
+        case Maxwell::VertexAttribute::Size::Size_8:
         case Maxwell::VertexAttribute::Size::Size_8_8:
+        case Maxwell::VertexAttribute::Size::Size_8_8_8:
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return GL_BYTE;
+        case Maxwell::VertexAttribute::Size::Size_16:
         case Maxwell::VertexAttribute::Size::Size_16_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16_16:
+        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
             return GL_SHORT;
+        case Maxwell::VertexAttribute::Size::Size_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
+            return GL_INT;
         case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
             return GL_INT_2_10_10_10_REV;
         }
@@ -61,9 +80,6 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
-    case Maxwell::VertexAttribute::Type::UnsignedInt:
-        return GL_UNSIGNED_INT;
-
     case Maxwell::VertexAttribute::Type::Float:
         return GL_FLOAT;
     }