boxart: use flycast-content github repo for arcade games screenshots

flyinghead · flyinghead · commit b2d8ad633df2 · 2025-09-26T15:30:01.000+02:00
diff --git a/core/ui/CMakeLists.txt b/core/ui/CMakeLists.txt
@@ -22,10 +22,12 @@ if(NOT LIBRETRO)
             settings_general.cpp
             settings_network.cpp
             settings_video.cpp
+            boxart/arcade_scraper.h
             boxart/boxart.cpp
             boxart/boxart.h
             boxart/gamesdb.cpp
             boxart/gamesdb.h
+            boxart/pvrparser.h
             boxart/scraper.cpp
             boxart/scraper.h)
 
diff --git a/core/ui/boxart/arcade_scraper.h b/core/ui/boxart/arcade_scraper.h
@@ -0,0 +1,77 @@
+/*
+	Copyright 2025 flyinghead
+
+	This file is part of Flycast.
+
+    Flycast is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    Flycast is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Flycast.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include "scraper.h"
+#include "oslib/http_client.h"
+
+class ArcadeScraper : public Scraper
+{
+public:
+	bool initialize(const std::string& saveDirectory) override;
+	void scrape(GameBoxart& item) override;
+};
+
+bool ArcadeScraper::initialize(const std::string& saveDirectory)
+{
+	if (!Scraper::initialize(saveDirectory))
+		return false;
+
+	http::init();
+
+	return true;
+}
+
+void ArcadeScraper::scrape(GameBoxart& item)
+{
+	if (item.fileName.empty() || !item.arcade)
+		// invalid rom or not an arcade game
+		return;
+	std::string filename = makeUniqueFilename("dummy.jpg");
+	std::string extension = get_file_extension(item.fileName);
+	if (extension == "zip" || extension == "7z")
+	{
+		std::string url = "https://flyinghead.github.io/flycast-content/arcade/jpg/" + get_file_basename(item.fileName) + ".jpg";
+		if (downloadImage(url, filename, true))
+		{
+			item.setBoxartPath(filename);
+			item.boxartUrl = url;
+			item.scraped = true;
+			return;
+		}
+	}
+	if (!item.uniqueId.empty())
+	{
+		bool valid = true;
+		for (char c : item.uniqueId)
+			if (c < ' ' || c > '~') {
+				valid = false;
+				break;
+			}
+		if (valid)
+		{
+			std::string url = "https://flyinghead.github.io/flycast-content/arcade/jpg/" + http::urlEncode(item.uniqueId) + ".jpg";
+			if (downloadImage(url, filename, true))
+			{
+				item.setBoxartPath(filename);
+				item.boxartUrl = url;
+				item.scraped = true;
+			}
+		}
+	}
+}
diff --git a/core/ui/boxart/boxart.cpp b/core/ui/boxart/boxart.cpp
@@ -21,6 +21,7 @@
 #include "../game_scanner.h"
 #include "oslib/oslib.h"
 #include "cfg/option.h"
+#include "arcade_scraper.h"
 #include <chrono>
 
 GameBoxart Boxart::getBoxart(const GameMedia& media)
@@ -50,6 +51,7 @@ GameBoxart Boxart::getBoxartAndLoad(const GameMedia& media)
 			{
 				boxart.busy = it->second.busy = true;
 				boxart.gamePath = media.path;
+				boxart.arcade = media.arcade;
 				toFetch.push_back(boxart);
 			}
 		}
@@ -60,6 +62,7 @@ GameBoxart Boxart::getBoxartAndLoad(const GameMedia& media)
 			boxart.name = media.name;
 			boxart.searchName = media.gameName;	// for arcade games
 			boxart.busy = true;
+			boxart.arcade = media.arcade;
 			games[boxart.fileName] = boxart;
 			toFetch.push_back(boxart);
 		}
@@ -83,14 +86,21 @@ void Boxart::fetchBoxart()
 			offlineScraper = std::unique_ptr<Scraper>(new OfflineScraper());
 			offlineScraper->initialize(getSaveDirectory());
 		}
-		if (config::FetchBoxart && scraper == nullptr)
+		if (config::FetchBoxart)
 		{
-			scraper = std::unique_ptr<Scraper>(new TheGamesDb());
-			if (!scraper->initialize(getSaveDirectory()))
+			if (scraper == nullptr)
 			{
-				ERROR_LOG(COMMON, "thegamesdb scraper initialization failed");
-				scraper.reset();
-				return;
+				scraper = std::unique_ptr<Scraper>(new TheGamesDb());
+				if (!scraper->initialize(getSaveDirectory()))
+				{
+					ERROR_LOG(COMMON, "thegamesdb scraper initialization failed");
+					scraper.reset();
+					return;
+				}
+			}
+			if (arcadeScraper == nullptr) {
+				arcadeScraper = std::make_unique<ArcadeScraper>();
+				arcadeScraper->initialize(getSaveDirectory());
 			}
 		}
 		std::vector<GameBoxart> boxart;
@@ -116,6 +126,7 @@ void Boxart::fetchBoxart()
 		if (config::FetchBoxart)
 		{
 			try {
+				arcadeScraper->scrape(boxart);
 				scraper->scrape(boxart);
 				{
 					std::lock_guard<std::mutex> guard(mutex);
diff --git a/core/ui/boxart/boxart.h b/core/ui/boxart/boxart.h
@@ -49,6 +49,7 @@ class Boxart
 	std::mutex mutex;
 	std::unique_ptr<Scraper> scraper;
 	std::unique_ptr<Scraper> offlineScraper;
+	std::unique_ptr<Scraper> arcadeScraper;
 	bool databaseLoaded = false;
 	bool databaseDirty = false;
 
diff --git a/core/ui/boxart/gamesdb.cpp b/core/ui/boxart/gamesdb.cpp
@@ -39,11 +39,6 @@ bool TheGamesDb::initialize(const std::string& saveDirectory)
 	return true;
 }
 
-TheGamesDb::~TheGamesDb()
-{
-	http::term();
-}
-
 void TheGamesDb::copyFile(const std::string& from, const std::string& to)
 {
 	FILE *ffrom = nowide::fopen(from.c_str(), "rb");
@@ -317,8 +312,8 @@ bool TheGamesDb::fetchGameInfo(GameBoxart& item, const std::string& url, const s
 
 void TheGamesDb::scrape(GameBoxart& item)
 {
-	if (item.searchName.empty())
-		// invalid rom or disk
+	if (item.searchName.empty() || item.arcade)
+		// invalid rom or disk, or arcade game
 		return;
 	fetchPlatforms();
 
@@ -395,8 +390,8 @@ void TheGamesDb::scrape(std::vector<GameBoxart>& items)
 				fetchByName(item);
 			else if (item.gamePath.empty())
 			{
-				std::string localPath = makeUniqueFilename("dreamcast_logo_grey.png");
-				std::string biosArtUrl{ "https://flyinghead.github.io/flycast-builds/dreamcast_logo_grey.png" };
+				std::string localPath = makeUniqueFilename("dreamcast_logo_grey.jpg");
+				std::string biosArtUrl{ "https://flyinghead.github.io/flycast-content/console/jpg/dreamcast_logo_grey.jpg" };
 				if (downloadImage(biosArtUrl, localPath)) {
 					item.setBoxartPath(localPath);
 					item.boxartUrl = biosArtUrl;
diff --git a/core/ui/boxart/gamesdb.h b/core/ui/boxart/gamesdb.h
@@ -32,7 +32,6 @@ class TheGamesDb : public Scraper
 	bool initialize(const std::string& saveDirectory) override;
 	void scrape(GameBoxart& item) override;
 	void scrape(std::vector<GameBoxart>& items) override;
-	~TheGamesDb() override;
 
 private:
 	void fetchPlatforms();
diff --git a/core/ui/boxart/scraper.cpp b/core/ui/boxart/scraper.cpp
@@ -18,6 +18,7 @@
  */
 #include "scraper.h"
 #include "oslib/http_client.h"
