copilot/infinipaint
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions 1

Remove some files

Browse source
This commit is contained in:
Yousef Khadadeh 2025-12-02 19:54:21 +03:00
parent c793ed6c55
commit a5a2c25a44
23 changed files with 0 additions and 779 deletions
Download patch file Download diff file Expand all files Collapse all files

1
conan/export_libs.sh
View file

@ -2,7 +2,6 @@
SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
conan export "$(dirname "$0")/mpg123/all/conanfile.py" --version=1.32.10
conan export "$(dirname "$0")/conan-skia/recipes/skia/all/conanfile.py" --version=143.20251028.0
conan export "$(dirname "$0")/sdl3/3.x/conanfile.py" --version=3.2.26
conan export "$(dirname "$0")/icu/all/conanfile.py" --version=77.1

10
conan/libdatachannel/all/conandata.yml
View file

@ -1,10 +0,0 @@
sources:
"0.23.2":
url: "https://github.com/paullouisageneau/libdatachannel/archive/refs/tags/v0.23.2.tar.gz"
sha256: "b9606efc5b2b173f2d22d0be3f6ba4f12af78c00ca02cde5932f3ff902980eb9"
"0.23.1":
url: "https://github.com/paullouisageneau/libdatachannel/archive/refs/tags/v0.23.1.tar.gz"
sha256: "63e14d619ac4d9cc310a0c7620b80e6da88abf878f27ccc78cd099f95d47b121"
"0.22.2":
url: "https://github.com/paullouisageneau/libdatachannel/archive/refs/tags/v0.22.2.tar.gz"
sha256: "8431ba62a3c83fbee05257226fb8bcb256b1a5ce48b449a718e3be5dbe9b2226"

142
conan/libdatachannel/all/conanfile.py
View file

