Port dolphin to SFML 2.1

CMakeLists.txt

@@ -600,16 +600,15 @@ if(LIBUSB_FOUND)
 	include_directories(${LIBUSB_INCLUDE_DIR})
 endif(LIBUSB_FOUND)
 
-set(SFML_FIND_VERSION TRUE)
-set(SFML_FIND_VERSION_MAJOR 1)
-set(SFML_FIND_VERSION_MINOR 5)
+set(SFML_REQD_VERSION 2.1)
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT ANDROID)
-	include(FindSFML OPTIONAL)
+	find_package(SFML ${SFML_REQD_VERSION} COMPONENTS network system)
 endif()
-if(SFML_FOUND AND NOT SFML_VERSION_MAJOR) # SFML 1.x doesn't define SFML_VERSION_MAJOR
+if(SFML_FOUND)
 	message("Using shared SFML")
 else()
-	message("Using static SFML ${SFML_FIND_VERSION_MAJOR}.${SFML_FIND_VERSION_MINOR} from Externals")
+	message("Using static SFML ${SFML_REQD_VERSION} from Externals")
+	add_definitions(-DSFML_STATIC)
 	add_subdirectory(Externals/SFML)
 	include_directories(BEFORE Externals/SFML/include)
 endif()

Externals/SFML/CMakeLists.txt

@@ -23,6 +23,5 @@ set(SRC_SYSTEM
 	src/SFML/System/Time.cpp
 )
 
-add_definitions(-DSFML_STATIC)
 add_library(sfml-network ${SRC_NETWORK})
 add_library(sfml-system ${SRC_SYSTEM})

Source/Core/Core/CMakeLists.txt

@@ -238,6 +238,7 @@ set(LIBS
 	inputcommon
 	${LZO}
 	sfml-network
+	sfml-system
 	videoogl
 	videosoftware
 	z

Source/Core/Core/HW/EXI_DeviceGecko.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2
 // Refer to the license.txt file included.
 
+#include "Common/StdMakeUnique.h"
 #include "Core/Core.h"
 #include "Core/HW/EXI_Device.h"
 #include "Core/HW/EXI_DeviceGecko.h"
@@ -10,8 +11,8 @@ u16                       GeckoSockServer::server_port;
 int                       GeckoSockServer::client_count;
 std::thread               GeckoSockServer::connectionThread;
 volatile bool             GeckoSockServer::server_running;
-std::queue<sf::SocketTCP> GeckoSockServer::waiting_socks;
 std::mutex                GeckoSockServer::connection_lock;
+std::queue<std::unique_ptr<sf::TcpSocket>> GeckoSockServer::waiting_socks;
 
 GeckoSockServer::GeckoSockServer()
 	: client_running(false)
@@ -41,11 +42,12 @@ void GeckoSockServer::GeckoConnectionWaiter()
 {
 	Common::SetCurrentThreadName("Gecko Connection Waiter");
 
-	sf::SocketTCP server;
+	sf::TcpListener server;
 	server_port = 0xd6ec; // "dolphin gecko"
 	for (int bind_tries = 0; bind_tries <= 10 && !server_running; bind_tries++)
 	{
-		if (!(server_running = server.Listen(server_port)))
+		server_running = server.listen(server_port) == sf::Socket::Done;
+		if (!server_running)
 			server_port++;
 	}
 
@@ -56,30 +58,31 @@ void GeckoSockServer::GeckoConnectionWaiter()
 		StringFromFormat("USBGecko: Listening on TCP port %u", server_port),
 		5000);
 
-	server.SetBlocking(false);
+	server.setBlocking(false);
 
-	sf::SocketTCP new_client;
+	auto new_client = std::make_unique<sf::TcpSocket>();
 	while (server_running)
 	{
-		if (server.Accept(new_client) == sf::Socket::Done)
+		if (server.accept(*new_client) == sf::Socket::Done)
 		{
 			std::lock_guard<std::mutex> lk(connection_lock);
-			waiting_socks.push(new_client);
+			waiting_socks.push(std::move(new_client));
+
+			new_client = std::make_unique<sf::TcpSocket>();
 		}
 		SLEEP(1);
 	}
-	server.Close();
 }
 
