10 files changed, 455 insertions, 84 deletions

diff --git a/src/citra/CMakeLists.txt b/src/citra/CMakeLists.txt
index 351752c1c..43fa06b4e 100644
--- a/src/citra/CMakeLists.txt
+++ b/src/citra/CMakeLists.txt
@@ -21,7 +21,7 @@ target_link_libraries(citra ${SDL2_LIBRARY} ${OPENGL_gl_LIBRARY} inih glad)
 if (MSVC)
     target_link_libraries(citra getopt)
 endif()
-target_link_libraries(citra ${PLATFORM_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(citra ${PLATFORM_LIBRARIES} Threads::Threads)
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux|FreeBSD|OpenBSD|NetBSD")
     install(TARGETS citra RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
diff --git a/src/citra_qt/CMakeLists.txt b/src/citra_qt/CMakeLists.txt
index 6660d9879..cc9e0c624 100644
--- a/src/citra_qt/CMakeLists.txt
+++ b/src/citra_qt/CMakeLists.txt
@@ -92,7 +92,7 @@ else()
 endif()
 target_link_libraries(citra-qt core video_core audio_core common qhexedit)
 target_link_libraries(citra-qt ${OPENGL_gl_LIBRARY} ${CITRA_QT_LIBS})
-target_link_libraries(citra-qt ${PLATFORM_LIBRARIES})
+target_link_libraries(citra-qt ${PLATFORM_LIBRARIES} Threads::Threads)
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux|FreeBSD|OpenBSD|NetBSD")
     install(TARGETS citra-qt RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
diff --git a/src/citra_qt/debugger/graphics_breakpoints.cpp b/src/citra_qt/debugger/graphics_breakpoints.cpp
index 819ec7707..c8510128a 100644
--- a/src/citra_qt/debugger/graphics_breakpoints.cpp
+++ b/src/citra_qt/debugger/graphics_breakpoints.cpp
@@ -75,7 +75,7 @@ QVariant BreakPointModel::data(const QModelIndex& index, int role) const
     case Role_IsEnabled:
     {
         auto context = context_weak.lock();
-        return context && context->breakpoints[event].enabled;
+        return context && context->breakpoints[(int)event].enabled;
     }
 
     default:
@@ -110,7 +110,7 @@ bool BreakPointModel::setData(const QModelIndex& index, const QVariant& value, i
         if (!context)
             return false;
 
-        context->breakpoints[event].enabled = value == Qt::Checked;
+        context->breakpoints[(int)event].enabled = value == Qt::Checked;
         QModelIndex changed_index = createIndex(index.row(), 0);
         emit dataChanged(changed_index, changed_index);
         return true;
diff --git a/src/common/assert.h b/src/common/assert.h
index d7f19f5eb..cd9b819a9 100644
--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -39,7 +39,7 @@ static void assert_noinline_call(const Fn& fn) {
     }); } while (0)
 
 #define UNREACHABLE() ASSERT_MSG(false, "Unreachable code!")
-#define UNREACHABLE_MSG(_a_, ...) ASSERT_MSG(false, _a_, __VA_ARGS__)
+#define UNREACHABLE_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
 
 #ifdef _DEBUG
 #define DEBUG_ASSERT(_a_) ASSERT(_a_)
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 9591522e5..3f71e7f2b 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -43,7 +43,7 @@ void FindContentInfos(Service::Interface* self) {
     am_content_count[media_type] = cmd_buff[4];
 
     cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_id=0x%016lx, content_cound=%u, content_ids_pointer=0x%08x, content_info_pointer=0x%08x",
+    LOG_WARNING(Service_AM, "(STUBBED) media_type=%u, title_id=0x%016llx, content_cound=%u, content_ids_pointer=0x%08x, content_info_pointer=0x%08x",
                 media_type, title_id, am_content_count[media_type], content_ids_pointer, content_info_pointer);
 }
 
diff --git a/src/core/hle/service/y2r_u.cpp b/src/core/hle/service/y2r_u.cpp
index 1672ad775..d16578f87 100644
--- a/src/core/hle/service/y2r_u.cpp
+++ b/src/core/hle/service/y2r_u.cpp
@@ -4,6 +4,7 @@
 
 #include <cstring>
 
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 
@@ -25,13 +26,17 @@ struct ConversionParameters {
     u16 input_line_width;
     u16 input_lines;
     StandardCoefficient standard_coefficient;
-    u8 reserved;
+    u8 padding;
     u16 alpha;
 };
 static_assert(sizeof(ConversionParameters) == 12, "ConversionParameters struct has incorrect size");
 
 static Kernel::SharedPtr<Kernel::Event> completion_event;
 static ConversionConfiguration conversion;
+static DitheringWeightParams dithering_weight_params;
+static u32 temporal_dithering_enabled = 0;
+static u32 transfer_end_interrupt_enabled = 0;
+static u32 spacial_dithering_enabled = 0;
 
 static const CoefficientSet standard_coefficients[4] = {
     {{ 0x100, 0x166, 0xB6, 0x58, 0x1C5, -0x166F, 0x10EE, -0x1C5B }}, // ITU_Rec601
@@ -70,7 +75,7 @@ ResultCode ConversionConfiguration::SetInputLines(u16 lines) {
 
 ResultCode ConversionConfiguration::SetStandardCoefficient(StandardCoefficient standard_coefficient) {
     size_t index = static_cast<size_t>(standard_coefficient);
-    if (index >= 4) {
+    if (index >= ARRAY_SIZE(standard_coefficients)) {
         return ResultCode(ErrorDescription::InvalidEnumValue, ErrorModule::CAM,
             ErrorSummary::InvalidArgument, ErrorLevel::Usage); // 0xE0E053ED
     }
@@ -83,44 +88,183 @@ static void SetInputFormat(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
     conversion.input_format = static_cast<InputFormat>(cmd_buff[1]);
+
+    cmd_buff[0] = IPC::MakeHeader(0x1, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
     LOG_DEBUG(Service_Y2R, "called input_format=%hhu", conversion.input_format);
+}
 
+static void GetInputFormat(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x2, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = static_cast<u32>(conversion.input_format);
+
+    LOG_DEBUG(Service_Y2R, "called input_format=%hhu", conversion.input_format);
 }
 
 static void SetOutputFormat(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
     conversion.output_format = static_cast<OutputFormat>(cmd_buff[1]);
+
+    cmd_buff[0] = IPC::MakeHeader(0x3, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
     LOG_DEBUG(Service_Y2R, "called output_format=%hhu", conversion.output_format);
+}
+
+static void GetOutputFormat(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
 
+    cmd_buff[0] = IPC::MakeHeader(0x4, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = static_cast<u32>(conversion.output_format);
+
+    LOG_DEBUG(Service_Y2R, "called output_format=%hhu", conversion.output_format);
 }
 
 static void SetRotation(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
     conversion.rotation = static_cast<Rotation>(cmd_buff[1]);
+
+    cmd_buff[0] = IPC::MakeHeader(0x5, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
     LOG_DEBUG(Service_Y2R, "called rotation=%hhu", conversion.rotation);
+}
+
+static void GetRotation(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
 
+    cmd_buff[0] = IPC::MakeHeader(0x6, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = static_cast<u32>(conversion.rotation);
+
+    LOG_DEBUG(Service_Y2R, "called rotation=%hhu", conversion.rotation);
 }
 
 static void SetBlockAlignment(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
     conversion.block_alignment = static_cast<BlockAlignment>(cmd_buff[1]);
-    LOG_DEBUG(Service_Y2R, "called alignment=%hhu", conversion.block_alignment);
 
+    cmd_buff[0] = IPC::MakeHeader(0x7, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called block_alignment=%hhu", conversion.block_alignment);
+}
+
+static void GetBlockAlignment(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x8, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = static_cast<u32>(conversion.block_alignment);
+
+    LOG_DEBUG(Service_Y2R, "called block_alignment=%hhu", conversion.block_alignment);
+}
+
+/**
+ * Y2R_U::SetSpacialDithering service function
+ *  Inputs:
+ *      1 : u8, 0 = Disabled, 1 = Enabled
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ */
+static void SetSpacialDithering(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+    spacial_dithering_enabled = cmd_buff[1] & 0xF;
+
+    cmd_buff[0] = IPC::MakeHeader(0x9, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
+}
+
+/**
+ * Y2R_U::GetSpacialDithering service function
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ *      2 : u8, 0 = Disabled, 1 = Enabled
+ */
+static void GetSpacialDithering(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0xA, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = spacial_dithering_enabled;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
+}
+
+/**
+ * Y2R_U::SetTemporalDithering service function
+ *  Inputs:
+ *      1 : u8, 0 = Disabled, 1 = Enabled
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ */
+static void SetTemporalDithering(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+    temporal_dithering_enabled = cmd_buff[1] & 0xF;
+
+    cmd_buff[0] = IPC::MakeHeader(0xB, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
+}
+
+/**
+ * Y2R_U::GetTemporalDithering service function
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ *      2 : u8, 0 = Disabled, 1 = Enabled
+ */
+static void GetTemporalDithering(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0xC, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = temporal_dithering_enabled;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
 }
 
+/**
+ * Y2R_U::SetTransferEndInterrupt service function
+ *  Inputs:
+ *      1 : u8, 0 = Disabled, 1 = Enabled
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ */
 static void SetTransferEndInterrupt(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
+    transfer_end_interrupt_enabled = cmd_buff[1] & 0xf;
 
     cmd_buff[0] = IPC::MakeHeader(0xD, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
-    LOG_DEBUG(Service_Y2R, "(STUBBED) called");
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
+}
+
+/**
+ * Y2R_U::GetTransferEndInterrupt service function
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ *      2 : u8, 0 = Disabled, 1 = Enabled
+ */
+static void GetTransferEndInterrupt(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0xE, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = transfer_end_interrupt_enabled;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
 }
 
 /**
@@ -132,8 +276,10 @@ static void SetTransferEndInterrupt(Service::Interface* self) {
 static void GetTransferEndEvent(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
+    cmd_buff[0] = IPC::MakeHeader(0xF, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
     cmd_buff[3] = Kernel::g_handle_table.Create(completion_event).MoveFrom();
+
     LOG_DEBUG(Service_Y2R, "called");
 }
 
@@ -144,12 +290,12 @@ static void SetSendingY(Service::Interface* self) {
     conversion.src_Y.image_size = cmd_buff[2];
     conversion.src_Y.transfer_unit = cmd_buff[3];
     conversion.src_Y.gap = cmd_buff[4];
-    u32 src_process_handle = cmd_buff[6];
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-        "src_process_handle=0x%08X", conversion.src_Y.image_size,
-        conversion.src_Y.transfer_unit, conversion.src_Y.gap, src_process_handle);
 
+    cmd_buff[0] = IPC::MakeHeader(0x10, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+            conversion.src_Y.image_size, conversion.src_Y.transfer_unit, conversion.src_Y.gap, cmd_buff[6]);
 }
 
 static void SetSendingU(Service::Interface* self) {
@@ -159,12 +305,12 @@ static void SetSendingU(Service::Interface* self) {
     conversion.src_U.image_size = cmd_buff[2];
     conversion.src_U.transfer_unit = cmd_buff[3];
     conversion.src_U.gap = cmd_buff[4];
-    u32 src_process_handle = cmd_buff[6];
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-        "src_process_handle=0x%08X", conversion.src_U.image_size,
-        conversion.src_U.transfer_unit, conversion.src_U.gap, src_process_handle);
 
+    cmd_buff[0] = IPC::MakeHeader(0x11, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+            conversion.src_U.image_size, conversion.src_U.transfer_unit, conversion.src_U.gap, cmd_buff[6]);
 }
 
 static void SetSendingV(Service::Interface* self) {
@@ -174,12 +320,12 @@ static void SetSendingV(Service::Interface* self) {
     conversion.src_V.image_size = cmd_buff[2];
     conversion.src_V.transfer_unit = cmd_buff[3];
     conversion.src_V.gap = cmd_buff[4];
-    u32 src_process_handle = cmd_buff[6];
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-        "src_process_handle=0x%08X", conversion.src_V.image_size,
-        conversion.src_V.transfer_unit, conversion.src_V.gap, src_process_handle);
 
+    cmd_buff[0] = IPC::MakeHeader(0x12, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+            conversion.src_V.image_size, conversion.src_V.transfer_unit, conversion.src_V.gap, cmd_buff[6]);
 }
 
 static void SetSendingYUYV(Service::Interface* self) {
@@ -189,12 +335,76 @@ static void SetSendingYUYV(Service::Interface* self) {
     conversion.src_YUYV.image_size = cmd_buff[2];
     conversion.src_YUYV.transfer_unit = cmd_buff[3];
     conversion.src_YUYV.gap = cmd_buff[4];
-    u32 src_process_handle = cmd_buff[6];
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-        "src_process_handle=0x%08X", conversion.src_YUYV.image_size,
-        conversion.src_YUYV.transfer_unit, conversion.src_YUYV.gap, src_process_handle);
 
+    cmd_buff[0] = IPC::MakeHeader(0x13, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, src_process_handle=0x%08X",
+            conversion.src_YUYV.image_size, conversion.src_YUYV.transfer_unit, conversion.src_YUYV.gap, cmd_buff[6]);
+}
+
+/**
+ * Y2R::IsFinishedSendingYuv service function
+ * Output:
+ *       1 : Result of the function, 0 on success, otherwise error code
+ *       2 : u8, 0 = Not Finished, 1 = Finished
+ */
+static void IsFinishedSendingYuv(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x14, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = 1;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
+}
+
+/**
+ * Y2R::IsFinishedSendingY service function
+ * Output:
+ *       1 : Result of the function, 0 on success, otherwise error code
+ *       2 : u8, 0 = Not Finished, 1 = Finished
+ */
+static void IsFinishedSendingY(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x15, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = 1;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
+}
+
+/**
+ * Y2R::IsFinishedSendingU service function
+ * Output:
+ *       1 : Result of the function, 0 on success, otherwise error code
+ *       2 : u8, 0 = Not Finished, 1 = Finished
+ */
+static void IsFinishedSendingU(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x16, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = 1;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
+}
+
+/**
+ * Y2R::IsFinishedSendingV service function
+ * Output:
+ *       1 : Result of the function, 0 on success, otherwise error code
+ *       2 : u8, 0 = Not Finished, 1 = Finished
+ */
+static void IsFinishedSendingV(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x17, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = 1;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
 }
 
 static void SetReceiving(Service::Interface* self) {
@@ -204,27 +414,66 @@ static void SetReceiving(Service::Interface* self) {
     conversion.dst.image_size = cmd_buff[2];
     conversion.dst.transfer_unit = cmd_buff[3];
     conversion.dst.gap = cmd_buff[4];
-    u32 dst_process_handle = cmd_buff[6];
-    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, "
-        "dst_process_handle=0x%08X", conversion.dst.image_size,
-        conversion.dst.transfer_unit, conversion.dst.gap,
-        dst_process_handle);
 
+    cmd_buff[0] = IPC::MakeHeader(0x18, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called image_size=0x%08X, transfer_unit=%hu, transfer_stride=%hu, dst_process_handle=0x%08X",
+            conversion.dst.image_size, conversion.dst.transfer_unit, conversion.dst.gap, cmd_buff[6]);
+}
+
+/**
+ * Y2R::IsFinishedReceiving service function
+ * Output:
+ *       1 : Result of the function, 0 on success, otherwise error code
+ *       2 : u8, 0 = Not Finished, 1 = Finished
+ */
+static void IsFinishedReceiving(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x19, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = 1;
+
+    LOG_WARNING(Service_Y2R, "(STUBBED) called");
 }
 
 static void SetInputLineWidth(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
-    LOG_DEBUG(Service_Y2R, "called input_line_width=%u", cmd_buff[1]);
+    cmd_buff[0] = IPC::MakeHeader(0x1A, 1, 0);
     cmd_buff[1] = conversion.SetInputLineWidth(cmd_buff[1]).raw;
+
+    LOG_DEBUG(Service_Y2R, "called input_line_width=%u", cmd_buff[1]);
+}
+
+static void GetInputLineWidth(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x1B, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = conversion.input_line_width;
+
+    LOG_DEBUG(Service_Y2R, "called input_line_width=%u", conversion.input_line_width);
 }
 
 static void SetInputLines(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
-    LOG_DEBUG(Service_Y2R, "called input_line_number=%u", cmd_buff[1]);
+    cmd_buff[0] = IPC::MakeHeader(0x1C, 1, 0);
     cmd_buff[1] = conversion.SetInputLines(cmd_buff[1]).raw;
+
+    LOG_DEBUG(Service_Y2R, "called input_lines=%u", cmd_buff[1]);
+}
+
+static void GetInputLines(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x1D, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = static_cast<u32>(conversion.input_lines);
+
+    LOG_DEBUG(Service_Y2R, "called input_lines=%u", conversion.input_lines);
 }
 
 static void SetCoefficient(Service::Interface* self) {
@@ -232,44 +481,111 @@ static void SetCoefficient(Service::Interface* self) {
 
     const u16* coefficients = reinterpret_cast<const u16*>(&cmd_buff[1]);
     std::memcpy(conversion.coefficients.data(), coefficients, sizeof(CoefficientSet));
+
+    cmd_buff[0] = IPC::MakeHeader(0x1E, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
     LOG_DEBUG(Service_Y2R, "called coefficients=[%hX, %hX, %hX, %hX, %hX, %hX, %hX, %hX]",
             coefficients[0], coefficients[1], coefficients[2], coefficients[3],
             coefficients[4], coefficients[5], coefficients[6], coefficients[7]);
+}
+
+static void GetCoefficient(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
 
+    cmd_buff[0] = IPC::MakeHeader(0x1F, 5, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+    std::memcpy(&cmd_buff[2], conversion.coefficients.data(), sizeof(CoefficientSet));
+
+    LOG_DEBUG(Service_Y2R, "called");
 }
 
 static void SetStandardCoefficient(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
-    LOG_DEBUG(Service_Y2R, "called standard_coefficient=%u", cmd_buff[1]);
+    u32 index = cmd_buff[1];
+
+    cmd_buff[0] = IPC::MakeHeader(0x20, 1, 0);
+    cmd_buff[1] = conversion.SetStandardCoefficient((StandardCoefficient)index).raw;
 
-    cmd_buff[1] = conversion.SetStandardCoefficient((StandardCoefficient)cmd_buff[1]).raw;
+    LOG_DEBUG(Service_Y2R, "called standard_coefficient=%u", index);
+}
+
+static void GetStandardCoefficient(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    u32 index = cmd_buff[1];
+
+    if (index < ARRAY_SIZE(standard_coefficients)) {
+        cmd_buff[0] = IPC::MakeHeader(0x21, 5, 0);
+        cmd_buff[1] = RESULT_SUCCESS.raw;
+        std::memcpy(&cmd_buff[2], &standard_coefficients[index], sizeof(CoefficientSet));
+
+        LOG_DEBUG(Service_Y2R, "called standard_coefficient=%u ", index);
+    } else {
+        cmd_buff[0] = IPC::MakeHeader(0x21, 1, 0);
+        cmd_buff[1] = -1; // TODO(bunnei): Identify the correct error code for this
+
+        LOG_ERROR(Service_Y2R, "called standard_coefficient=%u  The argument is invalid!", index);
+    }
 }
 
 static void SetAlpha(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
     conversion.alpha = cmd_buff[1];
+
+    cmd_buff[0] = IPC::MakeHeader(0x22, 1, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called alpha=%hu", conversion.alpha);
+}
+
+static void GetAlpha(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x23, 2, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    cmd_buff[2] = conversion.alpha;
+
     LOG_DEBUG(Service_Y2R, "called alpha=%hu", conversion.alpha);
+}
+
+static void SetDitheringWeightParams(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+    std::memcpy(&dithering_weight_params, &cmd_buff[1], sizeof(DitheringWeightParams));
 
+    cmd_buff[0] = IPC::MakeHeader(0x24, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called");
+}
+
+static void GetDitheringWeightParams(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x25, 9, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    std::memcpy(&cmd_buff[2], &dithering_weight_params, sizeof(DitheringWeightParams));
+
+    LOG_DEBUG(Service_Y2R, "called");
 }
 
 static void StartConversion(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
     // dst_image_size would seem to be perfect for this, but it doesn't include the gap :(
-    u32 total_output_size = conversion.input_lines *
-        (conversion.dst.transfer_unit + conversion.dst.gap);
+    u32 total_output_size = conversion.input_lines * (conversion.dst.transfer_unit + conversion.dst.gap);
     Memory::RasterizerFlushAndInvalidateRegion(Memory::VirtualToPhysicalAddress(conversion.dst.address), total_output_size);
 
     HW::Y2R::PerformConversion(conversion);
 
-    LOG_DEBUG(Service_Y2R, "called");
     completion_event->Signal();
 
+    cmd_buff[0] = IPC::MakeHeader(0x26, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called");
 }
 
 static void StopConversion(Service::Interface* self) {
@@ -277,6 +593,7 @@ static void StopConversion(Service::Interface* self) {
 
     cmd_buff[0] = IPC::MakeHeader(0x27, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
     LOG_DEBUG(Service_Y2R, "called");
 }
 
@@ -289,50 +606,61 @@ static void StopConversion(Service::Interface* self) {
 static void IsBusyConversion(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
+    cmd_buff[0] = IPC::MakeHeader(0x28, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
     cmd_buff[2] = 0; // StartConversion always finishes immediately
+
     LOG_DEBUG(Service_Y2R, "called");
 }
 
 /**
- * Y2R_U::SetConversionParams service function
+ * Y2R_U::SetPackageParameter service function
  */
-static void SetConversionParams(Service::Interface* self) {
+static void SetPackageParameter(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
     auto params = reinterpret_cast<const ConversionParameters*>(&cmd_buff[1]);
-    LOG_DEBUG(Service_Y2R,
-        "called input_format=%hhu output_format=%hhu rotation=%hhu block_alignment=%hhu "
-        "input_line_width=%hu input_lines=%hu standard_coefficient=%hhu "
-        "reserved=%hhu alpha=%hX",
-        params->input_format, params->output_format, params->rotation, params->block_alignment,
-        params->input_line_width, params->input_lines, params->standard_coefficient,
-        params->reserved, params->alpha);
-
-    ResultCode result = RESULT_SUCCESS;
 
     conversion.input_format = params->input_format;
     conversion.output_format = params->output_format;
     conversion.rotation = params->rotation;
     conversion.block_alignment = params->block_alignment;
-    result = conversion.SetInputLineWidth(params->input_line_width);
-    if (result.IsError()) goto cleanup;
+
+    ResultCode result = conversion.SetInputLineWidth(params->input_line_width);
+
+    if (result.IsError())
+        goto cleanup;
+
     result = conversion.SetInputLines(params->input_lines);
-    if (result.IsError()) goto cleanup;
+
+    if (result.IsError())
+        goto cleanup;
+
     result = conversion.SetStandardCoefficient(params->standard_coefficient);
-    if (result.IsError()) goto cleanup;
+
+    if (result.IsError())
+        goto cleanup;
+
+    conversion.padding = params->padding;
     conversion.alpha = params->alpha;
 
 cleanup:
     cmd_buff[0] = IPC::MakeHeader(0x29, 1, 0);
     cmd_buff[1] = result.raw;
+
+    LOG_DEBUG(Service_Y2R, "called input_format=%hhu output_format=%hhu rotation=%hhu block_alignment=%hhu "
+            "input_line_width=%hu input_lines=%hu standard_coefficient=%hhu reserved=%hhu alpha=%hX",
+            params->input_format, params->output_format, params->rotation, params->block_alignment,
+            params->input_line_width, params->input_lines, params->standard_coefficient, params->padding, params->alpha);
 }
 
 static void PingProcess(Service::Interface* self) {
     u32* cmd_buff = Kernel::GetCommandBuffer();
 
+    cmd_buff[0] = IPC::MakeHeader(0x2A, 2, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
     cmd_buff[2] = 0;
+
     LOG_WARNING(Service_Y2R, "(STUBBED) called");
 }
 
@@ -358,6 +686,7 @@ static void DriverInitialize(Service::Interface* self) {
 
     cmd_buff[0] = IPC::MakeHeader(0x2B, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
     LOG_DEBUG(Service_Y2R, "called");
 }
 
@@ -366,54 +695,67 @@ static void DriverFinalize(Service::Interface* self) {
 
     cmd_buff[0] = IPC::MakeHeader(0x2C, 1, 0);
     cmd_buff[1] = RESULT_SUCCESS.raw;
+
+    LOG_DEBUG(Service_Y2R, "called");
+}
+
+
+static void GetPackageParameter(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+
+    cmd_buff[0] = IPC::MakeHeader(0x2D, 4, 0);
+    cmd_buff[1] = RESULT_SUCCESS.raw;
+    std::memcpy(&cmd_buff[2], &conversion, sizeof(ConversionParameters));
+
     LOG_DEBUG(Service_Y2R, "called");
 }
 
 const Interface::FunctionInfo FunctionTable[] = {
     {0x00010040, SetInputFormat,          "SetInputFormat"},
-    {0x00020000, nullptr,                 "GetInputFormat"},
+    {0x00020000, GetInputFormat,          "GetInputFormat"},
     {0x00030040, SetOutputFormat,         "SetOutputFormat"},
-    {0x00040000, nullptr,                 "GetOutputFormat"},
+    {0x00040000, GetOutputFormat,         "GetOutputFormat"},
     {0x00050040, SetRotation,             "SetRotation"},
-    {0x00060000, nullptr,                 "GetRotation"},
+    {0x00060000, GetRotation,             "GetRotation"},
     {0x00070040, SetBlockAlignment,       "SetBlockAlignment"},
-    {0x00080000, nullptr,                 "GetBlockAlignment"},
-    {0x00090040, nullptr,                 "SetSpacialDithering"},
-    {0x000A0000, nullptr,                 "GetSpacialDithering"},
-    {0x000B0040, nullptr,                 "SetTemporalDithering"},
-    {0x000C0000, nullptr,                 "GetTemporalDithering"},
+    {0x00080000, GetBlockAlignment,       "GetBlockAlignment"},
+    {0x00090040, SetSpacialDithering,     "SetSpacialDithering"},
+    {0x000A0000, GetSpacialDithering,     "GetSpacialDithering"},
+    {0x000B0040, SetTemporalDithering,    "SetTemporalDithering"},
+    {0x000C0000, GetTemporalDithering,    "GetTemporalDithering"},
     {0x000D0040, SetTransferEndInterrupt, "SetTransferEndInterrupt"},
+    {0x000E0000, GetTransferEndInterrupt, "GetTransferEndInterrupt"},
     {0x000F0000, GetTransferEndEvent,     "GetTransferEndEvent"},
     {0x00100102, SetSendingY,             "SetSendingY"},
     {0x00110102, SetSendingU,             "SetSendingU"},
     {0x00120102, SetSendingV,             "SetSendingV"},
     {0x00130102, SetSendingYUYV,          "SetSendingYUYV"},
-    {0x00140000, nullptr,                 "IsFinishedSendingYuv"},
-    {0x00150000, nullptr,                 "IsFinishedSendingY"},
-    {0x00160000, nullptr,                 "IsFinishedSendingU"},
-    {0x00170000, nullptr,                 "IsFinishedSendingV"},
+    {0x00140000, IsFinishedSendingYuv,    "IsFinishedSendingYuv"},
+    {0x00150000, IsFinishedSendingY,      "IsFinishedSendingY"},
+    {0x00160000, IsFinishedSendingU,      "IsFinishedSendingU"},
+    {0x00170000, IsFinishedSendingV,      "IsFinishedSendingV"},
     {0x00180102, SetReceiving,            "SetReceiving"},
-    {0x00190000, nullptr,                 "IsFinishedReceiving"},
+    {0x00190000, IsFinishedReceiving,     "IsFinishedReceiving"},
     {0x001A0040, SetInputLineWidth,       "SetInputLineWidth"},
-    {0x001B0000, nullptr,                 "GetInputLineWidth"},
+    {0x001B0000, GetInputLineWidth,       "GetInputLineWidth"},
     {0x001C0040, SetInputLines,           "SetInputLines"},
-    {0x001D0000, nullptr,                 "GetInputLines"},
+    {0x001D0000, GetInputLines,           "GetInputLines"},
     {0x001E0100, SetCoefficient,          "SetCoefficient"},
-    {0x001F0000, nullptr,                 "GetCoefficient"},
+    {0x001F0000, GetCoefficient,          "GetCoefficient"},
     {0x00200040, SetStandardCoefficient,  "SetStandardCoefficient"},
-    {0x00210040, nullptr,                 "GetStandardCoefficientParams"},
+    {0x00210040, GetStandardCoefficient,  "GetStandardCoefficient"},
     {0x00220040, SetAlpha,                "SetAlpha"},
-    {0x00230000, nullptr,                 "GetAlpha"},
-    {0x00240200, nullptr,                 "SetDitheringWeightParams"},
-    {0x00250000, nullptr,                 "GetDitheringWeightParams"},
+    {0x00230000, GetAlpha,                "GetAlpha"},
+    {0x00240200, SetDitheringWeightParams,"SetDitheringWeightParams"},
+    {0x00250000, GetDitheringWeightParams,"GetDitheringWeightParams"},
     {0x00260000, StartConversion,         "StartConversion"},
     {0x00270000, StopConversion,          "StopConversion"},
     {0x00280000, IsBusyConversion,        "IsBusyConversion"},
-    {0x002901C0, SetConversionParams,     "SetConversionParams"},
+    {0x002901C0, SetPackageParameter,     "SetPackageParameter"},
     {0x002A0000, PingProcess,             "PingProcess"},
     {0x002B0000, DriverInitialize,        "DriverInitialize"},
     {0x002C0000, DriverFinalize,          "DriverFinalize"},
-    {0x002D0000, nullptr,                 "GetPackageParameter"},
+    {0x002D0000, GetPackageParameter,     "GetPackageParameter"},
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/service/y2r_u.h b/src/core/hle/service/y2r_u.h
index 3965a5545..95fa2fdb7 100644
--- a/src/core/hle/service/y2r_u.h
+++ b/src/core/hle/service/y2r_u.h
@@ -97,6 +97,7 @@ struct ConversionConfiguration {
     u16 input_line_width;
     u16 input_lines;
     CoefficientSet coefficients;
+    u8 padding;
     u16 alpha;
 
     /// Input parameters for the Y (luma) plane
@@ -109,6 +110,25 @@ struct ConversionConfiguration {
     ResultCode SetStandardCoefficient(StandardCoefficient standard_coefficient);
 };
 
+struct DitheringWeightParams {
+    u16 w0_xEven_yEven;
+    u16 w0_xOdd_yEven;
+    u16 w0_xEven_yOdd;
+    u16 w0_xOdd_yOdd;
+    u16 w1_xEven_yEven;
+    u16 w1_xOdd_yEven;
+    u16 w1_xEven_yOdd;
+    u16 w1_xOdd_yOdd;
+    u16 w2_xEven_yEven;
+    u16 w2_xOdd_yEven;
+    u16 w2_xEven_yOdd;
+    u16 w2_xOdd_yOdd;
+    u16 w3_xEven_yEven;
+    u16 w3_xOdd_yEven;
+    u16 w3_xEven_yOdd;
+    u16 w3_xOdd_yOdd;
+};
+
 class Interface : public Service::Interface {
 public:
     Interface();
diff --git a/src/video_core/debug_utils/debug_utils.cpp b/src/video_core/debug_utils/debug_utils.cpp
index 1f058c4e2..178a566f7 100644
--- a/src/video_core/debug_utils/debug_utils.cpp
+++ b/src/video_core/debug_utils/debug_utils.cpp
@@ -40,10 +40,7 @@ using nihstro::DVLPHeader;
 
 namespace Pica {
 
-void DebugContext::OnEvent(Event event, void* data) {
-    if (!breakpoints[event].enabled)
-        return;
-
+void DebugContext::DoOnEvent(Event event, void* data) {
     {
         std::unique_lock<std::mutex> lock(breakpoint_mutex);
 
diff --git a/src/video_core/debug_utils/debug_utils.h b/src/video_core/debug_utils/debug_utils.h
index 7df941619..56f9bd958 100644
--- a/src/video_core/debug_utils/debug_utils.h
+++ b/src/video_core/debug_utils/debug_utils.h
@@ -114,7 +114,15 @@ public:
      * @param event Event which has happened
      * @param data Optional data pointer (pass nullptr if unused). Needs to remain valid until Resume() is called.
      */
-    void OnEvent(Event event, void* data);
+    void OnEvent(Event event, void* data) {
+        // This check is left in the header to allow the compiler to inline it.
+        if (!breakpoints[(int)event].enabled)
+            return;
+        // For the rest of event handling, call a separate function.
+        DoOnEvent(event, data);
+    }
+
+    void DoOnEvent(Event event, void *data);
 
     /**
      * Resume from the current breakpoint.
@@ -126,12 +134,14 @@ public:
      * Delete all set breakpoints and resume emulation.
      */
     void ClearBreakpoints() {
-        breakpoints.clear();
+        for (auto &bp : breakpoints) {
+            bp.enabled = false;
+        }
         Resume();
     }
 
     // TODO: Evaluate if access to these members should be hidden behind a public interface.
-    std::map<Event, BreakPoint> breakpoints;
+    std::array<BreakPoint, (int)Event::NumEvents> breakpoints;
     Event active_breakpoint;
     bool at_breakpoint = false;
 
diff --git a/src/video_core/shader/shader_jit_x64.cpp b/src/video_core/shader/shader_jit_x64.cpp
index b47d3beda..b7747fa42 100644
--- a/src/video_core/shader/shader_jit_x64.cpp
+++ b/src/video_core/shader/shader_jit_x64.cpp
@@ -148,7 +148,7 @@ static Instruction GetVertexShaderInstruction(size_t offset) {
 }
 
 static void LogCritical(const char* msg) {
-    LOG_CRITICAL(HW_GPU, msg);
+    LOG_CRITICAL(HW_GPU, "%s", msg);
 }
 
 void JitShader::Compile_Assert(bool condition, const char* msg) {
@@ -795,6 +795,8 @@ void JitShader::FindReturnOffsets() {
         case OpCode::Id::CALLU:
             return_offsets.push_back(instr.flow_control.dest_offset + instr.flow_control.num_instructions);
             break;
+        default:
+            break;
         }
     }
 
@@ -854,7 +856,7 @@ void JitShader::Compile() {
     uintptr_t size = reinterpret_cast<uintptr_t>(GetCodePtr()) - reinterpret_cast<uintptr_t>(program);
     ASSERT_MSG(size <= MAX_SHADER_SIZE, "Compiled a shader that exceeds the allocated size!");
 
-    LOG_DEBUG(HW_GPU, "Compiled shader size=%d", size);
+    LOG_DEBUG(HW_GPU, "Compiled shader size=%lu", size);
 }
 
 JitShader::JitShader() {