+#include "oslib/storage.h"
 #include "stdclass.h"
 #include "emulator.h"
 #include "imgread/common.h"
@@ -47,6 +48,7 @@ json GameBoxart::to_json(const std::string& baseArtPath) const
 		{ "boxart_url", boxartUrl },
 		{ "parsed", parsed },
 		{ "scraped", scraped },
+		{ "arcade", arcade },
 	};
 	return j;
 }
@@ -64,28 +66,32 @@ GameBoxart::GameBoxart(const json& j, const std::string& baseArtPath)
 	loadProperty(boxartUrl, j, "boxart_url");
 	loadProperty(parsed, j, "parsed");
 	loadProperty(scraped, j, "scraped");
+	loadProperty(arcade, j, "arcade");
 	if (!boxartPath.empty() && !isAbsolutePath(boxartPath))
 		boxartPath = baseArtPath + boxartPath;
 }
 
-bool Scraper::downloadImage(const std::string& url, const std::string& localName)
+bool Scraper::downloadImage(const std::string& url, const std::string& localName, bool mute)
 {
 	DEBUG_LOG(COMMON, "downloading %s", url.c_str());
 	std::vector<u8> content;
 	std::string contentType;
 	if (!http::success(http::get(url, content, contentType)))
 	{
-		WARN_LOG(COMMON, "downloadImage http error: %s", url.c_str());
+		if (!mute)
+			WARN_LOG(COMMON, "downloadImage http error: %s", url.c_str());
 		return false;
 	}
 	if (contentType.substr(0, 6) != "image/")
 	{
-		WARN_LOG(COMMON, "downloadImage bad content type %s", contentType.c_str());
+		if (!mute)
+			WARN_LOG(COMMON, "downloadImage bad content type %s", contentType.c_str());
 		return false;
 	}
 	if (content.empty())
 	{
-		WARN_LOG(COMMON, "downloadImage: empty content");
+		if (!mute)
+			WARN_LOG(COMMON, "downloadImage: empty content");
 		return false;
 	}
 	FILE *f = nowide::fopen(localName.c_str(), "wb");
@@ -251,5 +257,18 @@ void OfflineScraper::scrape(GameBoxart& item)
 				break;
 			item.searchName = trim_trailing_ws(item.searchName.substr(0, pos));
 		}