@ -1,142 +0,0 @@
import os
from conan import ConanFile
from conan.errors import ConanInvalidConfiguration
from conan.tools.build import check_min_cppstd
from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout, CMakeDeps
from conan.tools.files import copy, get, rm, rmdir, replace_in_file
from conan.tools.microsoft import is_msvc
from conan.tools.apple import fix_apple_shared_install_name
required_conan_version = ">=2.1"
class libdatachannelConan(ConanFile):
name = "libdatachannel"
description = "C/C++ WebRTC network library featuring Data Channels, Media Transport, and WebSockets."
license = "MPL-2.0"
topics = ("webrtc", "rtc", "datachannel", "websocket")
url = "https://github.com/conan-io/conan-center-index"
homepage = "https://github.com/paullouisageneau/libdatachannel"
settings = "os", "compiler", "build_type", "arch"
package_type = "library"
options = {
"shared": [True, False],
"fPIC": [True, False],
"with_websocket": [True, False],
"with_nice": [True, False],
"with_ssl": ["openssl", "mbedtls", "gnutls"]
}
default_options = {
"shared": False,
"fPIC": True,
"with_websocket": True,
"with_nice": False,
"with_ssl": "openssl"
}
implements = ["auto_shared_fpic"]
def requirements(self):
if self.options.with_ssl == "openssl":
self.requires("openssl/[>=1.1 <4]")
elif self.options.with_ssl == "mbedtls":
self.requires("mbedtls/3.6.2")
elif self.options.with_ssl == "gnutls":
self.requires("gnutls/3.8.7")
if self.options.with_websocket:
self.requires("nettle/3.9.1")
self.requires("plog/1.1.10")
self.requires("usrsctp/0.9.5.0")
self.requires("libsrtp/2.6.0")
if self.options.with_nice:
self.requires("libnice/0.1.21")
else:
self.requires("libjuice/1.6.1", transitive_headers=True, transitive_libs=True)
def validate(self):
check_min_cppstd(self, 17)
if self.options.with_ssl == "mbedtls":
# dtlstransport.cpp:414:3: error: use of undeclared identifier 'mbedtls_ssl_conf_dtls_srtp_protection_profiles'
raise ConanInvalidConfiguration("Compilation error with mbedtls. Contributions are welcome.")
def layout(self):
cmake_layout(self, src_folder="src")
def source(self):
get(self, **self.conan_data["sources"][self.version], strip_root=True)
# Let Conan handle fpic
replace_in_file(self, os.path.join(self.source_folder, "CMakeLists.txt"),
"set(CMAKE_POSITION_INDEPENDENT_CODE ON)", "")
def generate(self):
tc = CMakeToolchain(self)
tc.cache_variables["PREFER_SYSTEM_LIB"] = True
tc.cache_variables["USE_SYSTEM_SRTP"] = True
tc.cache_variables["USE_SYSTEM_USRSCTP"] = True
tc.cache_variables["USE_SYSTEM_PLOG"] = True
tc.cache_variables["USE_SYSTEM_JSON"] = True
tc.cache_variables["NO_EXAMPLES"] = True
tc.cache_variables["NO_TESTS"] = True
tc.cache_variables["NO_WEBSOCKET"] = not self.options.with_websocket
tc.cache_variables["USE_NICE"] = self.options.with_nice
tc.cache_variables["USE_SYSTEM_JUICE"] = not self.options.with_nice
if self.options.with_ssl == "gnutls":
tc.cache_variables["USE_GNUTLS"] = True
elif self.options.with_ssl == "mbedtls":
tc.cache_variables["USE_MBEDTLS"] = True
tc.generate()
deps = CMakeDeps(self)
deps.set_property("usrsctp", "cmake_target_name", "Usrsctp::Usrsctp")
deps.set_property("libsrtp", "cmake_file_name", "libSRTP")
deps.set_property("libsrtp", "cmake_target_name", "libSRTP::srtp2")
if self.options.with_ssl == "mbedtls":
deps.set_property("mbedtls", "cmake_target_name", "MbedTLS::MbedTLS")
elif self.options.with_ssl == "gnutls" and self.options.with_websocket:
deps.set_property("nettle", "cmake_file_name", "Nettle")
deps.set_property("nettle", "cmake_target_name", "Nettle::Nettle")
if self.options.with_nice:
deps.set_property("libnice", "cmake_file_name", "LibNice")
deps.set_property("libnice", "cmake_target_name", "LibNice::LibNice")
elif not self.options.shared:
# Targetname is LibJuice::LibJuiceStatic for static, but upstream makes no distinction
deps.set_property("libjuice", "cmake_target_name", "LibJuice::LibJuice")
deps.generate()
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
copy(self, "LICENSE", self.source_folder, os.path.join(self.package_folder, "licenses"))
cmake = CMake(self)
cmake.install()
fix_apple_shared_install_name(self)
rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
rmdir(self, os.path.join(self.package_folder, "share"))
rm(self, "*.la", os.path.join(self.package_folder, "lib"))
rm(self, "*.pdb", os.path.join(self.package_folder, "lib"))
rm(self, "*.pdb", os.path.join(self.package_folder, "bin"))
def package_info(self):
suffix = ""
if is_msvc(self) and self.settings.build_type == "Debug":
suffix = "d"
self.cpp_info.libs = ["datachannel" + suffix]
self.cpp_info.set_property("cmake_file_name", "LibDataChannel")
self.cpp_info.set_property("cmake_target_name", "LibDataChannel::LibDataChannel")
if self.settings.os in ["Linux", "FreeBSD"]:
self.cpp_info.system_libs.extend(["m", "pthread", "dl"])
elif self.settings.os == "Windows":
self.cpp_info.system_libs.append("ws2_32")
if not self.options.shared:
self.cpp_info.defines.append("RTC_STATIC")
self.cpp_info.defines.append("RTC_ENABLE_WEBSOCKET=" + ("1" if self.options.with_websocket else "0"))
# This is True by default, and the recipe currently does not model it
self.cpp_info.defines.append("RTC_ENABLE_MEDIA=1")

9
conan/libdatachannel/all/test_package/CMakeLists.txt
View file

