def _configure_meson(self):
meson = Meson(self)
defs = {}
if self.settings.os == "Linux":
defs[
"wayland_backend" if self._gtk3 else
"wayland-backend"] = "true" if self.options.with_wayland else "false"
defs["x11_backend" if self._gtk3 else
"x11-backend"] = "true" if self.options.with_x11 else "false"
defs["introspection"] = "false" if self._gtk3 else "disabled"
defs["documentation"] = "false"
defs["man-pages"] = "false"
defs["tests" if self._gtk3 else "build-tests"] = "false"
defs["examples" if self._gtk3 else "build-examples"] = "false"
defs["demos"] = "false"
defs["datadir"] = os.path.join(self.package_folder, "res", "share")
defs["localedir"] = os.path.join(self.package_folder, "res", "share",
"locale")
defs["sysconfdir"] = os.path.join(self.package_folder, "res", "etc")
args = []
args.append("--wrap-mode=nofallback")
meson.configure(defs=defs,
build_folder=self._build_subfolder,
source_folder=self._source_subfolder,
pkg_config_paths=[self.install_folder],
args=args)
return meson
def _configure_meson(self):
meson = Meson(self)
defs = dict()
if tools.is_apple_os(self.settings.os):
defs[
"iconv"] = "external" # https://gitlab.gnome.org/GNOME/glib/issues/1557
defs["selinux"] = "enabled" if self.options.get_safe(
"with_selinux") else "disabled"
defs["libmount"] = "enabled" if self.options.get_safe(
"with_mount") else "disabled"
defs["internal_pcre"] = not self.options.with_pcre
if self.settings.os == "FreeBSD":
defs["xattr"] = "false"
defs["tests"] = "false"
if tools.Version(self.version) >= "2.67.0":
defs["libelf"] = "enabled" if self.options.with_elf else "disabled"
meson.configure(
source_folder=self._source_subfolder,
args=["--wrap-mode=nofallback"],
build_folder=self._build_subfolder,
defs=defs,
)
return meson
def build(self):
# ---------------------------
# Apply patches
# * 0001-disable-webrtc-example.patch
# * fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/867
# ---------------------------
repoFolder = os.path.join(self.build_folder, self.name)
gst_conan.base.execute("git config user.email [email protected]",
workingFolder=repoFolder)
gst_conan.base.execute("git config user.name gst_conan",
workingFolder=repoFolder)
patchFolder = os.path.join(self.build_folder, "patches")
if os.path.isdir(patchFolder):
for file in os.listdir(patchFolder):
patchPath = os.path.join(patchFolder, file)
if file.endswith(".patch") and os.path.isfile(patchPath):
self.output.info(f"Applying patch {file}")
gst_conan.base.execute(f"git am {patchPath}",
workingFolder=repoFolder)
# ---------------------------
# Build as usual
# ---------------------------
pcPaths = [
self.deps_cpp_info["gstreamer"].rootpath,
self.deps_cpp_info["gst-plugins-base"].rootpath
]
meson = Meson(self)
meson.configure(source_folder=self.name,
build_folder="build",
pkg_config_paths=pcPaths)
meson.build()
def build(self):
args = ["--auto-features=disabled", "-Dgl_platform=egl"]
args.append("-Dintrospection=" +
("enabled" if self.options.introspection else "disabled"))
args.append("-Dgl=" + ("enabled" if self.options.gl else "disabled"))
args.append("-Dx11=" + ("enabled" if self.options.x11 else "disabled"))
args.append("-Dvideotestsrc=" +
("enabled" if self.options.videotestsrc else "disabled"))
args.append("-Daudiotestsrc=" +
("enabled" if self.options.audiotestsrc else "disabled"))
args.append("-Dvideoconvert=" +
("enabled" if self.options.videoconvert else "disabled"))
args.append("-Dapp=" + ("enabled" if self.options.app else "disabled"))
args.append("-Dplayback=" +
("enabled" if self.options.playback else "disabled"))
args.append("-Dtypefind=" +
("enabled" if self.options.typefind else "disabled"))
args.append("-Dorc=" + ("enabled" if self.options.orc else "disabled"))
args.append("-Dopus=" +
("enabled" if self.options.opus else "disabled"))
args.append("-Dpango=" +
("enabled" if self.options.pango else "disabled"))
args.append("-Daudioresample=" +
("enabled" if self.options.audiotestsrc else "disabled"))
args.append("-Dvideoscale=" +
("enabled" if self.options.videoscale else "disabled"))
args.append("-Daudioconvert=" +
("enabled" if self.options.audioconvert else "disabled"))
meson = Meson(self)
meson.configure(
source_folder="gst-plugins-base-" + self.version,
args=args,
pkg_config_paths=os.environ["PKG_CONFIG_PATH"].split(":"))
meson.install()
def build(self):
args = []
if self.options.web:
args.append("--with-web")
args.append("--without-x")
args.append("--without-xpm")
args.append("--without-gif")
args.append("--without-tiff")
args.append("--without-sound")
args.append("--without-dbus")
args.append("--without-selinux")
args.append("--without-xml2")
args.append("--without-gnutls")
args.append("--without-libgmp")
elif self.options.nativecomp:
args.append("--with-nativecomp")
else:
args.append("--with-x-toolkit=gtk3")
if self.options.web:
meson = Meson(self)
meson.configure(source_folder="emacs")
else:
with tools.chdir("emacs"):
self.run("sh autogen.sh")
autotools = AutoToolsBuildEnvironment(self)
autotools.configure(args=args)
autotools.make()
def _configure_meson(self):
meson = Meson(self)
defs = {}
if self.settings.os == "Linux":
defs["wayland_backend" if self._gtk3 else "wayland-backend"] = "true" if self.options.with_wayland else "false"
defs["x11_backend" if self._gtk3 else "x11-backend"] = "true" if self.options.with_x11 else "false"
defs["introspection"] = "false" if self._gtk3 else "disabled"
defs["gtk_doc"] = "false"
defs["man-pages" if self._gtk4 else "man"] = "false"
defs["tests" if self._gtk3 else "build-tests"] = "false"
defs["examples" if self._gtk3 else "build-examples"] = "false"
defs["demos"] = "false"
defs["datadir"] = os.path.join(self.package_folder, "res", "share")
defs["localedir"] = os.path.join(self.package_folder, "res", "share", "locale")
defs["sysconfdir"] = os.path.join(self.package_folder, "res", "etc")
if self._gtk4:
enabled_disabled = lambda opt : "enabled" if opt else "disabled"
defs["media-ffmpeg"] = enabled_disabled(self.options.with_ffmpeg)
defs["media-gstreamer"] = enabled_disabled(self.options.with_gstreamer)
defs["print-cups"] = enabled_disabled(self.options.with_cups)
if tools.Version(self.version) < "4.3.2":
defs["print-cloudprint"] = enabled_disabled(self.options.with_cloudprint)
args=[]
args.append("--wrap-mode=nofallback")
meson.configure(defs=defs, build_folder=self._build_subfolder, source_folder=self._source_subfolder, pkg_config_paths=[self.install_folder], args=args)
return meson
def _configure_meson(self):
meson = Meson(self)
defs = dict()
if tools.is_apple_os(self.settings.os):
defs[
"iconv"] = "native" # https://gitlab.gnome.org/GNOME/glib/issues/1557
elif self.settings.os == "Linux":
defs["selinux"] = self.options.with_selinux
defs["libmount"] = self.options.with_mount
defs["libdir"] = "lib"
if str(self.settings.compiler) in ["gcc", "clang"]:
if self.settings.arch == "x86":
defs["c_args"] = "-m32"
defs["cpp_args"] = "-m32"
defs["c_link_args"] = "-m32"
defs["cpp_link_args"] = "-m32"
elif self.settings.arch == "x86_64":
defs["c_args"] = "-m64"
defs["cpp_args"] = "-m64"
defs["c_link_args"] = "-m64"
defs["cpp_link_args"] = "-m64"
meson.configure(source_folder=self._source_subfolder,
build_folder=self._build_subfolder,
defs=defs)
return meson
def build(self):
pcPaths = [
self.deps_cpp_info["gstreamer"].rootpath,
self.deps_cpp_info["gst-plugins-base"].rootpath
]
meson = Meson(self)
meson.configure(source_folder=self.name, build_folder="build", pkg_config_paths=pcPaths)
meson.build()
# ----------------------------------
# Create gstreamer-plugins-good-1.0.pc: The GES build requires it even though it serves no actual purpose.
# ----------------------------------
pcFileContents="""prefix=
exec_prefix=${prefix}
libdir=${prefix}/lib/x86_64-linux-gnu
includedir=${prefix}/include/gstreamer-1.0
pluginsdir=${prefix}/lib/x86_64-linux-gnu/gstreamer-1.0
Name: GStreamer Good Plugin libraries
Description: Streaming media framework, good plugins libraries
Requires: gstreamer-1.0 gstreamer-plugins-base-1.0
Version: """ + str(self.version) + "\n" + \
"""Libs:
Cflags:
"""
with open(os.path.join(self.build_folder, "build", "pkgconfig", "gstreamer-plugins-good-1.0.pc"), 'w') as pcFile:
pcFile.write(pcFileContents)
def build(self):
#args = ["--default-library={}".format("shared" if self.options.shared else "static")]
meson = Meson(self,
build_type=self.settings.build_type,
backend="ninja")
meson.configure(source_folder=self.name, build_folder="build")
meson.build()
def _configure_meson(self):
meson = Meson(self)
defs = {}
if tools.Version(self.version) >= "2.42.0":
defs["introspection"] = "false"
else:
defs["gir"] = "false"
defs["docs"] = "false"
defs["man"] = "false"
defs["installed_tests"] = "false"
defs["png"] = "true" if self.options.with_libpng else "false"
defs["tiff"] = "true" if self.options.with_libtiff else "false"
defs["jpeg"] = "true" if self.options.with_libjpeg else "false"
if "with_jasper" in self.options:
defs["jasper"] = "true" if self.options.with_jasper else "false"
if tools.Version(self.version) < "2.42.0":
defs["x11"] = "false"
defs["builtin_loaders"] = "all"
defs["gio_sniffing"] = "false"
defs[
"introspection"] = "enabled" if self.options.with_introspection else "disabled"
args = []
args.append("--wrap-mode=nofallback")
meson.configure(defs=defs,
build_folder=self._build_subfolder,
source_folder=self._source_subfolder,
pkg_config_paths=".",
args=args)
return meson
def build(self):
with tools.chdir(self.source_subfolder):
with tools.environment_append({
'LD_LIBRARY_PATH':
'%s/lib' % (self.deps_cpp_info["libffi"].rootpath),
'PATH':
'%s/bin:%s' %
(self.deps_cpp_info["gobject-introspection"].rootpath,
os.getenv("PATH"))
}):
meson = Meson(self)
meson.configure(
defs={
'disable_introspection': 'false',
'prefix': '%s/builddir/install' % (os.getcwd()),
'libdir': 'lib',
},
source_dir='%s' % (os.getcwd()),
build_dir='%s/builddir' % (os.getcwd()),
pkg_config_paths=[
'%s/lib/pkgconfig' %
(self.deps_cpp_info["libffi"].rootpath),
'%s/lib/pkgconfig' %
(self.deps_cpp_info["glib"].rootpath),
'%s/lib/pkgconfig' %
(self.deps_cpp_info["gobject-introspection"].rootpath),
])
meson.build(args=['-j4'])
self.run('ninja -C {0} install'.format(meson.build_dir))
def _configure_meson(self):
defs = dict()
def add_flag(name, value):
if name in defs:
defs[name] += " " + value
else:
defs[name] = value
def add_compiler_flag(value):
add_flag("c_args", value)
add_flag("cpp_args", value)
def add_linker_flag(value):
add_flag("c_link_args", value)
add_flag("cpp_link_args", value)
meson = Meson(self)
if self.settings.compiler == "Visual Studio":
add_linker_flag("-lws2_32")
add_compiler_flag("-%s" % self.settings.compiler.runtime)
if int(str(self.settings.compiler.version)) < 14:
add_compiler_flag("-Dsnprintf=_snprintf")
if self.settings.get_safe("compiler.runtime"):
defs["b_vscrt"] = str(self.settings.compiler.runtime).lower()
defs["tools"] = "disabled"
defs["examples"] = "disabled"
defs["benchmarks"] = "disabled"
defs["tests"] = "disabled"
meson.configure(build_folder=self._build_subfolder,
source_folder=self._source_subfolder,
defs=defs)
return meson
def build(self):
meson = Meson(self)
defs = dict()
defs["gir"] = False
meson.configure(build_folder="build",
source_folder=self._source_subfolder,
defs=defs)
meson.build()
def build(self):
tools.mkdir('build')
meson = Meson(self)
meson.configure(
args=['--prefix='+self.package_folder],
build_folder='build'
)
meson.build(targets=['install'])
def build(self):
self.create_meson_subprojects()
defs = {"b_coverage": "true"}
meson = Meson(self)
meson.configure(build_dir='meson_build', defs=defs)
meson.build()
def build(self):
pcPaths = [self.deps_cpp_info["gstreamer"].rootpath]
meson = Meson(self)
meson.configure(source_folder=self.name,
build_folder="build",
pkg_config_paths=pcPaths)
meson.build()
def _build_with_meson(self):
if self.options["qtbase"].shared and not tools.cross_building(self.settings):
self.output.info("Building with Meson")
tools.mkdir("meson_folder")
with tools.environment_append(RunEnvironment(self).vars):
meson = Meson(self)
meson.configure(build_folder="meson_folder", defs={"cpp_std": "c++11"})
meson.build()
def _configure_meson(self):
meson = Meson(self)
meson.options["doc"] = "disabled"
meson.options["nls"] = "disabled"
meson.options["tests"] = "disabled"
meson.options["tools"] = "disabled"
meson.configure(source_folder=self._source_subfolder, build_folder=self._build_subfolder)
return meson
def _configure_meson(self):
defs = dict()
defs["introspection"] = "false"
meson = Meson(self)
meson.configure(build_folder="build",
source_folder=self._source_subfolder,
defs=defs,
args=['--wrap-mode=nofallback'])
return meson
def _configure_meson(self):
meson = Meson(self)
meson.options["tests"] = False
meson.options["sharedstatedir"] = self._sharedstatedir
if not self.options.enable_lib:
meson.options["default_library"] = "static"
meson.configure(source_folder=self._source_subfolder,
build_folder=self._build_subfolder)
return meson
def build(self):
if self.options.build_system == "meson":
meson = Meson(self)
meson.configure(build_folder="build")
meson.install()
elif self.options.build_system == "cmake":
cmake = CMake(self, generator="Ninja")
cmake.configure()
cmake.install()
def build(self):
with tools.chdir(self.source_subfolder):
meson = Meson(self)
meson.configure(
defs={'prefix':'%s/builddir/install'%(os.getcwd()), 'libdir':'lib'},
source_dir = '%s'%(os.getcwd()),
build_dir= '%s/builddir'%(os.getcwd()),
)
meson.build(args=['-j2'])
self.run('ninja -C {0} install'.format(meson.build_dir))
def _configure_meson(self):
meson = Meson(self)
defs = {}
defs['introspection'] = 'no'
defs['docs'] = 'false'
defs['x11'] = 'yes' if self.options.with_x11 else 'no'
args=[]
args.append('--wrap-mode=nofallback')
meson.configure(defs=defs, build_folder=self._build_subfolder, source_folder=self._source_subfolder, pkg_config_paths='.', args=args)
return meson
def _configure_meson(self):
meson = Meson(self)
defs = {}
defs['introspection'] = 'false'
defs['docs'] = 'false'
args=[]
args.append('--wrap-mode=nofallback')
args.append('--localedir=%s' % os.path.join(self.package_folder, 'bin', 'share', 'locale'))
meson.configure(defs=defs, build_folder=self._build_subfolder, source_folder=self._source_subfolder, pkg_config_paths='.', args=args)
return meson
def build(self):
definitions = {}
definitions["gallium-drivers"]="swrast"
definitions["llvm"]="enabled"
definitions["shared-llvm"]="disabled"
definitions["llvm-rtti"]="enabled" if self.options["llvm-core"].rtti else "disabled"
meson = Meson(self)
meson.configure(source_folder="mesa-{}".format(self.version), defs=definitions, args=["--debug"])
meson.build()
meson.install()
def build(self):
pcPaths = [
os.path.join(self.deps_cpp_info["gstreamer"].rootpath),
os.path.join(self.deps_cpp_info["gst-plugins-base"].rootpath)
]
meson = Meson(self)
meson.configure(source_folder=self.name,
build_folder="build",
pkg_config_paths=pcPaths)
meson.build()
def build(self):
meson = Meson(self)
# conan is shadowing these meson parameters...
args = []
# args = ['-Db_coverage=true']
# args = ['-Db_coverage=true', '-Db_sanitize=address']
options = {'warning_level': 3, 'cpp_std': 'c++1z'}
meson.configure(args=args, defs=options)
meson.build()
def build(self):
tools.os.environ.update({
'BOOST_INCLUDEDIR':
self.deps_cpp_info['boost'].include_paths[0],
'BOOST_LIBRARYDIR':
self.deps_cpp_info['boost'].lib_paths[0]
})
meson = Meson(self)
meson.configure(build_folder='build')
meson.build()
def build(self):
args = ["--auto-features=disabled"]
args.append("-Dvideoparsers=" +
("enabled" if self.options.videoparsers else "disabled"))
args.append("-Dgl=" + ("enabled" if self.options.gl else "disabled"))
args.append("-Dpnm=" + ("enabled" if self.options.pnm else "disabled"))
args.append("-Dwebrtc=" +
("enabled" if self.options.webrtc else "disabled"))
args.append("-Dsrtp=" +
("enabled" if self.options.srtp else "disabled"))
args.append("-Drtmp2=" +
("enabled" if self.options.rtmp2 else "disabled"))
args.append("-Ddtls=" +
("enabled" if self.options.srtp else "disabled"))
args.append("-Dmpegtsmux=" +
("enabled" if self.options.mpegtsmux else "disabled"))
args.append("-Dmpegtsdemux=" +
("enabled" if self.options.mpegtsdemux else "disabled"))
args.append("-Ddebugutils=" +
("enabled" if self.options.debugutils else "disabled"))
args.append("-Dopencv=" +
("enabled" if self.options.opencv else "disabled"))
args.append("-Dclosedcaption=" +
("enabled" if self.options.closedcaption else "disabled"))
args.append("-Dinter=" +
("enabled" if self.options.inter else "disabled"))
use_cuda = self.options.nvdec or self.options.nvenc or self.options.nvcodec
if self.settings.arch == "x86_64":
args.append("-Dnvdec=" +
("enabled" if self.options.nvdec else "disabled"))
args.append("-Dnvenc=" +
("enabled" if self.options.nvenc else "disabled"))
if self.version == "master":
args.append("-Dnvcodec=" + (
"enabled" if self.options.nvcodec else "disabled"))
meson = Meson(self)
if use_cuda:
with tools.environment_append({
"CUDA_PATH":
self.deps_user_info["cuda_dev_config"].cuda_root
}):
meson.configure(
source_folder="gst-plugins-bad-%s" % self.version,
args=args,
pkg_config_paths=os.environ["PKG_CONFIG_PATH"].split(":"))
else:
meson.configure(
source_folder="gst-plugins-bad-%s" % self.version,
args=args,
pkg_config_paths=os.environ["PKG_CONFIG_PATH"].split(":"))
meson.build()
meson.install()
def _build_with_meson(self):
if self.options["qt"].shared and not tools.cross_building(self.settings) and not tools.os_info.is_macos:
self.output.info("Building with Meson")
tools.mkdir("meson_folder")
with tools.environment_append(RunEnvironment(self).vars):
meson = Meson(self)
try:
meson.configure(build_folder="meson_folder", defs={"cpp_std": "c++11"})
except ConanException:
self.output.info(open("meson_folder/meson-logs/meson-log.txt", 'r').read())
raise
meson.build()
def build(self):
meson = Meson(self)
meson.configure(cache_build_folder="build")
meson.build()
def build(self):
meson = Meson(self)
meson.configure()
meson.build()