-bool GeckoSockServer::GetAvailableSock(sf::SocketTCP &sock_to_fill)
+bool GeckoSockServer::GetAvailableSock()
 {
 	bool sock_filled = false;
 
 	std::lock_guard<std::mutex> lk(connection_lock);
 
 	if (!waiting_socks.empty())
 	{
-		sock_to_fill = waiting_socks.front();
+		client = std::move(waiting_socks.front());
 		if (clientThread.joinable())
 		{
 			client_running = false;
@@ -103,7 +106,7 @@ void GeckoSockServer::ClientThread()
 
 	Common::SetCurrentThreadName("Gecko Client");
 
-	client.SetBlocking(false);
+	client->setBlocking(false);
 
 	while (client_running)
 	{
@@ -116,7 +119,7 @@ void GeckoSockServer::ClientThread()
 		char data[128];
 		std::size_t got = 0;
 
-		if (client.Receive(&data[0], ArraySize(data), got) == sf::Socket::Disconnected)
+		if (client->receive(&data[0], ArraySize(data), got) == sf::Socket::Disconnected)
 			client_running = false;
 
 		if (got != 0)
@@ -133,7 +136,7 @@ void GeckoSockServer::ClientThread()
 			std::vector<char> packet(send_fifo.begin(), send_fifo.end());
 			send_fifo.clear();
 
-			if (client.Send(&packet[0], packet.size()) == sf::Socket::Disconnected)
+			if (client->send(&packet[0], packet.size()) == sf::Socket::Disconnected)
 				client_running = false;
 		}
 		} // unlock transfer
@@ -142,16 +145,16 @@ void GeckoSockServer::ClientThread()
 			Common::YieldCPU();
 	}
 
-	client.Close();
+	client->disconnect();
 }
 
 void CEXIGecko::ImmReadWrite(u32 &_uData, u32 _uSize)
 {
 	// We don't really care about _uSize
 	(void)_uSize;
 
-	if (!client.IsValid())
-		GetAvailableSock(client);
+	if (!client || client->getLocalPort() == 0)
+		GetAvailableSock();
 
 	switch (_uData >> 28)
 	{

Source/Core/Core/HW/EXI_DeviceGecko.h

@@ -14,15 +14,14 @@
 #include "Core/HW/EXI_Device.h"
 
 class GeckoSockServer
-	: public sf::SocketTCP
 {
 public:
 	GeckoSockServer();
 	~GeckoSockServer();
-	bool GetAvailableSock(sf::SocketTCP &sock_to_fill);
+	bool GetAvailableSock();
 
 	// Client for this server object
-	sf::SocketTCP client;
+	std::unique_ptr<sf::TcpSocket> client;
 	void ClientThread();
 	std::thread clientThread;
 	std::mutex transfer_lock;
@@ -40,8 +39,8 @@ class GeckoSockServer
 	static u16                       server_port;
 	static volatile bool             server_running;
 	static std::thread               connectionThread;
-	static std::queue<sf::SocketTCP> waiting_socks;
 	static std::mutex                connection_lock;
+	static std::queue<std::unique_ptr<sf::TcpSocket>> waiting_socks;
 };
 
 class CEXIGecko

Source/Core/Core/HW/SI_DeviceGBA.cpp

@@ -5,6 +5,7 @@
 #include <queue>
 
 #include "Common/CommonFuncs.h"
+#include "Common/StdMakeUnique.h"
 #include "Common/Thread.h"
 #include "Common/Logging/Log.h"
 #include "Core/HW/SI_Device.h"
@@ -13,7 +14,7 @@
 #include "SFML/Network.hpp"
 
 static std::thread connectionThread;
-static std::queue<sf::SocketTCP> waiting_socks;
+static std::queue<std::unique_ptr<sf::TcpSocket>> waiting_socks;
 static std::mutex cs_gba;
 namespace { volatile bool server_running; }
 
@@ -25,25 +26,25 @@ static void GBAConnectionWaiter()
 
 	Common::SetCurrentThreadName("GBA Connection Waiter");
 
-	sf::SocketTCP server;
+	sf::TcpListener server;
 	// "dolphin gba"
-	if (!server.Listen(0xd6ba))
+	if (server.listen(0xd6ba) != sf::Socket::Done)
 		return;
 
-	server.SetBlocking(false);
+	server.setBlocking(false);
 
-	sf::SocketTCP new_client;
+	auto new_client = std::make_unique<sf::TcpSocket>();
 	while (server_running)
 	{
-		if (server.Accept(new_client) == sf::Socket::Done)
+		if (server.accept(*new_client) == sf::Socket::Done)
 		{
 			std::lock_guard<std::mutex> lk(cs_gba);
-			waiting_socks.push(new_client);
+			waiting_socks.push(std::move(new_client));
+
+			new_client = std::make_unique<sf::TcpSocket>();
 		}
 		SLEEP(1);
 	}
-	server.Close();
-	return;
 }
 
 void GBAConnectionWaiter_Shutdown()
@@ -53,15 +54,15 @@ void GBAConnectionWaiter_Shutdown()
 		connectionThread.join();
 }
 