@ -1,9 +0,0 @@
cmake_minimum_required(VERSION 3.15)
project(test_package LANGUAGES CXX) # if the project uses c++
find_package(LibDataChannel REQUIRED CONFIG)
add_executable(${PROJECT_NAME} test_package.cpp)
target_link_libraries(${PROJECT_NAME} PRIVATE LibDataChannel::LibDataChannel)
#target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)

27
conan/libdatachannel/all/test_package/conanfile.py
View file

@ -1,27 +0,0 @@
from conan import ConanFile
from conan.tools.build import can_run
from conan.tools.cmake import cmake_layout, CMake
import os
# It will become the standard on Conan 2.x
class TestPackageConan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
generators = "CMakeDeps", "CMakeToolchain", "VirtualRunEnv"
test_type = "explicit"
def requirements(self):
self.requires(self.tested_reference_str)
def layout(self):
cmake_layout(self)
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def test(self):
if can_run(self):
bin_path = os.path.join(self.cpp.build.bindir, "test_package")
self.run(bin_path, env="conanrun")

9
conan/libdatachannel/all/test_package/test_package.cpp
View file

@ -1,9 +0,0 @@
#include <cstdlib>
#include <rtc/rtc.hpp>
#include <iostream>
int main(void) {
rtc::InitLogger(rtc::LogLevel::Debug);
return EXIT_SUCCESS;
}

7
conan/libdatachannel/config.yml
View file

@ -1,7 +0,0 @@
versions:
"0.23.2":
folder: all
"0.23.1":
folder: all
"0.22.2":
folder: all

7
conan/libjuice/all/conandata.yml
View file

@ -1,7 +0,0 @@
sources:
"1.6.1":
url: "https://github.com/paullouisageneau/libjuice/archive/refs/tags/v1.6.1.tar.gz"
sha256: "14d7cfc1a541843c1678828ad52d860d043bd82ed39ff076b260565796e4e4ee"
"1.5.7":
url: "https://github.com/paullouisageneau/libjuice/archive/refs/tags/v1.5.7.tar.gz"
sha256: "6385c574f3c33f766ed25cddf919625b0ae8ca0d76871f70301e5a0cf2c93dc8"

80
conan/libjuice/all/conanfile.py
View file

@ -1,80 +0,0 @@
import os
from conan import ConanFile
from conan.tools.build import check_min_cppstd
from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
from conan.tools.files import copy, get, rm, rmdir
from conan.tools.microsoft import is_msvc
from conan.tools.apple import fix_apple_shared_install_name
required_conan_version = ">=2.4"
class libjuiceConan(ConanFile):
name = "libjuice"
description = "JUICE is a UDP Interactive Connectivity Establishment library."
license = "MPL-2.0"
topics = ("webrtc", "ice")
url = "https://github.com/conan-io/conan-center-index"
homepage = "https://github.com/paullouisageneau/libjuice"
settings = "os", "compiler", "build_type", "arch"
package_type = "library"
options = {
"shared": [True, False],
"fPIC": [True, False],
}
default_options = {
"shared": False,
"fPIC": True,
}
languages = "C"
implements = ["auto_shared_fpic"]
def layout(self):
cmake_layout(self, src_folder="src")
def source(self):
get(self, **self.conan_data["sources"][self.version], strip_root=True)
def generate(self):
tc = CMakeToolchain(self)
tc.variables["NO_TESTS"] = True
tc.generate()
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
copy(self, "LICENSE", self.source_folder, os.path.join(self.package_folder, "licenses"))
cmake = CMake(self)
cmake.install()
fix_apple_shared_install_name(self)
rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
rmdir(self, os.path.join(self.package_folder, "share"))
rm(self, "*.la", os.path.join(self.package_folder, "lib"))
rm(self, "*.pdb", os.path.join(self.package_folder, "lib"))
rm(self, "*.pdb", os.path.join(self.package_folder, "bin"))
def package_info(self):
self.cpp_info.libs = ["juice"]
self.cpp_info.set_property("cmake_file_name", "LibJuice")
if self.options.shared:
self.cpp_info.set_property("cmake_target_name", "LibJuice::LibJuice")
else:
self.cpp_info.set_property("cmake_target_name", "LibJuice::LibJuiceStatic")
self.cpp_info.defines.append("JUICE_STATIC")
if self.settings.os in ["Linux", "FreeBSD"]:
self.cpp_info.system_libs.append("m")
self.cpp_info.system_libs.append("pthread")
self.cpp_info.system_libs.append("dl")
if self.settings.os == "Windows":
self.cpp_info.system_libs.extend(["ws2_32", "bcrypt"])
if is_msvc(self):
self.cpp_info.cxxflags.append("/bigobj")

