GC controller input using named pipes

Currently only works on unix, but can be extended to other systems. Can
also be extended to do wiimotes.

Searches the Pipes folder for readable named pipes and creates a dolphin
input device out of them. Send controller inputs to the game by writing
to the file. Commands are described in Pipes.h.

CMakeLists.txt

@@ -541,6 +541,11 @@ if(ENABLE_EVDEV)
 	endif()
 endif()
 
+if(UNIX)
+	message("Using named pipes as controller inputs")
+	add_definitions(-DUSE_PIPES=1)
+endif()
+
 ########################################
 # Setup include directories (and make sure they are preferred over the Externals)
 #

Source/Core/Common/CommonPaths.h

@@ -75,6 +75,7 @@
 #define WII_WC24CONF_DIR    "shared2" DIR_SEP "wc24"
 #define THEMES_DIR          "Themes"
 #define ANAGLYPH_DIR        "Anaglyph"
+#define PIPES_DIR           "Pipes"
 
 // Filenames
 // Files in the directory returned by GetUserPath(D_CONFIG_IDX)

Source/Core/Common/FileUtil.cpp

@@ -790,6 +790,7 @@ static void RebuildUserDirectories(unsigned int dir_index)
 		s_user_paths[D_LOGS_IDX]           = s_user_paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
 		s_user_paths[D_MAILLOGS_IDX]       = s_user_paths[D_LOGS_IDX] + MAIL_LOGS_DIR DIR_SEP;
 		s_user_paths[D_THEMES_IDX]         = s_user_paths[D_USER_IDX] + THEMES_DIR DIR_SEP;