-static bool GetAvailableSock(sf::SocketTCP& sock_to_fill)
+static bool GetAvailableSock(std::unique_ptr<sf::TcpSocket>& sock_to_fill)
 {
 	bool sock_filled = false;
 
 	std::lock_guard<std::mutex> lk(cs_gba);
 
 	if (!waiting_socks.empty())
 	{
-		sock_to_fill = waiting_socks.front();
+		sock_to_fill = std::move(waiting_socks.front());
 		waiting_socks.pop();
 		sock_filled = true;
 	}
@@ -77,13 +78,12 @@ GBASockServer::GBASockServer()
 
 GBASockServer::~GBASockServer()
 {
-	client.Close();
 }
 
 // Blocking, since GBA must always send lower byte of REG_JOYSTAT
 void GBASockServer::Transfer(char* si_buffer)
 {
-	if (!client.IsValid())
+	if (!client || client->getLocalPort() == 0)
 		if (!GetAvailableSock(client))
 			return;
 
@@ -93,18 +93,18 @@ void GBASockServer::Transfer(char* si_buffer)
 	u8 cmd = *current_data;
 
 	if (cmd == CMD_WRITE)
-		client.Send(current_data, sizeof(current_data));
+		client->send(current_data, sizeof(current_data));
 	else
-		client.Send(current_data, 1);
+		client->send(current_data, 1);
 
 	DEBUG_LOG(SERIALINTERFACE, "> command %02x %02x%02x%02x%02x",
 		(u8)current_data[0], (u8)current_data[1], (u8)current_data[2],
 		(u8)current_data[3], (u8)current_data[4]);
 
 	memset(current_data, 0, sizeof(current_data));
 	size_t num_received = 0;
-	if (client.Receive(current_data, sizeof(current_data), num_received) == sf::Socket::Disconnected)
-		client.Close();
+	if (client->receive(current_data, sizeof(current_data), num_received) == sf::Socket::Disconnected)
+		client->disconnect();
 
 	DEBUG_LOG(SERIALINTERFACE, "< %02x%02x%02x%02x%02x",
 		(u8)current_data[0], (u8)current_data[1], (u8)current_data[2],

Source/Core/Core/HW/SI_DeviceGBA.h

@@ -12,7 +12,7 @@
 
 void GBAConnectionWaiter_Shutdown();
 
-class GBASockServer : public sf::SocketTCP
+class GBASockServer
 {
 public:
 	GBASockServer();
@@ -29,7 +29,7 @@ class GBASockServer : public sf::SocketTCP
 		CMD_WRITE  = 0x15
 	};
 
-	sf::SocketTCP client;
+	std::unique_ptr<sf::TcpSocket> client;
 	char current_data[5];
 };
 

Source/Core/Core/HW/WiimoteReal/WiimoteReal.cpp

@@ -203,10 +203,10 @@ bool Wiimote::Read()
 		if (SConfig::GetInstance().m_LocalCoreStartupParameter.iBBDumpPort > 0 &&
 		    index == WIIMOTE_BALANCE_BOARD)
 		{
-			static sf::SocketUDP Socket;
-			Socket.Send((char*)rpt.data(),
+			static sf::UdpSocket Socket;
+			Socket.send((char*)rpt.data(),
 			            rpt.size(),
-			            sf::IPAddress::LocalHost,
+			            sf::IpAddress::LocalHost,
 		                SConfig::GetInstance().m_LocalCoreStartupParameter.iBBDumpPort);
 		}
 
@@ -236,8 +236,8 @@ bool Wiimote::Write()
 		{
 			if (SConfig::GetInstance().m_LocalCoreStartupParameter.iBBDumpPort > 0 && index == WIIMOTE_BALANCE_BOARD)
 			{
-				static sf::SocketUDP Socket;
-				Socket.Send((char*)rpt.data(), rpt.size(), sf::IPAddress::LocalHost, SConfig::GetInstance().m_LocalCoreStartupParameter.iBBDumpPort);
+				static sf::UdpSocket Socket;
+				Socket.send((char*)rpt.data(), rpt.size(), sf::IpAddress::LocalHost, SConfig::GetInstance().m_LocalCoreStartupParameter.iBBDumpPort);
 			}
 			IOWrite(rpt.data(), rpt.size());