Massive removal of unused modules
							
								
								
									
										12
									
								
								.gitmodules
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -4,12 +4,6 @@ | ||||
| [submodule "boost"] | ||||
|     path = externals/boost | ||||
|     url = https://github.com/yuzu-emu/ext-boost.git | ||||
| [submodule "nihstro"] | ||||
|     path = externals/nihstro | ||||
|     url = https://github.com/neobrain/nihstro.git | ||||
| [submodule "soundtouch"] | ||||
|     path = externals/soundtouch | ||||
|     url = https://github.com/citra-emu/ext-soundtouch.git | ||||
| [submodule "catch"] | ||||
|     path = externals/catch | ||||
|     url = https://github.com/philsquared/Catch.git | ||||
| @@ -22,12 +16,6 @@ | ||||
| [submodule "fmt"] | ||||
|     path = externals/fmt | ||||
|     url = https://github.com/fmtlib/fmt.git | ||||
| [submodule "enet"] | ||||
|     path = externals/enet | ||||
|     url = https://github.com/lsalzman/enet | ||||
| [submodule "cpr"] | ||||
|     path = externals/cpr | ||||
|     url = https://github.com/whoshuu/cpr.git | ||||
| [submodule "lz4"] | ||||
|     path = externals/lz4 | ||||
|     url = http://github.com/lz4/lz4.git | ||||
|   | ||||
| @@ -4,7 +4,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules") | ||||
| list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules") | ||||
| include(DownloadExternals) | ||||
|  | ||||
| project(citra) | ||||
| project(yuzu) | ||||
|  | ||||
| option(ENABLE_SDL2 "Enable the SDL2 frontend" ON) | ||||
| option(CITRA_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" OFF) | ||||
| @@ -14,17 +14,6 @@ option(CITRA_USE_BUNDLED_QT "Download bundled Qt binaries" OFF) | ||||
|  | ||||
| option(YUZU_USE_BUNDLED_UNICORN "Download bundled Unicorn binaries" OFF) | ||||
|  | ||||
| option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON) | ||||
| option(CITRA_USE_BUNDLED_CURL "FOR MINGW ONLY: Download curl configured against winssl instead of openssl" OFF) | ||||
| if (ENABLE_WEB_SERVICE AND CITRA_USE_BUNDLED_CURL AND WINDOWS AND MSVC) | ||||
|     message("Turning off use bundled curl as msvc can compile curl on cpr") | ||||
|     SET(CITRA_USE_BUNDLED_CURL OFF CACHE BOOL "" FORCE) | ||||
| endif() | ||||
| if (ENABLE_WEB_SERVICE AND NOT CITRA_USE_BUNDLED_CURL AND MINGW) | ||||
|     message(AUTHOR_WARNING "Turning on CITRA_USE_BUNDLED_CURL. Override it only if you know what you are doing.") | ||||
|     SET(CITRA_USE_BUNDLED_CURL ON CACHE BOOL "" FORCE) | ||||
| endif() | ||||
|  | ||||
| if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit) | ||||
|     message(STATUS "Copying pre-commit hook") | ||||
|     file(COPY hooks/pre-commit | ||||
| @@ -154,7 +143,6 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux") | ||||
|     add_definitions(-D_FILE_OFFSET_BITS=64) | ||||
| endif() | ||||
|  | ||||
| add_definitions(-DSINGLETHREADED) | ||||
| # CMake seems to only define _DEBUG on Windows | ||||
| set_property(DIRECTORY APPEND PROPERTY | ||||
|     COMPILE_DEFINITIONS $<$<CONFIG:Debug>:_DEBUG> $<$<NOT:$<CONFIG:Debug>>:NDEBUG>) | ||||
| @@ -163,11 +151,6 @@ set_property(DIRECTORY APPEND PROPERTY | ||||
| # System imported libraries | ||||
| # ====================== | ||||
|  | ||||
| find_package(PNG QUIET) | ||||
| if (NOT PNG_FOUND) | ||||
|     message(STATUS "libpng not found. Some debugging features have been disabled.") | ||||
| endif() | ||||
|  | ||||
| find_package(Boost 1.63.0 QUIET) | ||||
| if (NOT Boost_FOUND) | ||||
|     message(STATUS "Boost 1.63.0 or newer not found, falling back to externals") | ||||
| @@ -264,10 +247,6 @@ if (ENABLE_QT) | ||||
|     find_package(Qt5 REQUIRED COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT}) | ||||
| endif() | ||||
|  | ||||
| if (ENABLE_WEB_SERVICE) | ||||
|     add_definitions(-DENABLE_WEB_SERVICE) | ||||
| endif() | ||||
|  | ||||
| # Platform-specific library requirements | ||||
| # ====================================== | ||||
|  | ||||
|   | ||||
| @@ -13,5 +13,5 @@ function(copy_citra_Qt5_deps target_dir) | ||||
|         Qt5OpenGL$<$<CONFIG:Debug>:d>.* | ||||
|         Qt5Widgets$<$<CONFIG:Debug>:d>.* | ||||
|     ) | ||||
|     windows_copy_files(citra-qt ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*) | ||||
|     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*) | ||||
| endfunction(copy_citra_Qt5_deps) | ||||
|   | ||||
							
								
								
									
										40
									
								
								dist/citra-qt.6
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -1,40 +0,0 @@ | ||||
| .Dd November 22 2016 | ||||
| .Dt citra-qt 6 | ||||
| .Os | ||||
| .Sh NAME | ||||
| .Nm Citra-Qt | ||||
| .Nd Nintendo 3DS Emulator/Debugger (Qt) | ||||
| .Sh SYNOPSIS | ||||
| .Nm citra-qt | ||||
| .Op Ar file | ||||
| .Sh DESCRIPTION | ||||
| Citra is an experimental open-source Nintendo 3DS emulator/debugger. | ||||
| .Pp | ||||
| .Nm citra-qt | ||||
| is the Qt implementation. | ||||
| .Sh FILES | ||||
| .Bl -tag -width Ds | ||||
| .It Pa $XDG_DATA_HOME/citra-emu | ||||
| Emulator storage. | ||||
| .It Pa $XDG_CONFIG_HOME/citra-emu | ||||
| Configuration files. | ||||
| .El | ||||
| .Sh AUTHORS | ||||
| This document is made available to you under the CC-BY license. | ||||
| .Pp | ||||
| Citra is made by a team of volunteers. These contributors are listed | ||||
|  at <\fBhttps://github.com/citra-emu/citra/contributors\fR>. | ||||
| .Pp | ||||
| .Sh SEE ALSO | ||||
| .Bl -tag -width Ds | ||||
| .It Xr citra 6 | ||||
| The SDL frontend of the application | ||||
| .El | ||||
| .Pp | ||||
| Resources are available for this project: | ||||
| .Bl -tag -width Ds | ||||
| .It <\fBhttps://citra-emu.org\fR> | ||||
| The main homepage of the project. | ||||
| .It <\fBhttps://github.com/citra-emu/citra\fR> | ||||
| The main source code repository for the Citra emulator. | ||||
| .Pp | ||||
							
								
								
									
										49
									
								
								dist/citra.6
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -1,49 +0,0 @@ | ||||
| .Dd November 22 2016 | ||||
| .Dt citra 6 | ||||
| .Os | ||||
| .Sh NAME | ||||
| .Nm Citra | ||||
| .Nd Nintendo 3DS Emulator/Debugger (SDL) | ||||
| .Sh SYNOPSIS | ||||
| .Nm citra | ||||
| .Op Ar options | ||||
| .Op Ar file | ||||
| .Sh OPTIONS | ||||
| .Bl -tag -width Ds | ||||
| .It Fl g Ar port , Fl Fl gdbport Ar port | ||||
| Starts the GDB stub on the specified port | ||||
| .It Fl h , Fl Fl help | ||||
| Shows syntax help and exits | ||||
| .It Fl v , Fl Fl version | ||||
| Describes the installed version and exits | ||||
| .Sh DESCRIPTION | ||||
| Citra is an experimental open-source Nintendo 3DS emulator/debugger. | ||||
| .Pp | ||||
| .Nm citra | ||||
| is the Simple DirectMedia Layer (SDL) implementation. | ||||
| .Sh FILES | ||||
| .Bl -tag -width Ds | ||||
| .It Pa $XDG_DATA_HOME/citra-emu | ||||
| Emulator storage. | ||||
| .It Pa $XDG_CONFIG_HOME/citra-emu | ||||
| Configuration files. | ||||
| .El | ||||
| .Sh AUTHORS | ||||
| This document is made available to you under the CC-BY license. | ||||
| .Pp | ||||
| Citra is made by a team of volunteers. These contributors are listed | ||||
|  at <\fBhttps://github.com/citra-emu/citra/contributors\fR>. | ||||
| .Pp | ||||
| .Sh SEE ALSO | ||||
| .Bl -tag -width Ds | ||||
| .It Xr citra-qt 6 | ||||
| The Qt frontend of the application | ||||
| .El | ||||
| .Pp | ||||
| Resources are available for this project: | ||||
| .Bl -tag -width Ds | ||||
| .It <\fBhttps://citra-emu.org\fR> | ||||
| The main homepage of the project. | ||||
| .It <\fBhttps://github.com/citra-emu/citra\fR> | ||||
| The main source code repository for the Citra emulator. | ||||
| .Pp | ||||
							
								
								
									
										14
									
								
								dist/citra.desktop
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -1,14 +0,0 @@ | ||||
| [Desktop Entry] | ||||
| Version=1.0 | ||||
| Type=Application | ||||
| Name=Citra | ||||
| GenericName=3DS Emulator | ||||
| GenericName[fr]=Émulateur 3DS | ||||
| Comment=Nintendo 3DS video game console emulator | ||||
| Comment[fr]=Émulateur de console de jeu Nintendo 3DS | ||||
| Icon=citra | ||||
| TryExec=citra-qt | ||||
| Exec=citra-qt %f | ||||
| Categories=Game;Emulator;Qt; | ||||
| MimeType=application/x-ctr-3dsx;application/x-ctr-cci;application/x-ctr-cia;application/x-ctr-cxi; | ||||
| Keywords=3DS;Nintendo; | ||||
							
								
								
									
										
											BIN
										
									
								
								dist/citra.icns
									
									
									
									
										vendored
									
									
								
							
							
						
						
							
								
								
									
										
											BIN
										
									
								
								dist/citra.ico
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 361 KiB | 
							
								
								
									
										2
									
								
								dist/citra.svg
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 17 KiB | 
							
								
								
									
										59
									
								
								dist/citra.xml
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -1,59 +0,0 @@ | ||||
| <?xml version="1.0" encoding="UTF-8"?> | ||||
| <mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info"> | ||||
|     <mime-type type="application/x-ctr-3dsx"> | ||||
|         <comment>Nintendo 3DS homebrew executable</comment> | ||||
|         <comment xml:lang="fr">Exécutable non-officiel pour Nintendo 3DS </comment> | ||||
|         <acronym>3DSX</acronym> | ||||
|         <icon name="citra"/> | ||||
|         <glob pattern="*.3dsx"/> | ||||
|         <magic><match value="3DSX" type="string" offset="0"/></magic> | ||||
|     </mime-type> | ||||
|  | ||||
|     <mime-type type="application/x-ctr-cci"> | ||||
|         <comment>Nintendo 3DS cartridge image</comment> | ||||
|         <comment xml:lang="fr">Image de cartouche Nintendo 3DS</comment> | ||||
|         <acronym>CCI</acronym> | ||||
|         <expanded-acronym>CTR Cart Image</expanded-acronym> | ||||
|         <icon name="citra"/> | ||||
|         <glob pattern="*.cci"/> | ||||
|         <glob pattern="*.3ds"/> | ||||
|         <magic><match value="NCSD" type="string" offset="256"/></magic> | ||||
|     </mime-type> | ||||
|  | ||||
|     <mime-type type="application/x-ctr-cxi"> | ||||
|         <comment>Nintendo 3DS executable</comment> | ||||
|         <comment xml:lang="fr">Exécutable Nintendo 3DS</comment> | ||||
|         <acronym>CXI</acronym> | ||||
|         <expanded-acronym>CTR eXecutable Image</expanded-acronym> | ||||
|         <icon name="citra"/> | ||||
|         <glob pattern="*.cxi"/> | ||||
|         <magic><match value="NCCH" type="string" offset="256"/></magic> | ||||
|     </mime-type> | ||||
|  | ||||
|     <mime-type type="application/x-ctr-cia"> | ||||
|         <comment>Nintendo 3DS importable archive</comment> | ||||
|         <comment xml:lang="fr">Archive installable Nintendo 3DS</comment> | ||||
|         <acronym>CIA</acronym> | ||||
|         <expanded-acronym>CTR Importable Archive</expanded-acronym> | ||||
|         <icon name="citra"/> | ||||
|         <glob pattern="*.cia"/> | ||||
|     </mime-type> | ||||
|  | ||||
|     <mime-type type="application/x-ctr-smdh"> | ||||
|         <comment>Nintendo 3DS icon and metadata</comment> | ||||
|         <comment xml:lang="fr">Icône et métadonnées Nintendo 3DS</comment> | ||||
|         <acronym>SMDH</acronym> | ||||
|         <expanded-acronym>System Menu Data Header</expanded-acronym> | ||||
|         <glob pattern="*.smdh"/> | ||||
|         <magic><match value="SMDH" type="string" offset="0"/></magic> | ||||
|     </mime-type> | ||||
|  | ||||
|     <mime-type type="application/x-ctr-cbmd"> | ||||
|         <comment>Nintendo 3DS banner</comment> | ||||
|         <comment xml:lang="fr">Bannière Nintendo 3DS</comment> | ||||
|         <acronym>CBMD</acronym> | ||||
|         <expanded-acronym>CTR Banner Model Data</expanded-acronym> | ||||
|         <glob pattern="*.cbmd"/> | ||||
|         <magic><match value="CBMD" type="string" offset="0"/></magic> | ||||
|     </mime-type> | ||||
| </mime-info> | ||||
							
								
								
									
										
											BIN
										
									
								
								dist/doc-icon.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 7.6 KiB | 
							
								
								
									
										
											BIN
										
									
								
								dist/icons/checked.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 451 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/icons/failed.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 428 B | 
							
								
								
									
										6
									
								
								dist/icons/icons.qrc
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -1,6 +0,0 @@ | ||||
| <RCC> | ||||
|   <qresource prefix="icons"> | ||||
|     <file>checked.png</file> | ||||
|     <file>failed.png</file> | ||||
|   </qresource> | ||||
| </RCC> | ||||
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/Hmovetoolbar.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 220 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/Hsepartoolbar.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 172 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/Vmovetoolbar.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 228 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/Vsepartoolbar.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 187 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/branch_closed-on.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 147 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/branch_closed.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 160 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/branch_open-on.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 150 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/branch_open.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 166 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/checkbox_checked.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 492 B | 
| Before Width: | Height: | Size: 491 B | 
| Before Width: | Height: | Size: 252 B | 
| Before Width: | Height: | Size: 493 B | 
| Before Width: | Height: | Size: 492 B | 
| Before Width: | Height: | Size: 249 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/checkbox_unchecked.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 464 B | 
| Before Width: | Height: | Size: 464 B | 
| Before Width: | Height: | Size: 240 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/close-hover.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 598 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/close-pressed.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 598 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/close.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 586 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/down_arrow.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 165 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/down_arrow_disabled.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 166 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/left_arrow.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 166 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/left_arrow_disabled.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 166 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/radio_checked.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 940 B | 
| Before Width: | Height: | Size: 972 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/radio_checked_focus.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 846 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/radio_unchecked.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 728 B | 
| Before Width: | Height: | Size: 760 B | 
| Before Width: | Height: | Size: 646 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/right_arrow.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 160 B | 
| Before Width: | Height: | Size: 160 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/sizegrip.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 129 B | 
| Before Width: | Height: | Size: 224 B | 
| Before Width: | Height: | Size: 182 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/stylesheet-vline.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 239 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/transparent.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 195 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/undock.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 578 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/up_arrow.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 158 B | 
							
								
								
									
										
											BIN
										
									
								
								dist/qt_themes/qdarkstyle/rc/up_arrow_disabled.png
									
									
									
									
										vendored
									
									
								
							
							
						
						| Before Width: | Height: | Size: 159 B | 
							
								
								
									
										46
									
								
								dist/qt_themes/qdarkstyle/style.qrc
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -1,46 +0,0 @@ | ||||
| <RCC> | ||||
|   <qresource prefix="qss_icons"> | ||||
|     <file>rc/up_arrow_disabled.png</file> | ||||
|     <file>rc/Hmovetoolbar.png</file> | ||||
|     <file>rc/stylesheet-branch-end.png</file> | ||||
|     <file>rc/branch_closed-on.png</file> | ||||
|     <file>rc/stylesheet-vline.png</file> | ||||
|     <file>rc/branch_closed.png</file> | ||||
|     <file>rc/branch_open-on.png</file> | ||||
|     <file>rc/transparent.png</file> | ||||
|     <file>rc/right_arrow_disabled.png</file> | ||||
|     <file>rc/sizegrip.png</file> | ||||
|     <file>rc/close.png</file> | ||||
|     <file>rc/close-hover.png</file> | ||||
|     <file>rc/close-pressed.png</file> | ||||
|     <file>rc/down_arrow.png</file> | ||||
|     <file>rc/Vmovetoolbar.png</file> | ||||
|     <file>rc/left_arrow.png</file> | ||||
|     <file>rc/stylesheet-branch-more.png</file> | ||||
|     <file>rc/up_arrow.png</file> | ||||
|     <file>rc/right_arrow.png</file> | ||||
|     <file>rc/left_arrow_disabled.png</file> | ||||
|     <file>rc/Hsepartoolbar.png</file> | ||||
|     <file>rc/branch_open.png</file> | ||||
|     <file>rc/Vsepartoolbar.png</file> | ||||
|     <file>rc/down_arrow_disabled.png</file> | ||||
|     <file>rc/undock.png</file> | ||||
|     <file>rc/checkbox_checked_disabled.png</file> | ||||
|     <file>rc/checkbox_checked_focus.png</file> | ||||
|     <file>rc/checkbox_checked.png</file> | ||||
|     <file>rc/checkbox_indeterminate.png</file> | ||||
|     <file>rc/checkbox_indeterminate_focus.png</file> | ||||
|     <file>rc/checkbox_unchecked_disabled.png</file> | ||||
|     <file>rc/checkbox_unchecked_focus.png</file> | ||||
|     <file>rc/checkbox_unchecked.png</file> | ||||
|     <file>rc/radio_checked_disabled.png</file> | ||||
|     <file>rc/radio_checked_focus.png</file> | ||||
|     <file>rc/radio_checked.png</file> | ||||
|     <file>rc/radio_unchecked_disabled.png</file> | ||||
|     <file>rc/radio_unchecked_focus.png</file> | ||||
|     <file>rc/radio_unchecked.png</file> | ||||
|   </qresource> | ||||
|   <qresource prefix="qdarkstyle"> | ||||
|       <file>style.qss</file> | ||||
|   </qresource> | ||||
| </RCC> | ||||
							
								
								
									
										1268
									
								
								dist/qt_themes/qdarkstyle/style.qss
									
									
									
									
										vendored
									
									
								
							
							
						
						
							
								
								
									
										37
									
								
								externals/CMakeLists.txt
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -38,15 +38,6 @@ target_include_directories(lz4_static INTERFACE ./lz4/lib) | ||||
| add_library(microprofile INTERFACE) | ||||
| target_include_directories(microprofile INTERFACE ./microprofile) | ||||
|  | ||||
| # Nihstro | ||||
| add_library(nihstro-headers INTERFACE) | ||||
| target_include_directories(nihstro-headers INTERFACE ./nihstro/include) | ||||
|  | ||||
| # SoundTouch | ||||
| add_subdirectory(soundtouch) | ||||
| # The SoundTouch target doesn't export the necessary include paths as properties by default | ||||
| target_include_directories(SoundTouch INTERFACE ./soundtouch/include) | ||||
|  | ||||
| # Unicorn | ||||
| add_library(unicorn-headers INTERFACE) | ||||
| target_include_directories(unicorn-headers INTERFACE ./unicorn/include) | ||||
| @@ -58,31 +49,3 @@ if (ARCHITECTURE_x86_64) | ||||
|     target_include_directories(xbyak INTERFACE ./xbyak/xbyak) | ||||
|     target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES) | ||||
| endif() | ||||
|  | ||||
| # ENet | ||||
| add_subdirectory(enet) | ||||
| target_include_directories(enet INTERFACE ./enet/include) | ||||
|  | ||||
| if (ENABLE_WEB_SERVICE) | ||||
|     # msys installed curl is configured to use openssl, but that isn't portable | ||||
|     # since it relies on having the bundled certs install in the home folder for SSL | ||||
|     # by default on mingw, download the precompiled curl thats linked against windows native ssl | ||||
|     if (MINGW AND CITRA_USE_BUNDLED_CURL) | ||||
|         download_bundled_external("curl/" "curl-7_55_1" CURL_PREFIX) | ||||
|         set(CURL_PREFIX "${CMAKE_BINARY_DIR}/externals/curl-7_55_1") | ||||
|         set(CURL_FOUND YES) | ||||
|         set(CURL_INCLUDE_DIR "${CURL_PREFIX}/include" CACHE PATH "Path to curl headers") | ||||
|         set(CURL_LIBRARY "${CURL_PREFIX}/lib/libcurldll.a" CACHE PATH "Path to curl library") | ||||
|         set(CURL_DLL_DIR "${CURL_PREFIX}/lib/" CACHE PATH "Path to curl.dll") | ||||
|         set(USE_SYSTEM_CURL ON CACHE BOOL "") | ||||
|     endif() | ||||
|     # CPR | ||||
|     set(BUILD_TESTING OFF CACHE BOOL "") | ||||
|     set(BUILD_CPR_TESTS OFF CACHE BOOL "") | ||||
|     add_subdirectory(cpr) | ||||
|     target_include_directories(cpr INTERFACE ./cpr/include) | ||||
|  | ||||
|     # JSON | ||||
|     add_library(json-headers INTERFACE) | ||||
|     target_include_directories(json-headers INTERFACE ./json) | ||||
| endif() | ||||
|   | ||||
							
								
								
									
										7
									
								
								externals/json/README.md
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -1,7 +0,0 @@ | ||||
| JSON for Modern C++ | ||||
| =================== | ||||
|  | ||||
| This is a mirror providing the single required header file. | ||||
|  | ||||
| The original repository can be found at | ||||
|  https://github.com/nlohmann/json/commit/21d23982cafe826cae088b2bb37cb40c8e7a81fe | ||||
							
								
								
									
										14516
									
								
								externals/json/json.hpp
									
									
									
									
										vendored
									
									
								
							
							
						
						| @@ -4,16 +4,11 @@ include_directories(.) | ||||