+		std::string extension = get_file_extension(item.fileName);
+		if (extension != "zip" && extension != "7z" && extension != "lst")
+		{
+			FILE *file = hostfs::storage().openFile(item.gamePath, "rb");
+			if (file != nullptr)
+			{
+				fseek(file, 0x30, SEEK_SET);
+				u8 buf[0x20];
+				if (fread(buf, 1, sizeof(buf), file) == sizeof(buf))
+					item.uniqueId = trim_trailing_ws(std::string(&buf[0], &buf[0x20]));
+				fclose(file);
+			}
+		}
 	}
 }
diff --git a/core/ui/boxart/scraper.h b/core/ui/boxart/scraper.h
@@ -40,6 +40,7 @@ struct GameBoxart
 	std::string boxartPath;
 	std::string boxartUrl;
 
+	bool arcade = false;
 	bool parsed = false;
 	bool scraped = false;
 	bool busy = false;
@@ -87,7 +88,7 @@ class Scraper
 	virtual ~Scraper() = default;
 
 protected:
-	bool downloadImage(const std::string& url, const std::string& localName);
+	bool downloadImage(const std::string& url, const std::string& localName, bool mute = false);
 	std::string makeUniqueFilename(const std::string& url);
 
 private:
diff --git a/core/ui/game_scanner.cpp b/core/ui/game_scanner.cpp
@@ -24,7 +24,8 @@
 
 static bool operator<(const GameMedia &left, const GameMedia &right)
 {
-	return left.name < right.name;
+	return (int)left.arcade < (int)right.arcade
+			|| (left.arcade == right.arcade && left.name < right.name);
 }
 
 void GameScanner::insert_game(const GameMedia& game)
@@ -33,11 +34,6 @@ void GameScanner::insert_game(const GameMedia& game)
 	game_list.insert(std::upper_bound(game_list.begin(), game_list.end(), game), game);
 }
 
-void GameScanner::insert_arcade_game(const GameMedia& game)
-{
-	arcade_game_list.insert(std::upper_bound(arcade_game_list.begin(), arcade_game_list.end(), game), game);
-}
-
 void GameScanner::add_game_directory(const std::string& path)
 {
 	hostfs::DirectoryTree tree(path);
@@ -83,13 +79,13 @@ void GameScanner::add_game_directory(const std::string& path)
 				continue;
 			gameName = it->second->description;
 			fileName = fileName + " (" + gameName + ")";
-			insert_arcade_game(GameMedia{ fileName, item.path, item.name, gameName });
+			insert_game(GameMedia{ fileName, item.path, item.name, gameName, true });
 			continue;
 		}
 		else if (extension == "bin" || extension == "lst" || extension == "dat")
 		{
 			if (!config::HideLegacyNaomiRoms)
-				insert_arcade_game(GameMedia{ fileName, item.path, item.name, gameName });
+				insert_game(GameMedia{ fileName, item.path, item.name, gameName, true });
 			continue;
 		}
 		else if (extension == "chd" || extension == "gdi")