13
conan/libjuice/all/test_package/CMakeLists.txt
View file

@ -1,13 +0,0 @@
cmake_minimum_required(VERSION 3.15)
project(test_package LANGUAGES CXX) # if the project uses c++
find_package(LibJuice REQUIRED CONFIG)
add_executable(${PROJECT_NAME} test_package.cpp)
if (BUILD_SHARED_LIBS)
target_link_libraries(${PROJECT_NAME} PRIVATE LibJuice::LibJuice)
else()
target_link_libraries(${PROJECT_NAME} PRIVATE LibJuice::LibJuiceStatic)
endif()

32
conan/libjuice/all/test_package/conanfile.py
View file

@ -1,32 +0,0 @@
from conan import ConanFile
from conan.tools.build import can_run
from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
import os
# It will become the standard on Conan 2.x
class TestPackageConan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
generators = "CMakeDeps", "VirtualRunEnv"
test_type = "explicit"
def requirements(self):
self.requires(self.tested_reference_str)
def layout(self):
cmake_layout(self)
def generate(self):
tc = CMakeToolchain(self)
tc.variables["BUILD_SHARED_LIBS"] = self.dependencies[self.tested_reference_str].options.shared
tc.generate()
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def test(self):
if can_run(self):
bin_path = os.path.join(self.cpp.build.bindir, "test_package")
self.run(bin_path, env="conanrun")

8
conan/libjuice/all/test_package/test_package.cpp
View file

@ -1,8 +0,0 @@
#include <cstdlib>
#include <juice/juice.h>
int main(void) {
juice_config config;
juice_set_log_level(JUICE_LOG_LEVEL_WARN);
return EXIT_SUCCESS;
}

5
conan/libjuice/config.yml
View file

@ -1,5 +0,0 @@
versions:
"1.6.1":
folder: all
"1.5.7":
folder: all

30
conan/mpg123/all/conandata.yml
View file

@ -1,30 +0,0 @@
sources:
"1.32.10":
url:
- "https://sourceforge.net/projects/mpg123/files/mpg123/1.32.10/mpg123-1.32.10.tar.bz2"
- "https://www.mpg123.de/download/mpg123-1.32.10.tar.bz2"
sha256: "87b2c17fe0c979d3ef38eeceff6362b35b28ac8589fbf1854b5be75c9ab6557c"
"1.31.2":
url:
- "https://sourceforge.net/projects/mpg123/files/mpg123/1.31.2/mpg123-1.31.2.tar.bz2"
- "https://www.mpg123.de/download/mpg123-1.31.2.tar.bz2"
sha256: "b17f22905e31f43b6b401dfdf6a71ed11bb7d056f68db449d70b9f9ae839c7de"
"1.29.3":
url:
- "https://sourceforge.net/projects/mpg123/files/mpg123/1.29.3/mpg123-1.29.3.tar.bz2"
- "https://www.mpg123.de/download/mpg123-1.29.3.tar.bz2"
sha256: "963885d8cc77262f28b77187c7d189e32195e64244de2530b798ddf32183e847"
"1.26.4":
url:
- "https://sourceforge.net/projects/mpg123/files/mpg123/1.26.4/mpg123-1.26.4.tar.bz2"
- "https://www.mpg123.de/download/mpg123-1.26.4.tar.bz2"
sha256: "081991540df7a666b29049ad870f293cfa28863b36488ab4d58ceaa7b5846454"
patches:
"1.31.2":
- patch_file: "patches/0001-msvc-export-symbols.patch"
"1.26.4":
- patch_file: "patches/0001-msvc-export-symbols.patch"
"1.29.3":
- patch_file: "patches/0001-msvc-export-symbols.patch"
- patch_file: "patches/0002-cmake-read_api_version-fix.patch"