| add_subdirectory(common) | ||||
| add_subdirectory(core) | ||||
| add_subdirectory(video_core) | ||||
| add_subdirectory(audio_core) | ||||
| add_subdirectory(network) | ||||
| add_subdirectory(input_common) | ||||
| add_subdirectory(tests) | ||||
| if (ENABLE_SDL2) | ||||
|     add_subdirectory(citra) | ||||
|     add_subdirectory(yuzu_cmd) | ||||
| endif() | ||||
| if (ENABLE_QT) | ||||
|     add_subdirectory(citra_qt) | ||||
| endif() | ||||
| if (ENABLE_WEB_SERVICE) | ||||
|     add_subdirectory(web_service) | ||||
|     add_subdirectory(yuzu) | ||||
| endif() | ||||
|   | ||||
| @@ -1,44 +0,0 @@ | ||||
| set(SRCS | ||||
|             audio_core.cpp | ||||
|             codec.cpp | ||||
|             hle/dsp.cpp | ||||
|             hle/filter.cpp | ||||
|             hle/mixers.cpp | ||||
|             hle/pipe.cpp | ||||
|             hle/source.cpp | ||||
|             interpolate.cpp | ||||
|             sink_details.cpp | ||||
|             time_stretch.cpp | ||||
|             ) | ||||
|  | ||||
| set(HEADERS | ||||
|             audio_core.h | ||||
|             codec.h | ||||
|             hle/common.h | ||||
|             hle/dsp.h | ||||
|             hle/filter.h | ||||
|             hle/mixers.h | ||||
|             hle/pipe.h | ||||
|             hle/source.h | ||||
|             interpolate.h | ||||
|             null_sink.h | ||||
|             sink.h | ||||
|             sink_details.h | ||||
|             time_stretch.h | ||||
|             ) | ||||
|  | ||||
| if(SDL2_FOUND) | ||||
|     set(SRCS ${SRCS} sdl2_sink.cpp) | ||||
|     set(HEADERS ${HEADERS} sdl2_sink.h) | ||||
| endif() | ||||
|  | ||||
| create_directory_groups(${SRCS} ${HEADERS}) | ||||
|  | ||||
| add_library(audio_core STATIC ${SRCS} ${HEADERS}) | ||||
| target_link_libraries(audio_core PUBLIC common core) | ||||
| target_link_libraries(audio_core PRIVATE SoundTouch) | ||||
|  | ||||
| if(SDL2_FOUND) | ||||
|     target_link_libraries(audio_core PRIVATE SDL2) | ||||
|     target_compile_definitions(audio_core PRIVATE HAVE_SDL2) | ||||
| endif() | ||||
| @@ -1,61 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <array> | ||||
| #include <memory> | ||||
| #include <string> | ||||
| #include "audio_core/audio_core.h" | ||||
| #include "audio_core/hle/dsp.h" | ||||
| #include "audio_core/hle/pipe.h" | ||||
| #include "audio_core/null_sink.h" | ||||
| #include "audio_core/sink.h" | ||||
| #include "audio_core/sink_details.h" | ||||
| #include "common/common_types.h" | ||||
| #include "core/core_timing.h" | ||||
| #include "core/hle/service/dsp_dsp.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| // Audio Ticks occur about every 5 miliseconds. | ||||
| static CoreTiming::EventType* tick_event;            ///< CoreTiming event | ||||
| static constexpr u64 audio_frame_ticks = 1310252ull; ///< Units: ARM11 cycles | ||||
|  | ||||
| static void AudioTickCallback(u64 /*userdata*/, int cycles_late) { | ||||
|     if (DSP::HLE::Tick()) { | ||||
|         // TODO(merry): Signal all the other interrupts as appropriate. | ||||
|         Service::DSP_DSP::SignalPipeInterrupt(DSP::HLE::DspPipe::Audio); | ||||
|         // HACK(merry): Added to prevent regressions. Will remove soon. | ||||
|         Service::DSP_DSP::SignalPipeInterrupt(DSP::HLE::DspPipe::Binary); | ||||
|     } | ||||
|  | ||||
|     // Reschedule recurrent event | ||||
|     CoreTiming::ScheduleEvent(audio_frame_ticks - cycles_late, tick_event); | ||||
| } | ||||
|  | ||||
| void Init() { | ||||
|     DSP::HLE::Init(); | ||||
|  | ||||
|     tick_event = CoreTiming::RegisterEvent("AudioCore::tick_event", AudioTickCallback); | ||||
|     CoreTiming::ScheduleEvent(audio_frame_ticks, tick_event); | ||||
| } | ||||
|  | ||||
| std::array<u8, Memory::DSP_RAM_SIZE>& GetDspMemory() { | ||||
|     return DSP::HLE::g_dsp_memory.raw_memory; | ||||
| } | ||||
|  | ||||
| void SelectSink(std::string sink_id) { | ||||
|     const SinkDetails& sink_details = GetSinkDetails(sink_id); | ||||
|     DSP::HLE::SetSink(sink_details.factory()); | ||||
| } | ||||
|  | ||||
| void EnableStretching(bool enable) { | ||||
|     DSP::HLE::EnableStretching(enable); | ||||
| } | ||||
|  | ||||
| void Shutdown() { | ||||
|     CoreTiming::UnscheduleEvent(tick_event, 0); | ||||
|     DSP::HLE::Shutdown(); | ||||
| } | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,31 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <string> | ||||
| #include "common/common_types.h" | ||||
| #include "core/memory.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| constexpr int native_sample_rate = 32728; ///< 32kHz | ||||
|  | ||||
| /// Initialise Audio Core | ||||
| void Init(); | ||||
|  | ||||
| /// Returns a reference to the array backing DSP memory | ||||
| std::array<u8, Memory::DSP_RAM_SIZE>& GetDspMemory(); | ||||
|  | ||||
| /// Select the sink to use based on sink id. | ||||
| void SelectSink(std::string sink_id); | ||||
|  | ||||
| /// Enable/Disable stretching. | ||||
| void EnableStretching(bool enable); | ||||
|  | ||||
| /// Shutdown Audio Core | ||||
| void Shutdown(); | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,127 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <array> | ||||
| #include <cstddef> | ||||
| #include <cstring> | ||||
| #include <vector> | ||||
| #include "audio_core/codec.h" | ||||
| #include "common/assert.h" | ||||
| #include "common/common_types.h" | ||||
| #include "common/math_util.h" | ||||
|  | ||||
| namespace Codec { | ||||
|  | ||||
| StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count, | ||||
|                            const std::array<s16, 16>& adpcm_coeff, ADPCMState& state) { | ||||
|     // GC-ADPCM with scale factor and variable coefficients. | ||||
|     // Frames are 8 bytes long containing 14 samples each. | ||||
|     // Samples are 4 bits (one nibble) long. | ||||
|  | ||||
|     constexpr size_t FRAME_LEN = 8; | ||||
|     constexpr size_t SAMPLES_PER_FRAME = 14; | ||||
|     constexpr std::array<int, 16> SIGNED_NIBBLES = { | ||||
|         {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}}; | ||||
|  | ||||
|     const size_t ret_size = | ||||
|         sample_count % 2 == 0 ? sample_count : sample_count + 1; // Ensure multiple of two. | ||||
|     StereoBuffer16 ret(ret_size); | ||||
|  | ||||
|     int yn1 = state.yn1, yn2 = state.yn2; | ||||
|  | ||||
|     const size_t NUM_FRAMES = | ||||
|         (sample_count + (SAMPLES_PER_FRAME - 1)) / SAMPLES_PER_FRAME; // Round up. | ||||
|     for (size_t framei = 0; framei < NUM_FRAMES; framei++) { | ||||
|         const int frame_header = data[framei * FRAME_LEN]; | ||||
|         const int scale = 1 << (frame_header & 0xF); | ||||
|         const int idx = (frame_header >> 4) & 0x7; | ||||
|  | ||||
|         // Coefficients are fixed point with 11 bits fractional part. | ||||
|         const int coef1 = adpcm_coeff[idx * 2 + 0]; | ||||
|         const int coef2 = adpcm_coeff[idx * 2 + 1]; | ||||
|  | ||||
|         // Decodes an audio sample. One nibble produces one sample. | ||||
|         const auto decode_sample = [&](const int nibble) -> s16 { | ||||
|             const int xn = nibble * scale; | ||||
|             // We first transform everything into 11 bit fixed point, perform the second order | ||||
|             // digital filter, then transform back. | ||||
|             // 0x400 == 0.5 in 11 bit fixed point. | ||||
|             // Filter: y[n] = x[n] + 0.5 + c1 * y[n-1] + c2 * y[n-2] | ||||
|             int val = ((xn << 11) + 0x400 + coef1 * yn1 + coef2 * yn2) >> 11; | ||||
|             // Clamp to output range. | ||||
|             val = MathUtil::Clamp(val, -32768, 32767); | ||||
|             // Advance output feedback. | ||||
|             yn2 = yn1; | ||||
|             yn1 = val; | ||||
|             return (s16)val; | ||||
|         }; | ||||
|  | ||||
|         size_t outputi = framei * SAMPLES_PER_FRAME; | ||||
|         size_t datai = framei * FRAME_LEN + 1; | ||||
|         for (size_t i = 0; i < SAMPLES_PER_FRAME && outputi < sample_count; i += 2) { | ||||
|             const s16 sample1 = decode_sample(SIGNED_NIBBLES[data[datai] >> 4]); | ||||
|             ret[outputi].fill(sample1); | ||||
|             outputi++; | ||||
|  | ||||
|             const s16 sample2 = decode_sample(SIGNED_NIBBLES[data[datai] & 0xF]); | ||||
|             ret[outputi].fill(sample2); | ||||
|             outputi++; | ||||
|  | ||||
|             datai++; | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     state.yn1 = yn1; | ||||
|     state.yn2 = yn2; | ||||
|  | ||||
|     return ret; | ||||
| } | ||||
|  | ||||
| static s16 SignExtendS8(u8 x) { | ||||
|     // The data is actually signed PCM8. | ||||
|     // We sign extend this to signed PCM16. | ||||
|     return static_cast<s16>(static_cast<s8>(x)); | ||||
| } | ||||
|  | ||||
| StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data, | ||||
|                           const size_t sample_count) { | ||||
|     ASSERT(num_channels == 1 || num_channels == 2); | ||||
|  | ||||
|     StereoBuffer16 ret(sample_count); | ||||
|  | ||||
|     if (num_channels == 1) { | ||||
|         for (size_t i = 0; i < sample_count; i++) { | ||||
|             ret[i].fill(SignExtendS8(data[i])); | ||||
|         } | ||||
|     } else { | ||||
|         for (size_t i = 0; i < sample_count; i++) { | ||||
|             ret[i][0] = SignExtendS8(data[i * 2 + 0]); | ||||
|             ret[i][1] = SignExtendS8(data[i * 2 + 1]); | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     return ret; | ||||
| } | ||||
|  | ||||
| StereoBuffer16 DecodePCM16(const unsigned num_channels, const u8* const data, | ||||
|                            const size_t sample_count) { | ||||
|     ASSERT(num_channels == 1 || num_channels == 2); | ||||
|  | ||||
|     StereoBuffer16 ret(sample_count); | ||||
|  | ||||
|     if (num_channels == 1) { | ||||
|         for (size_t i = 0; i < sample_count; i++) { | ||||
|             s16 sample; | ||||
|             std::memcpy(&sample, data + i * sizeof(s16), sizeof(s16)); | ||||
|             ret[i].fill(sample); | ||||
|         } | ||||
|     } else { | ||||
|         for (size_t i = 0; i < sample_count; ++i) { | ||||
|             std::memcpy(&ret[i], data + i * sizeof(s16) * 2, 2 * sizeof(s16)); | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     return ret; | ||||
| } | ||||
| }; | ||||
| @@ -1,51 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <deque> | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace Codec { | ||||
|  | ||||
| /// A variable length buffer of signed PCM16 stereo samples. | ||||
| using StereoBuffer16 = std::deque<std::array<s16, 2>>; | ||||
|  | ||||
| /// See: Codec::DecodeADPCM | ||||
| struct ADPCMState { | ||||
|     // Two historical samples from previous processed buffer, | ||||
|     // required for ADPCM decoding | ||||
|     s16 yn1; ///< y[n-1] | ||||
|     s16 yn2; ///< y[n-2] | ||||
| }; | ||||
|  | ||||
| /** | ||||
|  * @param data Pointer to buffer that contains ADPCM data to decode | ||||
|  * @param sample_count Length of buffer in terms of number of samples | ||||
|  * @param adpcm_coeff ADPCM coefficients | ||||
|  * @param state ADPCM state, this is updated with new state | ||||
|  * @return Decoded stereo signed PCM16 data, sample_count in length | ||||
|  */ | ||||
| StereoBuffer16 DecodeADPCM(const u8* const data, const size_t sample_count, | ||||
|                            const std::array<s16, 16>& adpcm_coeff, ADPCMState& state); | ||||
|  | ||||
| /** | ||||
|  * @param num_channels Number of channels | ||||
|  * @param data Pointer to buffer that contains PCM8 data to decode | ||||
|  * @param sample_count Length of buffer in terms of number of samples | ||||
|  * @return Decoded stereo signed PCM16 data, sample_count in length | ||||
|  */ | ||||
| StereoBuffer16 DecodePCM8(const unsigned num_channels, const u8* const data, | ||||
|                           const size_t sample_count); | ||||
|  | ||||
| /** | ||||
|  * @param num_channels Number of channels | ||||
|  * @param data Pointer to buffer that contains PCM16 data to decode | ||||
|  * @param sample_count Length of buffer in terms of number of samples | ||||
|  * @return Decoded stereo signed PCM16 data, sample_count in length | ||||
|  */ | ||||
| StereoBuffer16 DecodePCM16(const unsigned num_channels, const u8* const data, | ||||
|                            const size_t sample_count); | ||||
| }; | ||||
| @@ -1,34 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <algorithm> | ||||
| #include <array> | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| constexpr int num_sources = 24; | ||||
| constexpr int samples_per_frame = 160; ///< Samples per audio frame at native sample rate | ||||
|  | ||||
| /// The final output to the speakers is stereo. Preprocessing output in Source is also stereo. | ||||
| using StereoFrame16 = std::array<std::array<s16, 2>, samples_per_frame>; | ||||
|  | ||||
| /// The DSP is quadraphonic internally. | ||||
| using QuadFrame32 = std::array<std::array<s32, 4>, samples_per_frame>; | ||||
|  | ||||
| /** | ||||
|  * This performs the filter operation defined by FilterT::ProcessSample on the frame in-place. | ||||
|  * FilterT::ProcessSample is called sequentially on the samples. | ||||
|  */ | ||||
| template <typename FrameT, typename FilterT> | ||||
| void FilterFrame(FrameT& frame, FilterT& filter) { | ||||
|     std::transform(frame.begin(), frame.end(), frame.begin(), | ||||
|                    [&filter](const auto& sample) { return filter.ProcessSample(sample); }); | ||||
| } | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,172 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <array> | ||||
| #include <memory> | ||||
| #include "audio_core/hle/dsp.h" | ||||
| #include "audio_core/hle/mixers.h" | ||||
| #include "audio_core/hle/pipe.h" | ||||
| #include "audio_core/hle/source.h" | ||||
| #include "audio_core/sink.h" | ||||
| #include "audio_core/time_stretch.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| // Region management | ||||
|  | ||||
| DspMemory g_dsp_memory; | ||||
|  | ||||
| static size_t CurrentRegionIndex() { | ||||
|     // The region with the higher frame counter is chosen unless there is wraparound. | ||||
|     // This function only returns a 0 or 1. | ||||
|     u16 frame_counter_0 = g_dsp_memory.region_0.frame_counter; | ||||
|     u16 frame_counter_1 = g_dsp_memory.region_1.frame_counter; | ||||
|  | ||||
|     if (frame_counter_0 == 0xFFFFu && frame_counter_1 != 0xFFFEu) { | ||||
|         // Wraparound has occurred. | ||||
|         return 1; | ||||
|     } | ||||
|  | ||||
|     if (frame_counter_1 == 0xFFFFu && frame_counter_0 != 0xFFFEu) { | ||||
|         // Wraparound has occurred. | ||||
|         return 0; | ||||
|     } | ||||
|  | ||||
|     return (frame_counter_0 > frame_counter_1) ? 0 : 1; | ||||
| } | ||||
|  | ||||
| static SharedMemory& ReadRegion() { | ||||
|     return CurrentRegionIndex() == 0 ? g_dsp_memory.region_0 : g_dsp_memory.region_1; | ||||
| } | ||||
|  | ||||
| static SharedMemory& WriteRegion() { | ||||
|     return CurrentRegionIndex() != 0 ? g_dsp_memory.region_0 : g_dsp_memory.region_1; | ||||
| } | ||||
|  | ||||
| // Audio processing and mixing | ||||
|  | ||||
| static std::array<Source, num_sources> sources = { | ||||
|     Source(0),  Source(1),  Source(2),  Source(3),  Source(4),  Source(5),  Source(6),  Source(7), | ||||
|     Source(8),  Source(9),  Source(10), Source(11), Source(12), Source(13), Source(14), Source(15), | ||||
|     Source(16), Source(17), Source(18), Source(19), Source(20), Source(21), Source(22), Source(23), | ||||
| }; | ||||
| static Mixers mixers; | ||||
|  | ||||
| static StereoFrame16 GenerateCurrentFrame() { | ||||
|     SharedMemory& read = ReadRegion(); | ||||
|     SharedMemory& write = WriteRegion(); | ||||
|  | ||||
|     std::array<QuadFrame32, 3> intermediate_mixes = {}; | ||||
|  | ||||
|     // Generate intermediate mixes | ||||
|     for (size_t i = 0; i < num_sources; i++) { | ||||
|         write.source_statuses.status[i] = | ||||
|             sources[i].Tick(read.source_configurations.config[i], read.adpcm_coefficients.coeff[i]); | ||||
|         for (size_t mix = 0; mix < 3; mix++) { | ||||
|             sources[i].MixInto(intermediate_mixes[mix], mix); | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     // Generate final mix | ||||
|     write.dsp_status = mixers.Tick(read.dsp_configuration, read.intermediate_mix_samples, | ||||
|                                    write.intermediate_mix_samples, intermediate_mixes); | ||||
|  | ||||
|     StereoFrame16 output_frame = mixers.GetOutput(); | ||||
|  | ||||
|     // Write current output frame to the shared memory region | ||||
|     for (size_t samplei = 0; samplei < output_frame.size(); samplei++) { | ||||
|         for (size_t channeli = 0; channeli < output_frame[0].size(); channeli++) { | ||||
|             write.final_samples.pcm16[samplei][channeli] = s16_le(output_frame[samplei][channeli]); | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     return output_frame; | ||||
| } | ||||
|  | ||||
| // Audio output | ||||
|  | ||||
| static bool perform_time_stretching = true; | ||||
| static std::unique_ptr<AudioCore::Sink> sink; | ||||
| static AudioCore::TimeStretcher time_stretcher; | ||||
|  | ||||
| static void FlushResidualStretcherAudio() { | ||||
|     time_stretcher.Flush(); | ||||
|     while (true) { | ||||
|         std::vector<s16> residual_audio = time_stretcher.Process(sink->SamplesInQueue()); | ||||
|         if (residual_audio.empty()) | ||||
|             break; | ||||
|         sink->EnqueueSamples(residual_audio.data(), residual_audio.size() / 2); | ||||
|     } | ||||
| } | ||||
|  | ||||
| static void OutputCurrentFrame(const StereoFrame16& frame) { | ||||
|     if (perform_time_stretching) { | ||||
|         time_stretcher.AddSamples(&frame[0][0], frame.size()); | ||||
|         std::vector<s16> stretched_samples = time_stretcher.Process(sink->SamplesInQueue()); | ||||
|         sink->EnqueueSamples(stretched_samples.data(), stretched_samples.size() / 2); | ||||
|     } else { | ||||
|         constexpr size_t maximum_sample_latency = 2048; // about 64 miliseconds | ||||
|         if (sink->SamplesInQueue() > maximum_sample_latency) { | ||||
|             // This can occur if we're running too fast and samples are starting to back up. | ||||
|             // Just drop the samples. | ||||
|             return; | ||||
|         } | ||||
|  | ||||
|         sink->EnqueueSamples(&frame[0][0], frame.size()); | ||||
|     } | ||||
| } | ||||
|  | ||||
| void EnableStretching(bool enable) { | ||||
|     if (perform_time_stretching == enable) | ||||
|         return; | ||||
|  | ||||
|     if (!enable) { | ||||
|         FlushResidualStretcherAudio(); | ||||
|     } | ||||
|     perform_time_stretching = enable; | ||||
| } | ||||
|  | ||||
| // Public Interface | ||||
|  | ||||
| void Init() { | ||||
|     DSP::HLE::ResetPipes(); | ||||
|  | ||||
|     for (auto& source : sources) { | ||||
|         source.Reset(); | ||||
|     } | ||||
|  | ||||
|     mixers.Reset(); | ||||
|  | ||||
|     time_stretcher.Reset(); | ||||
|     if (sink) { | ||||
|         time_stretcher.SetOutputSampleRate(sink->GetNativeSampleRate()); | ||||
|     } | ||||
| } | ||||
|  | ||||
| void Shutdown() { | ||||
|     if (perform_time_stretching) { | ||||
|         FlushResidualStretcherAudio(); | ||||
|     } | ||||
| } | ||||
|  | ||||
| bool Tick() { | ||||
|     StereoFrame16 current_frame = {}; | ||||
|  | ||||
|     // TODO: Check dsp::DSP semaphore (which indicates emulated application has finished writing to | ||||
|     // shared memory region) | ||||
|     current_frame = GenerateCurrentFrame(); | ||||
|  | ||||
|     OutputCurrentFrame(current_frame); | ||||
|  | ||||
|     return true; | ||||
| } | ||||
|  | ||||
| void SetSink(std::unique_ptr<AudioCore::Sink> sink_) { | ||||
|     sink = std::move(sink_); | ||||
|     time_stretcher.SetOutputSampleRate(sink->GetNativeSampleRate()); | ||||
| } | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,595 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <cstddef> | ||||
| #include <memory> | ||||
| #include <type_traits> | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "common/bit_field.h" | ||||
| #include "common/common_funcs.h" | ||||
| #include "common/common_types.h" | ||||
| #include "common/swap.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
| class Sink; | ||||
| } | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| // The application-accessible region of DSP memory consists of two parts. Both are marked as IO and | ||||
| // have Read/Write permissions. | ||||
| // | ||||
| // First Region:  0x1FF50000 (Size: 0x8000) | ||||
| // Second Region: 0x1FF70000 (Size: 0x8000) | ||||
| // | ||||
| // The DSP reads from each region alternately based on the frame counter for each region much like a | ||||
| // double-buffer. The frame counter is located as the very last u16 of each region and is | ||||
| // incremented each audio tick. | ||||
|  | ||||
| constexpr u32 region0_offset = 0x50000; | ||||
| constexpr u32 region1_offset = 0x70000; | ||||
|  | ||||
| /** | ||||
|  * The DSP is native 16-bit. The DSP also appears to be big-endian. When reading 32-bit numbers from | ||||
|  * its memory regions, the higher and lower 16-bit halves are swapped compared to the little-endian | ||||
|  * layout of the ARM11. Hence from the ARM11's point of view the memory space appears to be | ||||
|  * middle-endian. | ||||
|  * | ||||
|  * Unusually this does not appear to be an issue for floating point numbers. The DSP makes the more | ||||
|  * sensible choice of keeping that little-endian. There are also some exceptions such as the | ||||
|  * IntermediateMixSamples structure, which is little-endian. | ||||
|  * | ||||
|  * This struct implements the conversion to and from this middle-endianness. | ||||
|  */ | ||||
| struct u32_dsp { | ||||
|     u32_dsp() = default; | ||||
|     operator u32() const { | ||||
|         return Convert(storage); | ||||
|     } | ||||
|     void operator=(u32 new_value) { | ||||
|         storage = Convert(new_value); | ||||
|     } | ||||
|  | ||||
| private: | ||||
|     static constexpr u32 Convert(u32 value) { | ||||
|         return (value << 16) | (value >> 16); | ||||
|     } | ||||
|     u32_le storage; | ||||
| }; | ||||
| #if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER) | ||||
| static_assert(std::is_trivially_copyable<u32_dsp>::value, "u32_dsp isn't trivially copyable"); | ||||
| #endif | ||||
|  | ||||
| // There are 15 structures in each memory region. A table of them in the order they appear in memory | ||||
| // is presented below: | ||||
| // | ||||
| //       #           First Region DSP Address   Purpose                               Control | ||||
| //       5           0x8400                     DSP Status                            DSP | ||||
| //       9           0x8410                     DSP Debug Info                        DSP | ||||
| //       6           0x8540                     Final Mix Samples                     DSP | ||||
| //       2           0x8680                     Source Status [24]                    DSP | ||||
| //       8           0x8710                     Compressor Table                      Application | ||||
| //       4           0x9430                     DSP Configuration                     Application | ||||
| //       7           0x9492                     Intermediate Mix Samples              DSP + App | ||||
| //       1           0x9E92                     Source Configuration [24]             Application | ||||
| //       3           0xA792                     Source ADPCM Coefficients [24]        Application | ||||
| //       10          0xA912                     Surround Sound Related | ||||
| //       11          0xAA12                     Surround Sound Related | ||||
| //       12          0xAAD2                     Surround Sound Related | ||||
| //       13          0xAC52                     Surround Sound Related | ||||
| //       14          0xAC5C                     Surround Sound Related | ||||
| //       0           0xBFFF                     Frame Counter                         Application | ||||
| // | ||||
| // #: This refers to the order in which they appear in the DspPipe::Audio DSP pipe. | ||||
| //    See also: DSP::HLE::PipeRead. | ||||
| // | ||||
| // Note that the above addresses do vary slightly between audio firmwares observed; the addresses | ||||
| // are not fixed in stone. The addresses above are only an examplar; they're what this | ||||
| // implementation does and provides to applications. | ||||
| // | ||||
| // Application requests the DSP service to convert DSP addresses into ARM11 virtual addresses using | ||||
| // the ConvertProcessAddressFromDspDram service call. Applications seem to derive the addresses for | ||||
| // the second region via: | ||||
| //     second_region_dsp_addr = first_region_dsp_addr | 0x10000 | ||||
| // | ||||
| // Applications maintain most of its own audio state, the memory region is used mainly for | ||||
| // communication and not storage of state. | ||||
| // | ||||
| // In the documentation below, filter and effect transfer functions are specified in the z domain. | ||||
| // (If you are more familiar with the Laplace transform, z = exp(sT). The z domain is the digital | ||||
| // frequency domain, just like how the s domain is the analog frequency domain.) | ||||
|  | ||||
| #define INSERT_PADDING_DSPWORDS(num_words) INSERT_PADDING_BYTES(2 * (num_words)) | ||||
|  | ||||
| // GCC versions < 5.0 do not implement std::is_trivially_copyable. | ||||
| // Excluding MSVC because it has weird behaviour for std::is_trivially_copyable. | ||||
| #if (__GNUC__ >= 5) || defined(__clang__) | ||||
| #define ASSERT_DSP_STRUCT(name, size)                                                              \ | ||||
|     static_assert(std::is_standard_layout<name>::value,                                            \ | ||||
|                   "DSP structure " #name " doesn't use standard layout");                          \ | ||||
|     static_assert(std::is_trivially_copyable<name>::value,                                         \ | ||||
|                   "DSP structure " #name " isn't trivially copyable");                             \ | ||||
|     static_assert(sizeof(name) == (size), "Unexpected struct size for DSP structure " #name) | ||||
| #else | ||||
| #define ASSERT_DSP_STRUCT(name, size)                                                              \ | ||||
|     static_assert(std::is_standard_layout<name>::value,                                            \ | ||||
|                   "DSP structure " #name " doesn't use standard layout");                          \ | ||||
|     static_assert(sizeof(name) == (size), "Unexpected struct size for DSP structure " #name) | ||||
| #endif | ||||
|  | ||||
| struct SourceConfiguration { | ||||
|     struct Configuration { | ||||
|         /// These dirty flags are set by the application when it updates the fields in this struct. | ||||
|         /// The DSP clears these each audio frame. | ||||
|         union { | ||||
|             u32_le dirty_raw; | ||||
|  | ||||
|             BitField<0, 1, u32_le> format_dirty; | ||||
|             BitField<1, 1, u32_le> mono_or_stereo_dirty; | ||||
|             BitField<2, 1, u32_le> adpcm_coefficients_dirty; | ||||
|             /// Tends to be set when a looped buffer is queued. | ||||
|             BitField<3, 1, u32_le> partial_embedded_buffer_dirty; | ||||
|             BitField<4, 1, u32_le> partial_reset_flag; | ||||
|  | ||||
|             BitField<16, 1, u32_le> enable_dirty; | ||||
|             BitField<17, 1, u32_le> interpolation_dirty; | ||||
|             BitField<18, 1, u32_le> rate_multiplier_dirty; | ||||
|             BitField<19, 1, u32_le> buffer_queue_dirty; | ||||
|             BitField<20, 1, u32_le> loop_related_dirty; | ||||
|             /// Tends to also be set when embedded buffer is updated. | ||||
|             BitField<21, 1, u32_le> play_position_dirty; | ||||
|             BitField<22, 1, u32_le> filters_enabled_dirty; | ||||
|             BitField<23, 1, u32_le> simple_filter_dirty; | ||||
|             BitField<24, 1, u32_le> biquad_filter_dirty; | ||||
|             BitField<25, 1, u32_le> gain_0_dirty; | ||||
|             BitField<26, 1, u32_le> gain_1_dirty; | ||||
|             BitField<27, 1, u32_le> gain_2_dirty; | ||||
|             BitField<28, 1, u32_le> sync_dirty; | ||||
|             BitField<29, 1, u32_le> reset_flag; | ||||
|             BitField<30, 1, u32_le> embedded_buffer_dirty; | ||||
|         }; | ||||
|  | ||||
|         // Gain control | ||||
|  | ||||
|         /** | ||||
|          * Gain is between 0.0-1.0. This determines how much will this source appear on each of the | ||||
|          * 12 channels that feed into the intermediate mixers. Each of the three intermediate mixers | ||||
|          * is fed two left and two right channels. | ||||
|          */ | ||||
|         float_le gain[3][4]; | ||||
|  | ||||
|         // Interpolation | ||||
|  | ||||
|         /// Multiplier for sample rate. Resampling occurs with the selected interpolation method. | ||||
|         float_le rate_multiplier; | ||||
|  | ||||
|         enum class InterpolationMode : u8 { | ||||
|             Polyphase = 0, | ||||
|             Linear = 1, | ||||
|             None = 2, | ||||
|         }; | ||||
|  | ||||
|         InterpolationMode interpolation_mode; | ||||
|         INSERT_PADDING_BYTES(1); ///< Interpolation related | ||||
|  | ||||
|         // Filters | ||||
|  | ||||
|         /** | ||||
|          * This is the simplest normalized first-order digital recursive filter. | ||||
|          * The transfer function of this filter is: | ||||
|          *     H(z) = b0 / (1 - a1 z^-1) | ||||
|          * Note the feedbackward coefficient is negated. | ||||
|          * Values are signed fixed point with 15 fractional bits. | ||||
|          */ | ||||
|         struct SimpleFilter { | ||||
|             s16_le b0; | ||||
|             s16_le a1; | ||||
|         }; | ||||
|  | ||||
|         /** | ||||
|          * This is a normalised biquad filter (second-order). | ||||
|          * The transfer function of this filter is: | ||||
|          *     H(z) = (b0 + b1 z^-1 + b2 z^-2) / (1 - a1 z^-1 - a2 z^-2) | ||||
|          * Nintendo chose to negate the feedbackward coefficients. This differs from standard | ||||
|          * notation as in: https://ccrma.stanford.edu/~jos/filters/Direct_Form_I.html | ||||
|          * Values are signed fixed point with 14 fractional bits. | ||||
|          */ | ||||
|         struct BiquadFilter { | ||||
|             s16_le a2; | ||||
|             s16_le a1; | ||||
|             s16_le b2; | ||||
|             s16_le b1; | ||||
|             s16_le b0; | ||||
|         }; | ||||
|  | ||||
|         union { | ||||
|             u16_le filters_enabled; | ||||
|             BitField<0, 1, u16_le> simple_filter_enabled; | ||||
|             BitField<1, 1, u16_le> biquad_filter_enabled; | ||||
|         }; | ||||
|  | ||||
|         SimpleFilter simple_filter; | ||||
|         BiquadFilter biquad_filter; | ||||
|  | ||||
|         // Buffer Queue | ||||
|  | ||||
|         /// A buffer of audio data from the application, along with metadata about it. | ||||
|         struct Buffer { | ||||
|             /// Physical memory address of the start of the buffer | ||||
|             u32_dsp physical_address; | ||||
|  | ||||
|             /// This is length in terms of samples. | ||||
|             /// Note that in different buffer formats a sample takes up different number of bytes. | ||||
|             u32_dsp length; | ||||
|  | ||||
|             /// ADPCM Predictor (4 bits) and Scale (4 bits) | ||||
|             union { | ||||
|                 u16_le adpcm_ps; | ||||
|                 BitField<0, 4, u16_le> adpcm_scale; | ||||
|                 BitField<4, 4, u16_le> adpcm_predictor; | ||||
|             }; | ||||
|  | ||||
|             /// ADPCM Historical Samples (y[n-1] and y[n-2]) | ||||
|             u16_le adpcm_yn[2]; | ||||
|  | ||||
|             /// This is non-zero when the ADPCM values above are to be updated. | ||||
|             u8 adpcm_dirty; | ||||
|  | ||||
|             /// Is a looping buffer. | ||||
|             u8 is_looping; | ||||
|  | ||||
|             /// This value is shown in SourceStatus::previous_buffer_id when this buffer has | ||||
|             /// finished. This allows the emulated application to tell what buffer is currently | ||||
|             /// playing. | ||||
|             u16_le buffer_id; | ||||
|  | ||||
|             INSERT_PADDING_DSPWORDS(1); | ||||
|         }; | ||||
|  | ||||
|         u16_le buffers_dirty; ///< Bitmap indicating which buffers are dirty (bit i -> buffers[i]) | ||||
|         Buffer buffers[4];    ///< Queued Buffers | ||||
|  | ||||
|         // Playback controls | ||||
|  | ||||
|         u32_dsp loop_related; | ||||
|         u8 enable; | ||||
|         INSERT_PADDING_BYTES(1); | ||||
|         u16_le sync;           ///< Application-side sync (See also: SourceStatus::sync) | ||||
|         u32_dsp play_position; ///< Position. (Units: number of samples) | ||||
|         INSERT_PADDING_DSPWORDS(2); | ||||
|  | ||||
|         // Embedded Buffer | ||||
|         // This buffer is often the first buffer to be used when initiating audio playback, | ||||
|         // after which the buffer queue is used. | ||||
|  | ||||
|         u32_dsp physical_address; | ||||
|  | ||||
|         /// This is length in terms of samples. | ||||
|         /// Note a sample takes up different number of bytes in different buffer formats. | ||||
|         u32_dsp length; | ||||
|  | ||||
|         enum class MonoOrStereo : u16_le { | ||||
|             Mono = 1, | ||||
|             Stereo = 2, | ||||
|         }; | ||||
|  | ||||
|         enum class Format : u16_le { | ||||
|             PCM8 = 0, | ||||
|             PCM16 = 1, | ||||
|             ADPCM = 2, | ||||
|         }; | ||||
|  | ||||
|         union { | ||||
|             u16_le flags1_raw; | ||||
|             BitField<0, 2, MonoOrStereo> mono_or_stereo; | ||||
|             BitField<2, 2, Format> format; | ||||
|             BitField<5, 1, u16_le> fade_in; | ||||
|         }; | ||||
|  | ||||
|         /// ADPCM Predictor (4 bit) and Scale (4 bit) | ||||
|         union { | ||||
|             u16_le adpcm_ps; | ||||
|             BitField<0, 4, u16_le> adpcm_scale; | ||||
|             BitField<4, 4, u16_le> adpcm_predictor; | ||||
|         }; | ||||
|  | ||||
|         /// ADPCM Historical Samples (y[n-1] and y[n-2]) | ||||
|         u16_le adpcm_yn[2]; | ||||
|  | ||||
|         union { | ||||
|             u16_le flags2_raw; | ||||
|             BitField<0, 1, u16_le> adpcm_dirty; ///< Has the ADPCM info above been changed? | ||||
|             BitField<1, 1, u16_le> is_looping;  ///< Is this a looping buffer? | ||||
|         }; | ||||
|  | ||||
|         /// Buffer id of embedded buffer (used as a buffer id in SourceStatus to reference this | ||||
|         /// buffer). | ||||
|         u16_le buffer_id; | ||||
|     }; | ||||
|  | ||||
|     Configuration config[num_sources]; | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(SourceConfiguration::Configuration, 192); | ||||
| ASSERT_DSP_STRUCT(SourceConfiguration::Configuration::Buffer, 20); | ||||
|  | ||||
| struct SourceStatus { | ||||
|     struct Status { | ||||
|         u8 is_enabled; ///< Is this channel enabled? (Doesn't have to be playing anything.) | ||||
|         u8 current_buffer_id_dirty; ///< Non-zero when current_buffer_id changes | ||||
|         u16_le sync;                ///< Is set by the DSP to the value of SourceConfiguration::sync | ||||
|         u32_dsp buffer_position;    ///< Number of samples into the current buffer | ||||
|         u16_le current_buffer_id;   ///< Updated when a buffer finishes playing | ||||
|         INSERT_PADDING_DSPWORDS(1); | ||||
|     }; | ||||
|  | ||||
|     Status status[num_sources]; | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(SourceStatus::Status, 12); | ||||
|  | ||||
| struct DspConfiguration { | ||||
|     /// These dirty flags are set by the application when it updates the fields in this struct. | ||||
|     /// The DSP clears these each audio frame. | ||||
|     union { | ||||
|         u32_le dirty_raw; | ||||
|  | ||||
|         BitField<8, 1, u32_le> mixer1_enabled_dirty; | ||||
|         BitField<9, 1, u32_le> mixer2_enabled_dirty; | ||||
|         BitField<10, 1, u32_le> delay_effect_0_dirty; | ||||
|         BitField<11, 1, u32_le> delay_effect_1_dirty; | ||||
|         BitField<12, 1, u32_le> reverb_effect_0_dirty; | ||||
|         BitField<13, 1, u32_le> reverb_effect_1_dirty; | ||||
|  | ||||
|         BitField<16, 1, u32_le> volume_0_dirty; | ||||
|  | ||||
|         BitField<24, 1, u32_le> volume_1_dirty; | ||||
|         BitField<25, 1, u32_le> volume_2_dirty; | ||||
|         BitField<26, 1, u32_le> output_format_dirty; | ||||
|         BitField<27, 1, u32_le> limiter_enabled_dirty; | ||||
|         BitField<28, 1, u32_le> headphones_connected_dirty; | ||||
|     }; | ||||
|  | ||||
|     /// The DSP has three intermediate audio mixers. This controls the volume level (0.0-1.0) for | ||||
|     /// each at the final mixer. | ||||
|     float_le volume[3]; | ||||
|  | ||||
|     INSERT_PADDING_DSPWORDS(3); | ||||
|  | ||||
|     enum class OutputFormat : u16_le { | ||||
|         Mono = 0, | ||||
|         Stereo = 1, | ||||
|         Surround = 2, | ||||
|     }; | ||||
|  | ||||
|     OutputFormat output_format; | ||||
|  | ||||
|     u16_le limiter_enabled;      ///< Not sure of the exact gain equation for the limiter. | ||||
|     u16_le headphones_connected; ///< Application updates the DSP on headphone status. | ||||
|     INSERT_PADDING_DSPWORDS(4);  ///< TODO: Surround sound related | ||||
|     INSERT_PADDING_DSPWORDS(2);  ///< TODO: Intermediate mixer 1/2 related | ||||
|     u16_le mixer1_enabled; | ||||
|     u16_le mixer2_enabled; | ||||
|  | ||||
|     /** | ||||
|      * This is delay with feedback. | ||||
|      * Transfer function: | ||||
|      *     H(z) = a z^-N / (1 - b z^-1 + a g z^-N) | ||||
|      *   where | ||||
|      *     N = frame_count * samples_per_frame | ||||
|      * g, a and b are fixed point with 7 fractional bits | ||||
|      */ | ||||
|     struct DelayEffect { | ||||
|         /// These dirty flags are set by the application when it updates the fields in this struct. | ||||
|         /// The DSP clears these each audio frame. | ||||
|         union { | ||||
|             u16_le dirty_raw; | ||||
|             BitField<0, 1, u16_le> enable_dirty; | ||||
|             BitField<1, 1, u16_le> work_buffer_address_dirty; | ||||
|             BitField<2, 1, u16_le> other_dirty; ///< Set when anything else has been changed | ||||
|         }; | ||||
|  | ||||
|         u16_le enable; | ||||
|         INSERT_PADDING_DSPWORDS(1); | ||||
|         u16_le outputs; | ||||
|         /// The application allocates a block of memory for the DSP to use as a work buffer. | ||||
|         u32_dsp work_buffer_address; | ||||
|         /// Frames to delay by | ||||
|         u16_le frame_count; | ||||
|  | ||||
|         // Coefficients | ||||
|         s16_le g; ///< Fixed point with 7 fractional bits | ||||
|         s16_le a; ///< Fixed point with 7 fractional bits | ||||
|         s16_le b; ///< Fixed point with 7 fractional bits | ||||
|     }; | ||||
|  | ||||
|     DelayEffect delay_effect[2]; | ||||
|  | ||||
|     struct ReverbEffect { | ||||
|         INSERT_PADDING_DSPWORDS(26); ///< TODO | ||||
|     }; | ||||
|  | ||||
|     ReverbEffect reverb_effect[2]; | ||||
|  | ||||
|     INSERT_PADDING_DSPWORDS(4); | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(DspConfiguration, 196); | ||||
| ASSERT_DSP_STRUCT(DspConfiguration::DelayEffect, 20); | ||||
| ASSERT_DSP_STRUCT(DspConfiguration::ReverbEffect, 52); | ||||
|  | ||||
| struct AdpcmCoefficients { | ||||
|     /// Coefficients are signed fixed point with 11 fractional bits. | ||||
|     /// Each source has 16 coefficients associated with it. | ||||
|     s16_le coeff[num_sources][16]; | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(AdpcmCoefficients, 768); | ||||
|  | ||||
| struct DspStatus { | ||||
|     u16_le unknown; | ||||
|     u16_le dropped_frames; | ||||
|     INSERT_PADDING_DSPWORDS(0xE); | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(DspStatus, 32); | ||||
|  | ||||
| /// Final mixed output in PCM16 stereo format, what you hear out of the speakers. | ||||
| /// When the application writes to this region it has no effect. | ||||
| struct FinalMixSamples { | ||||
|     s16_le pcm16[samples_per_frame][2]; | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(FinalMixSamples, 640); | ||||
|  | ||||
| /// DSP writes output of intermediate mixers 1 and 2 here. | ||||
| /// Writes to this region by the application edits the output of the intermediate mixers. | ||||
| /// This seems to be intended to allow the application to do custom effects on the ARM11. | ||||
| /// Values that exceed s16 range will be clipped by the DSP after further processing. | ||||
| struct IntermediateMixSamples { | ||||
|     struct Samples { | ||||
|         s32_le pcm32[4][samples_per_frame]; ///< Little-endian as opposed to DSP middle-endian. | ||||
|     }; | ||||
|  | ||||
|     Samples mix1; | ||||
|     Samples mix2; | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(IntermediateMixSamples, 5120); | ||||
|  | ||||
| /// Compressor table | ||||
| struct Compressor { | ||||
|     INSERT_PADDING_DSPWORDS(0xD20); ///< TODO | ||||
| }; | ||||
|  | ||||
| /// There is no easy way to implement this in a HLE implementation. | ||||
| struct DspDebug { | ||||
|     INSERT_PADDING_DSPWORDS(0x130); | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(DspDebug, 0x260); | ||||
|  | ||||
| struct SharedMemory { | ||||
|     /// Padding | ||||
|     INSERT_PADDING_DSPWORDS(0x400); | ||||
|  | ||||
|     DspStatus dsp_status; | ||||
|  | ||||
|     DspDebug dsp_debug; | ||||
|  | ||||
|     FinalMixSamples final_samples; | ||||
|  | ||||
|     SourceStatus source_statuses; | ||||
|  | ||||
|     Compressor compressor; | ||||
|  | ||||
|     DspConfiguration dsp_configuration; | ||||
|  | ||||
|     IntermediateMixSamples intermediate_mix_samples; | ||||
|  | ||||
|     SourceConfiguration source_configurations; | ||||
|  | ||||
|     AdpcmCoefficients adpcm_coefficients; | ||||
|  | ||||
|     struct { | ||||
|         INSERT_PADDING_DSPWORDS(0x100); | ||||
|     } unknown10; | ||||
|  | ||||
|     struct { | ||||
|         INSERT_PADDING_DSPWORDS(0xC0); | ||||
|     } unknown11; | ||||
|  | ||||
|     struct { | ||||
|         INSERT_PADDING_DSPWORDS(0x180); | ||||
|     } unknown12; | ||||
|  | ||||
|     struct { | ||||
|         INSERT_PADDING_DSPWORDS(0xA); | ||||
|     } unknown13; | ||||
|  | ||||
|     struct { | ||||
|         INSERT_PADDING_DSPWORDS(0x13A3); | ||||
|     } unknown14; | ||||
|  | ||||
|     u16_le frame_counter; | ||||
| }; | ||||
| ASSERT_DSP_STRUCT(SharedMemory, 0x8000); | ||||
|  | ||||
| union DspMemory { | ||||
|     std::array<u8, 0x80000> raw_memory; | ||||
|     struct { | ||||
|         u8 unused_0[0x50000]; | ||||
|         SharedMemory region_0; | ||||
|         u8 unused_1[0x18000]; | ||||
|         SharedMemory region_1; | ||||
|         u8 unused_2[0x8000]; | ||||
|     }; | ||||
| }; | ||||
| static_assert(offsetof(DspMemory, region_0) == region0_offset, | ||||
|               "DSP region 0 is at the wrong offset"); | ||||
| static_assert(offsetof(DspMemory, region_1) == region1_offset, | ||||
|               "DSP region 1 is at the wrong offset"); | ||||
|  | ||||
| extern DspMemory g_dsp_memory; | ||||
|  | ||||
| // Structures must have an offset that is a multiple of two. | ||||
| static_assert(offsetof(SharedMemory, frame_counter) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, source_configurations) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, source_statuses) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, adpcm_coefficients) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, dsp_configuration) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, dsp_status) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, final_samples) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, intermediate_mix_samples) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, compressor) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, dsp_debug) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, unknown10) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, unknown11) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, unknown12) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, unknown13) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
| static_assert(offsetof(SharedMemory, unknown14) % 2 == 0, | ||||
|               "Structures in DSP::HLE::SharedMemory must be 2-byte aligned"); | ||||
|  | ||||
| #undef INSERT_PADDING_DSPWORDS | ||||
| #undef ASSERT_DSP_STRUCT | ||||
|  | ||||
| /// Initialize DSP hardware | ||||
| void Init(); | ||||
|  | ||||
| /// Shutdown DSP hardware | ||||
| void Shutdown(); | ||||
|  | ||||
| /** | ||||
|  * Perform processing and updates state of current shared memory buffer. | ||||
|  * This function is called every audio tick before triggering the audio interrupt. | ||||
|  * @return Whether an audio interrupt should be triggered this frame. | ||||
|  */ | ||||
| bool Tick(); | ||||
|  | ||||
| /** | ||||
|  * Set the output sink. This must be called before calling Tick(). | ||||
|  * @param sink The sink to which audio will be output to. | ||||
|  */ | ||||
| void SetSink(std::unique_ptr<AudioCore::Sink> sink); | ||||
|  | ||||
| /** | ||||
|  * Enables/Disables audio-stretching. | ||||
|  * Audio stretching is an enhancement that stretches audio to match emulation | ||||
|  * speed to prevent stuttering at the cost of some audio latency. | ||||
|  * @param enable true to enable, false to disable. | ||||
|  */ | ||||
| void EnableStretching(bool enable); | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,117 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <array> | ||||
| #include <cstddef> | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "audio_core/hle/dsp.h" | ||||
| #include "audio_core/hle/filter.h" | ||||
| #include "common/common_types.h" | ||||
| #include "common/math_util.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| void SourceFilters::Reset() { | ||||
|     Enable(false, false); | ||||
| } | ||||
|  | ||||
| void SourceFilters::Enable(bool simple, bool biquad) { | ||||
|     simple_filter_enabled = simple; | ||||
|     biquad_filter_enabled = biquad; | ||||
|  | ||||
|     if (!simple) | ||||
|         simple_filter.Reset(); | ||||
|     if (!biquad) | ||||
|         biquad_filter.Reset(); | ||||
| } | ||||
|  | ||||
| void SourceFilters::Configure(SourceConfiguration::Configuration::SimpleFilter config) { | ||||
|     simple_filter.Configure(config); | ||||
| } | ||||
|  | ||||
| void SourceFilters::Configure(SourceConfiguration::Configuration::BiquadFilter config) { | ||||
|     biquad_filter.Configure(config); | ||||
| } | ||||
|  | ||||
| void SourceFilters::ProcessFrame(StereoFrame16& frame) { | ||||
|     if (!simple_filter_enabled && !biquad_filter_enabled) | ||||
|         return; | ||||
|  | ||||
|     if (simple_filter_enabled) { | ||||
|         FilterFrame(frame, simple_filter); | ||||
|     } | ||||
|  | ||||
|     if (biquad_filter_enabled) { | ||||
|         FilterFrame(frame, biquad_filter); | ||||
|     } | ||||
| } | ||||
|  | ||||
| // SimpleFilter | ||||
|  | ||||
| void SourceFilters::SimpleFilter::Reset() { | ||||
|     y1.fill(0); | ||||
|     // Configure as passthrough. | ||||
|     a1 = 0; | ||||
|     b0 = 1 << 15; | ||||
| } | ||||
|  | ||||
| void SourceFilters::SimpleFilter::Configure( | ||||
|     SourceConfiguration::Configuration::SimpleFilter config) { | ||||
|  | ||||
|     a1 = config.a1; | ||||
|     b0 = config.b0; | ||||
| } | ||||
|  | ||||
| std::array<s16, 2> SourceFilters::SimpleFilter::ProcessSample(const std::array<s16, 2>& x0) { | ||||
|     std::array<s16, 2> y0; | ||||
|     for (size_t i = 0; i < 2; i++) { | ||||
|         const s32 tmp = (b0 * x0[i] + a1 * y1[i]) >> 15; | ||||
|         y0[i] = MathUtil::Clamp(tmp, -32768, 32767); | ||||
|     } | ||||
|  | ||||
|     y1 = y0; | ||||
|  | ||||
|     return y0; | ||||
| } | ||||
|  | ||||
| // BiquadFilter | ||||
|  | ||||
| void SourceFilters::BiquadFilter::Reset() { | ||||
|     x1.fill(0); | ||||
|     x2.fill(0); | ||||
|     y1.fill(0); | ||||
|     y2.fill(0); | ||||
|     // Configure as passthrough. | ||||
|     a1 = a2 = b1 = b2 = 0; | ||||
|     b0 = 1 << 14; | ||||
| } | ||||
|  | ||||
| void SourceFilters::BiquadFilter::Configure( | ||||
|     SourceConfiguration::Configuration::BiquadFilter config) { | ||||
|  | ||||
|     a1 = config.a1; | ||||
|     a2 = config.a2; | ||||
|     b0 = config.b0; | ||||
|     b1 = config.b1; | ||||
|     b2 = config.b2; | ||||
| } | ||||
|  | ||||
| std::array<s16, 2> SourceFilters::BiquadFilter::ProcessSample(const std::array<s16, 2>& x0) { | ||||
|     std::array<s16, 2> y0; | ||||
|     for (size_t i = 0; i < 2; i++) { | ||||
|         const s32 tmp = (b0 * x0[i] + b1 * x1[i] + b2 * x2[i] + a1 * y1[i] + a2 * y2[i]) >> 14; | ||||
|         y0[i] = MathUtil::Clamp(tmp, -32768, 32767); | ||||
|     } | ||||
|  | ||||
|     x2 = x1; | ||||
|     x1 = x0; | ||||
|     y2 = y1; | ||||
|     y1 = y0; | ||||
|  | ||||
|     return y0; | ||||
| } | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,117 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "audio_core/hle/dsp.h" | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| /// Preprocessing filters. There is an independent set of filters for each Source. | ||||
| class SourceFilters final { | ||||
| public: | ||||
|     SourceFilters() { | ||||
|         Reset(); | ||||
|     } | ||||
|  | ||||
|     /// Reset internal state. | ||||
|     void Reset(); | ||||
|  | ||||
|     /** | ||||
|      * Enable/Disable filters | ||||
|      * See also: SourceConfiguration::Configuration::simple_filter_enabled, | ||||
|      *           SourceConfiguration::Configuration::biquad_filter_enabled. | ||||
|      * @param simple If true, enables the simple filter. If false, disables it. | ||||
|      * @param biquad If true, enables the biquad filter. If false, disables it. | ||||
|      */ | ||||
|     void Enable(bool simple, bool biquad); | ||||
|  | ||||
|     /** | ||||
|      * Configure simple filter. | ||||
|      * @param config Configuration from DSP shared memory. | ||||
|      */ | ||||
|     void Configure(SourceConfiguration::Configuration::SimpleFilter config); | ||||
|  | ||||
|     /** | ||||
|      * Configure biquad filter. | ||||
|      * @param config Configuration from DSP shared memory. | ||||
|      */ | ||||
|     void Configure(SourceConfiguration::Configuration::BiquadFilter config); | ||||
|  | ||||
|     /** | ||||
|      * Processes a frame in-place. | ||||
|      * @param frame Audio samples to process. Modified in-place. | ||||
|      */ | ||||
|     void ProcessFrame(StereoFrame16& frame); | ||||
|  | ||||
| private: | ||||
|     bool simple_filter_enabled; | ||||
|     bool biquad_filter_enabled; | ||||
|  | ||||
|     struct SimpleFilter { | ||||
|         SimpleFilter() { | ||||
|             Reset(); | ||||
|         } | ||||
|  | ||||
|         /// Resets internal state. | ||||
|         void Reset(); | ||||
|  | ||||
|         /** | ||||
|          * Configures this filter with application settings. | ||||
|          * @param config Configuration from DSP shared memory. | ||||
|          */ | ||||
|         void Configure(SourceConfiguration::Configuration::SimpleFilter config); | ||||
|  | ||||
|         /** | ||||
|          * Processes a single stereo PCM16 sample. | ||||
|          * @param x0 Input sample | ||||
|          * @return Output sample | ||||
|          */ | ||||
|         std::array<s16, 2> ProcessSample(const std::array<s16, 2>& x0); | ||||
|  | ||||
|     private: | ||||
|         // Configuration | ||||
|         s32 a1, b0; | ||||
|         // Internal state | ||||
|         std::array<s16, 2> y1; | ||||
|     } simple_filter; | ||||
|  | ||||
|     struct BiquadFilter { | ||||
|         BiquadFilter() { | ||||
|             Reset(); | ||||
|         } | ||||
|  | ||||
|         /// Resets internal state. | ||||
|         void Reset(); | ||||
|  | ||||
|         /** | ||||
|          * Configures this filter with application settings. | ||||
|          * @param config Configuration from DSP shared memory. | ||||
|          */ | ||||
|         void Configure(SourceConfiguration::Configuration::BiquadFilter config); | ||||
|  | ||||
|         /** | ||||
|          * Processes a single stereo PCM16 sample. | ||||
|          * @param x0 Input sample | ||||
|          * @return Output sample | ||||
|          */ | ||||
|         std::array<s16, 2> ProcessSample(const std::array<s16, 2>& x0); | ||||
|  | ||||
|     private: | ||||
|         // Configuration | ||||
|         s32 a1, a2, b0, b1, b2; | ||||
|         // Internal state | ||||
|         std::array<s16, 2> x1; | ||||
|         std::array<s16, 2> x2; | ||||
|         std::array<s16, 2> y1; | ||||
|         std::array<s16, 2> y2; | ||||
|     } biquad_filter; | ||||
| }; | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,210 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <cstddef> | ||||
|  | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "audio_core/hle/dsp.h" | ||||
| #include "audio_core/hle/mixers.h" | ||||
| #include "common/assert.h" | ||||
| #include "common/logging/log.h" | ||||
| #include "common/math_util.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| void Mixers::Reset() { | ||||
|     current_frame.fill({}); | ||||
|     state = {}; | ||||
| } | ||||
|  | ||||
| DspStatus Mixers::Tick(DspConfiguration& config, const IntermediateMixSamples& read_samples, | ||||
|                        IntermediateMixSamples& write_samples, | ||||
|                        const std::array<QuadFrame32, 3>& input) { | ||||
|     ParseConfig(config); | ||||
|  | ||||
|     AuxReturn(read_samples); | ||||
|     AuxSend(write_samples, input); | ||||
|  | ||||
|     MixCurrentFrame(); | ||||
|  | ||||
|     return GetCurrentStatus(); | ||||
| } | ||||
|  | ||||
| void Mixers::ParseConfig(DspConfiguration& config) { | ||||
|     if (!config.dirty_raw) { | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     if (config.mixer1_enabled_dirty) { | ||||
|         config.mixer1_enabled_dirty.Assign(0); | ||||
|         state.mixer1_enabled = config.mixer1_enabled != 0; | ||||
|         LOG_TRACE(Audio_DSP, "mixers mixer1_enabled = %hu", config.mixer1_enabled); | ||||
|     } | ||||
|  | ||||
|     if (config.mixer2_enabled_dirty) { | ||||
|         config.mixer2_enabled_dirty.Assign(0); | ||||
|         state.mixer2_enabled = config.mixer2_enabled != 0; | ||||
|         LOG_TRACE(Audio_DSP, "mixers mixer2_enabled = %hu", config.mixer2_enabled); | ||||
|     } | ||||
|  | ||||
|     if (config.volume_0_dirty) { | ||||
|         config.volume_0_dirty.Assign(0); | ||||
|         state.intermediate_mixer_volume[0] = config.volume[0]; | ||||
|         LOG_TRACE(Audio_DSP, "mixers volume[0] = %f", config.volume[0]); | ||||
|     } | ||||
|  | ||||
|     if (config.volume_1_dirty) { | ||||
|         config.volume_1_dirty.Assign(0); | ||||
|         state.intermediate_mixer_volume[1] = config.volume[1]; | ||||
|         LOG_TRACE(Audio_DSP, "mixers volume[1] = %f", config.volume[1]); | ||||
|     } | ||||
|  | ||||
|     if (config.volume_2_dirty) { | ||||
|         config.volume_2_dirty.Assign(0); | ||||
|         state.intermediate_mixer_volume[2] = config.volume[2]; | ||||
|         LOG_TRACE(Audio_DSP, "mixers volume[2] = %f", config.volume[2]); | ||||
|     } | ||||
|  | ||||
|     if (config.output_format_dirty) { | ||||
|         config.output_format_dirty.Assign(0); | ||||
|         state.output_format = config.output_format; | ||||
|         LOG_TRACE(Audio_DSP, "mixers output_format = %zu", | ||||
|                   static_cast<size_t>(config.output_format)); | ||||
|     } | ||||
|  | ||||
|     if (config.headphones_connected_dirty) { | ||||
|         config.headphones_connected_dirty.Assign(0); | ||||
|         // Do nothing. (Note: Whether headphones are connected does affect coefficients used for | ||||
|         // surround sound.) | ||||
|         LOG_TRACE(Audio_DSP, "mixers headphones_connected=%hu", config.headphones_connected); | ||||
|     } | ||||
|  | ||||
|     if (config.dirty_raw) { | ||||
|         LOG_DEBUG(Audio_DSP, "mixers remaining_dirty=%x", config.dirty_raw); | ||||
|     } | ||||
|  | ||||
|     config.dirty_raw = 0; | ||||
| } | ||||
|  | ||||
| static s16 ClampToS16(s32 value) { | ||||
|     return static_cast<s16>(MathUtil::Clamp(value, -32768, 32767)); | ||||
| } | ||||
|  | ||||
| static std::array<s16, 2> AddAndClampToS16(const std::array<s16, 2>& a, | ||||
|                                            const std::array<s16, 2>& b) { | ||||
|     return {ClampToS16(static_cast<s32>(a[0]) + static_cast<s32>(b[0])), | ||||
|             ClampToS16(static_cast<s32>(a[1]) + static_cast<s32>(b[1]))}; | ||||
| } | ||||
|  | ||||
| void Mixers::DownmixAndMixIntoCurrentFrame(float gain, const QuadFrame32& samples) { | ||||
|     // TODO(merry): Limiter. (Currently we're performing final mixing assuming a disabled limiter.) | ||||
|  | ||||
|     switch (state.output_format) { | ||||
|     case OutputFormat::Mono: | ||||
|         std::transform( | ||||
|             current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(), | ||||
|             [gain](const std::array<s16, 2>& accumulator, | ||||
|                    const std::array<s32, 4>& sample) -> std::array<s16, 2> { | ||||
|                 // Downmix to mono | ||||
|                 s16 mono = ClampToS16(static_cast<s32>( | ||||
|                     (gain * sample[0] + gain * sample[1] + gain * sample[2] + gain * sample[3]) / | ||||
|                     2)); | ||||
|                 // Mix into current frame | ||||
|                 return AddAndClampToS16(accumulator, {mono, mono}); | ||||
|             }); | ||||
|         return; | ||||
|  | ||||
|     case OutputFormat::Surround: | ||||
|     // TODO(merry): Implement surround sound. | ||||
|     // fallthrough | ||||
|  | ||||
|     case OutputFormat::Stereo: | ||||
|         std::transform( | ||||
|             current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(), | ||||
|             [gain](const std::array<s16, 2>& accumulator, | ||||
|                    const std::array<s32, 4>& sample) -> std::array<s16, 2> { | ||||
|                 // Downmix to stereo | ||||
|                 s16 left = ClampToS16(static_cast<s32>(gain * sample[0] + gain * sample[2])); | ||||
|                 s16 right = ClampToS16(static_cast<s32>(gain * sample[1] + gain * sample[3])); | ||||
|                 // Mix into current frame | ||||
|                 return AddAndClampToS16(accumulator, {left, right}); | ||||
|             }); | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     UNREACHABLE_MSG("Invalid output_format %zu", static_cast<size_t>(state.output_format)); | ||||
| } | ||||
|  | ||||
| void Mixers::AuxReturn(const IntermediateMixSamples& read_samples) { | ||||
|     // NOTE: read_samples.mix{1,2}.pcm32 annoyingly have their dimensions in reverse order to | ||||
|     // QuadFrame32. | ||||
|  | ||||
|     if (state.mixer1_enabled) { | ||||
|         for (size_t sample = 0; sample < samples_per_frame; sample++) { | ||||
|             for (size_t channel = 0; channel < 4; channel++) { | ||||
|                 state.intermediate_mix_buffer[1][sample][channel] = | ||||
|                     read_samples.mix1.pcm32[channel][sample]; | ||||
|             } | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     if (state.mixer2_enabled) { | ||||
|         for (size_t sample = 0; sample < samples_per_frame; sample++) { | ||||
|             for (size_t channel = 0; channel < 4; channel++) { | ||||
|                 state.intermediate_mix_buffer[2][sample][channel] = | ||||
|                     read_samples.mix2.pcm32[channel][sample]; | ||||
|             } | ||||
|         } | ||||
|     } | ||||
| } | ||||
|  | ||||
| void Mixers::AuxSend(IntermediateMixSamples& write_samples, | ||||
|                      const std::array<QuadFrame32, 3>& input) { | ||||
|     // NOTE: read_samples.mix{1,2}.pcm32 annoyingly have their dimensions in reverse order to | ||||
|     // QuadFrame32. | ||||
|  | ||||
|     state.intermediate_mix_buffer[0] = input[0]; | ||||
|  | ||||
|     if (state.mixer1_enabled) { | ||||
|         for (size_t sample = 0; sample < samples_per_frame; sample++) { | ||||
|             for (size_t channel = 0; channel < 4; channel++) { | ||||
|                 write_samples.mix1.pcm32[channel][sample] = input[1][sample][channel]; | ||||
|             } | ||||
|         } | ||||
|     } else { | ||||
|         state.intermediate_mix_buffer[1] = input[1]; | ||||
|     } | ||||
|  | ||||
|     if (state.mixer2_enabled) { | ||||
|         for (size_t sample = 0; sample < samples_per_frame; sample++) { | ||||
|             for (size_t channel = 0; channel < 4; channel++) { | ||||
|                 write_samples.mix2.pcm32[channel][sample] = input[2][sample][channel]; | ||||
|             } | ||||
|         } | ||||
|     } else { | ||||
|         state.intermediate_mix_buffer[2] = input[2]; | ||||
|     } | ||||
| } | ||||
|  | ||||
| void Mixers::MixCurrentFrame() { | ||||
|     current_frame.fill({}); | ||||
|  | ||||
|     for (size_t mix = 0; mix < 3; mix++) { | ||||
|         DownmixAndMixIntoCurrentFrame(state.intermediate_mixer_volume[mix], | ||||
|                                       state.intermediate_mix_buffer[mix]); | ||||
|     } | ||||
|  | ||||
|     // TODO(merry): Compressor. (We currently assume a disabled compressor.) | ||||
| } | ||||
|  | ||||
| DspStatus Mixers::GetCurrentStatus() const { | ||||
|     DspStatus status; | ||||
|     status.unknown = 0; | ||||
|     status.dropped_frames = 0; | ||||
|     return status; | ||||
| } | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,61 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "audio_core/hle/dsp.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| class Mixers final { | ||||
| public: | ||||
|     Mixers() { | ||||
|         Reset(); | ||||
|     } | ||||
|  | ||||
|     void Reset(); | ||||
|  | ||||
|     DspStatus Tick(DspConfiguration& config, const IntermediateMixSamples& read_samples, | ||||
|                    IntermediateMixSamples& write_samples, const std::array<QuadFrame32, 3>& input); | ||||
|  | ||||
|     StereoFrame16 GetOutput() const { | ||||
|         return current_frame; | ||||
|     } | ||||
|  | ||||
| private: | ||||
|     StereoFrame16 current_frame = {}; | ||||
|  | ||||
|     using OutputFormat = DspConfiguration::OutputFormat; | ||||
|  | ||||
|     struct { | ||||
|         std::array<float, 3> intermediate_mixer_volume = {}; | ||||
|  | ||||
|         bool mixer1_enabled = false; | ||||
|         bool mixer2_enabled = false; | ||||
|         std::array<QuadFrame32, 3> intermediate_mix_buffer = {}; | ||||
|  | ||||
|         OutputFormat output_format = OutputFormat::Stereo; | ||||
|  | ||||
|     } state; | ||||
|  | ||||
|     /// INTERNAL: Update our internal state based on the current config. | ||||
|     void ParseConfig(DspConfiguration& config); | ||||
|     /// INTERNAL: Read samples from shared memory that have been modified by the ARM11. | ||||
|     void AuxReturn(const IntermediateMixSamples& read_samples); | ||||
|     /// INTERNAL: Write samples to shared memory for the ARM11 to modify. | ||||
|     void AuxSend(IntermediateMixSamples& write_samples, const std::array<QuadFrame32, 3>& input); | ||||
|     /// INTERNAL: Mix current_frame. | ||||
|     void MixCurrentFrame(); | ||||
|     /// INTERNAL: Downmix from quadraphonic to stereo based on status.output_format and accumulate | ||||
|     /// into current_frame. | ||||
|     void DownmixAndMixIntoCurrentFrame(float gain, const QuadFrame32& samples); | ||||
|     /// INTERNAL: Generate DspStatus based on internal state. | ||||
|     DspStatus GetCurrentStatus() const; | ||||
| }; | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,177 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <array> | ||||
| #include <vector> | ||||
| #include "audio_core/hle/dsp.h" | ||||
| #include "audio_core/hle/pipe.h" | ||||
| #include "common/assert.h" | ||||
| #include "common/common_types.h" | ||||
| #include "common/logging/log.h" | ||||
| #include "core/hle/service/dsp_dsp.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| static DspState dsp_state = DspState::Off; | ||||
|  | ||||
| static std::array<std::vector<u8>, NUM_DSP_PIPE> pipe_data; | ||||
|  | ||||
| void ResetPipes() { | ||||
|     for (auto& data : pipe_data) { | ||||
|         data.clear(); | ||||
|     } | ||||
|     dsp_state = DspState::Off; | ||||
| } | ||||
|  | ||||
| std::vector<u8> PipeRead(DspPipe pipe_number, u32 length) { | ||||
|     const size_t pipe_index = static_cast<size_t>(pipe_number); | ||||
|  | ||||
|     if (pipe_index >= NUM_DSP_PIPE) { | ||||
|         LOG_ERROR(Audio_DSP, "pipe_number = %zu invalid", pipe_index); | ||||
|         return {}; | ||||
|     } | ||||
|  | ||||
|     if (length > UINT16_MAX) { // Can only read at most UINT16_MAX from the pipe | ||||
|         LOG_ERROR(Audio_DSP, "length of %u greater than max of %u", length, UINT16_MAX); | ||||
|         return {}; | ||||
|     } | ||||
|  | ||||
|     std::vector<u8>& data = pipe_data[pipe_index]; | ||||
|  | ||||
|     if (length > data.size()) { | ||||
|         LOG_WARNING( | ||||
|             Audio_DSP, | ||||
|             "pipe_number = %zu is out of data, application requested read of %u but %zu remain", | ||||
|             pipe_index, length, data.size()); | ||||
|         length = static_cast<u32>(data.size()); | ||||
|     } | ||||
|  | ||||
|     if (length == 0) | ||||
|         return {}; | ||||
|  | ||||
|     std::vector<u8> ret(data.begin(), data.begin() + length); | ||||
|     data.erase(data.begin(), data.begin() + length); | ||||
|     return ret; | ||||
| } | ||||
|  | ||||
| size_t GetPipeReadableSize(DspPipe pipe_number) { | ||||
|     const size_t pipe_index = static_cast<size_t>(pipe_number); | ||||
|  | ||||
|     if (pipe_index >= NUM_DSP_PIPE) { | ||||
|         LOG_ERROR(Audio_DSP, "pipe_number = %zu invalid", pipe_index); | ||||
|         return 0; | ||||
|     } | ||||
|  | ||||
|     return pipe_data[pipe_index].size(); | ||||
| } | ||||
|  | ||||
| static void WriteU16(DspPipe pipe_number, u16 value) { | ||||
|     const size_t pipe_index = static_cast<size_t>(pipe_number); | ||||
|  | ||||
|     std::vector<u8>& data = pipe_data.at(pipe_index); | ||||
|     // Little endian | ||||
|     data.emplace_back(value & 0xFF); | ||||
|     data.emplace_back(value >> 8); | ||||
| } | ||||
|  | ||||
| static void AudioPipeWriteStructAddresses() { | ||||
|     // These struct addresses are DSP dram addresses. | ||||
|     // See also: DSP_DSP::ConvertProcessAddressFromDspDram | ||||
|     static const std::array<u16, 15> struct_addresses = { | ||||
|         0x8000 + offsetof(SharedMemory, frame_counter) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, source_configurations) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, source_statuses) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, adpcm_coefficients) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, dsp_configuration) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, dsp_status) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, final_samples) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, intermediate_mix_samples) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, compressor) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, dsp_debug) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, unknown10) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, unknown11) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, unknown12) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, unknown13) / 2, | ||||
|         0x8000 + offsetof(SharedMemory, unknown14) / 2, | ||||
|     }; | ||||
|  | ||||
|     // Begin with a u16 denoting the number of structs. | ||||
|     WriteU16(DspPipe::Audio, static_cast<u16>(struct_addresses.size())); | ||||
|     // Then write the struct addresses. | ||||
|     for (u16 addr : struct_addresses) { | ||||
|         WriteU16(DspPipe::Audio, addr); | ||||
|     } | ||||
|     // Signal that we have data on this pipe. | ||||
|     Service::DSP_DSP::SignalPipeInterrupt(DspPipe::Audio); | ||||
| } | ||||
|  | ||||
| void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) { | ||||
|     switch (pipe_number) { | ||||
|     case DspPipe::Audio: { | ||||
|         if (buffer.size() != 4) { | ||||
|             LOG_ERROR(Audio_DSP, "DspPipe::Audio: Unexpected buffer length %zu was written", | ||||
|                       buffer.size()); | ||||
|             return; | ||||
|         } | ||||
|  | ||||
|         enum class StateChange { | ||||
|             Initialize = 0, | ||||
|             Shutdown = 1, | ||||
|             Wakeup = 2, | ||||
|             Sleep = 3, | ||||
|         }; | ||||
|  | ||||
|         // The difference between Initialize and Wakeup is that Input state is maintained | ||||
|         // when sleeping but isn't when turning it off and on again. (TODO: Implement this.) | ||||
|         // Waking up from sleep garbles some of the structs in the memory region. (TODO: | ||||
|         // Implement this.) Applications store away the state of these structs before | ||||
|         // sleeping and reset it back after wakeup on behalf of the DSP. | ||||
|  | ||||
|         switch (static_cast<StateChange>(buffer[0])) { | ||||
|         case StateChange::Initialize: | ||||
|             LOG_INFO(Audio_DSP, "Application has requested initialization of DSP hardware"); | ||||
|             ResetPipes(); | ||||
|             AudioPipeWriteStructAddresses(); | ||||
|             dsp_state = DspState::On; | ||||
|             break; | ||||
|         case StateChange::Shutdown: | ||||
|             LOG_INFO(Audio_DSP, "Application has requested shutdown of DSP hardware"); | ||||
|             dsp_state = DspState::Off; | ||||
|             break; | ||||
|         case StateChange::Wakeup: | ||||
|             LOG_INFO(Audio_DSP, "Application has requested wakeup of DSP hardware"); | ||||
|             ResetPipes(); | ||||
|             AudioPipeWriteStructAddresses(); | ||||
|             dsp_state = DspState::On; | ||||
|             break; | ||||
|         case StateChange::Sleep: | ||||
|             LOG_INFO(Audio_DSP, "Application has requested sleep of DSP hardware"); | ||||
|             UNIMPLEMENTED(); | ||||
|             dsp_state = DspState::Sleeping; | ||||
|             break; | ||||
|         default: | ||||
|             LOG_ERROR(Audio_DSP, | ||||
|                       "Application has requested unknown state transition of DSP hardware %hhu", | ||||
|                       buffer[0]); | ||||
|             dsp_state = DspState::Off; | ||||
|             break; | ||||
|         } | ||||
|  | ||||
|         return; | ||||
|     } | ||||
|     default: | ||||
|         LOG_CRITICAL(Audio_DSP, "pipe_number = %zu unimplemented", | ||||
|                      static_cast<size_t>(pipe_number)); | ||||
|         UNIMPLEMENTED(); | ||||
|         return; | ||||
|     } | ||||
| } | ||||
|  | ||||
| DspState GetDspState() { | ||||
|     return dsp_state; | ||||
| } | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,63 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <cstddef> | ||||
| #include <vector> | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| /// Reset the pipes by setting pipe positions back to the beginning. | ||||
| void ResetPipes(); | ||||
|  | ||||
| enum class DspPipe { | ||||
|     Debug = 0, | ||||
|     Dma = 1, | ||||
|     Audio = 2, | ||||
|     Binary = 3, | ||||
| }; | ||||
| constexpr size_t NUM_DSP_PIPE = 8; | ||||
|  | ||||
| /** | ||||
|  * Reads `length` bytes from the DSP pipe identified with `pipe_number`. | ||||
|  * @note Can read up to the maximum value of a u16 in bytes (65,535). | ||||
|  * @note IF an error is encoutered with either an invalid `pipe_number` or `length` value, an empty | ||||
|  * vector will be returned. | ||||
|  * @note IF `length` is set to 0, an empty vector will be returned. | ||||
|  * @note IF `length` is greater than the amount of data available, this function will only read the | ||||
|  * available amount. | ||||
|  * @param pipe_number a `DspPipe` | ||||
|  * @param length the number of bytes to read. The max is 65,535 (max of u16). | ||||
|  * @returns a vector of bytes from the specified pipe. On error, will be empty. | ||||
|  */ | ||||
| std::vector<u8> PipeRead(DspPipe pipe_number, u32 length); | ||||
|  | ||||
| /** | ||||
|  * How much data is left in pipe | ||||
|  * @param pipe_number The Pipe ID | ||||
|  * @return The amount of data remaning in the pipe. This is the maximum length PipeRead will return. | ||||
|  */ | ||||
| size_t GetPipeReadableSize(DspPipe pipe_number); | ||||
|  | ||||
| /** | ||||
|  * Write to a DSP pipe. | ||||
|  * @param pipe_number The Pipe ID | ||||
|  * @param buffer The data to write to the pipe. | ||||
|  */ | ||||
| void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer); | ||||
|  | ||||
| enum class DspState { | ||||
|     Off, | ||||
|     On, | ||||
|     Sleeping, | ||||
| }; | ||||
|  | ||||
| /// Get the state of the DSP | ||||
| DspState GetDspState(); | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,349 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <algorithm> | ||||
| #include <array> | ||||
| #include "audio_core/codec.h" | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "audio_core/hle/source.h" | ||||
| #include "audio_core/interpolate.h" | ||||
| #include "common/assert.h" | ||||
| #include "common/logging/log.h" | ||||
| #include "core/memory.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| SourceStatus::Status Source::Tick(SourceConfiguration::Configuration& config, | ||||
|                                   const s16_le (&adpcm_coeffs)[16]) { | ||||
|     ParseConfig(config, adpcm_coeffs); | ||||
|  | ||||
|     if (state.enabled) { | ||||
|         GenerateFrame(); | ||||
|     } | ||||
|  | ||||
|     return GetCurrentStatus(); | ||||
| } | ||||
|  | ||||
| void Source::MixInto(QuadFrame32& dest, size_t intermediate_mix_id) const { | ||||
|     if (!state.enabled) | ||||
|         return; | ||||
|  | ||||
|     const std::array<float, 4>& gains = state.gain.at(intermediate_mix_id); | ||||
|     for (size_t samplei = 0; samplei < samples_per_frame; samplei++) { | ||||
|         // Conversion from stereo (current_frame) to quadraphonic (dest) occurs here. | ||||
|         dest[samplei][0] += static_cast<s32>(gains[0] * current_frame[samplei][0]); | ||||
|         dest[samplei][1] += static_cast<s32>(gains[1] * current_frame[samplei][1]); | ||||
|         dest[samplei][2] += static_cast<s32>(gains[2] * current_frame[samplei][0]); | ||||
|         dest[samplei][3] += static_cast<s32>(gains[3] * current_frame[samplei][1]); | ||||
|     } | ||||
| } | ||||
|  | ||||
| void Source::Reset() { | ||||
|     current_frame.fill({}); | ||||
|     state = {}; | ||||
| } | ||||
|  | ||||
| void Source::ParseConfig(SourceConfiguration::Configuration& config, | ||||
|                          const s16_le (&adpcm_coeffs)[16]) { | ||||
|     if (!config.dirty_raw) { | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     if (config.reset_flag) { | ||||
|         config.reset_flag.Assign(0); | ||||
|         Reset(); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu reset", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.partial_reset_flag) { | ||||
|         config.partial_reset_flag.Assign(0); | ||||
|         state.input_queue = std::priority_queue<Buffer, std::vector<Buffer>, BufferOrder>{}; | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu partial_reset", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.enable_dirty) { | ||||
|         config.enable_dirty.Assign(0); | ||||
|         state.enabled = config.enable != 0; | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu enable=%d", source_id, state.enabled); | ||||
|     } | ||||
|  | ||||
|     if (config.sync_dirty) { | ||||
|         config.sync_dirty.Assign(0); | ||||
|         state.sync = config.sync; | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu sync=%u", source_id, state.sync); | ||||
|     } | ||||
|  | ||||
|     if (config.rate_multiplier_dirty) { | ||||
|         config.rate_multiplier_dirty.Assign(0); | ||||
|         state.rate_multiplier = config.rate_multiplier; | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu rate=%f", source_id, state.rate_multiplier); | ||||
|  | ||||
|         if (state.rate_multiplier <= 0) { | ||||
|             LOG_ERROR(Audio_DSP, "Was given an invalid rate multiplier: source_id=%zu rate=%f", | ||||
|                       source_id, state.rate_multiplier); | ||||
|             state.rate_multiplier = 1.0f; | ||||
|             // Note: Actual firmware starts producing garbage if this occurs. | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     if (config.adpcm_coefficients_dirty) { | ||||
|         config.adpcm_coefficients_dirty.Assign(0); | ||||
|         std::transform(adpcm_coeffs, adpcm_coeffs + state.adpcm_coeffs.size(), | ||||
|                        state.adpcm_coeffs.begin(), | ||||
|                        [](const auto& coeff) { return static_cast<s16>(coeff); }); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu adpcm update", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.gain_0_dirty) { | ||||
|         config.gain_0_dirty.Assign(0); | ||||
|         std::transform(config.gain[0], config.gain[0] + state.gain[0].size(), state.gain[0].begin(), | ||||
|                        [](const auto& coeff) { return static_cast<float>(coeff); }); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu gain 0 update", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.gain_1_dirty) { | ||||
|         config.gain_1_dirty.Assign(0); | ||||
|         std::transform(config.gain[1], config.gain[1] + state.gain[1].size(), state.gain[1].begin(), | ||||
|                        [](const auto& coeff) { return static_cast<float>(coeff); }); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu gain 1 update", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.gain_2_dirty) { | ||||
|         config.gain_2_dirty.Assign(0); | ||||
|         std::transform(config.gain[2], config.gain[2] + state.gain[2].size(), state.gain[2].begin(), | ||||
|                        [](const auto& coeff) { return static_cast<float>(coeff); }); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu gain 2 update", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.filters_enabled_dirty) { | ||||
|         config.filters_enabled_dirty.Assign(0); | ||||
|         state.filters.Enable(config.simple_filter_enabled.ToBool(), | ||||
|                              config.biquad_filter_enabled.ToBool()); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu enable_simple=%hu enable_biquad=%hu", source_id, | ||||
|                   config.simple_filter_enabled.Value(), config.biquad_filter_enabled.Value()); | ||||
|     } | ||||
|  | ||||
|     if (config.simple_filter_dirty) { | ||||
|         config.simple_filter_dirty.Assign(0); | ||||
|         state.filters.Configure(config.simple_filter); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu simple filter update", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.biquad_filter_dirty) { | ||||
|         config.biquad_filter_dirty.Assign(0); | ||||
|         state.filters.Configure(config.biquad_filter); | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu biquad filter update", source_id); | ||||
|     } | ||||
|  | ||||
|     if (config.interpolation_dirty) { | ||||
|         config.interpolation_dirty.Assign(0); | ||||
|         state.interpolation_mode = config.interpolation_mode; | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu interpolation_mode=%zu", source_id, | ||||
|                   static_cast<size_t>(state.interpolation_mode)); | ||||
|     } | ||||
|  | ||||
|     if (config.format_dirty || config.embedded_buffer_dirty) { | ||||
|         config.format_dirty.Assign(0); | ||||
|         state.format = config.format; | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu format=%zu", source_id, | ||||
|                   static_cast<size_t>(state.format)); | ||||
|     } | ||||
|  | ||||
|     if (config.mono_or_stereo_dirty || config.embedded_buffer_dirty) { | ||||
|         config.mono_or_stereo_dirty.Assign(0); | ||||
|         state.mono_or_stereo = config.mono_or_stereo; | ||||
|         LOG_TRACE(Audio_DSP, "source_id=%zu mono_or_stereo=%zu", source_id, | ||||
|                   static_cast<size_t>(state.mono_or_stereo)); | ||||
|     } | ||||
|  | ||||
|     u32_dsp play_position = {}; | ||||
|     if (config.play_position_dirty && config.play_position != 0) { | ||||
|         config.play_position_dirty.Assign(0); | ||||
|         play_position = config.play_position; | ||||
|         // play_position applies only to the embedded buffer, and defaults to 0 w/o a dirty bit | ||||
|         // This will be the starting sample for the first time the buffer is played. | ||||
|     } | ||||
|  | ||||
|     if (config.embedded_buffer_dirty) { | ||||
|         config.embedded_buffer_dirty.Assign(0); | ||||
|         state.input_queue.emplace(Buffer{ | ||||
|             config.physical_address, | ||||
|             config.length, | ||||
|             static_cast<u8>(config.adpcm_ps), | ||||
|             {config.adpcm_yn[0], config.adpcm_yn[1]}, | ||||
|             config.adpcm_dirty.ToBool(), | ||||
|             config.is_looping.ToBool(), | ||||
|             config.buffer_id, | ||||
|             state.mono_or_stereo, | ||||
|             state.format, | ||||
|             false, | ||||
|             play_position, | ||||
|             false, | ||||
|         }); | ||||
|         LOG_TRACE(Audio_DSP, "enqueuing embedded addr=0x%08x len=%u id=%hu start=%u", | ||||
|                   config.physical_address, config.length, config.buffer_id, | ||||
|                   static_cast<u32>(config.play_position)); | ||||
|     } | ||||
|  | ||||
|     if (config.loop_related_dirty && config.loop_related != 0) { | ||||
|         config.loop_related_dirty.Assign(0); | ||||
|         LOG_WARNING(Audio_DSP, "Unhandled complex loop with loop_related=0x%08x", | ||||
|                     static_cast<u32>(config.loop_related)); | ||||
|     } | ||||
|  | ||||
|     if (config.buffer_queue_dirty) { | ||||
|         config.buffer_queue_dirty.Assign(0); | ||||
|         for (size_t i = 0; i < 4; i++) { | ||||
|             if (config.buffers_dirty & (1 << i)) { | ||||
|                 const auto& b = config.buffers[i]; | ||||
|                 state.input_queue.emplace(Buffer{ | ||||
|                     b.physical_address, | ||||
|                     b.length, | ||||
|                     static_cast<u8>(b.adpcm_ps), | ||||
|                     {b.adpcm_yn[0], b.adpcm_yn[1]}, | ||||
|                     b.adpcm_dirty != 0, | ||||
|                     b.is_looping != 0, | ||||
|                     b.buffer_id, | ||||
|                     state.mono_or_stereo, | ||||
|                     state.format, | ||||
|                     true, | ||||
|                     {}, // 0 in u32_dsp | ||||
|                     false, | ||||
|                 }); | ||||
|                 LOG_TRACE(Audio_DSP, "enqueuing queued %zu addr=0x%08x len=%u id=%hu", i, | ||||
|                           b.physical_address, b.length, b.buffer_id); | ||||
|             } | ||||
|         } | ||||
|         config.buffers_dirty = 0; | ||||
|     } | ||||
|  | ||||
|     if (config.dirty_raw) { | ||||
|         LOG_DEBUG(Audio_DSP, "source_id=%zu remaining_dirty=%x", source_id, config.dirty_raw); | ||||
|     } | ||||
|  | ||||
|     config.dirty_raw = 0; | ||||
| } | ||||
|  | ||||
| void Source::GenerateFrame() { | ||||
|     current_frame.fill({}); | ||||
|  | ||||
|     if (state.current_buffer.empty() && !DequeueBuffer()) { | ||||
|         state.enabled = false; | ||||
|         state.buffer_update = true; | ||||
|         state.current_buffer_id = 0; | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     size_t frame_position = 0; | ||||
|  | ||||
|     state.current_sample_number = state.next_sample_number; | ||||
|     while (frame_position < current_frame.size()) { | ||||
|         if (state.current_buffer.empty() && !DequeueBuffer()) { | ||||
|             break; | ||||
|         } | ||||
|  | ||||
|         switch (state.interpolation_mode) { | ||||
|         case InterpolationMode::None: | ||||
|             AudioInterp::None(state.interp_state, state.current_buffer, state.rate_multiplier, | ||||
|                               current_frame, frame_position); | ||||
|             break; | ||||
|         case InterpolationMode::Linear: | ||||
|             AudioInterp::Linear(state.interp_state, state.current_buffer, state.rate_multiplier, | ||||
|                                 current_frame, frame_position); | ||||
|             break; | ||||
|         case InterpolationMode::Polyphase: | ||||
|             // TODO(merry): Implement polyphase interpolation | ||||
|             LOG_DEBUG(Audio_DSP, "Polyphase interpolation unimplemented; falling back to linear"); | ||||
|             AudioInterp::Linear(state.interp_state, state.current_buffer, state.rate_multiplier, | ||||
|                                 current_frame, frame_position); | ||||
|             break; | ||||
|         default: | ||||
|             UNIMPLEMENTED(); | ||||
|             break; | ||||
|         } | ||||
|     } | ||||
|     state.next_sample_number += static_cast<u32>(frame_position); | ||||
|  | ||||
|     state.filters.ProcessFrame(current_frame); | ||||
| } | ||||
|  | ||||
| bool Source::DequeueBuffer() { | ||||
|     ASSERT_MSG(state.current_buffer.empty(), | ||||
|                "Shouldn't dequeue; we still have data in current_buffer"); | ||||
|  | ||||
|     if (state.input_queue.empty()) | ||||
|         return false; | ||||
|  | ||||
|     Buffer buf = state.input_queue.top(); | ||||
|  | ||||
|     // if we're in a loop, the current sound keeps playing afterwards, so leave the queue alone | ||||
|     if (!buf.is_looping) { | ||||
|         state.input_queue.pop(); | ||||
|     } | ||||
|  | ||||
|     if (buf.adpcm_dirty) { | ||||
|         state.adpcm_state.yn1 = buf.adpcm_yn[0]; | ||||
|         state.adpcm_state.yn2 = buf.adpcm_yn[1]; | ||||
|     } | ||||
|  | ||||
|     const u8* const memory = Memory::GetPhysicalPointer(buf.physical_address); | ||||
|     if (memory) { | ||||
|         const unsigned num_channels = buf.mono_or_stereo == MonoOrStereo::Stereo ? 2 : 1; | ||||
|         switch (buf.format) { | ||||
|         case Format::PCM8: | ||||
|             state.current_buffer = Codec::DecodePCM8(num_channels, memory, buf.length); | ||||
|             break; | ||||
|         case Format::PCM16: | ||||
|             state.current_buffer = Codec::DecodePCM16(num_channels, memory, buf.length); | ||||
|             break; | ||||
|         case Format::ADPCM: | ||||
|             DEBUG_ASSERT(num_channels == 1); | ||||
|             state.current_buffer = | ||||
|                 Codec::DecodeADPCM(memory, buf.length, state.adpcm_coeffs, state.adpcm_state); | ||||
|             break; | ||||
|         default: | ||||
|             UNIMPLEMENTED(); | ||||
|             break; | ||||
|         } | ||||
|     } else { | ||||
|         LOG_WARNING(Audio_DSP, | ||||
|                     "source_id=%zu buffer_id=%hu length=%u: Invalid physical address 0x%08X", | ||||
|                     source_id, buf.buffer_id, buf.length, buf.physical_address); | ||||
|         state.current_buffer.clear(); | ||||
|         return true; | ||||
|     } | ||||
|  | ||||
|     // the first playthrough starts at play_position, loops start at the beginning of the buffer | ||||
|     state.current_sample_number = (!buf.has_played) ? buf.play_position : 0; | ||||
|     state.next_sample_number = state.current_sample_number; | ||||
|     state.current_buffer_id = buf.buffer_id; | ||||
|     state.buffer_update = buf.from_queue && !buf.has_played; | ||||
|  | ||||
|     buf.has_played = true; | ||||
|  | ||||
|     LOG_TRACE(Audio_DSP, "source_id=%zu buffer_id=%hu from_queue=%s current_buffer.size()=%zu", | ||||
|               source_id, buf.buffer_id, buf.from_queue ? "true" : "false", | ||||
|               state.current_buffer.size()); | ||||
|     return true; | ||||
| } | ||||
|  | ||||
| SourceStatus::Status Source::GetCurrentStatus() { | ||||
|     SourceStatus::Status ret; | ||||
|  | ||||
|     // Applications depend on the correct emulation of | ||||
|     // current_buffer_id_dirty and current_buffer_id to synchronise | ||||
|     // audio with video. | ||||
|     ret.is_enabled = state.enabled; | ||||
|     ret.current_buffer_id_dirty = state.buffer_update ? 1 : 0; | ||||
|     state.buffer_update = false; | ||||
|     ret.current_buffer_id = state.current_buffer_id; | ||||
|     ret.buffer_position = state.current_sample_number; | ||||
|     ret.sync = state.sync; | ||||
|  | ||||
|     return ret; | ||||
| } | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,149 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <queue> | ||||
| #include <vector> | ||||
| #include "audio_core/codec.h" | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "audio_core/hle/dsp.h" | ||||
| #include "audio_core/hle/filter.h" | ||||
| #include "audio_core/interpolate.h" | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace DSP { | ||||
| namespace HLE { | ||||
|  | ||||
| /** | ||||
|  * This module performs: | ||||
|  * - Buffer management | ||||
|  * - Decoding of buffers | ||||
|  * - Buffer resampling and interpolation | ||||
|  * - Per-source filtering (SimpleFilter, BiquadFilter) | ||||
|  * - Per-source gain | ||||
|  * - Other per-source processing | ||||
|  */ | ||||
| class Source final { | ||||
| public: | ||||
|     explicit Source(size_t source_id_) : source_id(source_id_) { | ||||
|         Reset(); | ||||
|     } | ||||
|  | ||||
|     /// Resets internal state. | ||||
|     void Reset(); | ||||
|  | ||||
|     /** | ||||
|      * This is called once every audio frame. This performs per-source processing every frame. | ||||
|      * @param config The new configuration we've got for this Source from the application. | ||||
|      * @param adpcm_coeffs ADPCM coefficients to use if config tells us to use them (may contain | ||||
|      * invalid values otherwise). | ||||
|      * @return The current status of this Source. This is given back to the emulated application via | ||||
|      * SharedMemory. | ||||
|      */ | ||||
|     SourceStatus::Status Tick(SourceConfiguration::Configuration& config, | ||||
|                               const s16_le (&adpcm_coeffs)[16]); | ||||
|  | ||||
|     /** | ||||
|      * Mix this source's output into dest, using the gains for the `intermediate_mix_id`-th | ||||
|      * intermediate mixer. | ||||
|      * @param dest The QuadFrame32 to mix into. | ||||
|      * @param intermediate_mix_id The id of the intermediate mix whose gains we are using. | ||||
|      */ | ||||
|     void MixInto(QuadFrame32& dest, size_t intermediate_mix_id) const; | ||||
|  | ||||
| private: | ||||
|     const size_t source_id; | ||||
|     StereoFrame16 current_frame; | ||||
|  | ||||
|     using Format = SourceConfiguration::Configuration::Format; | ||||
|     using InterpolationMode = SourceConfiguration::Configuration::InterpolationMode; | ||||
|     using MonoOrStereo = SourceConfiguration::Configuration::MonoOrStereo; | ||||
|  | ||||
|     /// Internal representation of a buffer for our buffer queue | ||||
|     struct Buffer { | ||||
|         PAddr physical_address; | ||||
|         u32 length; | ||||
|         u8 adpcm_ps; | ||||
|         std::array<u16, 2> adpcm_yn; | ||||
|         bool adpcm_dirty; | ||||
|         bool is_looping; | ||||
|         u16 buffer_id; | ||||
|  | ||||
|         MonoOrStereo mono_or_stereo; | ||||
|         Format format; | ||||
|  | ||||
|         bool from_queue; | ||||
|         u32_dsp play_position; // = 0; | ||||
|         bool has_played;       // = false; | ||||
|     }; | ||||
|  | ||||
|     struct BufferOrder { | ||||
|         bool operator()(const Buffer& a, const Buffer& b) const { | ||||
|             // Lower buffer_id comes first. | ||||
|             return a.buffer_id > b.buffer_id; | ||||
|         } | ||||
|     }; | ||||
|  | ||||
|     struct { | ||||
|  | ||||
|         // State variables | ||||
|  | ||||
|         bool enabled = false; | ||||
|         u16 sync = 0; | ||||
|  | ||||
|         // Mixing | ||||
|  | ||||
|         std::array<std::array<float, 4>, 3> gain = {}; | ||||
|  | ||||
|         // Buffer queue | ||||
|  | ||||
|         std::priority_queue<Buffer, std::vector<Buffer>, BufferOrder> input_queue; | ||||
|         MonoOrStereo mono_or_stereo = MonoOrStereo::Mono; | ||||
|         Format format = Format::ADPCM; | ||||
|  | ||||
|         // Current buffer | ||||
|  | ||||
|         u32 current_sample_number = 0; | ||||
|         u32 next_sample_number = 0; | ||||
|         AudioInterp::StereoBuffer16 current_buffer; | ||||
|  | ||||
|         // buffer_id state | ||||
|  | ||||
|         bool buffer_update = false; | ||||
|         u32 current_buffer_id = 0; | ||||
|  | ||||
|         // Decoding state | ||||
|  | ||||
|         std::array<s16, 16> adpcm_coeffs = {}; | ||||
|         Codec::ADPCMState adpcm_state = {}; | ||||
|  | ||||
|         // Resampling state | ||||
|  | ||||
|         float rate_multiplier = 1.0; | ||||
|         InterpolationMode interpolation_mode = InterpolationMode::Polyphase; | ||||
|         AudioInterp::State interp_state = {}; | ||||
|  | ||||
|         // Filter state | ||||
|  | ||||
|         SourceFilters filters; | ||||
|  | ||||
|     } state; | ||||
|  | ||||
|     // Internal functions | ||||
|  | ||||
|     /// INTERNAL: Update our internal state based on the current config. | ||||
|     void ParseConfig(SourceConfiguration::Configuration& config, const s16_le (&adpcm_coeffs)[16]); | ||||
|     /// INTERNAL: Generate the current audio output for this frame based on our internal state. | ||||
|     void GenerateFrame(); | ||||
|     /// INTERNAL: Dequeues a buffer and does preprocessing on it (decoding, resampling). Puts it | ||||
|     /// into current_buffer. | ||||
|     bool DequeueBuffer(); | ||||
|     /// INTERNAL: Generates a SourceStatus::Status based on our internal state. | ||||
|     SourceStatus::Status GetCurrentStatus(); | ||||
| }; | ||||
|  | ||||
| } // namespace HLE | ||||
| } // namespace DSP | ||||
| @@ -1,76 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include "audio_core/interpolate.h" | ||||
| #include "common/assert.h" | ||||
| #include "common/math_util.h" | ||||
|  | ||||
| namespace AudioInterp { | ||||
|  | ||||
| // Calculations are done in fixed point with 24 fractional bits. | ||||
| // (This is not verified. This was chosen for minimal error.) | ||||
| constexpr u64 scale_factor = 1 << 24; | ||||
| constexpr u64 scale_mask = scale_factor - 1; | ||||
|  | ||||
| /// Here we step over the input in steps of rate, until we consume all of the input. | ||||
| /// Three adjacent samples are passed to fn each step. | ||||
| template <typename Function> | ||||
| static void StepOverSamples(State& state, StereoBuffer16& input, float rate, | ||||
|                             DSP::HLE::StereoFrame16& output, size_t& outputi, Function fn) { | ||||
|     ASSERT(rate > 0); | ||||
|  | ||||
|     if (input.empty()) | ||||
|         return; | ||||
|  | ||||
|     input.insert(input.begin(), {state.xn2, state.xn1}); | ||||
|  | ||||
|     const u64 step_size = static_cast<u64>(rate * scale_factor); | ||||
|     u64 fposition = state.fposition; | ||||
|     size_t inputi = 0; | ||||
|  | ||||
|     while (outputi < output.size()) { | ||||
|         inputi = static_cast<size_t>(fposition / scale_factor); | ||||
|  | ||||
|         if (inputi + 2 >= input.size()) { | ||||
|             inputi = input.size() - 2; | ||||
|             break; | ||||
|         } | ||||
|  | ||||
|         u64 fraction = fposition & scale_mask; | ||||
|         output[outputi++] = fn(fraction, input[inputi], input[inputi + 1], input[inputi + 2]); | ||||
|  | ||||
|         fposition += step_size; | ||||
|     } | ||||
|  | ||||
|     state.xn2 = input[inputi]; | ||||
|     state.xn1 = input[inputi + 1]; | ||||
|     state.fposition = fposition - inputi * scale_factor; | ||||
|  | ||||
|     input.erase(input.begin(), std::next(input.begin(), inputi + 2)); | ||||
| } | ||||
|  | ||||
| void None(State& state, StereoBuffer16& input, float rate, DSP::HLE::StereoFrame16& output, | ||||
|           size_t& outputi) { | ||||
|     StepOverSamples( | ||||
|         state, input, rate, output, outputi, | ||||
|         [](u64 fraction, const auto& x0, const auto& x1, const auto& x2) { return x0; }); | ||||
| } | ||||
|  | ||||
| void Linear(State& state, StereoBuffer16& input, float rate, DSP::HLE::StereoFrame16& output, | ||||
|             size_t& outputi) { | ||||
|     // Note on accuracy: Some values that this produces are +/- 1 from the actual firmware. | ||||
|     StepOverSamples(state, input, rate, output, outputi, | ||||
|                     [](u64 fraction, const auto& x0, const auto& x1, const auto& x2) { | ||||
|                         // This is a saturated subtraction. (Verified by black-box fuzzing.) | ||||
|                         s64 delta0 = MathUtil::Clamp<s64>(x1[0] - x0[0], -32768, 32767); | ||||
|                         s64 delta1 = MathUtil::Clamp<s64>(x1[1] - x0[1], -32768, 32767); | ||||
|  | ||||
|                         return std::array<s16, 2>{ | ||||
|                             static_cast<s16>(x0[0] + fraction * delta0 / scale_factor), | ||||
|                             static_cast<s16>(x0[1] + fraction * delta1 / scale_factor), | ||||
|                         }; | ||||
|                     }); | ||||
| } | ||||
|  | ||||
| } // namespace AudioInterp | ||||
| @@ -1,49 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <deque> | ||||
| #include "audio_core/hle/common.h" | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace AudioInterp { | ||||
|  | ||||
| /// A variable length buffer of signed PCM16 stereo samples. | ||||
| using StereoBuffer16 = std::deque<std::array<s16, 2>>; | ||||
|  | ||||
| struct State { | ||||
|     /// Two historical samples. | ||||
|     std::array<s16, 2> xn1 = {}; ///< x[n-1] | ||||
|     std::array<s16, 2> xn2 = {}; ///< x[n-2] | ||||
|     /// Current fractional position. | ||||
|     u64 fposition = 0; | ||||
| }; | ||||
|  | ||||
| /** | ||||
|  * No interpolation. This is equivalent to a zero-order hold. There is a two-sample predelay. | ||||
|  * @param state Interpolation state. | ||||
|  * @param input Input buffer. | ||||
|  * @param rate Stretch factor. Must be a positive non-zero value. | ||||
|  *             rate > 1.0 performs decimation and rate < 1.0 performs upsampling. | ||||
|  * @param output The resampled audio buffer. | ||||
|  * @param outputi The index of output to start writing to. | ||||
|  */ | ||||
| void None(State& state, StereoBuffer16& input, float rate, DSP::HLE::StereoFrame16& output, | ||||
|           size_t& outputi); | ||||
|  | ||||
| /** | ||||
|  * Linear interpolation. This is equivalent to a first-order hold. There is a two-sample predelay. | ||||
|  * @param state Interpolation state. | ||||
|  * @param input Input buffer. | ||||
|  * @param rate Stretch factor. Must be a positive non-zero value. | ||||
|  *             rate > 1.0 performs decimation and rate < 1.0 performs upsampling. | ||||
|  * @param output The resampled audio buffer. | ||||
|  * @param outputi The index of output to start writing to. | ||||
|  */ | ||||
| void Linear(State& state, StereoBuffer16& input, float rate, DSP::HLE::StereoFrame16& output, | ||||
|             size_t& outputi); | ||||
|  | ||||
| } // namespace AudioInterp | ||||
| @@ -1,34 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <cstddef> | ||||
| #include "audio_core/audio_core.h" | ||||
| #include "audio_core/sink.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| class NullSink final : public Sink { | ||||
| public: | ||||
|     ~NullSink() override = default; | ||||
|  | ||||
|     unsigned int GetNativeSampleRate() const override { | ||||
|         return native_sample_rate; | ||||
|     } | ||||
|  | ||||
|     void EnqueueSamples(const s16*, size_t) override {} | ||||
|  | ||||
|     size_t SamplesInQueue() const override { | ||||
|         return 0; | ||||
|     } | ||||
|  | ||||
|     void SetDevice(int device_id) override {} | ||||
|  | ||||
|     std::vector<std::string> GetDeviceList() const override { | ||||
|         return {}; | ||||
|     } | ||||
| }; | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,147 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <list> | ||||
| #include <numeric> | ||||
| #include <SDL.h> | ||||
| #include "audio_core/audio_core.h" | ||||
| #include "audio_core/sdl2_sink.h" | ||||
| #include "common/assert.h" | ||||
| #include "common/logging/log.h" | ||||
| #include "core/settings.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| struct SDL2Sink::Impl { | ||||
|     unsigned int sample_rate = 0; | ||||
|  | ||||
|     SDL_AudioDeviceID audio_device_id = 0; | ||||
|  | ||||
|     std::list<std::vector<s16>> queue; | ||||
|  | ||||
|     static void Callback(void* impl_, u8* buffer, int buffer_size_in_bytes); | ||||
| }; | ||||
|  | ||||
| SDL2Sink::SDL2Sink() : impl(std::make_unique<Impl>()) { | ||||
|     if (SDL_Init(SDL_INIT_AUDIO) < 0) { | ||||
|         LOG_CRITICAL(Audio_Sink, "SDL_Init(SDL_INIT_AUDIO) failed with: %s", SDL_GetError()); | ||||
|         impl->audio_device_id = 0; | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     SDL_AudioSpec desired_audiospec; | ||||
|     SDL_zero(desired_audiospec); | ||||
|     desired_audiospec.format = AUDIO_S16; | ||||
|     desired_audiospec.channels = 2; | ||||
|     desired_audiospec.freq = native_sample_rate; | ||||
|     desired_audiospec.samples = 512; | ||||
|     desired_audiospec.userdata = impl.get(); | ||||
|     desired_audiospec.callback = &Impl::Callback; | ||||
|  | ||||
|     SDL_AudioSpec obtained_audiospec; | ||||
|     SDL_zero(obtained_audiospec); | ||||
|  | ||||
|     int device_count = SDL_GetNumAudioDevices(0); | ||||
|     device_list.clear(); | ||||
|     for (int i = 0; i < device_count; ++i) { | ||||
|         device_list.push_back(SDL_GetAudioDeviceName(i, 0)); | ||||
|     } | ||||
|  | ||||
|     const char* device = nullptr; | ||||
|  | ||||
|     if (device_count >= 1 && Settings::values.audio_device_id != "auto" && | ||||
|         !Settings::values.audio_device_id.empty()) { | ||||
|         device = Settings::values.audio_device_id.c_str(); | ||||
|     } | ||||
|  | ||||
|     impl->audio_device_id = SDL_OpenAudioDevice(device, false, &desired_audiospec, | ||||
|                                                 &obtained_audiospec, SDL_AUDIO_ALLOW_ANY_CHANGE); | ||||
|     if (impl->audio_device_id <= 0) { | ||||
|         LOG_CRITICAL(Audio_Sink, "SDL_OpenAudioDevice failed with code %d for device \"%s\"", | ||||
|                      impl->audio_device_id, Settings::values.audio_device_id.c_str()); | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     impl->sample_rate = obtained_audiospec.freq; | ||||
|  | ||||
|     // SDL2 audio devices start out paused, unpause it: | ||||
|     SDL_PauseAudioDevice(impl->audio_device_id, 0); | ||||
| } | ||||
|  | ||||
| SDL2Sink::~SDL2Sink() { | ||||
|     if (impl->audio_device_id <= 0) | ||||
|         return; | ||||
|  | ||||
|     SDL_CloseAudioDevice(impl->audio_device_id); | ||||
| } | ||||
|  | ||||
| unsigned int SDL2Sink::GetNativeSampleRate() const { | ||||
|     if (impl->audio_device_id <= 0) | ||||
|         return native_sample_rate; | ||||
|  | ||||
|     return impl->sample_rate; | ||||
| } | ||||
|  | ||||
| std::vector<std::string> SDL2Sink::GetDeviceList() const { | ||||
|     return device_list; | ||||
| } | ||||
|  | ||||
| void SDL2Sink::EnqueueSamples(const s16* samples, size_t sample_count) { | ||||
|     if (impl->audio_device_id <= 0) | ||||
|         return; | ||||
|  | ||||
|     SDL_LockAudioDevice(impl->audio_device_id); | ||||
|     impl->queue.emplace_back(samples, samples + sample_count * 2); | ||||
|     SDL_UnlockAudioDevice(impl->audio_device_id); | ||||
| } | ||||
|  | ||||
| size_t SDL2Sink::SamplesInQueue() const { | ||||
|     if (impl->audio_device_id <= 0) | ||||
|         return 0; | ||||
|  | ||||
|     SDL_LockAudioDevice(impl->audio_device_id); | ||||
|  | ||||
|     size_t total_size = std::accumulate(impl->queue.begin(), impl->queue.end(), | ||||
|                                         static_cast<size_t>(0), [](size_t sum, const auto& buffer) { | ||||
|                                             // Division by two because each stereo sample is made of | ||||
|                                             // two s16. | ||||
|                                             return sum + buffer.size() / 2; | ||||
|                                         }); | ||||
|  | ||||
|     SDL_UnlockAudioDevice(impl->audio_device_id); | ||||
|  | ||||
|     return total_size; | ||||
| } | ||||
|  | ||||
| void SDL2Sink::SetDevice(int device_id) { | ||||
|     this->device_id = device_id; | ||||
| } | ||||
|  | ||||
| void SDL2Sink::Impl::Callback(void* impl_, u8* buffer, int buffer_size_in_bytes) { | ||||
|     Impl* impl = reinterpret_cast<Impl*>(impl_); | ||||
|  | ||||
|     size_t remaining_size = static_cast<size_t>(buffer_size_in_bytes) / | ||||
|                             sizeof(s16); // Keep track of size in 16-bit increments. | ||||
|  | ||||
|     while (remaining_size > 0 && !impl->queue.empty()) { | ||||
|         if (impl->queue.front().size() <= remaining_size) { | ||||
|             memcpy(buffer, impl->queue.front().data(), impl->queue.front().size() * sizeof(s16)); | ||||
|             buffer += impl->queue.front().size() * sizeof(s16); | ||||
|             remaining_size -= impl->queue.front().size(); | ||||
|             impl->queue.pop_front(); | ||||
|         } else { | ||||
|             memcpy(buffer, impl->queue.front().data(), remaining_size * sizeof(s16)); | ||||
|             buffer += remaining_size * sizeof(s16); | ||||
|             impl->queue.front().erase(impl->queue.front().begin(), | ||||
|                                       impl->queue.front().begin() + remaining_size); | ||||
|             remaining_size = 0; | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     if (remaining_size > 0) { | ||||
|         memset(buffer, 0, remaining_size * sizeof(s16)); | ||||
|     } | ||||
| } | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,34 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <cstddef> | ||||
| #include <memory> | ||||
| #include "audio_core/sink.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| class SDL2Sink final : public Sink { | ||||
| public: | ||||
|     SDL2Sink(); | ||||
|     ~SDL2Sink() override; | ||||
|  | ||||
|     unsigned int GetNativeSampleRate() const override; | ||||
|  | ||||
|     void EnqueueSamples(const s16* samples, size_t sample_count) override; | ||||
|  | ||||
|     size_t SamplesInQueue() const override; | ||||
|  | ||||
|     std::vector<std::string> GetDeviceList() const override; | ||||
|     void SetDevice(int device_id) override; | ||||
|  | ||||
| private: | ||||
|     struct Impl; | ||||
|     std::unique_ptr<Impl> impl; | ||||
|     int device_id; | ||||
|     std::vector<std::string> device_list; | ||||
| }; | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,45 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <vector> | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| /** | ||||
|  * This class is an interface for an audio sink. An audio sink accepts samples in stereo signed | ||||
|  * PCM16 format to be output. Sinks *do not* handle resampling and expect the correct sample rate. | ||||
|  * They are dumb outputs. | ||||
|  */ | ||||
| class Sink { | ||||
| public: | ||||
|     virtual ~Sink() = default; | ||||
|  | ||||
|     /// The native rate of this sink. The sink expects to be fed samples that respect this. (Units: | ||||
|     /// samples/sec) | ||||
|     virtual unsigned int GetNativeSampleRate() const = 0; | ||||
|  | ||||
|     /** | ||||
|      * Feed stereo samples to sink. | ||||
|      * @param samples Samples in interleaved stereo PCM16 format. | ||||
|      * @param sample_count Number of samples. | ||||
|      */ | ||||
|     virtual void EnqueueSamples(const s16* samples, size_t sample_count) = 0; | ||||
|  | ||||
|     /// Samples enqueued that have not been played yet. | ||||
|     virtual std::size_t SamplesInQueue() const = 0; | ||||
|  | ||||
|     /** | ||||
|      * Sets the desired output device. | ||||
|      * @param device_id ID of the desired device. | ||||
|      */ | ||||
|     virtual void SetDevice(int device_id) = 0; | ||||
|  | ||||
|     /// Returns the list of available devices. | ||||
|     virtual std::vector<std::string> GetDeviceList() const = 0; | ||||
| }; | ||||
|  | ||||
| } // namespace | ||||
| @@ -1,42 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <algorithm> | ||||
| #include <memory> | ||||
| #include <vector> | ||||
| #include "audio_core/null_sink.h" | ||||
| #include "audio_core/sink_details.h" | ||||
| #ifdef HAVE_SDL2 | ||||
| #include "audio_core/sdl2_sink.h" | ||||
| #endif | ||||
| #include "common/logging/log.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| // g_sink_details is ordered in terms of desirability, with the best choice at the top. | ||||
| const std::vector<SinkDetails> g_sink_details = { | ||||
| #ifdef HAVE_SDL2 | ||||
|     {"sdl2", []() { return std::make_unique<SDL2Sink>(); }}, | ||||
| #endif | ||||
|     {"null", []() { return std::make_unique<NullSink>(); }}, | ||||
| }; | ||||
|  | ||||
| const SinkDetails& GetSinkDetails(std::string sink_id) { | ||||
|     auto iter = | ||||
|         std::find_if(g_sink_details.begin(), g_sink_details.end(), | ||||
|                      [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; }); | ||||
|  | ||||
|     if (sink_id == "auto" || iter == g_sink_details.end()) { | ||||
|         if (sink_id != "auto") { | ||||
|             LOG_ERROR(Audio, "AudioCore::SelectSink given invalid sink_id %s", sink_id.c_str()); | ||||
|         } | ||||
|         // Auto-select. | ||||
|         // g_sink_details is ordered in terms of desirability, with the best choice at the front. | ||||
|         iter = g_sink_details.begin(); | ||||
|     } | ||||
|  | ||||
|     return *iter; | ||||
| } | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,29 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <functional> | ||||
| #include <memory> | ||||
| #include <vector> | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| class Sink; | ||||
|  | ||||
| struct SinkDetails { | ||||
|     SinkDetails(const char* id_, std::function<std::unique_ptr<Sink>()> factory_) | ||||
|         : id(id_), factory(factory_) {} | ||||
|  | ||||
|     /// Name for this sink. | ||||
|     const char* id; | ||||
|     /// A method to call to construct an instance of this type of sink. | ||||
|     std::function<std::unique_ptr<Sink>()> factory; | ||||
| }; | ||||
|  | ||||
| extern const std::vector<SinkDetails> g_sink_details; | ||||
|  | ||||
| const SinkDetails& GetSinkDetails(std::string sink_id); | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,143 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <chrono> | ||||
| #include <cmath> | ||||
| #include <vector> | ||||
| #include <SoundTouch.h> | ||||
| #include "audio_core/audio_core.h" | ||||
| #include "audio_core/time_stretch.h" | ||||
| #include "common/common_types.h" | ||||
| #include "common/logging/log.h" | ||||
| #include "common/math_util.h" | ||||
|  | ||||
| using steady_clock = std::chrono::steady_clock; | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| constexpr double MIN_RATIO = 0.1; | ||||
| constexpr double MAX_RATIO = 100.0; | ||||
|  | ||||
| static double ClampRatio(double ratio) { | ||||
|     return MathUtil::Clamp(ratio, MIN_RATIO, MAX_RATIO); | ||||
| } | ||||
|  | ||||
| constexpr double MIN_DELAY_TIME = 0.05;            // Units: seconds | ||||
| constexpr double MAX_DELAY_TIME = 0.25;            // Units: seconds | ||||
| constexpr size_t DROP_FRAMES_SAMPLE_DELAY = 16000; // Units: samples | ||||
|  | ||||
| constexpr double SMOOTHING_FACTOR = 0.007; | ||||
|  | ||||
| struct TimeStretcher::Impl { | ||||
|     soundtouch::SoundTouch soundtouch; | ||||
|  | ||||
|     steady_clock::time_point frame_timer = steady_clock::now(); | ||||
|     size_t samples_queued = 0; | ||||
|  | ||||
|     double smoothed_ratio = 1.0; | ||||
|  | ||||
|     double sample_rate = static_cast<double>(native_sample_rate); | ||||
| }; | ||||
|  | ||||
| std::vector<s16> TimeStretcher::Process(size_t samples_in_queue) { | ||||
|     // This is a very simple algorithm without any fancy control theory. It works and is stable. | ||||
|  | ||||
|     double ratio = CalculateCurrentRatio(); | ||||
|     ratio = CorrectForUnderAndOverflow(ratio, samples_in_queue); | ||||
|     impl->smoothed_ratio = | ||||
|         (1.0 - SMOOTHING_FACTOR) * impl->smoothed_ratio + SMOOTHING_FACTOR * ratio; | ||||
|     impl->smoothed_ratio = ClampRatio(impl->smoothed_ratio); | ||||
|  | ||||
|     // SoundTouch's tempo definition the inverse of our ratio definition. | ||||
|     impl->soundtouch.setTempo(1.0 / impl->smoothed_ratio); | ||||
|  | ||||
|     std::vector<s16> samples = GetSamples(); | ||||
|     if (samples_in_queue >= DROP_FRAMES_SAMPLE_DELAY) { | ||||
|         samples.clear(); | ||||
|         LOG_TRACE(Audio, "Dropping frames!"); | ||||
|     } | ||||
|     return samples; | ||||
| } | ||||
|  | ||||
| TimeStretcher::TimeStretcher() : impl(std::make_unique<Impl>()) { | ||||
|     impl->soundtouch.setPitch(1.0); | ||||
|     impl->soundtouch.setChannels(2); | ||||
|     impl->soundtouch.setSampleRate(native_sample_rate); | ||||
|     Reset(); | ||||
| } | ||||
|  | ||||
| TimeStretcher::~TimeStretcher() { | ||||
|     impl->soundtouch.clear(); | ||||
| } | ||||
|  | ||||
| void TimeStretcher::SetOutputSampleRate(unsigned int sample_rate) { | ||||
|     impl->sample_rate = static_cast<double>(sample_rate); | ||||
|     impl->soundtouch.setRate(static_cast<double>(native_sample_rate) / impl->sample_rate); | ||||
| } | ||||
|  | ||||
| void TimeStretcher::AddSamples(const s16* buffer, size_t num_samples) { | ||||
|     impl->soundtouch.putSamples(buffer, static_cast<uint>(num_samples)); | ||||
|     impl->samples_queued += num_samples; | ||||
| } | ||||
|  | ||||
| void TimeStretcher::Flush() { | ||||
|     impl->soundtouch.flush(); | ||||
| } | ||||
|  | ||||
| void TimeStretcher::Reset() { | ||||
|     impl->soundtouch.setTempo(1.0); | ||||
|     impl->soundtouch.clear(); | ||||
|     impl->smoothed_ratio = 1.0; | ||||
|     impl->frame_timer = steady_clock::now(); | ||||
|     impl->samples_queued = 0; | ||||
|     SetOutputSampleRate(native_sample_rate); | ||||
| } | ||||
|  | ||||
| double TimeStretcher::CalculateCurrentRatio() { | ||||
|     const steady_clock::time_point now = steady_clock::now(); | ||||
|     const std::chrono::duration<double> duration = now - impl->frame_timer; | ||||
|  | ||||
|     const double expected_time = | ||||
|         static_cast<double>(impl->samples_queued) / static_cast<double>(native_sample_rate); | ||||
|     const double actual_time = duration.count(); | ||||
|  | ||||
|     double ratio; | ||||
|     if (expected_time != 0) { | ||||
|         ratio = ClampRatio(actual_time / expected_time); | ||||
|     } else { | ||||
|         ratio = impl->smoothed_ratio; | ||||
|     } | ||||
|  | ||||
|     impl->frame_timer = now; | ||||
|     impl->samples_queued = 0; | ||||
|  | ||||
|     return ratio; | ||||
| } | ||||
|  | ||||
| double TimeStretcher::CorrectForUnderAndOverflow(double ratio, size_t sample_delay) const { | ||||
|     const size_t min_sample_delay = static_cast<size_t>(MIN_DELAY_TIME * impl->sample_rate); | ||||
|     const size_t max_sample_delay = static_cast<size_t>(MAX_DELAY_TIME * impl->sample_rate); | ||||
|  | ||||
|     if (sample_delay < min_sample_delay) { | ||||
|         // Make the ratio bigger. | ||||
|         ratio = ratio > 1.0 ? ratio * ratio : sqrt(ratio); | ||||
|     } else if (sample_delay > max_sample_delay) { | ||||
|         // Make the ratio smaller. | ||||
|         ratio = ratio > 1.0 ? sqrt(ratio) : ratio * ratio; | ||||
|     } | ||||
|  | ||||
|     return ClampRatio(ratio); | ||||
| } | ||||
|  | ||||
| std::vector<s16> TimeStretcher::GetSamples() { | ||||
|     uint available = impl->soundtouch.numSamples(); | ||||
|  | ||||
|     std::vector<s16> output(static_cast<size_t>(available) * 2); | ||||
|  | ||||
|     impl->soundtouch.receiveSamples(output.data(), available); | ||||
|  | ||||
|     return output; | ||||
| } | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,60 +0,0 @@ | ||||
| // Copyright 2016 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <cstddef> | ||||
| #include <memory> | ||||
| #include <vector> | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace AudioCore { | ||||
|  | ||||
| class TimeStretcher final { | ||||
| public: | ||||
|     TimeStretcher(); | ||||
|     ~TimeStretcher(); | ||||
|  | ||||
|     /** | ||||
|      * Set sample rate for the samples that Process returns. | ||||
|      * @param sample_rate The sample rate. | ||||
|      */ | ||||
|     void SetOutputSampleRate(unsigned int sample_rate); | ||||
|  | ||||
|     /** | ||||
|      * Add samples to be processed. | ||||
|      * @param sample_buffer Buffer of samples in interleaved stereo PCM16 format. | ||||
|      * @param num_samples Number of samples. | ||||
|      */ | ||||
|     void AddSamples(const s16* sample_buffer, size_t num_samples); | ||||
|  | ||||
|     /// Flush audio remaining in internal buffers. | ||||
|     void Flush(); | ||||
|  | ||||
|     /// Resets internal state and clears buffers. | ||||
|     void Reset(); | ||||
|  | ||||
|     /** | ||||
|      * Does audio stretching and produces the time-stretched samples. | ||||
|      * Timer calculations use sample_delay to determine how much of a margin we have. | ||||
|      * @param sample_delay How many samples are buffered downstream of this module and haven't been | ||||
|      * played yet. | ||||
|      * @return Samples to play in interleaved stereo PCM16 format. | ||||
|      */ | ||||
|     std::vector<s16> Process(size_t sample_delay); | ||||
|  | ||||
| private: | ||||
|     struct Impl; | ||||
|     std::unique_ptr<Impl> impl; | ||||
|  | ||||
|     /// INTERNAL: ratio = wallclock time / emulated time | ||||
|     double CalculateCurrentRatio(); | ||||
|     /// INTERNAL: If we have too many or too few samples downstream, nudge ratio in the appropriate | ||||
|     /// direction. | ||||
|     double CorrectForUnderAndOverflow(double ratio, size_t sample_delay) const; | ||||
|     /// INTERNAL: Gets the time-stretched samples from SoundTouch. | ||||
|     std::vector<s16> GetSamples(); | ||||
| }; | ||||
|  | ||||
| } // namespace AudioCore | ||||
| @@ -1,18 +0,0 @@ | ||||
| set(SRCS | ||||
|             network.cpp | ||||
|             packet.cpp | ||||
|             room.cpp | ||||
|             room_member.cpp | ||||
|             ) | ||||
|  | ||||
| set(HEADERS | ||||
|             network.h | ||||
|             packet.h | ||||
|             room.h | ||||
|             room_member.h | ||||
|             ) | ||||
|  | ||||
| create_directory_groups(${SRCS} ${HEADERS}) | ||||
|  | ||||
| add_library(network STATIC ${SRCS} ${HEADERS}) | ||||
| target_link_libraries(network PRIVATE common enet) | ||||
| @@ -1,50 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include "common/assert.h" | ||||
| #include "common/logging/log.h" | ||||
| #include "enet/enet.h" | ||||
| #include "network/network.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| static std::shared_ptr<RoomMember> g_room_member; ///< RoomMember (Client) for network games | ||||
| static std::shared_ptr<Room> g_room;              ///< Room (Server) for network games | ||||
| // TODO(B3N30): Put these globals into a networking class | ||||
|  | ||||
| bool Init() { | ||||
|     if (enet_initialize() != 0) { | ||||
|         LOG_ERROR(Network, "Error initalizing ENet"); | ||||
|         return false; | ||||
|     } | ||||
|     g_room = std::make_shared<Room>(); | ||||
|     g_room_member = std::make_shared<RoomMember>(); | ||||
|     LOG_DEBUG(Network, "initialized OK"); | ||||
|     return true; | ||||
| } | ||||
|  | ||||
| std::weak_ptr<Room> GetRoom() { | ||||
|     return g_room; | ||||
| } | ||||
|  | ||||
| std::weak_ptr<RoomMember> GetRoomMember() { | ||||
|     return g_room_member; | ||||
| } | ||||
|  | ||||
| void Shutdown() { | ||||
|     if (g_room_member) { | ||||
|         if (g_room_member->IsConnected()) | ||||
|             g_room_member->Leave(); | ||||
|         g_room_member.reset(); | ||||
|     } | ||||
|     if (g_room) { | ||||
|         if (g_room->GetState() == Room::State::Open) | ||||
|             g_room->Destroy(); | ||||
|         g_room.reset(); | ||||
|     } | ||||
|     enet_deinitialize(); | ||||
|     LOG_DEBUG(Network, "shutdown OK"); | ||||
| } | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,25 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <memory> | ||||
| #include "network/room.h" | ||||
| #include "network/room_member.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| /// Initializes and registers the network device, the room, and the room member. | ||||
| bool Init(); | ||||
|  | ||||
| /// Returns a pointer to the room handle | ||||
| std::weak_ptr<Room> GetRoom(); | ||||
|  | ||||
| /// Returns a pointer to the room member handle | ||||
| std::weak_ptr<RoomMember> GetRoomMember(); | ||||
|  | ||||
| /// Unregisters the network device, the room, and the room member and shut them down. | ||||
| void Shutdown(); | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,263 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #ifdef _WIN32 | ||||
| #include <winsock2.h> | ||||
| #else | ||||
| #include <arpa/inet.h> | ||||
| #endif | ||||
| #include <cstring> | ||||
| #include <string> | ||||
| #include "network/packet.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| #ifndef htonll | ||||
| u64 htonll(u64 x) { | ||||
|     return ((1 == htonl(1)) ? (x) : ((uint64_t)htonl((x)&0xFFFFFFFF) << 32) | htonl((x) >> 32)); | ||||
| } | ||||
| #endif | ||||
|  | ||||
| #ifndef ntohll | ||||
| u64 ntohll(u64 x) { | ||||
|     return ((1 == ntohl(1)) ? (x) : ((uint64_t)ntohl((x)&0xFFFFFFFF) << 32) | ntohl((x) >> 32)); | ||||
| } | ||||
| #endif | ||||
|  | ||||
| void Packet::Append(const void* in_data, std::size_t size_in_bytes) { | ||||
|     if (in_data && (size_in_bytes > 0)) { | ||||
|         std::size_t start = data.size(); | ||||
|         data.resize(start + size_in_bytes); | ||||
|         std::memcpy(&data[start], in_data, size_in_bytes); | ||||
|     } | ||||
| } | ||||
|  | ||||
| void Packet::Read(void* out_data, std::size_t size_in_bytes) { | ||||
|     if (out_data && CheckSize(size_in_bytes)) { | ||||
|         std::memcpy(out_data, &data[read_pos], size_in_bytes); | ||||
|         read_pos += size_in_bytes; | ||||
|     } | ||||
| } | ||||
|  | ||||
| void Packet::Clear() { | ||||
|     data.clear(); | ||||
|     read_pos = 0; | ||||
|     is_valid = true; | ||||
| } | ||||
|  | ||||
| const void* Packet::GetData() const { | ||||
|     return !data.empty() ? &data[0] : nullptr; | ||||
| } | ||||
|  | ||||
| void Packet::IgnoreBytes(u32 length) { | ||||
|     read_pos += length; | ||||
| } | ||||
|  | ||||
| std::size_t Packet::GetDataSize() const { | ||||
|     return data.size(); | ||||
| } | ||||
|  | ||||
| bool Packet::EndOfPacket() const { | ||||
|     return read_pos >= data.size(); | ||||
| } | ||||
|  | ||||
| Packet::operator bool() const { | ||||
|     return is_valid ? &Packet::CheckSize : nullptr; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(bool& out_data) { | ||||
|     u8 value; | ||||
|     if (*this >> value) { | ||||
|         out_data = (value != 0); | ||||
|     } | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(s8& out_data) { | ||||
|     Read(&out_data, sizeof(out_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(u8& out_data) { | ||||
|     Read(&out_data, sizeof(out_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(s16& out_data) { | ||||
|     s16 value; | ||||
|     Read(&value, sizeof(value)); | ||||
|     out_data = ntohs(value); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(u16& out_data) { | ||||
|     u16 value; | ||||
|     Read(&value, sizeof(value)); | ||||
|     out_data = ntohs(value); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(s32& out_data) { | ||||
|     s32 value; | ||||
|     Read(&value, sizeof(value)); | ||||
|     out_data = ntohl(value); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(u32& out_data) { | ||||
|     u32 value; | ||||
|     Read(&value, sizeof(value)); | ||||
|     out_data = ntohl(value); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(s64& out_data) { | ||||
|     s64 value; | ||||
|     Read(&value, sizeof(value)); | ||||
|     out_data = ntohll(value); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(u64& out_data) { | ||||
|     u64 value; | ||||
|     Read(&value, sizeof(value)); | ||||
|     out_data = ntohll(value); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(float& out_data) { | ||||
|     Read(&out_data, sizeof(out_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(double& out_data) { | ||||
|     Read(&out_data, sizeof(out_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(char* out_data) { | ||||
|     // First extract string length | ||||
|     u32 length = 0; | ||||
|     *this >> length; | ||||
|  | ||||
|     if ((length > 0) && CheckSize(length)) { | ||||
|         // Then extract characters | ||||
|         std::memcpy(out_data, &data[read_pos], length); | ||||
|         out_data[length] = '\0'; | ||||
|  | ||||
|         // Update reading position | ||||
|         read_pos += length; | ||||
|     } | ||||
|  | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator>>(std::string& out_data) { | ||||
|     // First extract string length | ||||
|     u32 length = 0; | ||||
|     *this >> length; | ||||
|  | ||||
|     out_data.clear(); | ||||
|     if ((length > 0) && CheckSize(length)) { | ||||
|         // Then extract characters | ||||
|         out_data.assign(&data[read_pos], length); | ||||
|  | ||||
|         // Update reading position | ||||
|         read_pos += length; | ||||
|     } | ||||
|  | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(bool in_data) { | ||||
|     *this << static_cast<u8>(in_data); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(s8 in_data) { | ||||
|     Append(&in_data, sizeof(in_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(u8 in_data) { | ||||
|     Append(&in_data, sizeof(in_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(s16 in_data) { | ||||
|     s16 toWrite = htons(in_data); | ||||
|     Append(&toWrite, sizeof(toWrite)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(u16 in_data) { | ||||
|     u16 toWrite = htons(in_data); | ||||
|     Append(&toWrite, sizeof(toWrite)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(s32 in_data) { | ||||
|     s32 toWrite = htonl(in_data); | ||||
|     Append(&toWrite, sizeof(toWrite)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(u32 in_data) { | ||||
|     u32 toWrite = htonl(in_data); | ||||
|     Append(&toWrite, sizeof(toWrite)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(s64 in_data) { | ||||
|     s64 toWrite = htonll(in_data); | ||||
|     Append(&toWrite, sizeof(toWrite)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(u64 in_data) { | ||||
|     u64 toWrite = htonll(in_data); | ||||
|     Append(&toWrite, sizeof(toWrite)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(float in_data) { | ||||
|     Append(&in_data, sizeof(in_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(double in_data) { | ||||
|     Append(&in_data, sizeof(in_data)); | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(const char* in_data) { | ||||
|     // First insert string length | ||||
|     u32 length = static_cast<u32>(std::strlen(in_data)); | ||||
|     *this << length; | ||||
|  | ||||
|     // Then insert characters | ||||
|     Append(in_data, length * sizeof(char)); | ||||
|  | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| Packet& Packet::operator<<(const std::string& in_data) { | ||||
|     // First insert string length | ||||
|     u32 length = static_cast<u32>(in_data.size()); | ||||
|     *this << length; | ||||
|  | ||||
|     // Then insert characters | ||||
|     if (length > 0) | ||||
|         Append(in_data.c_str(), length * sizeof(std::string::value_type)); | ||||
|  | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| bool Packet::CheckSize(std::size_t size) { | ||||
|     is_valid = is_valid && (read_pos + size <= data.size()); | ||||
|  | ||||
|     return is_valid; | ||||
| } | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,166 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <vector> | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| /// A class that serializes data for network transfer. It also handles endianess | ||||
| class Packet { | ||||
| public: | ||||
|     Packet() = default; | ||||
|     ~Packet() = default; | ||||
|  | ||||
|     /** | ||||
|      * Append data to the end of the packet | ||||
|      * @param data        Pointer to the sequence of bytes to append | ||||
|      * @param size_in_bytes Number of bytes to append | ||||
|      */ | ||||
|     void Append(const void* data, std::size_t size_in_bytes); | ||||
|  | ||||
|     /** | ||||
|      * Reads data from the current read position of the packet | ||||
|      * @param out_data        Pointer where the data should get written to | ||||
|      * @param size_in_bytes Number of bytes to read | ||||
|      */ | ||||
|     void Read(void* out_data, std::size_t size_in_bytes); | ||||
|  | ||||
|     /** | ||||
|      * Clear the packet | ||||
|      * After calling Clear, the packet is empty. | ||||
|      */ | ||||
|     void Clear(); | ||||
|  | ||||
|     /** | ||||
|      * Ignores bytes while reading | ||||
|      * @param length THe number of bytes to ignore | ||||
|      */ | ||||
|     void IgnoreBytes(u32 length); | ||||
|  | ||||
|     /** | ||||
|      * Get a pointer to the data contained in the packet | ||||
|      * @return Pointer to the data | ||||
|      */ | ||||
|     const void* GetData() const; | ||||
|  | ||||
|     /** | ||||
|      * This function returns the number of bytes pointed to by | ||||
|      * what getData returns. | ||||
|      * @return Data size, in bytes | ||||
|      */ | ||||
|     std::size_t GetDataSize() const; | ||||
|  | ||||
|     /** | ||||
|      * This function is useful to know if there is some data | ||||
|      * left to be read, without actually reading it. | ||||
|      * @return True if all data was read, false otherwise | ||||
|      */ | ||||
|     bool EndOfPacket() const; | ||||
|  | ||||
|     explicit operator bool() const; | ||||
|  | ||||
|     /// Overloads of operator >> to read data from the packet | ||||
|     Packet& operator>>(bool& out_data); | ||||
|     Packet& operator>>(s8& out_data); | ||||
|     Packet& operator>>(u8& out_data); | ||||
|     Packet& operator>>(s16& out_data); | ||||
|     Packet& operator>>(u16& out_data); | ||||
|     Packet& operator>>(s32& out_data); | ||||
|     Packet& operator>>(u32& out_data); | ||||
|     Packet& operator>>(s64& out_data); | ||||
|     Packet& operator>>(u64& out_data); | ||||
|     Packet& operator>>(float& out_data); | ||||
|     Packet& operator>>(double& out_data); | ||||
|     Packet& operator>>(char* out_data); | ||||
|     Packet& operator>>(std::string& out_data); | ||||
|     template <typename T> | ||||
|     Packet& operator>>(std::vector<T>& out_data); | ||||
|     template <typename T, std::size_t S> | ||||
|     Packet& operator>>(std::array<T, S>& out_data); | ||||
|  | ||||
|     /// Overloads of operator << to write data into the packet | ||||
|     Packet& operator<<(bool in_data); | ||||
|     Packet& operator<<(s8 in_data); | ||||
|     Packet& operator<<(u8 in_data); | ||||
|     Packet& operator<<(s16 in_data); | ||||
|     Packet& operator<<(u16 in_data); | ||||
|     Packet& operator<<(s32 in_data); | ||||
|     Packet& operator<<(u32 in_data); | ||||
|     Packet& operator<<(s64 in_data); | ||||
|     Packet& operator<<(u64 in_data); | ||||
|     Packet& operator<<(float in_data); | ||||
|     Packet& operator<<(double in_data); | ||||
|     Packet& operator<<(const char* in_data); | ||||
|     Packet& operator<<(const std::string& in_data); | ||||
|     template <typename T> | ||||
|     Packet& operator<<(const std::vector<T>& in_data); | ||||
|     template <typename T, std::size_t S> | ||||
|     Packet& operator<<(const std::array<T, S>& data); | ||||
|  | ||||
| private: | ||||
|     /** | ||||
|      * Check if the packet can extract a given number of bytes | ||||
|      * This function updates accordingly the state of the packet. | ||||
|      * @param size Size to check | ||||
|      * @return True if size bytes can be read from the packet | ||||
|      */ | ||||
|     bool CheckSize(std::size_t size); | ||||
|  | ||||
|     // Member data | ||||
|     std::vector<char> data;   ///< Data stored in the packet | ||||
|     std::size_t read_pos = 0; ///< Current reading position in the packet | ||||
|     bool is_valid = true;     ///< Reading state of the packet | ||||
| }; | ||||
|  | ||||
| template <typename T> | ||||
| Packet& Packet::operator>>(std::vector<T>& out_data) { | ||||
|     // First extract the size | ||||
|     u32 size = 0; | ||||
|     *this >> size; | ||||
|     out_data.resize(size); | ||||
|  | ||||
|     // Then extract the data | ||||
|     for (std::size_t i = 0; i < out_data.size(); ++i) { | ||||
|         T character = 0; | ||||
|         *this >> character; | ||||
|         out_data[i] = character; | ||||
|     } | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| template <typename T, std::size_t S> | ||||
| Packet& Packet::operator>>(std::array<T, S>& out_data) { | ||||
|     for (std::size_t i = 0; i < out_data.size(); ++i) { | ||||
|         T character = 0; | ||||
|         *this >> character; | ||||
|         out_data[i] = character; | ||||
|     } | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| template <typename T> | ||||
| Packet& Packet::operator<<(const std::vector<T>& in_data) { | ||||
|     // First insert the size | ||||
|     *this << static_cast<u32>(in_data.size()); | ||||
|  | ||||
|     // Then insert the data | ||||
|     for (std::size_t i = 0; i < in_data.size(); ++i) { | ||||
|         *this << in_data[i]; | ||||
|     } | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| template <typename T, std::size_t S> | ||||
| Packet& Packet::operator<<(const std::array<T, S>& in_data) { | ||||
|     for (std::size_t i = 0; i < in_data.size(); ++i) { | ||||
|         *this << in_data[i]; | ||||
|     } | ||||
|     return *this; | ||||
| } | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,497 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <algorithm> | ||||
| #include <atomic> | ||||
| #include <mutex> | ||||
| #include <random> | ||||
| #include <thread> | ||||
| #include "enet/enet.h" | ||||
| #include "network/packet.h" | ||||
| #include "network/room.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| /// Maximum number of concurrent connections allowed to this room. | ||||
| static constexpr u32 MaxConcurrentConnections = 10; | ||||
|  | ||||
| class Room::RoomImpl { | ||||
| public: | ||||
|     // This MAC address is used to generate a 'Nintendo' like Mac address. | ||||
|     const MacAddress NintendoOUI; | ||||
|     std::mt19937 random_gen; ///< Random number generator. Used for GenerateMacAddress | ||||
|  | ||||
|     ENetHost* server = nullptr; ///< Network interface. | ||||
|  | ||||
|     std::atomic<State> state{State::Closed}; ///< Current state of the room. | ||||
|     RoomInformation room_information;        ///< Information about this room. | ||||
|  | ||||
|     struct Member { | ||||
|         std::string nickname;   ///< The nickname of the member. | ||||
|         GameInfo game_info;     ///< The current game of the member | ||||
|         MacAddress mac_address; ///< The assigned mac address of the member. | ||||
|         ENetPeer* peer;         ///< The remote peer. | ||||
|     }; | ||||
|     using MemberList = std::vector<Member>; | ||||
|     MemberList members;              ///< Information about the members of this room | ||||
|     mutable std::mutex member_mutex; ///< Mutex for locking the members list | ||||
|     /// This should be a std::shared_mutex as soon as C++17 is supported | ||||
|  | ||||
|     RoomImpl() | ||||
|         : random_gen(std::random_device()()), NintendoOUI{0x00, 0x1F, 0x32, 0x00, 0x00, 0x00} {} | ||||
|  | ||||
|     /// Thread that receives and dispatches network packets | ||||
|     std::unique_ptr<std::thread> room_thread; | ||||
|  | ||||
|     /// Thread function that will receive and dispatch messages until the room is destroyed. | ||||
|     void ServerLoop(); | ||||
|     void StartLoop(); | ||||
|  | ||||
|     /** | ||||
|      * Parses and answers a room join request from a client. | ||||
|      * Validates the uniqueness of the username and assigns the MAC address | ||||
|      * that the client will use for the remainder of the connection. | ||||
|      */ | ||||
|     void HandleJoinRequest(const ENetEvent* event); | ||||
|  | ||||
|     /** | ||||
|      * Returns whether the nickname is valid, ie. isn't already taken by someone else in the room. | ||||
|      */ | ||||
|     bool IsValidNickname(const std::string& nickname) const; | ||||
|  | ||||
|     /** | ||||
|      * Returns whether the MAC address is valid, ie. isn't already taken by someone else in the | ||||
|      * room. | ||||
|      */ | ||||
|     bool IsValidMacAddress(const MacAddress& address) const; | ||||
|  | ||||
|     /** | ||||
|      * Sends a ID_ROOM_NAME_COLLISION message telling the client that the name is invalid. | ||||
|      */ | ||||
|     void SendNameCollision(ENetPeer* client); | ||||
|  | ||||
|     /** | ||||
|      * Sends a ID_ROOM_MAC_COLLISION message telling the client that the MAC is invalid. | ||||
|      */ | ||||
|     void SendMacCollision(ENetPeer* client); | ||||
|  | ||||
|     /** | ||||
|      * Sends a ID_ROOM_VERSION_MISMATCH message telling the client that the version is invalid. | ||||
|      */ | ||||
|     void SendVersionMismatch(ENetPeer* client); | ||||
|  | ||||
|     /** | ||||
|      * Notifies the member that its connection attempt was successful, | ||||
|      * and it is now part of the room. | ||||
|      */ | ||||
|     void SendJoinSuccess(ENetPeer* client, MacAddress mac_address); | ||||
|  | ||||
|     /** | ||||
|      * Notifies the members that the room is closed, | ||||
|      */ | ||||
|     void SendCloseMessage(); | ||||
|  | ||||
|     /** | ||||
|      * Sends the information about the room, along with the list of members | ||||
|      * to every connected client in the room. | ||||
|      * The packet has the structure: | ||||
|      * <MessageID>ID_ROOM_INFORMATION | ||||
|      * <String> room_name | ||||
|      * <u32> member_slots: The max number of clients allowed in this room | ||||
|      * <u32> num_members: the number of currently joined clients | ||||
|      * This is followed by the following three values for each member: | ||||
|      * <String> nickname of that member | ||||
|      * <MacAddress> mac_address of that member | ||||
|      * <String> game_name of that member | ||||
|      */ | ||||
|     void BroadcastRoomInformation(); | ||||
|  | ||||
|     /** | ||||
|      * Generates a free MAC address to assign to a new client. | ||||
|      * The first 3 bytes are the NintendoOUI 0x00, 0x1F, 0x32 | ||||
|      */ | ||||
|     MacAddress GenerateMacAddress(); | ||||
|  | ||||
|     /** | ||||
|      * Broadcasts this packet to all members except the sender. | ||||
|      * @param event The ENet event containing the data | ||||
|      */ | ||||
|     void HandleWifiPacket(const ENetEvent* event); | ||||
|  | ||||
|     /** | ||||
|      * Extracts a chat entry from a received ENet packet and adds it to the chat queue. | ||||
|      * @param event The ENet event that was received. | ||||
|      */ | ||||
|     void HandleChatPacket(const ENetEvent* event); | ||||
|  | ||||
|     /** | ||||
|      * Extracts the game name from a received ENet packet and broadcasts it. | ||||
|      * @param event The ENet event that was received. | ||||
|      */ | ||||
|     void HandleGameNamePacket(const ENetEvent* event); | ||||
|  | ||||
|     /** | ||||
|      * Removes the client from the members list if it was in it and announces the change | ||||
|      * to all other clients. | ||||
|      */ | ||||
|     void HandleClientDisconnection(ENetPeer* client); | ||||
| }; | ||||
|  | ||||
| // RoomImpl | ||||
| void Room::RoomImpl::ServerLoop() { | ||||
|     while (state != State::Closed) { | ||||
|         ENetEvent event; | ||||
|         if (enet_host_service(server, &event, 100) > 0) { | ||||
|             switch (event.type) { | ||||
|             case ENET_EVENT_TYPE_RECEIVE: | ||||
|                 switch (event.packet->data[0]) { | ||||
|                 case IdJoinRequest: | ||||
|                     HandleJoinRequest(&event); | ||||
|                     break; | ||||
|                 case IdSetGameInfo: | ||||
|                     HandleGameNamePacket(&event); | ||||
|                     break; | ||||
|                 case IdWifiPacket: | ||||
|                     HandleWifiPacket(&event); | ||||
|                     break; | ||||
|                 case IdChatMessage: | ||||
|                     HandleChatPacket(&event); | ||||
|                     break; | ||||
|                 } | ||||
|                 enet_packet_destroy(event.packet); | ||||
|                 break; | ||||
|             case ENET_EVENT_TYPE_DISCONNECT: | ||||
|                 HandleClientDisconnection(event.peer); | ||||
|                 break; | ||||
|             } | ||||
|         } | ||||
|     } | ||||
|     // Close the connection to all members: | ||||
|     SendCloseMessage(); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::StartLoop() { | ||||
|     room_thread = std::make_unique<std::thread>(&Room::RoomImpl::ServerLoop, this); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) { | ||||
|     Packet packet; | ||||
|     packet.Append(event->packet->data, event->packet->dataLength); | ||||
|     packet.IgnoreBytes(sizeof(u8)); // Igonore the message type | ||||
|     std::string nickname; | ||||
|     packet >> nickname; | ||||
|  | ||||
|     MacAddress preferred_mac; | ||||
|     packet >> preferred_mac; | ||||
|  | ||||
|     u32 client_version; | ||||
|     packet >> client_version; | ||||
|  | ||||
|     if (!IsValidNickname(nickname)) { | ||||
|         SendNameCollision(event->peer); | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     if (preferred_mac != NoPreferredMac) { | ||||
|         // Verify if the preferred mac is available | ||||
|         if (!IsValidMacAddress(preferred_mac)) { | ||||
|             SendMacCollision(event->peer); | ||||
|             return; | ||||
|         } | ||||
|     } else { | ||||
|         // Assign a MAC address of this client automatically | ||||
|         preferred_mac = GenerateMacAddress(); | ||||
|     } | ||||
|  | ||||
|     if (client_version != network_version) { | ||||
|         SendVersionMismatch(event->peer); | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     // At this point the client is ready to be added to the room. | ||||
|     Member member{}; | ||||
|     member.mac_address = preferred_mac; | ||||
|     member.nickname = nickname; | ||||
|     member.peer = event->peer; | ||||
|  | ||||
|     { | ||||
|         std::lock_guard<std::mutex> lock(member_mutex); | ||||
|         members.push_back(std::move(member)); | ||||
|     } | ||||
|  | ||||
|     // Notify everyone that the room information has changed. | ||||
|     BroadcastRoomInformation(); | ||||
|     SendJoinSuccess(event->peer, preferred_mac); | ||||
| } | ||||
|  | ||||
| bool Room::RoomImpl::IsValidNickname(const std::string& nickname) const { | ||||
|     // A nickname is valid if it is not already taken by anybody else in the room. | ||||
|     // TODO(B3N30): Check for empty names, spaces, etc. | ||||
|     std::lock_guard<std::mutex> lock(member_mutex); | ||||
|     return std::all_of(members.begin(), members.end(), | ||||
|                        [&nickname](const auto& member) { return member.nickname != nickname; }); | ||||
| } | ||||
|  | ||||
| bool Room::RoomImpl::IsValidMacAddress(const MacAddress& address) const { | ||||
|     // A MAC address is valid if it is not already taken by anybody else in the room. | ||||
|     std::lock_guard<std::mutex> lock(member_mutex); | ||||
|     return std::all_of(members.begin(), members.end(), | ||||
|                        [&address](const auto& member) { return member.mac_address != address; }); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::SendNameCollision(ENetPeer* client) { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdNameCollision); | ||||
|  | ||||
|     ENetPacket* enet_packet = | ||||
|         enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); | ||||
|     enet_peer_send(client, 0, enet_packet); | ||||
|     enet_host_flush(server); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::SendMacCollision(ENetPeer* client) { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdMacCollision); | ||||
|  | ||||
|     ENetPacket* enet_packet = | ||||
|         enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); | ||||
|     enet_peer_send(client, 0, enet_packet); | ||||
|     enet_host_flush(server); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::SendVersionMismatch(ENetPeer* client) { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdVersionMismatch); | ||||
|     packet << network_version; | ||||
|  | ||||
|     ENetPacket* enet_packet = | ||||
|         enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); | ||||
|     enet_peer_send(client, 0, enet_packet); | ||||
|     enet_host_flush(server); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::SendJoinSuccess(ENetPeer* client, MacAddress mac_address) { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdJoinSuccess); | ||||
|     packet << mac_address; | ||||
|     ENetPacket* enet_packet = | ||||
|         enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); | ||||
|     enet_peer_send(client, 0, enet_packet); | ||||
|     enet_host_flush(server); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::SendCloseMessage() { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdCloseRoom); | ||||
|     ENetPacket* enet_packet = | ||||
|         enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); | ||||
|     std::lock_guard<std::mutex> lock(member_mutex); | ||||
|     for (auto& member : members) { | ||||
|         enet_peer_send(member.peer, 0, enet_packet); | ||||
|     } | ||||
|     enet_host_flush(server); | ||||
|     for (auto& member : members) { | ||||
|         enet_peer_disconnect(member.peer, 0); | ||||
|     } | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::BroadcastRoomInformation() { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdRoomInformation); | ||||
|     packet << room_information.name; | ||||
|     packet << room_information.member_slots; | ||||
|  | ||||
|     packet << static_cast<u32>(members.size()); | ||||
|     { | ||||
|         std::lock_guard<std::mutex> lock(member_mutex); | ||||
|         for (const auto& member : members) { | ||||
|             packet << member.nickname; | ||||
|             packet << member.mac_address; | ||||
|             packet << member.game_info.name; | ||||
|             packet << member.game_info.id; | ||||
|         } | ||||
|     } | ||||
|  | ||||
|     ENetPacket* enet_packet = | ||||
|         enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); | ||||
|     enet_host_broadcast(server, 0, enet_packet); | ||||
|     enet_host_flush(server); | ||||
| } | ||||
|  | ||||
| MacAddress Room::RoomImpl::GenerateMacAddress() { | ||||
|     MacAddress result_mac = | ||||
|         NintendoOUI; // The first three bytes of each MAC address will be the NintendoOUI | ||||
|     std::uniform_int_distribution<> dis(0x00, 0xFF); // Random byte between 0 and 0xFF | ||||
|     do { | ||||
|         for (size_t i = 3; i < result_mac.size(); ++i) { | ||||
|             result_mac[i] = dis(random_gen); | ||||
|         } | ||||
|     } while (!IsValidMacAddress(result_mac)); | ||||
|     return result_mac; | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::HandleWifiPacket(const ENetEvent* event) { | ||||
|     Packet in_packet; | ||||
|     in_packet.Append(event->packet->data, event->packet->dataLength); | ||||
|     in_packet.IgnoreBytes(sizeof(u8));         // Message type | ||||
|     in_packet.IgnoreBytes(sizeof(u8));         // WifiPacket Type | ||||
|     in_packet.IgnoreBytes(sizeof(u8));         // WifiPacket Channel | ||||
|     in_packet.IgnoreBytes(sizeof(MacAddress)); // WifiPacket Transmitter Address | ||||
|     MacAddress destination_address; | ||||
|     in_packet >> destination_address; | ||||
|  | ||||
|     Packet out_packet; | ||||
|     out_packet.Append(event->packet->data, event->packet->dataLength); | ||||
|     ENetPacket* enet_packet = enet_packet_create(out_packet.GetData(), out_packet.GetDataSize(), | ||||
|                                                  ENET_PACKET_FLAG_RELIABLE); | ||||
|  | ||||
|     if (destination_address == BroadcastMac) { // Send the data to everyone except the sender | ||||
|         std::lock_guard<std::mutex> lock(member_mutex); | ||||
|         for (const auto& member : members) { | ||||
|             if (member.peer != event->peer) | ||||
|                 enet_peer_send(member.peer, 0, enet_packet); | ||||
|         } | ||||
|     } else { // Send the data only to the destination client | ||||
|         std::lock_guard<std::mutex> lock(member_mutex); | ||||
|         auto member = std::find_if(members.begin(), members.end(), | ||||
|                                    [destination_address](const Member& member) -> bool { | ||||
|                                        return member.mac_address == destination_address; | ||||
|                                    }); | ||||
|         if (member != members.end()) { | ||||
|             enet_peer_send(member->peer, 0, enet_packet); | ||||
|         } | ||||
|     } | ||||
|     enet_host_flush(server); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::HandleChatPacket(const ENetEvent* event) { | ||||
|     Packet in_packet; | ||||
|     in_packet.Append(event->packet->data, event->packet->dataLength); | ||||
|  | ||||
|     in_packet.IgnoreBytes(sizeof(u8)); // Igonore the message type | ||||
|     std::string message; | ||||
|     in_packet >> message; | ||||
|     auto CompareNetworkAddress = [event](const Member member) -> bool { | ||||
|         return member.peer == event->peer; | ||||
|     }; | ||||
|  | ||||
|     std::lock_guard<std::mutex> lock(member_mutex); | ||||
|     const auto sending_member = std::find_if(members.begin(), members.end(), CompareNetworkAddress); | ||||
|     if (sending_member == members.end()) { | ||||
|         return; // Received a chat message from a unknown sender | ||||
|     } | ||||
|  | ||||
|     Packet out_packet; | ||||
|     out_packet << static_cast<u8>(IdChatMessage); | ||||
|     out_packet << sending_member->nickname; | ||||
|     out_packet << message; | ||||
|  | ||||
|     ENetPacket* enet_packet = enet_packet_create(out_packet.GetData(), out_packet.GetDataSize(), | ||||
|                                                  ENET_PACKET_FLAG_RELIABLE); | ||||
|     for (const auto& member : members) { | ||||
|         if (member.peer != event->peer) | ||||
|             enet_peer_send(member.peer, 0, enet_packet); | ||||
|     } | ||||
|     enet_host_flush(server); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::HandleGameNamePacket(const ENetEvent* event) { | ||||
|     Packet in_packet; | ||||
|     in_packet.Append(event->packet->data, event->packet->dataLength); | ||||
|  | ||||
|     in_packet.IgnoreBytes(sizeof(u8)); // Igonore the message type | ||||
|     GameInfo game_info; | ||||
|     in_packet >> game_info.name; | ||||
|     in_packet >> game_info.id; | ||||
|  | ||||
|     { | ||||
|         std::lock_guard<std::mutex> lock(member_mutex); | ||||
|         auto member = | ||||
|             std::find_if(members.begin(), members.end(), [event](const Member& member) -> bool { | ||||
|                 return member.peer == event->peer; | ||||
|             }); | ||||
|         if (member != members.end()) { | ||||
|             member->game_info = game_info; | ||||
|         } | ||||
|     } | ||||
|     BroadcastRoomInformation(); | ||||
| } | ||||
|  | ||||
| void Room::RoomImpl::HandleClientDisconnection(ENetPeer* client) { | ||||
|     // Remove the client from the members list. | ||||
|     { | ||||
|         std::lock_guard<std::mutex> lock(member_mutex); | ||||
|         members.erase( | ||||
|             std::remove_if(members.begin(), members.end(), | ||||
|                            [client](const Member& member) { return member.peer == client; }), | ||||
|             members.end()); | ||||
|     } | ||||
|  | ||||
|     // Announce the change to all clients. | ||||
|     enet_peer_disconnect(client, 0); | ||||
|     BroadcastRoomInformation(); | ||||
| } | ||||
|  | ||||
| // Room | ||||
| Room::Room() : room_impl{std::make_unique<RoomImpl>()} {} | ||||
|  | ||||
| Room::~Room() = default; | ||||
|  | ||||
| void Room::Create(const std::string& name, const std::string& server_address, u16 server_port) { | ||||
|     ENetAddress address; | ||||
|     address.host = ENET_HOST_ANY; | ||||
|     if (!server_address.empty()) { | ||||
|         enet_address_set_host(&address, server_address.c_str()); | ||||
|     } | ||||
|     address.port = server_port; | ||||
|  | ||||
|     room_impl->server = enet_host_create(&address, MaxConcurrentConnections, NumChannels, 0, 0); | ||||
|     // TODO(B3N30): Allow specifying the maximum number of concurrent connections. | ||||
|     room_impl->state = State::Open; | ||||
|  | ||||
|     room_impl->room_information.name = name; | ||||
|     room_impl->room_information.member_slots = MaxConcurrentConnections; | ||||
|     room_impl->StartLoop(); | ||||
| } | ||||
|  | ||||
| Room::State Room::GetState() const { | ||||
|     return room_impl->state; | ||||
| } | ||||
|  | ||||
| const RoomInformation& Room::GetRoomInformation() const { | ||||
|     return room_impl->room_information; | ||||
| } | ||||
|  | ||||
| std::vector<Room::Member> Room::GetRoomMemberList() const { | ||||
|     std::vector<Room::Member> member_list; | ||||
|     std::lock_guard<std::mutex> lock(room_impl->member_mutex); | ||||
|     for (const auto& member_impl : room_impl->members) { | ||||
|         Member member; | ||||
|         member.nickname = member_impl.nickname; | ||||
|         member.mac_address = member_impl.mac_address; | ||||
|         member.game_info = member_impl.game_info; | ||||
|         member_list.push_back(member); | ||||
|     } | ||||
|     return member_list; | ||||
| }; | ||||
|  | ||||
| void Room::Destroy() { | ||||
|     room_impl->state = State::Closed; | ||||
|     room_impl->room_thread->join(); | ||||
|     room_impl->room_thread.reset(); | ||||
|  | ||||
|     if (room_impl->server) { | ||||
|         enet_host_destroy(room_impl->server); | ||||
|     } | ||||
|     room_impl->room_information = {}; | ||||
|     room_impl->server = nullptr; | ||||
|     { | ||||
|         std::lock_guard<std::mutex> lock(room_impl->member_mutex); | ||||
|         room_impl->members.clear(); | ||||
|     } | ||||
|     room_impl->room_information.member_slots = 0; | ||||
|     room_impl->room_information.name.clear(); | ||||
| } | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,101 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <memory> | ||||
| #include <string> | ||||
| #include <vector> | ||||
| #include "common/common_types.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| constexpr u32 network_version = 1; ///< The version of this Room and RoomMember | ||||
|  | ||||
| constexpr u16 DefaultRoomPort = 1234; | ||||
| constexpr size_t NumChannels = 1; // Number of channels used for the connection | ||||
|  | ||||
| struct RoomInformation { | ||||
|     std::string name; ///< Name of the server | ||||
|     u32 member_slots; ///< Maximum number of members in this room | ||||
| }; | ||||
|  | ||||
| struct GameInfo { | ||||
|     std::string name{""}; | ||||
|     u64 id{0}; | ||||
| }; | ||||
|  | ||||
| using MacAddress = std::array<u8, 6>; | ||||
| /// A special MAC address that tells the room we're joining to assign us a MAC address | ||||
| /// automatically. | ||||
| constexpr MacAddress NoPreferredMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; | ||||
|  | ||||
| // 802.11 broadcast MAC address | ||||
| constexpr MacAddress BroadcastMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; | ||||
|  | ||||
| // The different types of messages that can be sent. The first byte of each packet defines the type | ||||
| enum RoomMessageTypes : u8 { | ||||
|     IdJoinRequest = 1, | ||||
|     IdJoinSuccess, | ||||
|     IdRoomInformation, | ||||
|     IdSetGameInfo, | ||||
|     IdWifiPacket, | ||||
|     IdChatMessage, | ||||
|     IdNameCollision, | ||||
|     IdMacCollision, | ||||
|     IdVersionMismatch, | ||||
|     IdCloseRoom | ||||
| }; | ||||
|  | ||||
| /// This is what a server [person creating a server] would use. | ||||
| class Room final { | ||||
| public: | ||||
|     enum class State : u8 { | ||||
|         Open,   ///< The room is open and ready to accept connections. | ||||
|         Closed, ///< The room is not opened and can not accept connections. | ||||
|     }; | ||||
|  | ||||
|     struct Member { | ||||
|         std::string nickname;   ///< The nickname of the member. | ||||
|         GameInfo game_info;     ///< The current game of the member | ||||
|         MacAddress mac_address; ///< The assigned mac address of the member. | ||||
|     }; | ||||
|  | ||||
|     Room(); | ||||
|     ~Room(); | ||||
|  | ||||
|     /** | ||||
|      * Gets the current state of the room. | ||||
|      */ | ||||
|     State GetState() const; | ||||
|  | ||||
|     /** | ||||
|      * Gets the room information of the room. | ||||
|      */ | ||||
|     const RoomInformation& GetRoomInformation() const; | ||||
|  | ||||
|     /** | ||||
|      * Gets a list of the mbmers connected to the room. | ||||
|      */ | ||||
|     std::vector<Member> GetRoomMemberList() const; | ||||
|  | ||||
|     /** | ||||
|      * Creates the socket for this room. Will bind to default address if | ||||
|      * server is empty string. | ||||
|      */ | ||||
|     void Create(const std::string& name, const std::string& server = "", | ||||
|                 u16 server_port = DefaultRoomPort); | ||||
|  | ||||
|     /** | ||||
|      * Destroys the socket | ||||
|      */ | ||||
|     void Destroy(); | ||||
|  | ||||
| private: | ||||
|     class RoomImpl; | ||||
|     std::unique_ptr<RoomImpl> room_impl; | ||||
| }; | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,490 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <atomic> | ||||
| #include <list> | ||||
| #include <mutex> | ||||
| #include <set> | ||||
| #include <thread> | ||||
| #include "common/assert.h" | ||||
| #include "enet/enet.h" | ||||
| #include "network/packet.h" | ||||
| #include "network/room_member.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| constexpr u32 ConnectionTimeoutMs = 5000; | ||||
|  | ||||
| class RoomMember::RoomMemberImpl { | ||||
| public: | ||||
|     ENetHost* client = nullptr; ///< ENet network interface. | ||||
|     ENetPeer* server = nullptr; ///< The server peer the client is connected to | ||||
|  | ||||
|     /// Information about the clients connected to the same room as us. | ||||
|     MemberList member_information; | ||||
|     /// Information about the room we're connected to. | ||||
|     RoomInformation room_information; | ||||
|  | ||||
|     /// The current game name, id and version | ||||
|     GameInfo current_game_info; | ||||
|  | ||||
|     std::atomic<State> state{State::Idle}; ///< Current state of the RoomMember. | ||||
|     void SetState(const State new_state); | ||||
|     bool IsConnected() const; | ||||
|  | ||||
|     std::string nickname;   ///< The nickname of this member. | ||||
|     MacAddress mac_address; ///< The mac_address of this member. | ||||
|  | ||||
|     std::mutex network_mutex; ///< Mutex that controls access to the `client` variable. | ||||
|     /// Thread that receives and dispatches network packets | ||||
|     std::unique_ptr<std::thread> loop_thread; | ||||
|     std::mutex send_list_mutex;  ///< Mutex that controls access to the `send_list` variable. | ||||
|     std::list<Packet> send_list; ///< A list that stores all packets to send the async | ||||
|  | ||||
|     template <typename T> | ||||
|     using CallbackSet = std::set<CallbackHandle<T>>; | ||||
|     std::mutex callback_mutex; ///< The mutex used for handling callbacks | ||||
|  | ||||
|     class Callbacks { | ||||
|     public: | ||||
|         template <typename T> | ||||
|         CallbackSet<T>& Get(); | ||||
|  | ||||
|     private: | ||||
|         CallbackSet<WifiPacket> callback_set_wifi_packet; | ||||
|         CallbackSet<ChatEntry> callback_set_chat_messages; | ||||
|         CallbackSet<RoomInformation> callback_set_room_information; | ||||
|         CallbackSet<State> callback_set_state; | ||||
|     }; | ||||
|     Callbacks callbacks; ///< All CallbackSets to all events | ||||
|  | ||||
|     void MemberLoop(); | ||||
|  | ||||
|     void StartLoop(); | ||||
|  | ||||
|     /** | ||||
|      * Sends data to the room. It will be send on channel 0 with flag RELIABLE | ||||
|      * @param packet The data to send | ||||
|      */ | ||||
|     void Send(Packet&& packet); | ||||
|  | ||||
|     /** | ||||
|      * Sends a request to the server, asking for permission to join a room with the specified | ||||
|      * nickname and preferred mac. | ||||
|      * @params nickname The desired nickname. | ||||
|      * @params preferred_mac The preferred MAC address to use in the room, the NoPreferredMac tells | ||||
|      * the server to assign one for us. | ||||
|      */ | ||||
|     void SendJoinRequest(const std::string& nickname, | ||||
|                          const MacAddress& preferred_mac = NoPreferredMac); | ||||
|  | ||||
|     /** | ||||
|      * Extracts a MAC Address from a received ENet packet. | ||||
|      * @param event The ENet event that was received. | ||||
|      */ | ||||
|     void HandleJoinPacket(const ENetEvent* event); | ||||
|     /** | ||||
|      * Extracts RoomInformation and MemberInformation from a received RakNet packet. | ||||
|      * @param event The ENet event that was received. | ||||
|      */ | ||||
|     void HandleRoomInformationPacket(const ENetEvent* event); | ||||
|  | ||||
|     /** | ||||
|      * Extracts a WifiPacket from a received ENet packet. | ||||
|      * @param event The  ENet event that was received. | ||||
|      */ | ||||
|     void HandleWifiPackets(const ENetEvent* event); | ||||
|  | ||||
|     /** | ||||
|      * Extracts a chat entry from a received ENet packet and adds it to the chat queue. | ||||
|      * @param event The ENet event that was received. | ||||
|      */ | ||||
|     void HandleChatPacket(const ENetEvent* event); | ||||
|  | ||||
|     /** | ||||
|      * Disconnects the RoomMember from the Room | ||||
|      */ | ||||
|     void Disconnect(); | ||||
|  | ||||
|     template <typename T> | ||||
|     void Invoke(const T& data); | ||||
|  | ||||
|     template <typename T> | ||||
|     CallbackHandle<T> Bind(std::function<void(const T&)> callback); | ||||
| }; | ||||
|  | ||||
| // RoomMemberImpl | ||||
| void RoomMember::RoomMemberImpl::SetState(const State new_state) { | ||||
|     if (state != new_state) { | ||||
|         state = new_state; | ||||
|         Invoke<State>(state); | ||||
|     } | ||||
| } | ||||
|  | ||||
| bool RoomMember::RoomMemberImpl::IsConnected() const { | ||||
|     return state == State::Joining || state == State::Joined; | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::MemberLoop() { | ||||
|     // Receive packets while the connection is open | ||||
|     while (IsConnected()) { | ||||
|         std::lock_guard<std::mutex> lock(network_mutex); | ||||
|         ENetEvent event; | ||||
|         if (enet_host_service(client, &event, 100) > 0) { | ||||
|             switch (event.type) { | ||||
|             case ENET_EVENT_TYPE_RECEIVE: | ||||
|                 switch (event.packet->data[0]) { | ||||
|                 case IdWifiPacket: | ||||
|                     HandleWifiPackets(&event); | ||||
|                     break; | ||||
|                 case IdChatMessage: | ||||
|                     HandleChatPacket(&event); | ||||
|                     break; | ||||
|                 case IdRoomInformation: | ||||
|                     HandleRoomInformationPacket(&event); | ||||
|                     break; | ||||
|                 case IdJoinSuccess: | ||||
|                     // The join request was successful, we are now in the room. | ||||
|                     // If we joined successfully, there must be at least one client in the room: us. | ||||
|                     ASSERT_MSG(member_information.size() > 0, | ||||
|                                "We have not yet received member information."); | ||||
|                     HandleJoinPacket(&event); // Get the MAC Address for the client | ||||
|                     SetState(State::Joined); | ||||
|                     break; | ||||
|                 case IdNameCollision: | ||||
|                     SetState(State::NameCollision); | ||||
|                     break; | ||||
|                 case IdMacCollision: | ||||
|                     SetState(State::MacCollision); | ||||
|                     break; | ||||
|                 case IdVersionMismatch: | ||||
|                     SetState(State::WrongVersion); | ||||
|                     break; | ||||
|                 case IdCloseRoom: | ||||
|                     SetState(State::LostConnection); | ||||
|                     break; | ||||
|                 } | ||||
|                 enet_packet_destroy(event.packet); | ||||
|                 break; | ||||
|             case ENET_EVENT_TYPE_DISCONNECT: | ||||
|                 SetState(State::LostConnection); | ||||
|                 break; | ||||
|             } | ||||
|         } | ||||
|         { | ||||
|             std::lock_guard<std::mutex> lock(send_list_mutex); | ||||
|             for (const auto& packet : send_list) { | ||||
|                 ENetPacket* enetPacket = enet_packet_create(packet.GetData(), packet.GetDataSize(), | ||||
|                                                             ENET_PACKET_FLAG_RELIABLE); | ||||
|                 enet_peer_send(server, 0, enetPacket); | ||||
|             } | ||||
|             enet_host_flush(client); | ||||
|             send_list.clear(); | ||||
|         } | ||||
|     } | ||||
|     Disconnect(); | ||||
| }; | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::StartLoop() { | ||||
|     loop_thread = std::make_unique<std::thread>(&RoomMember::RoomMemberImpl::MemberLoop, this); | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::Send(Packet&& packet) { | ||||
|     std::lock_guard<std::mutex> lock(send_list_mutex); | ||||
|     send_list.push_back(std::move(packet)); | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::SendJoinRequest(const std::string& nickname, | ||||
|                                                  const MacAddress& preferred_mac) { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdJoinRequest); | ||||
|     packet << nickname; | ||||
|     packet << preferred_mac; | ||||
|     packet << network_version; | ||||
|     Send(std::move(packet)); | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::HandleRoomInformationPacket(const ENetEvent* event) { | ||||
|     Packet packet; | ||||
|     packet.Append(event->packet->data, event->packet->dataLength); | ||||
|  | ||||
|     // Ignore the first byte, which is the message id. | ||||
|     packet.IgnoreBytes(sizeof(u8)); // Igonore the message type | ||||
|  | ||||
|     RoomInformation info{}; | ||||
|     packet >> info.name; | ||||
|     packet >> info.member_slots; | ||||
|     room_information.name = info.name; | ||||
|     room_information.member_slots = info.member_slots; | ||||
|  | ||||
|     u32 num_members; | ||||
|     packet >> num_members; | ||||
|     member_information.resize(num_members); | ||||
|  | ||||
|     for (auto& member : member_information) { | ||||
|         packet >> member.nickname; | ||||
|         packet >> member.mac_address; | ||||
|         packet >> member.game_info.name; | ||||
|         packet >> member.game_info.id; | ||||
|     } | ||||
|     Invoke(room_information); | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::HandleJoinPacket(const ENetEvent* event) { | ||||
|     Packet packet; | ||||
|     packet.Append(event->packet->data, event->packet->dataLength); | ||||
|  | ||||
|     // Ignore the first byte, which is the message id. | ||||
|     packet.IgnoreBytes(sizeof(u8)); // Igonore the message type | ||||
|  | ||||
|     // Parse the MAC Address from the packet | ||||
|     packet >> mac_address; | ||||
|     SetState(State::Joined); | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::HandleWifiPackets(const ENetEvent* event) { | ||||
|     WifiPacket wifi_packet{}; | ||||
|     Packet packet; | ||||
|     packet.Append(event->packet->data, event->packet->dataLength); | ||||
|  | ||||
|     // Ignore the first byte, which is the message id. | ||||
|     packet.IgnoreBytes(sizeof(u8)); // Igonore the message type | ||||
|  | ||||
|     // Parse the WifiPacket from the packet | ||||
|     u8 frame_type; | ||||
|     packet >> frame_type; | ||||
|     WifiPacket::PacketType type = static_cast<WifiPacket::PacketType>(frame_type); | ||||
|  | ||||
|     wifi_packet.type = type; | ||||
|     packet >> wifi_packet.channel; | ||||
|     packet >> wifi_packet.transmitter_address; | ||||
|     packet >> wifi_packet.destination_address; | ||||
|  | ||||
|     u32 data_length; | ||||
|     packet >> data_length; | ||||
|  | ||||
|     packet >> wifi_packet.data; | ||||
|  | ||||
|     Invoke<WifiPacket>(wifi_packet); | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::HandleChatPacket(const ENetEvent* event) { | ||||
|     Packet packet; | ||||
|     packet.Append(event->packet->data, event->packet->dataLength); | ||||
|  | ||||
|     // Ignore the first byte, which is the message id. | ||||
|     packet.IgnoreBytes(sizeof(u8)); | ||||
|  | ||||
|     ChatEntry chat_entry{}; | ||||
|     packet >> chat_entry.nickname; | ||||
|     packet >> chat_entry.message; | ||||
|     Invoke<ChatEntry>(chat_entry); | ||||
| } | ||||
|  | ||||
| void RoomMember::RoomMemberImpl::Disconnect() { | ||||
|     member_information.clear(); | ||||
|     room_information.member_slots = 0; | ||||
|     room_information.name.clear(); | ||||
|  | ||||
|     if (!server) | ||||
|         return; | ||||
|     enet_peer_disconnect(server, 0); | ||||
|  | ||||
|     ENetEvent event; | ||||
|     while (enet_host_service(client, &event, ConnectionTimeoutMs) > 0) { | ||||
|         switch (event.type) { | ||||
|         case ENET_EVENT_TYPE_RECEIVE: | ||||
|             enet_packet_destroy(event.packet); // Ignore all incoming data | ||||
|             break; | ||||
|         case ENET_EVENT_TYPE_DISCONNECT: | ||||
|             server = nullptr; | ||||
|             return; | ||||
|         } | ||||
|     } | ||||
|     // didn't disconnect gracefully force disconnect | ||||
|     enet_peer_reset(server); | ||||
|     server = nullptr; | ||||
| } | ||||
|  | ||||
| template <> | ||||
| RoomMember::RoomMemberImpl::CallbackSet<WifiPacket>& RoomMember::RoomMemberImpl::Callbacks::Get() { | ||||
|     return callback_set_wifi_packet; | ||||
| } | ||||
|  | ||||
| template <> | ||||
| RoomMember::RoomMemberImpl::CallbackSet<RoomMember::State>& | ||||
| RoomMember::RoomMemberImpl::Callbacks::Get() { | ||||
|     return callback_set_state; | ||||
| } | ||||
|  | ||||
| template <> | ||||
| RoomMember::RoomMemberImpl::CallbackSet<RoomInformation>& | ||||
| RoomMember::RoomMemberImpl::Callbacks::Get() { | ||||
|     return callback_set_room_information; | ||||
| } | ||||
|  | ||||
| template <> | ||||
| RoomMember::RoomMemberImpl::CallbackSet<ChatEntry>& RoomMember::RoomMemberImpl::Callbacks::Get() { | ||||
|     return callback_set_chat_messages; | ||||
| } | ||||
|  | ||||
| template <typename T> | ||||
| void RoomMember::RoomMemberImpl::Invoke(const T& data) { | ||||
|     std::lock_guard<std::mutex> lock(callback_mutex); | ||||
|     CallbackSet<T> callback_set = callbacks.Get<T>(); | ||||
|     for (auto const& callback : callback_set) | ||||
|         (*callback)(data); | ||||
| } | ||||
|  | ||||
| template <typename T> | ||||
| RoomMember::CallbackHandle<T> RoomMember::RoomMemberImpl::Bind( | ||||
|     std::function<void(const T&)> callback) { | ||||
|     std::lock_guard<std::mutex> lock(callback_mutex); | ||||
|     CallbackHandle<T> handle; | ||||
|     handle = std::make_shared<std::function<void(const T&)>>(callback); | ||||
|     callbacks.Get<T>().insert(handle); | ||||
|     return handle; | ||||
| } | ||||
|  | ||||
| // RoomMember | ||||
| RoomMember::RoomMember() : room_member_impl{std::make_unique<RoomMemberImpl>()} { | ||||
|     room_member_impl->client = enet_host_create(nullptr, 1, NumChannels, 0, 0); | ||||
|     ASSERT_MSG(room_member_impl->client != nullptr, "Could not create client"); | ||||
| } | ||||
|  | ||||
| RoomMember::~RoomMember() { | ||||
|     ASSERT_MSG(!IsConnected(), "RoomMember is being destroyed while connected"); | ||||
|     enet_host_destroy(room_member_impl->client); | ||||
| } | ||||
|  | ||||
| RoomMember::State RoomMember::GetState() const { | ||||
|     return room_member_impl->state; | ||||
| } | ||||
|  | ||||
| const RoomMember::MemberList& RoomMember::GetMemberInformation() const { | ||||
|     return room_member_impl->member_information; | ||||
| } | ||||
|  | ||||
| const std::string& RoomMember::GetNickname() const { | ||||
|     return room_member_impl->nickname; | ||||
| } | ||||
|  | ||||
| const MacAddress& RoomMember::GetMacAddress() const { | ||||
|     ASSERT_MSG(IsConnected(), "Tried to get MAC address while not connected"); | ||||
|     return room_member_impl->mac_address; | ||||
| } | ||||
|  | ||||
| RoomInformation RoomMember::GetRoomInformation() const { | ||||
|     return room_member_impl->room_information; | ||||
| } | ||||
|  | ||||
| void RoomMember::Join(const std::string& nick, const char* server_addr, u16 server_port, | ||||
|                       u16 client_port, const MacAddress& preferred_mac) { | ||||
|     // If the member is connected, kill the connection first | ||||
|     if (room_member_impl->loop_thread && room_member_impl->loop_thread->joinable()) { | ||||
|         room_member_impl->SetState(State::Error); | ||||
|         room_member_impl->loop_thread->join(); | ||||
|         room_member_impl->loop_thread.reset(); | ||||
|     } | ||||
|     // If the thread isn't running but the ptr still exists, reset it | ||||
|     else if (room_member_impl->loop_thread) { | ||||
|         room_member_impl->loop_thread.reset(); | ||||
|     } | ||||
|  | ||||
|     ENetAddress address{}; | ||||
|     enet_address_set_host(&address, server_addr); | ||||
|     address.port = server_port; | ||||
|     room_member_impl->server = | ||||
|         enet_host_connect(room_member_impl->client, &address, NumChannels, 0); | ||||
|  | ||||
|     if (!room_member_impl->server) { | ||||
|         room_member_impl->SetState(State::Error); | ||||
|         return; | ||||
|     } | ||||
|  | ||||
|     ENetEvent event{}; | ||||
|     int net = enet_host_service(room_member_impl->client, &event, ConnectionTimeoutMs); | ||||
|     if (net > 0 && event.type == ENET_EVENT_TYPE_CONNECT) { | ||||
|         room_member_impl->nickname = nick; | ||||
|         room_member_impl->SetState(State::Joining); | ||||
|         room_member_impl->StartLoop(); | ||||
|         room_member_impl->SendJoinRequest(nick, preferred_mac); | ||||
|         SendGameInfo(room_member_impl->current_game_info); | ||||
|     } else { | ||||
|         room_member_impl->SetState(State::CouldNotConnect); | ||||
|     } | ||||
| } | ||||
|  | ||||
| bool RoomMember::IsConnected() const { | ||||
|     return room_member_impl->IsConnected(); | ||||
| } | ||||
|  | ||||
| void RoomMember::SendWifiPacket(const WifiPacket& wifi_packet) { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdWifiPacket); | ||||
|     packet << static_cast<u8>(wifi_packet.type); | ||||
|     packet << wifi_packet.channel; | ||||
|     packet << wifi_packet.transmitter_address; | ||||
|     packet << wifi_packet.destination_address; | ||||
|     packet << wifi_packet.data; | ||||
|     room_member_impl->Send(std::move(packet)); | ||||
| } | ||||
|  | ||||
| void RoomMember::SendChatMessage(const std::string& message) { | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdChatMessage); | ||||
|     packet << message; | ||||
|     room_member_impl->Send(std::move(packet)); | ||||
| } | ||||
|  | ||||
| void RoomMember::SendGameInfo(const GameInfo& game_info) { | ||||
|     room_member_impl->current_game_info = game_info; | ||||
|     if (!IsConnected()) | ||||
|         return; | ||||
|  | ||||
|     Packet packet; | ||||
|     packet << static_cast<u8>(IdSetGameInfo); | ||||
|     packet << game_info.name; | ||||
|     packet << game_info.id; | ||||
|     room_member_impl->Send(std::move(packet)); | ||||
| } | ||||
|  | ||||
| RoomMember::CallbackHandle<RoomMember::State> RoomMember::BindOnStateChanged( | ||||
|     std::function<void(const RoomMember::State&)> callback) { | ||||
|     return room_member_impl->Bind(callback); | ||||
| } | ||||
|  | ||||
| RoomMember::CallbackHandle<WifiPacket> RoomMember::BindOnWifiPacketReceived( | ||||
|     std::function<void(const WifiPacket&)> callback) { | ||||
|     return room_member_impl->Bind(callback); | ||||
| } | ||||
|  | ||||
| RoomMember::CallbackHandle<RoomInformation> RoomMember::BindOnRoomInformationChanged( | ||||
|     std::function<void(const RoomInformation&)> callback) { | ||||
|     return room_member_impl->Bind(callback); | ||||
| } | ||||
|  | ||||
| RoomMember::CallbackHandle<ChatEntry> RoomMember::BindOnChatMessageRecieved( | ||||
|     std::function<void(const ChatEntry&)> callback) { | ||||
|     return room_member_impl->Bind(callback); | ||||
| } | ||||
|  | ||||
| template <typename T> | ||||
| void RoomMember::Unbind(CallbackHandle<T> handle) { | ||||
|     std::lock_guard<std::mutex> lock(room_member_impl->callback_mutex); | ||||
|     room_member_impl->callbacks.Get<T>().erase(handle); | ||||
| } | ||||
|  | ||||
| void RoomMember::Leave() { | ||||
|     room_member_impl->SetState(State::Idle); | ||||
|     room_member_impl->loop_thread->join(); | ||||
|     room_member_impl->loop_thread.reset(); | ||||
| } | ||||
|  | ||||
| template void RoomMember::Unbind(CallbackHandle<WifiPacket>); | ||||
| template void RoomMember::Unbind(CallbackHandle<RoomMember::State>); | ||||
| template void RoomMember::Unbind(CallbackHandle<RoomInformation>); | ||||
| template void RoomMember::Unbind(CallbackHandle<ChatEntry>); | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,182 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <functional> | ||||
| #include <memory> | ||||
| #include <string> | ||||
| #include <vector> | ||||
| #include "common/common_types.h" | ||||
| #include "network/room.h" | ||||
|  | ||||
| namespace Network { | ||||
|  | ||||
| /// Information about the received WiFi packets. | ||||
| /// Acts as our own 802.11 header. | ||||
| struct WifiPacket { | ||||
|     enum class PacketType : u8 { Beacon, Data, Authentication, AssociationResponse }; | ||||
|     PacketType type;      ///< The type of 802.11 frame. | ||||
|     std::vector<u8> data; ///< Raw 802.11 frame data, starting at the management frame header | ||||
|                           /// for management frames. | ||||
|     MacAddress transmitter_address; ///< Mac address of the transmitter. | ||||
|     MacAddress destination_address; ///< Mac address of the receiver. | ||||
|     u8 channel;                     ///< WiFi channel where this frame was transmitted. | ||||
| }; | ||||
|  | ||||
| /// Represents a chat message. | ||||
| struct ChatEntry { | ||||
|     std::string nickname; ///< Nickname of the client who sent this message. | ||||
|     std::string message;  ///< Body of the message. | ||||
| }; | ||||
|  | ||||
| /** | ||||
|  * This is what a client [person joining a server] would use. | ||||
|  * It also has to be used if you host a game yourself (You'd create both, a Room and a | ||||
|  * RoomMembership for yourself) | ||||
|  */ | ||||
| class RoomMember final { | ||||
| public: | ||||
|     enum class State : u8 { | ||||
|         Idle,    ///< Default state | ||||
|         Error,   ///< Some error [permissions to network device missing or something] | ||||
|         Joining, ///< The client is attempting to join a room. | ||||
|         Joined,  ///< The client is connected to the room and is ready to send/receive packets. | ||||
|         LostConnection, ///< Connection closed | ||||
|  | ||||
|         // Reasons why connection was rejected | ||||
|         NameCollision,  ///< Somebody is already using this name | ||||
|         MacCollision,   ///< Somebody is already using that mac-address | ||||
|         WrongVersion,   ///< The room version is not the same as for this RoomMember | ||||
|         CouldNotConnect ///< The room is not responding to a connection attempt | ||||
|     }; | ||||
|  | ||||
|     struct MemberInformation { | ||||
|         std::string nickname;   ///< Nickname of the member. | ||||
|         GameInfo game_info;     ///< Name of the game they're currently playing, or empty if they're | ||||
|                                 /// not playing anything. | ||||
|         MacAddress mac_address; ///< MAC address associated with this member. | ||||
|     }; | ||||
|     using MemberList = std::vector<MemberInformation>; | ||||
|  | ||||
|     // The handle for the callback functions | ||||
|     template <typename T> | ||||
|     using CallbackHandle = std::shared_ptr<std::function<void(const T&)>>; | ||||
|  | ||||
|     /** | ||||
|      * Unbinds a callback function from the events. | ||||
|      * @param handle The connection handle to disconnect | ||||
|      */ | ||||
|     template <typename T> | ||||
|     void Unbind(CallbackHandle<T> handle); | ||||
|  | ||||
|     RoomMember(); | ||||
|     ~RoomMember(); | ||||
|  | ||||
|     /** | ||||
|      * Returns the status of our connection to the room. | ||||
|      */ | ||||
|     State GetState() const; | ||||
|  | ||||
|     /** | ||||
|      * Returns information about the members in the room we're currently connected to. | ||||
|      */ | ||||
|     const MemberList& GetMemberInformation() const; | ||||
|  | ||||
|     /** | ||||
|      * Returns the nickname of the RoomMember. | ||||
|      */ | ||||
|     const std::string& GetNickname() const; | ||||
|  | ||||
|     /** | ||||
|      * Returns the MAC address of the RoomMember. | ||||
|      */ | ||||
|     const MacAddress& GetMacAddress() const; | ||||
|  | ||||
|     /** | ||||
|      * Returns information about the room we're currently connected to. | ||||
|      */ | ||||
|     RoomInformation GetRoomInformation() const; | ||||
|  | ||||
|     /** | ||||
|      * Returns whether we're connected to a server or not. | ||||
|      */ | ||||
|     bool IsConnected() const; | ||||
|  | ||||
|     /** | ||||
|      * Attempts to join a room at the specified address and port, using the specified nickname. | ||||
|      * This may fail if the username is already taken. | ||||
|      */ | ||||
|     void Join(const std::string& nickname, const char* server_addr = "127.0.0.1", | ||||
|               const u16 serverPort = DefaultRoomPort, const u16 clientPort = 0, | ||||
|               const MacAddress& preferred_mac = NoPreferredMac); | ||||
|  | ||||
|     /** | ||||
|      * Sends a WiFi packet to the room. | ||||
|      * @param packet The WiFi packet to send. | ||||
|      */ | ||||
|     void SendWifiPacket(const WifiPacket& packet); | ||||
|  | ||||
|     /** | ||||
|      * Sends a chat message to the room. | ||||
|      * @param message The contents of the message. | ||||
|      */ | ||||
|     void SendChatMessage(const std::string& message); | ||||
|  | ||||
|     /** | ||||
|      * Sends the current game info to the room. | ||||
|      * @param game_info The game information. | ||||
|      */ | ||||
|     void SendGameInfo(const GameInfo& game_info); | ||||
|  | ||||
|     /** | ||||
|      * Binds a function to an event that will be triggered every time the State of the member | ||||
|      * changed. The function wil be called every time the event is triggered. The callback function | ||||
|      * must not bind or unbind a function. Doing so will cause a deadlock | ||||
|      * @param callback The function to call | ||||
|      * @return A handle used for removing the function from the registered list | ||||
|      */ | ||||
|     CallbackHandle<State> BindOnStateChanged(std::function<void(const State&)> callback); | ||||
|  | ||||
|     /** | ||||
|      * Binds a function to an event that will be triggered every time a WifiPacket is received. | ||||
|      * The function wil be called everytime the event is triggered. | ||||
|      * The callback function must not bind or unbind a function. Doing so will cause a deadlock | ||||
|      * @param callback The function to call | ||||
|      * @return A handle used for removing the function from the registered list | ||||
|      */ | ||||
|     CallbackHandle<WifiPacket> BindOnWifiPacketReceived( | ||||
|         std::function<void(const WifiPacket&)> callback); | ||||
|  | ||||
|     /** | ||||
|      * Binds a function to an event that will be triggered every time the RoomInformation changes. | ||||
|      * The function wil be called every time the event is triggered. | ||||
|      * The callback function must not bind or unbind a function. Doing so will cause a deadlock | ||||
|      * @param callback The function to call | ||||
|      * @return A handle used for removing the function from the registered list | ||||
|      */ | ||||
|     CallbackHandle<RoomInformation> BindOnRoomInformationChanged( | ||||
|         std::function<void(const RoomInformation&)> callback); | ||||
|  | ||||
|     /** | ||||
|      * Binds a function to an event that will be triggered every time a ChatMessage is received. | ||||
|      * The function wil be called every time the event is triggered. | ||||
|      * The callback function must not bind or unbind a function. Doing so will cause a deadlock | ||||
|      * @param callback The function to call | ||||
|      * @return A handle used for removing the function from the registered list | ||||
|      */ | ||||
|     CallbackHandle<ChatEntry> BindOnChatMessageRecieved( | ||||
|         std::function<void(const ChatEntry&)> callback); | ||||
|  | ||||
|     /** | ||||
|      * Leaves the current room. | ||||
|      */ | ||||
|     void Leave(); | ||||
|  | ||||
| private: | ||||
|     class RoomMemberImpl; | ||||
|     std::unique_ptr<RoomMemberImpl> room_member_impl; | ||||
| }; | ||||
|  | ||||
| } // namespace Network | ||||
| @@ -1,16 +0,0 @@ | ||||
| set(SRCS | ||||
|             telemetry_json.cpp | ||||
|             verify_login.cpp | ||||
|             web_backend.cpp | ||||
|             ) | ||||
|  | ||||
| set(HEADERS | ||||
|             telemetry_json.h | ||||
|             verify_login.h | ||||
|             web_backend.h | ||||
|             ) | ||||
|  | ||||
| create_directory_groups(${SRCS} ${HEADERS}) | ||||
|  | ||||
| add_library(web_service STATIC ${SRCS} ${HEADERS}) | ||||
| target_link_libraries(web_service PUBLIC common cpr json-headers) | ||||
| @@ -1,86 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include "common/assert.h" | ||||
| #include "web_service/telemetry_json.h" | ||||
| #include "web_service/web_backend.h" | ||||
|  | ||||
| namespace WebService { | ||||
|  | ||||
| template <class T> | ||||
| void TelemetryJson::Serialize(Telemetry::FieldType type, const std::string& name, T value) { | ||||
|     sections[static_cast<u8>(type)][name] = value; | ||||
| } | ||||
|  | ||||
| void TelemetryJson::SerializeSection(Telemetry::FieldType type, const std::string& name) { | ||||
|     TopSection()[name] = sections[static_cast<unsigned>(type)]; | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<bool>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<double>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<float>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<u8>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<u16>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<u32>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<u64>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<s8>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<s16>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<s32>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<s64>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<std::string>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<const char*>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), std::string(field.GetValue())); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Visit(const Telemetry::Field<std::chrono::microseconds>& field) { | ||||
|     Serialize(field.GetType(), field.GetName(), field.GetValue().count()); | ||||
| } | ||||
|  | ||||
| void TelemetryJson::Complete() { | ||||
|     SerializeSection(Telemetry::FieldType::App, "App"); | ||||
|     SerializeSection(Telemetry::FieldType::Session, "Session"); | ||||
|     SerializeSection(Telemetry::FieldType::Performance, "Performance"); | ||||
|     SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback"); | ||||
|     SerializeSection(Telemetry::FieldType::UserConfig, "UserConfig"); | ||||
|     SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem"); | ||||
|     PostJson(endpoint_url, TopSection().dump(), true, username, token); | ||||
| } | ||||
|  | ||||
| } // namespace WebService | ||||
| @@ -1,59 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <array> | ||||
| #include <string> | ||||
| #include <json.hpp> | ||||
| #include "common/telemetry.h" | ||||
|  | ||||
| namespace WebService { | ||||
|  | ||||
| /** | ||||
|  * Implementation of VisitorInterface that serialized telemetry into JSON, and submits it to the | ||||
|  * Citra web service | ||||
|  */ | ||||
| class TelemetryJson : public Telemetry::VisitorInterface { | ||||
| public: | ||||
|     TelemetryJson(const std::string& endpoint_url, const std::string& username, | ||||
|                   const std::string& token) | ||||
|         : endpoint_url(endpoint_url), username(username), token(token) {} | ||||
|     ~TelemetryJson() = default; | ||||
|  | ||||
|     void Visit(const Telemetry::Field<bool>& field) override; | ||||
|     void Visit(const Telemetry::Field<double>& field) override; | ||||
|     void Visit(const Telemetry::Field<float>& field) override; | ||||
|     void Visit(const Telemetry::Field<u8>& field) override; | ||||
|     void Visit(const Telemetry::Field<u16>& field) override; | ||||
|     void Visit(const Telemetry::Field<u32>& field) override; | ||||
|     void Visit(const Telemetry::Field<u64>& field) override; | ||||
|     void Visit(const Telemetry::Field<s8>& field) override; | ||||
|     void Visit(const Telemetry::Field<s16>& field) override; | ||||
|     void Visit(const Telemetry::Field<s32>& field) override; | ||||
|     void Visit(const Telemetry::Field<s64>& field) override; | ||||
|     void Visit(const Telemetry::Field<std::string>& field) override; | ||||
|     void Visit(const Telemetry::Field<const char*>& field) override; | ||||
|     void Visit(const Telemetry::Field<std::chrono::microseconds>& field) override; | ||||
|  | ||||
|     void Complete() override; | ||||
|  | ||||
| private: | ||||
|     nlohmann::json& TopSection() { | ||||
|         return sections[static_cast<u8>(Telemetry::FieldType::None)]; | ||||
|     } | ||||
|  | ||||
|     template <class T> | ||||
|     void Serialize(Telemetry::FieldType type, const std::string& name, T value); | ||||
|  | ||||
|     void SerializeSection(Telemetry::FieldType type, const std::string& name); | ||||
|  | ||||
|     nlohmann::json output; | ||||
|     std::array<nlohmann::json, 7> sections; | ||||
|     std::string endpoint_url; | ||||
|     std::string username; | ||||
|     std::string token; | ||||
| }; | ||||
|  | ||||
| } // namespace WebService | ||||
| @@ -1,28 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #include <json.hpp> | ||||
| #include "web_service/verify_login.h" | ||||
| #include "web_service/web_backend.h" | ||||
|  | ||||
| namespace WebService { | ||||
|  | ||||
| std::future<bool> VerifyLogin(std::string& username, std::string& token, | ||||
|                               const std::string& endpoint_url, std::function<void()> func) { | ||||
|     auto get_func = [func, username](const std::string& reply) -> bool { | ||||
|         func(); | ||||
|         if (reply.empty()) | ||||
|             return false; | ||||
|         nlohmann::json json = nlohmann::json::parse(reply); | ||||
|         std::string result; | ||||
|         try { | ||||
|             result = json["username"]; | ||||
|         } catch (const nlohmann::detail::out_of_range&) { | ||||
|         } | ||||
|         return result == username; | ||||
|     }; | ||||
|     return GetJson<bool>(get_func, endpoint_url, false, username, token); | ||||
| } | ||||
|  | ||||
| } // namespace WebService | ||||
| @@ -1,24 +0,0 @@ | ||||
| // Copyright 2017 Citra Emulator Project | ||||
| // Licensed under GPLv2 or any later version | ||||
| // Refer to the license.txt file included. | ||||
|  | ||||
| #pragma once | ||||
|  | ||||
| #include <functional> | ||||
| #include <future> | ||||
| #include <string> | ||||
|  | ||||
| namespace WebService { | ||||
|  | ||||
| /** | ||||
|  * Checks if username and token is valid | ||||
|  * @param username Citra username to use for authentication. | ||||
|  * @param token Citra token to use for authentication. | ||||
|  * @param endpoint_url URL of the services.citra-emu.org endpoint. | ||||
|  * @param func A function that gets exectued when the verification is finished | ||||
|  * @returns Future with bool indicating whether the verification succeeded | ||||
|  */ | ||||
| std::future<bool> VerifyLogin(std::string& username, std::string& token, | ||||
|                               const std::string& endpoint_url, std::function<void()> func); | ||||
|  | ||||
| } // namespace WebService | ||||