input_common: Rewrite tas input

5 files changed, 2 insertions, 840 deletions

diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index c8871513c..19270dc84 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -5,6 +5,8 @@ add_library(input_common STATIC
     drivers/keyboard.h
     drivers/mouse.cpp
     drivers/mouse.h
+    drivers/tas_input.cpp
+    drivers/tas_input.h
     drivers/touch_screen.cpp
     drivers/touch_screen.h
     helpers/stick_from_buttons.cpp
@@ -27,10 +29,6 @@ add_library(input_common STATIC
     motion_input.h
     sdl/sdl.cpp
     sdl/sdl.h
-    tas/tas_input.cpp
-    tas/tas_input.h
-    tas/tas_poller.cpp
-    tas/tas_poller.h
     udp/client.cpp
     udp/client.h
     udp/udp.cpp
diff --git a/src/input_common/tas/tas_input.cpp b/src/input_common/tas/tas_input.cpp
deleted file mode 100644
index 1598092b6..000000000
--- a/src/input_common/tas/tas_input.cpp
+++ /dev/null
@@ -1,455 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <regex>
-
-#include "common/fs/file.h"
-#include "common/fs/fs_types.h"
-#include "common/fs/path_util.h"
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "input_common/tas/tas_input.h"
-
-namespace TasInput {
-
-// Supported keywords and buttons from a TAS file
-constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_button = {
-    std::pair{"KEY_A", TasButton::BUTTON_A},
-    {"KEY_B", TasButton::BUTTON_B},
-    {"KEY_X", TasButton::BUTTON_X},
-    {"KEY_Y", TasButton::BUTTON_Y},
-    {"KEY_LSTICK", TasButton::STICK_L},
-    {"KEY_RSTICK", TasButton::STICK_R},
-    {"KEY_L", TasButton::TRIGGER_L},
-    {"KEY_R", TasButton::TRIGGER_R},
-    {"KEY_PLUS", TasButton::BUTTON_PLUS},
-    {"KEY_MINUS", TasButton::BUTTON_MINUS},
-    {"KEY_DLEFT", TasButton::BUTTON_LEFT},
-    {"KEY_DUP", TasButton::BUTTON_UP},
-    {"KEY_DRIGHT", TasButton::BUTTON_RIGHT},
-    {"KEY_DDOWN", TasButton::BUTTON_DOWN},
-    {"KEY_SL", TasButton::BUTTON_SL},
-    {"KEY_SR", TasButton::BUTTON_SR},
-    {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE},
-    {"KEY_HOME", TasButton::BUTTON_HOME},
-    {"KEY_ZL", TasButton::TRIGGER_ZL},
-    {"KEY_ZR", TasButton::TRIGGER_ZR},
-};
-
-Tas::Tas() {
-    if (!Settings::values.tas_enable) {
-        needs_reset = true;
-        return;
-    }
-    LoadTasFiles();
-}
-
-Tas::~Tas() {
-    Stop();
-};
-
-void Tas::LoadTasFiles() {
-    script_length = 0;
-    for (size_t i = 0; i < commands.size(); i++) {
-        LoadTasFile(i);
-        if (commands[i].size() > script_length) {
-            script_length = commands[i].size();
-        }
-    }
-}
-
-void Tas::LoadTasFile(size_t player_index) {
-    if (!commands[player_index].empty()) {
-        commands[player_index].clear();
-    }
-    std::string file =
-        Common::FS::ReadStringFromFile(Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) /
-                                           fmt::format("script0-{}.txt", player_index + 1),
-                                       Common::FS::FileType::BinaryFile);
-    std::stringstream command_line(file);
-    std::string line;
-    int frame_no = 0;
-    while (std::getline(command_line, line, '\n')) {
-        if (line.empty()) {
-            continue;
-        }
-        LOG_DEBUG(Input, "Loading line: {}", line);
-        std::smatch m;
-
-        std::stringstream linestream(line);
-        std::string segment;
-        std::vector<std::string> seglist;
-
-        while (std::getline(linestream, segment, ' ')) {
-            seglist.push_back(segment);
-        }
-
-        if (seglist.size() < 4) {
-            continue;
-        }
-
-        while (frame_no < std::stoi(seglist.at(0))) {
-            commands[player_index].push_back({});
-            frame_no++;
-        }
-
-        TASCommand command = {
-            .buttons = ReadCommandButtons(seglist.at(1)),
-            .l_axis = ReadCommandAxis(seglist.at(2)),
-            .r_axis = ReadCommandAxis(seglist.at(3)),
-        };
-        commands[player_index].push_back(command);
-        frame_no++;
-    }
-    LOG_INFO(Input, "TAS file loaded! {} frames", frame_no);
-}
-
-void Tas::WriteTasFile(std::u8string file_name) {
-    std::string output_text;
-    for (size_t frame = 0; frame < record_commands.size(); frame++) {
-        if (!output_text.empty()) {
-            output_text += "\n";
-        }
-        const TASCommand& line = record_commands[frame];
-        output_text += std::to_string(frame) + " " + WriteCommandButtons(line.buttons) + " " +
-                       WriteCommandAxis(line.l_axis) + " " + WriteCommandAxis(line.r_axis);
-    }
-    const auto bytes_written = Common::FS::WriteStringToFile(
-        Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name,
-        Common::FS::FileType::TextFile, output_text);
-    if (bytes_written == output_text.size()) {
-        LOG_INFO(Input, "TAS file written to file!");
-    } else {
-        LOG_ERROR(Input, "Writing the TAS-file has failed! {} / {} bytes written", bytes_written,
-                  output_text.size());
-    }
-}
-
-std::pair<float, float> Tas::FlipAxisY(std::pair<float, float> old) {
-    auto [x, y] = old;
-    return {x, -y};
-}
-
-void Tas::RecordInput(u32 buttons, const std::array<std::pair<float, float>, 2>& axes) {
-    last_input = {buttons, FlipAxisY(axes[0]), FlipAxisY(axes[1])};
-}
-
-std::tuple<TasState, size_t, size_t> Tas::GetStatus() const {
-    TasState state;
-    if (is_recording) {
-        return {TasState::Recording, 0, record_commands.size()};
-    }
-
-    if (is_running) {
-        state = TasState::Running;
-    } else {
-        state = TasState::Stopped;
-    }
-
-    return {state, current_command, script_length};
-}
-
-std::string Tas::DebugButtons(u32 buttons) const {
-    return fmt::format("{{ {} }}", TasInput::Tas::ButtonsToString(buttons));
-}
-
-std::string Tas::DebugJoystick(float x, float y) const {
-    return fmt::format("[ {} , {} ]", std::to_string(x), std::to_string(y));
-}
-
-std::string Tas::DebugInput(const TasData& data) const {
-    return fmt::format("{{ {} , {} , {} }}", DebugButtons(data.buttons),
-                       DebugJoystick(data.axis[0], data.axis[1]),
-                       DebugJoystick(data.axis[2], data.axis[3]));
-}
-
-std::string Tas::DebugInputs(const std::array<TasData, PLAYER_NUMBER>& arr) const {
-    std::string returns = "[ ";
-    for (size_t i = 0; i < arr.size(); i++) {
-        returns += DebugInput(arr[i]);
-        if (i != arr.size() - 1) {
-            returns += " , ";
-        }
-    }
-    return returns + "]";
-}
-
-std::string Tas::ButtonsToString(u32 button) const {
-    std::string returns;
-    for (auto [text_button, tas_button] : text_to_tas_button) {
-        if ((button & static_cast<u32>(tas_button)) != 0)
-            returns += fmt::format(", {}", text_button.substr(4));
-    }
-    return returns.empty() ? "" : returns.substr(2);
-}
-
-void Tas::UpdateThread() {
-    if (!Settings::values.tas_enable) {
-        if (is_running) {
-            Stop();
-        }
-        return;
-    }
-
-    if (is_recording) {
-        record_commands.push_back(last_input);
-    }
-    if (needs_reset) {
-        current_command = 0;
-        needs_reset = false;
-        LoadTasFiles();
-        LOG_DEBUG(Input, "tas_reset done");
-    }
-
-    if (!is_running) {
-        tas_data.fill({});
-        return;
-    }
-    if (current_command < script_length) {
-        LOG_DEBUG(Input, "Playing TAS {}/{}", current_command, script_length);
-        size_t frame = current_command++;
-        for (size_t i = 0; i < commands.size(); i++) {
-            if (frame < commands[i].size()) {
-                TASCommand command = commands[i][frame];
-                tas_data[i].buttons = command.buttons;
-                auto [l_axis_x, l_axis_y] = command.l_axis;
-                tas_data[i].axis[0] = l_axis_x;
-                tas_data[i].axis[1] = l_axis_y;
-                auto [r_axis_x, r_axis_y] = command.r_axis;
-                tas_data[i].axis[2] = r_axis_x;
-                tas_data[i].axis[3] = r_axis_y;
-            } else {
-                tas_data[i] = {};
-            }
-        }
-    } else {
-        is_running = Settings::values.tas_loop.GetValue();
-        current_command = 0;
-        tas_data.fill({});
-        if (!is_running) {
-            SwapToStoredController();
-        }
-    }
-    LOG_DEBUG(Input, "TAS inputs: {}", DebugInputs(tas_data));
-}
-
-TasAnalog Tas::ReadCommandAxis(const std::string& line) const {
-    std::stringstream linestream(line);
-    std::string segment;
-    std::vector<std::string> seglist;
-
-    while (std::getline(linestream, segment, ';')) {
-        seglist.push_back(segment);
-    }
-
-    const float x = std::stof(seglist.at(0)) / 32767.0f;
-    const float y = std::stof(seglist.at(1)) / 32767.0f;
-
-    return {x, y};
-}
-
-u32 Tas::ReadCommandButtons(const std::string& data) const {
-    std::stringstream button_text(data);
-    std::string line;
-    u32 buttons = 0;
-    while (std::getline(button_text, line, ';')) {
-        for (auto [text, tas_button] : text_to_tas_button) {
-            if (text == line) {
-                buttons |= static_cast<u32>(tas_button);
-                break;
-            }
-        }
-    }
-    return buttons;
-}
-
-std::string Tas::WriteCommandAxis(TasAnalog data) const {
-    auto [x, y] = data;
-    std::string line;
-    line += std::to_string(static_cast<int>(x * 32767));
-    line += ";";
-    line += std::to_string(static_cast<int>(y * 32767));
-    return line;
-}
-
-std::string Tas::WriteCommandButtons(u32 data) const {
-    if (data == 0) {
-        return "NONE";
-    }
-
-    std::string line;
-    u32 index = 0;
-    while (data > 0) {
-        if ((data & 1) == 1) {
-            for (auto [text, tas_button] : text_to_tas_button) {
-                if (tas_button == static_cast<TasButton>(1 << index)) {
-                    if (line.size() > 0) {
-                        line += ";";
-                    }
-                    line += text;
-                    break;
-                }
-            }
-        }
-        index++;
-        data >>= 1;
-    }
-    return line;
-}
-
-void Tas::StartStop() {
-    if (!Settings::values.tas_enable) {
-        return;
-    }
-    if (is_running) {
-        Stop();
-    } else {
-        is_running = true;
-        SwapToTasController();
-    }
-}
-
-void Tas::Stop() {
-    is_running = false;
-    SwapToStoredController();
-}
-
-void Tas::SwapToTasController() {
-    if (!Settings::values.tas_swap_controllers) {
-        return;
-    }
-    auto& players = Settings::values.players.GetValue();
-    for (std::size_t index = 0; index < players.size(); index++) {
-        auto& player = players[index];
-        player_mappings[index] = player;
-
-        // Only swap active controllers
-        if (!player.connected) {
-            continue;
-        }
-
-        Common::ParamPackage tas_param;
-        tas_param.Set("pad", static_cast<u8>(index));
-        auto button_mapping = GetButtonMappingForDevice(tas_param);
-        auto analog_mapping = GetAnalogMappingForDevice(tas_param);
-        auto& buttons = player.buttons;
-        auto& analogs = player.analogs;
-
-        for (std::size_t i = 0; i < buttons.size(); ++i) {
-            buttons[i] = button_mapping[static_cast<Settings::NativeButton::Values>(i)].Serialize();
-        }
-        for (std::size_t i = 0; i < analogs.size(); ++i) {
-            analogs[i] = analog_mapping[static_cast<Settings::NativeAnalog::Values>(i)].Serialize();
-        }
-    }
-    is_old_input_saved = true;
-    Settings::values.is_device_reload_pending.store(true);
-}
-
-void Tas::SwapToStoredController() {
-    if (!is_old_input_saved) {
-        return;
-    }
-    auto& players = Settings::values.players.GetValue();
-    for (std::size_t index = 0; index < players.size(); index++) {
-        players[index] = player_mappings[index];
-    }
-    is_old_input_saved = false;
-    Settings::values.is_device_reload_pending.store(true);
-}
-
-void Tas::Reset() {
-    if (!Settings::values.tas_enable) {
-        return;
-    }
-    needs_reset = true;
-}
-
-bool Tas::Record() {
-    if (!Settings::values.tas_enable) {
-        return true;
-    }
-    is_recording = !is_recording;
-    return is_recording;
-}
-
-void Tas::SaveRecording(bool overwrite_file) {
-    if (is_recording) {
-        return;
-    }
-    if (record_commands.empty()) {
-        return;
-    }
-    WriteTasFile(u8"record.txt");
-    if (overwrite_file) {
-        WriteTasFile(u8"script0-1.txt");
-    }
-    needs_reset = true;
-    record_commands.clear();
-}
-
-InputCommon::ButtonMapping Tas::GetButtonMappingForDevice(
-    const Common::ParamPackage& params) const {
-    // This list is missing ZL/ZR since those are not considered buttons.
-    // We will add those afterwards
-    // This list also excludes any button that can't be really mapped
-    static constexpr std::array<std::pair<Settings::NativeButton::Values, TasButton>, 20>
-        switch_to_tas_button = {
-            std::pair{Settings::NativeButton::A, TasButton::BUTTON_A},
-            {Settings::NativeButton::B, TasButton::BUTTON_B},
-            {Settings::NativeButton::X, TasButton::BUTTON_X},
-            {Settings::NativeButton::Y, TasButton::BUTTON_Y},
-            {Settings::NativeButton::LStick, TasButton::STICK_L},
-            {Settings::NativeButton::RStick, TasButton::STICK_R},
-            {Settings::NativeButton::L, TasButton::TRIGGER_L},
-            {Settings::NativeButton::R, TasButton::TRIGGER_R},
-            {Settings::NativeButton::Plus, TasButton::BUTTON_PLUS},
-            {Settings::NativeButton::Minus, TasButton::BUTTON_MINUS},
-            {Settings::NativeButton::DLeft, TasButton::BUTTON_LEFT},
-            {Settings::NativeButton::DUp, TasButton::BUTTON_UP},
-            {Settings::NativeButton::DRight, TasButton::BUTTON_RIGHT},
-            {Settings::NativeButton::DDown, TasButton::BUTTON_DOWN},
-            {Settings::NativeButton::SL, TasButton::BUTTON_SL},
-            {Settings::NativeButton::SR, TasButton::BUTTON_SR},
-            {Settings::NativeButton::Screenshot, TasButton::BUTTON_CAPTURE},
-            {Settings::NativeButton::Home, TasButton::BUTTON_HOME},
-            {Settings::NativeButton::ZL, TasButton::TRIGGER_ZL},
-            {Settings::NativeButton::ZR, TasButton::TRIGGER_ZR},
-        };
-
-    InputCommon::ButtonMapping mapping{};
-    for (const auto& [switch_button, tas_button] : switch_to_tas_button) {
-        Common::ParamPackage button_params({{"engine", "tas"}});
-        button_params.Set("pad", params.Get("pad", 0));
-        button_params.Set("button", static_cast<int>(tas_button));
-        mapping.insert_or_assign(switch_button, std::move(button_params));
-    }
-
-    return mapping;
-}
-
-InputCommon::AnalogMapping Tas::GetAnalogMappingForDevice(
-    const Common::ParamPackage& params) const {
-
-    InputCommon::AnalogMapping mapping = {};
-    Common::ParamPackage left_analog_params;
-    left_analog_params.Set("engine", "tas");
-    left_analog_params.Set("pad", params.Get("pad", 0));
-    left_analog_params.Set("axis_x", static_cast<int>(TasAxes::StickX));
-    left_analog_params.Set("axis_y", static_cast<int>(TasAxes::StickY));
-    mapping.insert_or_assign(Settings::NativeAnalog::LStick, std::move(left_analog_params));
-    Common::ParamPackage right_analog_params;
-    right_analog_params.Set("engine", "tas");
-    right_analog_params.Set("pad", params.Get("pad", 0));
-    right_analog_params.Set("axis_x", static_cast<int>(TasAxes::SubstickX));
-    right_analog_params.Set("axis_y", static_cast<int>(TasAxes::SubstickY));
-    mapping.insert_or_assign(Settings::NativeAnalog::RStick, std::move(right_analog_params));
-    return mapping;
-}
-
-const TasData& Tas::GetTasState(std::size_t pad) const {
-    return tas_data[pad];
-}
-} // namespace TasInput
diff --git a/src/input_common/tas/tas_input.h b/src/input_common/tas/tas_input.h
deleted file mode 100644
index 3e2db8f00..000000000
--- a/src/input_common/tas/tas_input.h
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-#include "common/common_types.h"
-#include "common/settings_input.h"
-#include "core/frontend/input.h"
-#include "input_common/main.h"
-
-/*
-To play back TAS scripts on Yuzu, select the folder with scripts in the configuration menu below
-Tools -> Configure TAS. The file itself has normal text format and has to be called script0-1.txt
-for controller 1, script0-2.txt for controller 2 and so forth (with max. 8 players).
-
-A script file has the same format as TAS-nx uses, so final files will look like this:
-
-1 KEY_B 0;0 0;0
-6 KEY_ZL 0;0 0;0
-41 KEY_ZL;KEY_Y 0;0 0;0
-43 KEY_X;KEY_A 32767;0 0;0
-44 KEY_A 32767;0 0;0
-45 KEY_A 32767;0 0;0
-46 KEY_A 32767;0 0;0
-47 KEY_A 32767;0 0;0
-
-After placing the file at the correct location, it can be read into Yuzu with the (default) hotkey
-CTRL+F6 (refresh). In the bottom left corner, it will display the amount of frames the script file
-has. Playback can be started or stopped using CTRL+F5.
-
-However, for playback to actually work, the correct input device has to be selected: In the Controls
-menu, select TAS from the device list for the controller that the script should be played on.
-
-Recording a new script file is really simple: Just make sure that the proper device (not TAS) is
-connected on P1, and press CTRL+F7 to start recording. When done, just press the same keystroke
-again (CTRL+F7). The new script will be saved at the location previously selected, as the filename
-record.txt.
-
-For debugging purposes, the common controller debugger can be used (View -> Debugging -> Controller
-P1).
-*/
-
-namespace TasInput {
-
-constexpr size_t PLAYER_NUMBER = 8;
-
-using TasAnalog = std::pair<float, float>;
-
-enum class TasState {
-    Running,
-    Recording,
-    Stopped,
-};
-
-enum class TasButton : u32 {
-    BUTTON_A = 1U << 0,
-    BUTTON_B = 1U << 1,
-    BUTTON_X = 1U << 2,
-    BUTTON_Y = 1U << 3,
-    STICK_L = 1U << 4,
-    STICK_R = 1U << 5,
-    TRIGGER_L = 1U << 6,
-    TRIGGER_R = 1U << 7,
-    TRIGGER_ZL = 1U << 8,
-    TRIGGER_ZR = 1U << 9,
-    BUTTON_PLUS = 1U << 10,
-    BUTTON_MINUS = 1U << 11,
-    BUTTON_LEFT = 1U << 12,
-    BUTTON_UP = 1U << 13,
-    BUTTON_RIGHT = 1U << 14,
-    BUTTON_DOWN = 1U << 15,
-    BUTTON_SL = 1U << 16,
-    BUTTON_SR = 1U << 17,
-    BUTTON_HOME = 1U << 18,
-    BUTTON_CAPTURE = 1U << 19,
-};
-
-enum class TasAxes : u8 {
-    StickX,
-    StickY,
-    SubstickX,
-    SubstickY,
-    Undefined,
-};
-
-struct TasData {
-    u32 buttons{};
-    std::array<float, 4> axis{};
-};
-
-class Tas {
-public:
-    Tas();
-    ~Tas();
-
-    // Changes the input status that will be stored in each frame
-    void RecordInput(u32 buttons, const std::array<std::pair<float, float>, 2>& axes);
-
-    // Main loop that records or executes input
-    void UpdateThread();
-
-    //  Sets the flag to start or stop the TAS command excecution and swaps controllers profiles
-    void StartStop();
-
-    //  Stop the TAS and reverts any controller profile
-    void Stop();
-
-    // Sets the flag to reload the file and start from the begining in the next update
-    void Reset();
-
-    /**
-     * Sets the flag to enable or disable recording of inputs
-     * @return Returns true if the current recording status is enabled
-     */
-    bool Record();
-
-    // Saves contents of record_commands on a file if overwrite is enabled player 1 will be
-    // overwritten with the recorded commands
-    void SaveRecording(bool overwrite_file);
-
-    /**
-     * Returns the current status values of TAS playback/recording
-     * @return Tuple of
-     * TasState indicating the current state out of Running, Recording or Stopped ;
-     * Current playback progress or amount of frames (so far) for Recording ;
-     * Total length of script file currently loaded or amount of frames (so far) for Recording
-     */
-    std::tuple<TasState, size_t, size_t> GetStatus() const;
-
-    // Retuns an array of the default button mappings
-    InputCommon::ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) const;
-
-    // Retuns an array of the default analog mappings
-    InputCommon::AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) const;
-    [[nodiscard]] const TasData& GetTasState(std::size_t pad) const;
-
-private:
-    struct TASCommand {
-        u32 buttons{};
-        TasAnalog l_axis{};
-        TasAnalog r_axis{};
-    };
-
-    // Loads TAS files from all players
-    void LoadTasFiles();
-
-    // Loads TAS file from the specified player
-    void LoadTasFile(size_t player_index);
-
-    // Writes a TAS file from the recorded commands
-    void WriteTasFile(std::u8string file_name);
-
-    /**
-     * Parses a string containing the axis values with the following format "x;y"
-     * X and Y have a range from -32767 to 32767
-     * @return Returns a TAS analog object with axis values with range from -1.0 to 1.0
-     */
-    TasAnalog ReadCommandAxis(const std::string& line) const;
-
-    /**
-     * Parses a string containing the button values with the following format "a;b;c;d..."
-     * Each button is represented by it's text format specified in text_to_tas_button array
-     * @return Returns a u32 with each bit representing the status of a button
-     */
-    u32 ReadCommandButtons(const std::string& line) const;
-
-    /**
-     * Converts an u32 containing the button status into the text equivalent
-     * @return Returns a string with the name of the buttons to be written to the file
-     */
-    std::string WriteCommandButtons(u32 data) const;
-
-    /**
-     * Converts an TAS analog object containing the axis status into the text equivalent
-     * @return Returns a string with the value of the axis to be written to the file
-     */
-    std::string WriteCommandAxis(TasAnalog data) const;
-
-    // Inverts the Y axis polarity
-    std::pair<float, float> FlipAxisY(std::pair<float, float> old);
-
-    /**
-     * Converts an u32 containing the button status into the text equivalent
-     * @return Returns a string with the name of the buttons to be printed on console
-     */
-    std::string DebugButtons(u32 buttons) const;
-
-    /**
-     * Converts an TAS analog object containing the axis status into the text equivalent
-     * @return Returns a string with the value of the axis to be printed on console
-     */
-    std::string DebugJoystick(float x, float y) const;
-
-    /**
-     * Converts the given TAS status into the text equivalent
-     * @return Returns a string with the value of the TAS status to be printed on console
-     */
-    std::string DebugInput(const TasData& data) const;
-
-    /**
-     * Converts the given TAS status of multiple players into the text equivalent
-     * @return Returns a string with the value of the status of all TAS players to be printed on
-     * console
-     */
-    std::string DebugInputs(const std::array<TasData, PLAYER_NUMBER>& arr) const;
-
-    /**
-     * Converts an u32 containing the button status into the text equivalent
-     * @return Returns a string with the name of the buttons
-     */
-    std::string ButtonsToString(u32 button) const;
-
-    // Stores current controller configuration and sets a TAS controller for every active controller
-    // to the current config
-    void SwapToTasController();
-
-    // Sets the stored controller configuration to the current config
-    void SwapToStoredController();
-
-    size_t script_length{0};
-    std::array<TasData, PLAYER_NUMBER> tas_data;
-    bool is_old_input_saved{false};
-    bool is_recording{false};
-    bool is_running{false};
-    bool needs_reset{false};
-    std::array<std::vector<TASCommand>, PLAYER_NUMBER> commands{};
-    std::vector<TASCommand> record_commands{};
-    size_t current_command{0};
-    TASCommand last_input{}; // only used for recording
-
-    // Old settings for swapping controllers
-    std::array<Settings::PlayerInput, 10> player_mappings;
-};
-} // namespace TasInput
diff --git a/src/input_common/tas/tas_poller.cpp b/src/input_common/tas/tas_poller.cpp
deleted file mode 100644
index 15810d6b0..000000000
--- a/src/input_common/tas/tas_poller.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <mutex>
-#include <utility>
-
-#include "common/settings.h"
-#include "common/threadsafe_queue.h"
-#include "input_common/tas/tas_input.h"
-#include "input_common/tas/tas_poller.h"
-
-namespace InputCommon {
-
-class TasButton final : public Input::ButtonDevice {
-public:
-    explicit TasButton(u32 button_, u32 pad_, const TasInput::Tas* tas_input_)
-        : button(button_), pad(pad_), tas_input(tas_input_) {}
-
-    bool GetStatus() const override {
-        return (tas_input->GetTasState(pad).buttons & button) != 0;
-    }
-
-private:
-    const u32 button;
-    const u32 pad;
-    const TasInput::Tas* tas_input;
-};
-
-TasButtonFactory::TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_)
-    : tas_input(std::move(tas_input_)) {}
-
-std::unique_ptr<Input::ButtonDevice> TasButtonFactory::Create(const Common::ParamPackage& params) {
-    const auto button_id = params.Get("button", 0);
-    const auto pad = params.Get("pad", 0);
-
-    return std::make_unique<TasButton>(button_id, pad, tas_input.get());
-}
-
-class TasAnalog final : public Input::AnalogDevice {
-public:
-    explicit TasAnalog(u32 pad_, u32 axis_x_, u32 axis_y_, const TasInput::Tas* tas_input_)
-        : pad(pad_), axis_x(axis_x_), axis_y(axis_y_), tas_input(tas_input_) {}
-
-    float GetAxis(u32 axis) const {
-        std::lock_guard lock{mutex};
-        return tas_input->GetTasState(pad).axis.at(axis);
-    }
-
-    std::pair<float, float> GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const {
-        float x = GetAxis(analog_axis_x);
-        float y = GetAxis(analog_axis_y);
-
-        // Make sure the coordinates are in the unit circle,
-        // otherwise normalize it.
-        float r = x * x + y * y;
-        if (r > 1.0f) {
-            r = std::sqrt(r);
-            x /= r;
-            y /= r;
-        }
-
-        return {x, y};
-    }
-
-    std::tuple<float, float> GetStatus() const override {
-        return GetAnalog(axis_x, axis_y);
-    }
-
-    Input::AnalogProperties GetAnalogProperties() const override {
-        return {0.0f, 1.0f, 0.5f};
-    }
-
-private:
-    const u32 pad;
-    const u32 axis_x;
-    const u32 axis_y;
-    const TasInput::Tas* tas_input;
-    mutable std::mutex mutex;
-};
-
-/// An analog device factory that creates analog devices from GC Adapter
-TasAnalogFactory::TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_)
-    : tas_input(std::move(tas_input_)) {}
-
-/**
- * Creates analog device from joystick axes
- * @param params contains parameters for creating the device:
- *     - "port": the nth gcpad on the adapter
- *     - "axis_x": the index of the axis to be bind as x-axis
- *     - "axis_y": the index of the axis to be bind as y-axis
- */
-std::unique_ptr<Input::AnalogDevice> TasAnalogFactory::Create(const Common::ParamPackage& params) {
-    const auto pad = static_cast<u32>(params.Get("pad", 0));
-    const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
-    const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
-
-    return std::make_unique<TasAnalog>(pad, axis_x, axis_y, tas_input.get());
-}
-
-} // namespace InputCommon
diff --git a/src/input_common/tas/tas_poller.h b/src/input_common/tas/tas_poller.h
deleted file mode 100644
index 09e426cef..000000000
--- a/src/input_common/tas/tas_poller.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/frontend/input.h"
-#include "input_common/tas/tas_input.h"
-
-namespace InputCommon {
-
-/**
- * A button device factory representing a tas bot. It receives tas events and forward them
- * to all button devices it created.
- */
-class TasButtonFactory final : public Input::Factory<Input::ButtonDevice> {
-public:
-    explicit TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_);
-
-    /**
-     * Creates a button device from a button press
-     * @param params contains parameters for creating the device:
-     *     - "code": the code of the key to bind with the button
-     */
-    std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override;
-
-private:
-    std::shared_ptr<TasInput::Tas> tas_input;
-};
-
-/// An analog device factory that creates analog devices from tas
-class TasAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
-public:
-    explicit TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_);
-
-    std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override;
-
-private:
-    std::shared_ptr<TasInput::Tas> tas_input;
-};
-
-} // namespace InputCommon