222
conan/mpg123/all/conanfile.py
View file

@ -1,222 +0,0 @@
from conan import ConanFile
from conan.errors import ConanInvalidConfiguration
from conan.tools.apple import is_apple_os, fix_apple_shared_install_name
from conan.tools.cmake import cmake_layout, CMake, CMakeDeps, CMakeToolchain
from conan.tools.layout import basic_layout
from conan.tools.gnu import Autotools, AutotoolsDeps, AutotoolsToolchain
from conan.tools.files import get, copy, export_conandata_patches, apply_conandata_patches, replace_in_file, rmdir, rm
from conan.tools.microsoft import is_msvc
from conan.tools.env import VirtualBuildEnv, VirtualRunEnv
from conan.tools.build import cross_building
import os
required_conan_version = ">=1.53.0"
class Mpg123Conan(ConanFile):
name = "mpg123"
description = "Fast console MPEG Audio Player and decoder library"
topics = ("mpeg", "audio", "player", "decoder")
url = "https://github.com/conan-io/conan-center-index"
homepage = "http://mpg123.org/"
license = "LGPL-2.1-or-later", "GPL-2.0-or-later"
settings = "os", "compiler", "build_type", "arch"
options = {
"shared": [True, False],
"fPIC": [True, False],
"flexible_resampling": [True, False],
"network": [True, False],
"icy": [True, False],
"id3v2": [True, False],
"ieeefloat": [True, False],
"layer1": [True, False],
"layer2": [True, False],
"layer3": [True, False],
"moreinfo": [True, False],
"seektable": [None, "ANY"],
"module": ["dummy", "libalsa", "tinyalsa", "win32"],
}
default_options = {
"shared": False,
"fPIC": True,
"flexible_resampling": True,
"network": True,
"icy": True,
"id3v2": True,
"ieeefloat": True,
"layer1": True,
"layer2": True,
"layer3": True,
"moreinfo": True,
"seektable": "1000",
"module": "dummy",
}
@property
def _audio_module(self):
return {
"libalsa": "alsa",
}.get(str(self.options.module), str(self.options.module))
def export_sources(self):
export_conandata_patches(self)
def config_options(self):
if self.settings.os == "Windows":
self.options.rm_safe("fPIC")
def configure(self):
self.settings.rm_safe("compiler.libcxx")
self.settings.rm_safe("compiler.cppstd")
if self.options.shared:
self.options.rm_safe("fPIC")
def layout(self):
if is_msvc(self):
cmake_layout(self, src_folder="src")
else:
basic_layout(self, src_folder="src")
def requirements(self):
if self.options.module == "libalsa":
self.requires("libalsa/1.2.10")
if self.options.module == "tinyalsa":
self.requires("tinyalsa/2.0.0")
def validate(self):
if not str(self.options.seektable).isdigit():
raise ConanInvalidConfiguration(f"The option -o {self.ref.name}:seektable must be an integer number.")
if self.settings.os != "Windows" and self.options.module == "win32":
raise ConanInvalidConfiguration(f"The option -o {self.ref.name}:module should not use 'win32' for non-Windows OS")
def build_requirements(self):
if not self.conf.get("tools.gnu:pkg_config", default=False, check_type=str):
self.tool_requires("pkgconf/2.0.3")
if self.settings.arch in ["x86", "x86_64"]:
self.tool_requires("yasm/1.3.0")
if self.settings_build.os == "Windows" and not is_msvc(self):
self.win_bash = True
if not self.conf.get("tools.microsoft.bash:path", default=False, check_type=str):
self.tool_requires("msys2/cci.latest")
def source(self):
get(self, **self.conan_data["sources"][self.version], strip_root=True)
def generate(self):
env = VirtualBuildEnv(self)
env.generate()
if not cross_building(self):
env = VirtualRunEnv(self)
env.generate(scope="build")
if is_msvc(self):
tc = CMakeToolchain(self)
tc.variables["NO_MOREINFO"] = not self.options.moreinfo
tc.variables["NETWORK"] = self.options.network
tc.variables["NO_NTOM"] = not self.options.flexible_resampling
tc.variables["NO_ICY"] = not self.options.icy
tc.variables["NO_ID3V2"] = not self.options.id3v2
tc.variables["IEEE_FLOAT"] = self.options.ieeefloat
tc.variables["NO_LAYER1"] = not self.options.layer1
tc.variables["NO_LAYER2"] = not self.options.layer2
tc.variables["NO_LAYER3"] = not self.options.layer3
tc.variables["USE_MODULES"] = False
tc.variables["CHECK_MODULES"] = self._audio_module
tc.variables["WITH_SEEKTABLE"] = self.options.seektable
tc.generate()
tc = CMakeDeps(self)
tc.generate()
else:
yes_no = lambda v: "yes" if v else "no"
tc = AutotoolsToolchain(self)
tc.configure_args.extend([
f"--enable-moreinfo={yes_no(self.options.moreinfo)}",
f"--enable-network={yes_no(self.options.network)}",
f"--enable-ntom={yes_no(self.options.flexible_resampling)}",
f"--enable-icy={yes_no(self.options.icy)}",
f"--enable-id3v2={yes_no(self.options.id3v2)}",
f"--enable-ieeefloat={yes_no(self.options.ieeefloat)}",
f"--enable-layer1={yes_no(self.options.layer1)}",
f"--enable-layer2={yes_no(self.options.layer2)}",
f"--enable-layer3={yes_no(self.options.layer3)}",
f"--with-audio={self._audio_module}",
f"--with-default-audio={self._audio_module}",
f"--with-seektable={self.options.seektable}",
f"--enable-modules=no",
f"--enable-shared={yes_no(self.options.shared)}",
f"--enable-static={yes_no(not self.options.shared)}",
])
if is_apple_os(self):
# Needed for fix_apple_shared_install_name invocation in package method
tc.extra_cflags += ["-headerpad_max_install_names"]
# The finite-math-only optimization has no effect and will cause linking errors
# when linked against glibc >= 2.31
tc.extra_cflags += ["-fno-finite-math-only"]
tc.generate()
tc = AutotoolsDeps(self)
tc.generate()
def build(self):
apply_conandata_patches(self)
if is_msvc(self):
cmake = CMake(self)
cmake.configure(build_script_folder=os.path.join(self.source_folder, "ports", "cmake"))
cmake.build()
else:
if self.settings.compiler == "apple-clang" and cross_building(self):
# when testing if the assembler supports avx - propagate cflags (CFLAGS) to the assembler
# (which should contain "-arch x86_64" when crossbuilding with appleclang)
replace_in_file(self, os.path.join(self.source_folder, "configure"),
"$CCAS -c -o conftest.o",
"$CCAS $CFLAGS -c -o conftest.o")
autotools = Autotools(self)
autotools.configure()
autotools.make()
def package(self):
copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
if is_msvc(self):
cmake = CMake(self)
cmake.install()
rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
else:
autotools = Autotools(self)
autotools.install()
rm(self, "*.la", os.path.join(self.package_folder, "lib"))
rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
rmdir(self, os.path.join(self.package_folder, "share"))
fix_apple_shared_install_name(self)
def package_info(self):
self.cpp_info.set_property("cmake_file_name", "mpg123")
self.cpp_info.components["libmpg123"].libs = ["mpg123"]
self.cpp_info.components["libmpg123"].set_property("pkg_config_name", "libmpg123")
self.cpp_info.components["libmpg123"].set_property("cmake_target_name", "MPG123::libmpg123")
if self.settings.os == "Windows" and self.options.shared:
self.cpp_info.components["libmpg123"].defines.append("LINK_MPG123_DLL")
self.cpp_info.components["libout123"].libs = ["out123"]
self.cpp_info.components["libout123"].set_property("pkg_config_name", "libout123")
self.cpp_info.components["libout123"].set_property("cmake_target_name", "MPG123::libout123")
self.cpp_info.components["libout123"].requires = ["libmpg123"]
self.cpp_info.components["libsyn123"].libs = ["syn123"]
self.cpp_info.components["libsyn123"].set_property("pkg_config_name", "libsyn123")
self.cpp_info.components["libsyn123"].set_property("cmake_target_name", "MPG123::libsyn123")
self.cpp_info.components["libsyn123"].requires = ["libmpg123"]
if self.settings.os == "Linux":
self.cpp_info.components["libmpg123"].system_libs = ["m"]
if self.settings.arch in ["x86", "x86_64"]:
self.cpp_info.components["libsyn123"].system_libs = ["mvec"]
elif self.settings.os == "Windows":
self.cpp_info.components["libmpg123"].system_libs = ["shlwapi"]
if self.options.module == "libalsa":
self.cpp_info.components["libout123"].requires.append("libalsa::libalsa")
if self.options.module == "tinyalsa":
self.cpp_info.components["libout123"].requires.append("tinyalsa::tinyalsa")
if self.options.module == "win32":
self.cpp_info.components["libout123"].system_libs.append("winmm")

