# -*- Mode: Python -*- vi:si:et:sw=4:sts=4:ts=4:syntax=python from custom import GStreamer from cerbero.errors import FatalError from cerbero.utils import messages as m from cerbero.utils import shell, determine_num_cargo_jobs, determine_total_ram from pathlib import Path import re import shutil import tempfile class Recipe(recipe.Recipe): name = 'gst-plugins-rs' version = '0.12.9' stype = SourceType.GIT remotes = {'origin': 'https://gitlab.freedesktop.org/gstreamer/%(name)s.git'} if GStreamer.tagged_for_release: commit = f'gstreamer-{GStreamer.version}' else: commit = 'origin/0.12' # Each plugin uses one or more of these licenses. licenses = [{ License.Apachev2: ['LICENSE-APACHE'], License.MIT: ['LICENSE-MIT'], License.LGPLv2_1Plus: None, }] btype = BuildType.CARGO_C cargo_packages = [ 'audiofx', 'aws', 'cdg', 'claxon', 'closedcaption', 'dav1d', 'fallbackswitch', 'ffv1', 'fmp4', 'gif', 'hlssink3', 'hsv', 'inter', 'json', 'livesync', 'lewton', 'mp4', 'ndi', 'onvif', 'rav1e', 'regex', 'reqwest', 'raptorq', 'png', 'rtp', 'rtsp', 'textahead', 'textwrap', 'threadshare', 'togglerecord', 'tracers', 'uriplaylistbin', 'videofx', 'webrtc', 'webrtchttp', ] # If the system has less than 8GB ram or less than 4 cores, # block parallelism at both recipe and architectural level. if determine_num_cargo_jobs() == 1: allow_parallel_build = False allow_universal_parallel_build = False elif determine_total_ram() <= (32 << 30): # gst-plugins-rs peaks at ~17GB per architectural build. # Let's assume that > 32GB is enough, but that can be upped # afterwards. Currently a 32GB box freezes when trying the # universal build, as soon as it reaches the gstrswebrtc and # gstaws crates. allow_universal_parallel_build = False # Needed for openssl use_system_libs = True deps = ['gstreamer-1.0', 'gst-plugins-base-1.0', 'pango', 'cairo', 'gst-plugins-bad-1.0', 'dav1d'] def enable_plugin(self, name, category): if self.library_type in (LibraryType.SHARED, LibraryType.BOTH): attr = f'files_plugins_{category}' if not hasattr(self, attr): setattr(self, attr, []) self.update_categories() f = getattr(self, attr) f += [f'%(libdir)s/gstreamer-1.0/libgst{name}%(mext)s'] if self.library_type in (LibraryType.STATIC, LibraryType.BOTH): attr = f'files_plugins_{category}_devel' if not hasattr(self, attr): setattr(self, attr, []) d = getattr(self, attr) d += [ f'%(libdir)s/gstreamer-1.0/libgst{name}.a', f'%(libdir)s/gstreamer-1.0/libgst{name}.la', ] def prepare(self): if self.config.target_platform in (Platform.IOS, Platform.ANDROID): self.library_type = LibraryType.STATIC else: self.library_type = LibraryType.BOTH if self.config.target_platform != Platform.LINUX or self.config.cross_compiling(): self.deps.append('openssl') plugin_files = { 'core': ['fallbackswitch', 'livesync', 'rsinter', 'rstracers', 'threadshare', 'togglerecord'], 'net': ['aws', 'hlssink3', 'ndi', 'rsonvif', 'raptorq', 'reqwest', 'rsrtp', 'rsrtsp', 'webrtchttp', 'rswebrtc'], 'effects': ['rsaudiofx', 'rsvideofx'], 'codecs': ['cdg', 'claxon', 'dav1d', 'rsclosedcaption', 'ffv1', 'fmp4', 'mp4', 'gif', 'hsv', 'lewton', 'rav1e', 'json', 'rspng', 'regex', 'textwrap', 'textahead'], 'playback': ['uriplaylistbin'], } for category, names in plugin_files.items(): for name in names: self.enable_plugin(name, category) self.cargo_packages = [f'gst-plugin-{pkg}' for pkg in self.cargo_packages] # Build with Cerbero's latest glib version as minimum version self.cargo_features += ['glib/v2_74', 'gio/v2_74'] # Enable assembly optimizations via nasm self.cargo_features.append('gst-plugin-rav1e/asm') # Build with the current GStreamer version as minimum version components = ('', '-app', '-audio', '-base', '-check', '-net', '-pbutils', '-plugin-tracers', '-rtp', '-sdp', '-utils', '-video', '-webrtc') for each in components: self.cargo_features.append(f'gst{each}/v1_22') self.cargo_features.append('gst-plugin-webrtc/v1_22') async def configure(self): # Check that the Cargo.toml version matches the recipe version toml_version = self.get_cargo_toml_version() if toml_version != self.version: msg = f'{self.name} version {self.version} doesn\'t match Cargo.toml version {toml_version}' if GStreamer.tagged_for_release: raise FatalError(msg) else: m.warning(msg) await super().configure() def post_install(self): # Cargo-C currently can't install pc files into custom dirs, so we need # to move these plugin pkgconfig files to the right place. for f in self.files_list_by_category(self.DEVEL_CAT): if not f.endswith('.pc') or not 'gstreamer-1.0' in f: continue name = os.path.basename(f) src = os.path.join(self.config.libdir, 'pkgconfig', name) dst = os.path.join(self.config.prefix, f) if os.path.exists(src): shutil.copy(src, dst) # Cargo-C names MinGW DLLs as foo.dll instead of libfoo.dll # https://github.com/lu-zero/cargo-c/issues/280 # It also follows MSVC convention for static/import libraries if self.using_msvc(): for f in self.files_list_by_category(self.DEVEL_CAT): if not f.endswith('.a'): continue dst = Path(self.config.prefix) / f src = dst.with_name(f'{dst.stem[3:]}.lib') if src.exists(): shutil.copy(src, dst) else: for f in self.dist_files_list(): if not f.endswith('.dll'): continue name = os.path.basename(f) d = os.path.dirname(f) src = os.path.join(self.config.prefix, d, f'{name[3:]}') dst = os.path.join(self.config.prefix, f) if os.path.exists(src): shutil.copy(src, dst) # if there's a .dll.a it also needs renaming if os.path.exists(src + '.a'): shutil.copy(src + '.a', dst + '.a') libraries = [f for f in self.devel_files_list() if f.endswith('.a')] for f in libraries: if self.config.target_platform in (Platform.IOS, Platform.DARWIN): # Apple wants you to do Single-Object Prelink source = Path(self.config.prefix) / f # Only global symbols # Only symbol names # Use portable output format # Skip undefined symbols # Write pathname of the object file manifest = shell.check_output( [self.get_llvm_tool("llvm-nm"), "-gjPUA", source.absolute()], env=self.env, ) # Now we need to match the symbols to the pattern # Here's the catch: Apple strip is silly enough to be unable to # -undefined suppress a .o because of the -two_level_namespace being # the default post-10.1. So we need to determine which objects have # matching symbols. The rest can be safely stripped. # The symbol listing format is as follows: #  ./libgstrswebrtc.a[gstrswebrtc-3a8116aacab254c2.2u9b7sba8k2fvc9v.rcgu.o]: _gst_plugin_rswebrtc_get_desc T 500 0 # Field 1 has the object name between brackets. # Field 2 is the symbol name. symbol_pattern = re.compile('_gst_plugin_*') with tempfile.TemporaryDirectory(prefix='cerbero', dir=self.config.home_dir) as tmp: # List those symbols that will be kept symbols_to_keep = set() for line in manifest.splitlines(): data = line.split(sep=" ") symbol = data[1] if symbol_pattern.match(symbol): symbols_to_keep.add(symbol) module = ( Path(tmp) / source.name).with_suffix('.symbols') with module.open('w', encoding='utf-8') as f: f.write('# Stripped by Cerbero\n') for symbol in symbols_to_keep: f.write(f'{symbol}\n') m.log( f"Symbols to preserve in {source.absolute()}:", self.logfile ) for symbol in symbols_to_keep: m.log(f"\t{symbol}", self.logfile) # Unpack archive m.log(f"Unpacking {source.absolute()} with ar", self.logfile) shell.new_call( [shutil.which('ar'), 'xv', source.absolute()], cmd_dir=tmp, logfile=self.logfile) # Now everything is flat in the pwd m.log("Performing Single-Object Prelinking", self.logfile) prelinked_obj = ( Path(tmp) / source.name).with_suffix('.prelinked.o') ld = shutil.which("ld") if ld is None: raise FatalError(f'ld not found') # DO NOT split this into an array unless # you wrap this into a 'sh -c' call. # It needs the glob to be parsed by the shell! shell.new_call( ' '.join([ ld, "-r", "-exported_symbols_list", str(module.absolute()), "-o", str(prelinked_obj.absolute()), "*.o", ]), cmd_dir=tmp, logfile=self.logfile, ) # With the stripping done, all files now need to be rearchived dest = Path(tmp) / source.name m.log(f"Repacking library to {dest.absolute()}", self.logfile) libtool = shutil.which("libtool") if libtool is None: raise FatalError(f'libtool not found') shell.new_call([ libtool, "-static", prelinked_obj.absolute(), "-o", dest.absolute(), ], cmd_dir=tmp, logfile=self.logfile, ) # And now we paper over os.replace(dest.absolute(), source.absolute()) elif self.config.target_platform in (Platform.LINUX, Platform.ANDROID): # This is a very similar approach, however Clang # will itself do a really bad job if one supplies # a LD version script -- that'll suppress 99% of # the things needed for a working .o file. # The result, just like using # `strip --wildcard --keep-symbol=gst_plugin_*`, # is a .o that has all the symbols you want, but # placeholders/duds/broken references for all unfortunate # .rodata symbols referenced in the exported functions. # # See https://maskray.me/blog/2022-11-21-relocatable-linking source = Path(self.config.prefix) / f with tempfile.TemporaryDirectory(prefix='cerbero', dir=self.config.home_dir) as tmp: # Unpack archive m.log(f"Unpacking {source.absolute()} with ar", self.logfile) if self.config.target_platform == Platform.ANDROID: ar = shutil.which('llvm-ar', path=self.config.env['ANDROID_NDK_TOOLCHAIN_BIN']) else: ar = shutil.which('llvm-ar') if not ar: ar = shutil.which('ar') if ar is None: raise FatalError('ar not found') shell.new_call( [ar, 'xv', source.absolute()], cmd_dir=tmp, logfile=self.logfile) # Now everything is flat in the pwd m.log("Performing Single-Object Prelinking", self.logfile) prelinked_obj = ( Path(tmp) / source.name).with_suffix('.prelinked.o') if self.config.target_platform == Platform.ANDROID: ld = shutil.which("ld.lld", path=self.config.env['ANDROID_NDK_TOOLCHAIN_BIN']) else: ld = shutil.which('ld') if ld is None: raise FatalError('ld not found') # DO NOT split this into an array unless # you wrap this into a 'sh -c' call. # It needs the glob to be parsed by the shell! shell.new_call( ' '.join([ ld, "--relocatable", "--export-dynamic-symbol=gst_plugin_*", "-o", str(prelinked_obj.absolute()), "*.o", ]), cmd_dir=tmp, logfile=self.logfile, ) # WE ARE NOT DONE! ld.lld merged all the files, # stripping those not referenced in the dynamic symbol # glob, but we still need to hide all the Rust cruft. if self.config.target_platform == Platform.ANDROID: objcopy = shutil.which("llvm-objcopy", path=self.config.env['ANDROID_NDK_TOOLCHAIN_BIN']) else: objcopy = shutil.which("llvm-objcopy") if objcopy is None: objcopy = shutil.which("objcopy") if objcopy is None: raise FatalError('objcopy not found') shell.new_call( [ objcopy, "--wildcard", "--keep-global-symbol=gst_plugin_*", prelinked_obj.absolute(), ], cmd_dir=tmp, logfile=self.logfile, ) # With the stripping (really) done, all files now need to be rearchived dest = Path(tmp) / source.name m.log(f"Repacking library to {dest.absolute()}", self.logfile) shell.new_call( [ ar, 'rs', dest.absolute(), prelinked_obj.absolute() ], cmd_dir=tmp, logfile=self.logfile ) # And now we paper over os.replace(dest.absolute(), source.absolute()) super().post_install()