@@ -139,7 +135,6 @@ void GameScanner::fetch_game_list()
 				LockGuard _(mutex);
 				game_list.clear();
 			}
-			arcade_game_list.clear();
 			for (const auto& path : config::ContentPath.get())
 			{
 				try {
@@ -162,13 +157,11 @@ void GameScanner::fetch_game_list()
 						name = it->substr(4);
 					else
 						name = *it;
-					game_list.insert(game_list.begin(), { name, *it, name, "", true });
+					game_list.insert(game_list.begin(), { name, *it, name, "", false, true });
 				}
 				// Dreamcast BIOS
 				if (!dcbios.empty())
 					game_list.insert(game_list.begin(), { "Dreamcast BIOS" });
-				// Arcade games
-				game_list.insert(game_list.end(), arcade_game_list.begin(), arcade_game_list.end());
 			}
 			if (running)
 				scan_done = true;
diff --git a/core/ui/game_scanner.h b/core/ui/game_scanner.h
@@ -32,13 +32,13 @@ struct GameMedia
 	std::string path;		// Full path to rom. May be an encoded uri
 	std::string fileName;	// Last component of the path, decoded
 	std::string gameName;	// for arcade games only, description from the rom list
+	bool arcade = false;	// Arcade game (naomi, atomiswave, system sp, ...)
 	bool device = false;	// Corresponds to a physical cdrom device
 };
 
 class GameScanner
 {
 	std::vector<GameMedia> game_list;
-	std::vector<GameMedia> arcade_game_list;
 	std::mutex mutex;
 	std::mutex threadMutex;
 	std::unique_ptr<std::thread> scan_thread;
@@ -49,7 +49,7 @@ class GameScanner
 	using LockGuard = std::lock_guard<std::mutex>;
 
 	void insert_game(const GameMedia& game);
-	void insert_arcade_game(const GameMedia& game);
+	void insert_arcade_game(GameMedia game);
 	void add_game_directory(const std::string& path);
 
 public:

Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`#include "../game_scanner.h"`
`22`	`22`	`#include "oslib/oslib.h"`
`23`	`23`	`#include "cfg/option.h"`
	`24`	`+#include "arcade_scraper.h"`
`24`	`25`	`#include <chrono>`
`25`	`26`
`26`	`27`	`GameBoxart Boxart::getBoxart(const GameMedia& media)`
`@@ -50,6 +51,7 @@ GameBoxart Boxart::getBoxartAndLoad(const GameMedia& media)`
`50`	`51`	`{`
`51`	`52`	`boxart.busy = it->second.busy = true;`
`52`	`53`	`boxart.gamePath = media.path;`
	`54`	`+ boxart.arcade = media.arcade;`
`53`	`55`	`toFetch.push_back(boxart);`
`54`	`56`	`}`
`55`	`57`	`}`
`@@ -60,6 +62,7 @@ GameBoxart Boxart::getBoxartAndLoad(const GameMedia& media)`
`60`	`62`	`boxart.name = media.name;`
`61`	`63`	`boxart.searchName = media.gameName; // for arcade games`
`62`	`64`	`boxart.busy = true;`
	`65`	`+ boxart.arcade = media.arcade;`
`63`	`66`	`games[boxart.fileName] = boxart;`
`64`	`67`	`toFetch.push_back(boxart);`
`65`	`68`	`}`
`@@ -83,14 +86,21 @@ void Boxart::fetchBoxart()`
`83`	`86`	`offlineScraper = std::unique_ptr<Scraper>(new OfflineScraper());`
`84`	`87`	`offlineScraper->initialize(getSaveDirectory());`
`85`	`88`	`}`
`86`		`- if (config::FetchBoxart && scraper == nullptr)`
	`89`	`+ if (config::FetchBoxart)`
`87`	`90`	`{`
`88`		`- scraper = std::unique_ptr<Scraper>(new TheGamesDb());`
`89`		`- if (!scraper->initialize(getSaveDirectory()))`
	`91`	`+ if (scraper == nullptr)`
`90`	`92`	`{`
`91`		`- ERROR_LOG(COMMON, "thegamesdb scraper initialization failed");`
`92`		`- scraper.reset();`
`93`		`- return;`
	`93`	`+ scraper = std::unique_ptr<Scraper>(new TheGamesDb());`
	`94`	`+ if (!scraper->initialize(getSaveDirectory()))`
	`95`	`+ {`
	`96`	`+ ERROR_LOG(COMMON, "thegamesdb scraper initialization failed");`
	`97`	`+ scraper.reset();`
	`98`	`+ return;`
	`99`	`+ }`
	`100`	`+ }`
	`101`	`+ if (arcadeScraper == nullptr) {`
	`102`	`+ arcadeScraper = std::make_unique<ArcadeScraper>();`
	`103`	`+ arcadeScraper->initialize(getSaveDirectory());`
`94`	`104`	`}`
`95`	`105`	`}`
`96`	`106`	`std::vector<GameBoxart> boxart;`
`@@ -116,6 +126,7 @@ void Boxart::fetchBoxart()`
`116`	`126`	`if (config::FetchBoxart)`
`117`	`127`	`{`
`118`	`128`	`try {`
	`129`	`+ arcadeScraper->scrape(boxart);`
`119`	`130`	`scraper->scrape(boxart);`
`120`	`131`	`{`
`121`	`132`	`std::lock_guard<std::mutex> guard(mutex);`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,8 @@`
`24`	`24`
`25`	`25`	`static bool operator<(const GameMedia &left, const GameMedia &right)`
`26`	`26`	`{`
`27`		`- return left.name < right.name;`
	`27`	`+ return (int)left.arcade < (int)right.arcade`
	`28`	`+ \|\| (left.arcade == right.arcade && left.name < right.name);`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`void GameScanner::insert_game(const GameMedia& game)`
`@@ -33,11 +34,6 @@ void GameScanner::insert_game(const GameMedia& game)`
`33`	`34`	`game_list.insert(std::upper_bound(game_list.begin(), game_list.end(), game), game);`
`34`	`35`	`}`
`35`	`36`
`36`		`-void GameScanner::insert_arcade_game(const GameMedia& game)`
`37`		`-{`
`38`		`- arcade_game_list.insert(std::upper_bound(arcade_game_list.begin(), arcade_game_list.end(), game), game);`
`39`		`-}`
`40`		`-`
`41`	`37`	`void GameScanner::add_game_directory(const std::string& path)`
`42`	`38`	`{`
`43`	`39`	`hostfs::DirectoryTree tree(path);`
`@@ -83,13 +79,13 @@ void GameScanner::add_game_directory(const std::string& path)`
`83`	`79`	`continue;`
`84`	`80`	`gameName = it->second->description;`
`85`	`81`	`fileName = fileName + " (" + gameName + ")";`
`86`		`- insert_arcade_game(GameMedia{ fileName, item.path, item.name, gameName });`
	`82`	`+ insert_game(GameMedia{ fileName, item.path, item.name, gameName, true });`
`87`	`83`	`continue;`
`88`	`84`	`}`
`89`	`85`	`else if (extension == "bin" \|\| extension == "lst" \|\| extension == "dat")`
`90`	`86`	`{`
`91`	`87`	`if (!config::HideLegacyNaomiRoms)`
`92`		`- insert_arcade_game(GameMedia{ fileName, item.path, item.name, gameName });`
	`88`	`+ insert_game(GameMedia{ fileName, item.path, item.name, gameName, true });`
`93`	`89`	`continue;`
`94`	`90`	`}`
`95`	`91`	`else if (extension == "chd" \|\| extension == "gdi")`
`@@ -139,7 +135,6 @@ void GameScanner::fetch_game_list()`
`139`	`135`	`LockGuard _(mutex);`
`140`	`136`	`game_list.clear();`
`141`	`137`	`}`
`142`		`- arcade_game_list.clear();`
`143`	`138`	`for (const auto& path : config::ContentPath.get())`
`144`	`139`	`{`
`145`	`140`	`try {`
`@@ -162,13 +157,11 @@ void GameScanner::fetch_game_list()`
`162`	`157`	`name = it->substr(4);`
`163`	`158`	`else`
`164`	`159`	`name = *it;`
`165`		`- game_list.insert(game_list.begin(), { name, *it, name, "", true });`
	`160`	`+ game_list.insert(game_list.begin(), { name, *it, name, "", false, true });`
`166`	`161`	`}`
`167`	`162`	`// Dreamcast BIOS`
`168`	`163`	`if (!dcbios.empty())`
`169`	`164`	`game_list.insert(game_list.begin(), { "Dreamcast BIOS" });`
`170`		`- // Arcade games`
`171`		`- game_list.insert(game_list.end(), arcade_game_list.begin(), arcade_game_list.end());`
`172`	`165`	`}`
`173`	`166`	`if (running)`
`174`	`167`	`scan_done = true;`