+		s_user_paths[D_PIPES_IDX]          = s_user_paths[D_USER_IDX] + PIPES_DIR DIR_SEP;
 		s_user_paths[F_DOLPHINCONFIG_IDX]  = s_user_paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
 		s_user_paths[F_DEBUGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
 		s_user_paths[F_LOGGERCONFIG_IDX]   = s_user_paths[D_CONFIG_IDX] + LOGGER_CONFIG;

Source/Core/Common/FileUtil.h

@@ -41,6 +41,7 @@ enum {
 	D_LOGS_IDX,
 	D_MAILLOGS_IDX,
 	D_THEMES_IDX,
+	D_PIPES_IDX,
 	F_DOLPHINCONFIG_IDX,
 	F_DEBUGGERCONFIG_IDX,
 	F_LOGGERCONFIG_IDX,

Source/Core/InputCommon/CMakeLists.txt

@@ -42,6 +42,10 @@ if(LIBEVDEV_FOUND AND LIBUDEV_FOUND)
 	set(LIBS ${LIBS} ${LIBEVDEV_LIBRARY} ${LIBUDEV_LIBRARY})
 endif()
 
+if(UNIX)
+	set(SRCS ${SRCS} ControllerInterface/Pipes/Pipes.cpp)
+endif()
+
 if(SDL_FOUND OR SDL2_FOUND)
 	set(SRCS ${SRCS} ControllerInterface/SDL/SDL.cpp)
 	if (SDL2_FOUND)

Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp

@@ -29,6 +29,9 @@
 #ifdef CIFACE_USE_EVDEV
 	#include "InputCommon/ControllerInterface/evdev/evdev.h"
 #endif
+#ifdef CIFACE_USE_PIPES
+	#include "InputCommon/ControllerInterface/Pipes/Pipes.h"
+#endif
 
 using namespace ciface::ExpressionParser;
 
@@ -75,6 +78,9 @@ void ControllerInterface::Initialize(void* const hwnd)
 #ifdef CIFACE_USE_EVDEV
 	ciface::evdev::Init(m_devices);
 #endif
+#ifdef CIFACE_USE_PIPES
+	ciface::Pipes::Init(m_devices);
+#endif
 
 	m_is_init = true;
 }

Source/Core/InputCommon/ControllerInterface/ControllerInterface.h

@@ -38,6 +38,9 @@
 #if defined(HAVE_LIBEVDEV) && defined(HAVE_LIBUDEV)
 	#define CIFACE_USE_EVDEV
 #endif
+#if defined(USE_PIPES)
+	#define CIFACE_USE_PIPES
+#endif
 
 //
 // ControllerInterface

Source/Core/InputCommon/ControllerInterface/Pipes/Pipes.cpp

@@ -0,0 +1,180 @@
+// Copyright 2015 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <array>
+#include <cstdlib>
+#include <fcntl.h>
+#include <iostream>
+#include <map>
+#include <string>
+#include <unistd.h>
+#include <vector>
+#include <sys/stat.h>
+
+#include "Common/FileUtil.h"
+#include "Common/MathUtil.h"
+#include "Common/StringUtil.h"
+#include "InputCommon/ControllerInterface/Pipes/Pipes.h"
+
+namespace ciface
+{
+namespace Pipes
+{
+
+static const std::array<std::string, 12> s_button_tokens
+{{
+	"A",
+	"B",
+	"X",
+	"Y",
+	"Z",
+	"START",
+	"L",
+	"R",
+	"D_UP",
+	"D_DOWN",
+	"D_LEFT",
+	"D_RIGHT"
+}};
+
+static const std::array<std::string, 2> s_shoulder_tokens
+{{
+	"L",
+	"R"
+}};
+
+static const std::array<std::string, 2> s_axis_tokens
+{{
+	"MAIN",
+	"C"
+}};
+
+void Init(std::vector<Core::Device*>& devices)
+{
+	// Search the Pipes directory for files that we can open in read-only,
+	// non-blocking mode. The device name is the virtual name of the file.
+	File::FSTEntry fst;
+	int found = 0;
+	std::string dir_path = File::GetUserPath(D_PIPES_IDX);
+	if (!File::Exists(dir_path))
+		return;
+	fst = File::ScanDirectoryTree(dir_path, false);
+	if (!fst.isDirectory)
+		return;
+	for (unsigned int i = 0; i < fst.size; ++i)
+	{
+		const File::FSTEntry& child = fst.children[i];
+		if (child.isDirectory)
+			continue;
+		int fd = open(child.physicalName.c_str(), O_RDONLY | O_NONBLOCK);
+		if (fd < 0)
+			continue;
+		devices.push_back(new PipeDevice(fd, child.virtualName, found++));
+	}
+}
+
+PipeDevice::PipeDevice(int fd, const std::string& name, int id)
+	: m_fd(fd), m_name(name), m_id(id)
+{
+	for (const auto& tok : s_button_tokens)
+	{
+		PipeInput* btn = new PipeInput("Button " + tok);
+		AddInput(btn);
+		m_buttons[tok] = btn;
+	}
+	for (const auto& tok : s_shoulder_tokens)
+	{
+		AddAxis(tok, 0.0);
+	}
+	for (const auto& tok : s_axis_tokens)
+	{
+		AddAxis(tok + " X", 0.5);
+		AddAxis(tok + " Y", 0.5);
+	}
+}
+
+PipeDevice::~PipeDevice()
+{
+	close(m_fd);
+}
+
+void PipeDevice::UpdateInput()
+{
+	// Read any pending characters off the pipe. If we hit a newline,
+	// then dequeue a command off the front of m_buf and parse it.
+	char buf[32];
+	ssize_t bytes_read = read(m_fd, buf, sizeof buf);
+	while (bytes_read > 0)
+	{
+		m_buf.append(buf, bytes_read);
+		bytes_read = read(m_fd, buf, sizeof buf);
+	}
+	std::size_t newline = m_buf.find("\n");
+	std::size_t erase_until = 0;
+	while (newline != std::string::npos)
+	{
+		std::string command = m_buf.substr(0, newline);
+		ParseCommand(command);
+		erase_until = newline + 1;
+		newline = m_buf.find("\n", erase_until);
+	}
+	m_buf.erase(0, erase_until);
+}
+
+void PipeDevice::AddAxis(const std::string& name, double value)
+{
+	// Dolphin uses separate axes for left/right, which complicates things.
+	PipeInput* ax_hi = new PipeInput("Axis " + name + " +");
+	ax_hi->SetState(value);
+	PipeInput* ax_lo = new PipeInput("Axis " + name + " -");
+	ax_lo->SetState(value);
+	m_axes[name + " +"] = ax_hi;
+	m_axes[name + " -"] = ax_lo;
+	AddAnalogInputs(ax_lo, ax_hi);
+}
+
+void PipeDevice::SetAxis(const std::string& entry, double value)
+{
+	value = MathUtil::Clamp(value, 0.0, 1.0);
+	double hi = std::max(0.0, value - 0.5) * 2.0;
+	double lo = (0.5 - std::min(0.5, value)) * 2.0;
+	auto search_hi = m_axes.find(entry + " +");
+	if (search_hi != m_axes.end())
+		search_hi->second->SetState(hi);
+	auto search_lo = m_axes.find(entry + " -");
+	if (search_lo != m_axes.end())
+		search_lo->second->SetState(lo);
+}
+
+void PipeDevice::ParseCommand(const std::string& command)
+{
+	std::vector<std::string> tokens;
+	SplitString(command, ' ', tokens);
+	if (tokens.size() < 2 || tokens.size() > 4)
+		return;
+	if (tokens[0] == "PRESS" || tokens[0] == "RELEASE")
+	{
+		auto search = m_buttons.find(tokens[1]);
+		if (search != m_buttons.end())
+			search->second->SetState(tokens[0] == "PRESS" ? 1.0 : 0.0);
+	}
+	else if (tokens[0] == "SET")
+	{
+		if (tokens.size() == 3)
+		{
+			double value = strtod(tokens[2].c_str(), nullptr);
+			SetAxis(tokens[1], (value / 2.0) + 0.5);
+		}
+		else
+		{
+			double x = strtod(tokens[2].c_str(), nullptr);
+			double y = strtod(tokens[3].c_str(), nullptr);
+			SetAxis(tokens[1] + " X", x);
+			SetAxis(tokens[1] + " Y", y);
+		}
+	}
+}
+
+}
+}

Source/Core/InputCommon/ControllerInterface/Pipes/Pipes.h

@@ -0,0 +1,65 @@
+// Copyright 2015 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "InputCommon/ControllerInterface/Device.h"
+
+namespace ciface
+{
+namespace Pipes
+{
+// To create a piped controller input, create a named pipe in the
+// Pipes directory and write commands out to it. Commands are separated
+// by a newline character, with spaces separating command tokens.
+// Command syntax is as follows, where curly brackets are one-of and square
+// brackets are inclusive numeric ranges. Cases are sensitive. Numeric inputs
+// are clamped to [0, 1] and otherwise invalid commands are discarded.
+// {PRESS, RELEASE} {A, B, X, Y, Z, START, L, R, D_UP, D_DOWN, D_LEFT, D_RIGHT}
+// SET {L, R} [0, 1]
+// SET {MAIN, C} [0, 1] [0, 1]
+
+void Init(std::vector<Core::Device*>& devices);
+
+class PipeDevice : public Core::Device
+{
+public:
+	PipeDevice(int fd, const std::string& name, int id);
+	~PipeDevice();
+
+	void UpdateInput() override;
+	std::string GetName() const override { return m_name; }
+	int GetId() const override { return m_id; }
+	std::string GetSource() const override { return "Pipe"; }
+
+private:
+	class PipeInput : public Input
+	{
+	public:
+		PipeInput(const std::string& name) : m_name(name), m_state(0.0) {}
+		std::string GetName() const override { return m_name; }
+		ControlState GetState() const override { return m_state; }
+		void SetState(ControlState state) { m_state = state; }
+	private:
+		const std::string m_name;
+		ControlState m_state;
+	};
+
+	void AddAxis(const std::string& name, double value);
+	void ParseCommand(const std::string& command);
+	void SetAxis(const std::string& entry, double value);
+
+	const int m_fd;
+	const std::string m_name;
+	const int m_id;
+	std::string m_buf;
+	std::map<std::string, PipeInput*> m_buttons;
+	std::map<std::string, PipeInput*> m_axes;
+};
+}
+}