22
conan/mpg123/all/patches/0001-msvc-export-symbols.patch
View file

@ -1,22 +0,0 @@
--- a/ports/cmake/src/libout123/CMakeLists.txt
+++ b/ports/cmake/src/libout123/CMakeLists.txt
@@ -18,7 +18,7 @@ add_library(${TARGET}
$<TARGET_OBJECTS:compat>
$<$<BOOL:${USE_MODULES}>:$<TARGET_OBJECTS:compat_dl>>)
-set_target_properties(${TARGET} PROPERTIES OUTPUT_NAME out123)
+set_target_properties(${TARGET} PROPERTIES OUTPUT_NAME out123 WINDOWS_EXPORT_ALL_SYMBOLS ON)
target_link_libraries(${TARGET} PRIVATE
$<TARGET_NAME_IF_EXISTS:defaultmodule>
--- a/ports/cmake/src/libsyn123/CMakeLists.txt
+++ b/ports/cmake/src/libsyn123/CMakeLists.txt
@@ -15,7 +15,7 @@ add_library(${TARGET}
"${CMAKE_CURRENT_SOURCE_DIR}/../../../../src/libsyn123/sampleconv.c"
$<TARGET_OBJECTS:compat_str>)
-set_target_properties(${TARGET} PROPERTIES OUTPUT_NAME syn123)
+set_target_properties(${TARGET} PROPERTIES OUTPUT_NAME syn123 WINDOWS_EXPORT_ALL_SYMBOLS ON)
target_include_directories(${TARGET} INTERFACE
"$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>"

10
conan/mpg123/all/patches/0002-cmake-read_api_version-fix.patch
View file

@ -1,10 +0,0 @@
--- a/ports/cmake/cmake/read_api_version.cmake
+++ b/ports/cmake/cmake/read_api_version.cmake
@@ -1,6 +1,6 @@
function(read_api_version project_version api_version outapi_version synapi_version )
- file( READ "${CMAKE_SOURCE_DIR}/../../configure.ac" configure_ac )
+ file( READ "${CMAKE_CURRENT_SOURCE_DIR}/../../configure.ac" configure_ac )
string( REGEX MATCH "AC_INIT\\(\\[mpg123\\], \\[([0-9\\.]+)" result ${configure_ac} )
set( ${project_version} ${CMAKE_MATCH_1} PARENT_SCOPE )

7
conan/mpg123/all/test_package/CMakeLists.txt
View file

@ -1,7 +0,0 @@
cmake_minimum_required(VERSION 3.8)
project(test_package LANGUAGES C)
find_package(mpg123 REQUIRED CONFIG)
add_executable(${PROJECT_NAME} test_package.c)
target_link_libraries(${PROJECT_NAME} PRIVATE MPG123::libmpg123)

26
conan/mpg123/all/test_package/conanfile.py
View file

@ -1,26 +0,0 @@
from conan import ConanFile
from conan.tools.build import can_run
from conan.tools.cmake import cmake_layout, CMake
import os
class TestPackageConan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
generators = "CMakeDeps", "CMakeToolchain", "VirtualRunEnv"
test_type = "explicit"
def requirements(self):
self.requires(self.tested_reference_str)
def layout(self):
cmake_layout(self)
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def test(self):
if can_run(self):
bin_path = os.path.join(self.cpp.build.bindirs[0], "test_package")
self.run(bin_path, env="conanrun")

12
conan/mpg123/all/test_package/test_package.c
View file

@ -1,12 +0,0 @@
#include "mpg123.h"
#include <stdio.h>
int main() {
int error;
mpg123_pars *pars;
pars = mpg123_new_pars(&error);
mpg123_fmt_all(pars);
mpg123_delete_pars(pars);
return 0;
}

9
conan/mpg123/config.yml
View file

@ -1,9 +0,0 @@
versions:
"1.32.10":
folder: "all"
"1.31.2":
folder: "all"
"1.29.3":
folder: "all"
"1.26.4":
folder: "all"

36
src/Server/CMakeLists.txt
View file

@ -1,36 +0,0 @@
cmake_minimum_required(VERSION 3.27.0)
set(CMAKE_CXX_STANDARD 23)
project(canvasprogramserver)
set(sources "servermain.cpp"
"MainServer.cpp"
"ClientData.cpp"
"../../include/Helpers/Networking/NetServer.cpp"
"../../include/Helpers/Networking/NetClient.cpp"
"../../include/Helpers/Networking/ByteStream.cpp"
"../../include/Helpers/Random.cpp"
"../DrawComponents/DrawBrushStroke.cpp"
"../DrawComponents/DrawComponent.cpp"
"../DrawComponents/DrawEllipse.cpp"
"../DrawComponents/DrawRectangle.cpp"
"../DrawComponents/DrawTextBox.cpp"
"../DrawComponents/DrawImage.cpp"
)
find_package(GameNetworkingSockets)
add_executable(canvasprogramserver ${sources})
target_compile_definitions(canvasprogramserver PRIVATE IS_SERVER)
if(WIN32)
set_property(TARGET canvasprogramserver PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
target_include_directories(canvasprogramserver PRIVATE "../../include" "../..")
target_link_libraries(canvasprogramserver GameNetworkingSockets::shared)
else()
target_include_directories(canvasprogramserver PRIVATE "../../include" "../.." "../../../GameNetworkingSockets/include")
target_compile_options(canvasprogramserver PRIVATE -O3)
target_link_options(canvasprogramserver PRIVATE -O3)
target_link_libraries(canvasprogramserver GameNetworkingSockets::shared)
endif()
install(TARGETS canvasprogramserver DESTINATION bin)

55
src/Server/servermain.cpp
View file

@ -1,55 +0,0 @@
#include "MainServer.hpp"
#include "steam/steamnetworkingsockets.h"
#include "steam/steamnetworkingtypes.h"
#include <queue>
#include <string>
#include <thread>
std::mutex inputMutex;
std::queue<std::string> inputQueue;
std::unique_ptr<std::thread> inputThread;
void user_input_init() {
inputThread = std::make_unique<std::thread>([&]() {
for(;;) {
std::string newMessage;
std::cin >> newMessage;
inputMutex.lock();
inputQueue.emplace(newMessage);
inputMutex.unlock();
if(newMessage == "stop")
break;
}
});
}
int main(int argc, char** argv) {
SteamDatagramErrMsg errMsg;
if(!GameNetworkingSockets_Init(nullptr, errMsg))
std::cout << "[GameNetworkingSockets_Init] Failed to initialize network sockets " << errMsg << std::endl;
MainServer server("");
user_input_init();
for(;;) {
server.update();
inputMutex.lock();
bool isQuitting = false;
while(!inputQueue.empty()) {
std::string newMessage = inputQueue.front();
inputQueue.pop();
if(newMessage == "stop") {
isQuitting = true;
break;
}
else {
std::cout << "Unknown command: " << newMessage << std::endl;
}
}
inputMutex.unlock();
if(isQuitting)
break;
}
inputThread->join();
return 0;
}