Add libaom to libheif build

Reviewed-on: https://git.onlyoffice.com/ONLYOFFICE/build_tools/pulls/158

linux-start.sh

@@ -0,0 +1,66 @@
+sudo apt-get install git curl wget p7zip-full
+
+sudo apt-get install git-lfs
+# for old system (ubuntu 16)
+#curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
+#sudo apt-get install git-lfs
+
+# save login
+git config --global credential.helper store
+
+# clone build_tools
+git clone https://git.onlyoffice.com/ONLYOFFICE/build_tools.git
+
+# deps =========================================
+
+cd ./build_tools/tools/linux
+
+# python 3.10
+./python.sh
+
+# qt
+#./python3/bin/python3 ./qt_binary_fetch.py amd64
+#./python3/bin/python3 ./qt_binary_fetch.py arm64
+./python3/bin/python3 ./qt_binary_fetch.py all
+
+# deps
+./python3/bin/python3 ./deps.py
+
+# cmake 3.30
+sudo ./cmake.sh
+
+cd ../../
+
+# ==============================================
+
+# sysroots (IF NEEDED) =========================
+
+cd ./build_tools/tools/linux/sysroot
+#./python3/bin/python3 ./fetch.py amd64
+#./python3/bin/python3 ./fetch.py arm64
+./../python3/bin/python3 ./fetch.py all
+cd ../../../
+
+# ==============================================
+
+
+# configure ====================================
+
+./tools/linux/python3/bin/python3 ./configure.py --clean "0" --update-light "1" --update "1" --branch "hotfix/v9.2.1" --module "desktop" --qt-dir "$(pwd)/tools/linux/qt_build/Qt-5.9.9"
+
+# with sysroot: sysroot "1"
+
+# ==============================================
+
+# cross build linux_arm64
+sudo apt install qemu-user qemu-user-static binfmt-support
+sudo update-binfmts --enable qemu-aarch64
+
+# 1) without sysroot
+#sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
+#sudo dpkg --add-architecture arm64
+#sudo apt update
+#... install all dev packages ...
+
+# 2) official supported: with sysroot
+./tools/linux/python3/bin/python3 ./configure.py sysroot "1" #...

make.py

@@ -91,8 +91,6 @@ if config.check_option("module", "desktop"):
     config.extend_option("config", "updmodule")
     base.set_env("DESKTOP_URL_UPDATES_MAIN_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/appcast.json")
     base.set_env("DESKTOP_URL_UPDATES_DEV_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/appcastdev.json")
-    base.set_env("DESKTOP_URL_INSTALL_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/distrib/onlyoffice/<file>")
-    base.set_env("DESKTOP_URL_INSTALL_DEV_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/onlineinstallerdev/<file>")
 
 # build
 build_sln.make()

scripts/base.py

@@ -433,11 +433,46 @@ def cmd_in_dir(directory, prog, args=[], is_no_errors=False):
   return ret
 
 def cmd_in_dir_qemu(platform, directory, prog, args=[], is_no_errors=False):
-  if (platform == "linux_arm64"):
-    return cmd_in_dir(directory, "qemu-aarch64", ["-L", "/usr/aarch64-linux-gnu", prog] + args, is_no_errors)
-  if (platform == "linux_arm32"):
-    return cmd_in_dir(directory, "qemu-arm", ["-L", "/usr/arm-linux-gnueabi", prog] + args, is_no_errors)
-  return 0
+  platform_config = {
+    "linux_arm64": {
+      "qemu": "qemu-aarch64",
+      "default_libs": "/usr/aarch64-linux-gnu"
+    },
+    "linux_arm32": {
+      "qemu": "qemu-arm",
+      "default_libs": "/usr/arm-linux-gnueabi"
+    }
+  }
+  
+  if platform not in platform_config:
+    return 0
+
+  libs_path = platform_config[platform]["default_libs"]
+  if config.option("sysroot") != "":
+    libs_path = config.option("sysroot_" + platform)
+  
+  return cmd_in_dir(directory, platform_config[platform]["qemu"], ["-L", libs_path, prog] + args, is_no_errors)
+
+def create_qemu_wrapper(binary_path, platform):
+  binary_dir = os.path.dirname(binary_path)
+  binary_name = os.path.basename(binary_path)
+  binary_bin = binary_path + '.bin'
+  sysroot = config.option("sysroot_" + platform)
+  
+  if os.path.exists(binary_path):
+    os.rename(binary_path, binary_bin)
+  
+  wrapper_content = f'''#!/bin/bash
+DIR="$(cd "$(dirname "${{BASH_SOURCE[0]}}")" && pwd)"
+export QEMU_LD_PREFIX={sysroot}
+exec qemu-aarch64 -L {sysroot} "$DIR/{binary_name}.bin" "$@"
+'''
+  
+  with open(binary_path, 'w') as f:
+    f.write(wrapper_content)
+  
+  os.chmod(binary_path, 0o755)
+  return binary_bin
 
 def cmd_and_return_cwd(prog, args=[], is_no_errors=False):
   cur_dir = os.getcwd()
@@ -691,13 +726,19 @@ def git_dir():
   if ("windows" == host_platform()):
     return run_command("git --info-path")['stdout'] + "/../../.."
 
-def get_prefix_cross_compiler_arm64():
-  directory = config.option("arm64-toolchain-bin")
-  if is_file(directory + "/aarch64-linux-gnu-g++") and is_file(directory + "/aarch64-linux-gnu-gcc"):
-    return "aarch64-linux-gnu-"
-  if is_file(directory + "/aarch64-unknown-linux-gnu-g++") and is_file(directory + "/aarch64-unknown-linux-gnu-gcc"):
-    return "aarch64-unknown-linux-gnu-"
-  return ""
+def get_compiler_gcc_prefix(platform):
+  directory = "/usr/bin"
+
+  if config.option("sysroot") != "":
+    use_platform = platform
+    if ("linux_arm64" == platform and not is_os_arm()):
+      use_platform = "linux_64"
+    directory = config.option("sysroot_" + use_platform) + "/usr/bin"
+
+  if ("linux_arm64" == platform and not is_os_arm()):
+    return directory + "/aarch64-linux-gnu-"
+
+  return directory + "/"
 
 def get_gcc_version():
   # if use sysroot - fix gcc version
@@ -753,13 +794,6 @@ def qt_setup(platform):
       set_env("QT_QMAKE_ADDON", "-spec win32-arm64-msvc2017")
 
   set_env("QT_DEPLOY", qt_dir + "/bin")
-
-  if ("linux_arm64" == platform):
-    cross_compiler_arm64 = config.option("arm64-toolchain-bin")
-    if ("" != cross_compiler_arm64):
-      set_env("ARM64_TOOLCHAIN_BIN", cross_compiler_arm64)
-      set_env("ARM64_TOOLCHAIN_BIN_PREFIX", get_prefix_cross_compiler_arm64())
-
   return qt_dir
 
 def qt_version():
@@ -900,14 +934,16 @@ def qt_copy_lib(lib, dir):
 def _check_icu_common(dir, out):
   isExist = False
   for file in glob.glob(dir + "/libicu*"):
-    isExist = True
-    break
-
+    # Skip static libraries
+    if not file.endswith('.a'):
+      isExist = True
+      break
   if isExist:
-    copy_files(dir + "/libicui18n*", out)
-    copy_files(dir + "/libicuuc*", out)
-    copy_files(dir + "/libicudata*", out)
-
+    # Copy only shared libraries (skip .a files)
+    for pattern in ["/libicui18n*", "/libicuuc*", "/libicudata*"]:
+      for file in glob.glob(dir + pattern):
+        if not file.endswith('.a'):
+          copy_file(file, out)
   return isExist
 
 def qt_copy_icu(out, platform):
@@ -1355,7 +1391,8 @@ def mac_correct_rpath_x2t(dir):
   mac_correct_rpath_library("OFDFile", ["UnicodeConverter", "kernel", "graphics", "PdfFile"])
   mac_correct_rpath_library("DocxRenderer", ["UnicodeConverter", "kernel", "graphics"])
   mac_correct_rpath_library("IWorkFile", ["UnicodeConverter", "kernel"])
-  mac_correct_rpath_library("HWPFile", ["UnicodeConverter", "kernel", "graphics"])
+  mac_correct_rpath_library("HWPFile", ["UnicodeConverter", "kernel", "graphics", "StarMathConverter"])
+  mac_correct_rpath_library("StarMathConverter", ["kernel"])
 
   def correct_core_executable(name, libs):
     cmd("chmod", ["-v", "+x", name])
@@ -1363,7 +1400,7 @@ def mac_correct_rpath_x2t(dir):
     mac_correct_rpath_binary(name, mac_icu_libs + libs)
     return
 
-  correct_core_executable("x2t", ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile"])
+  correct_core_executable("x2t", ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile", "StarMathConverter"])
   if is_file("./allfontsgen"):
     correct_core_executable("allfontsgen", ["UnicodeConverter", "kernel", "graphics"])
   if is_file("./allthemesgen"):
@@ -1670,6 +1707,9 @@ def replaceFileLicence(path, license):
 def copy_v8_files(core_dir, deploy_dir, platform, is_xp=False):
   if (-1 != config.option("config").find("use_javascript_core")):
     return
+  if (0 == platform.find("mac")) and not (config.check_option("config", "use_v8")):
+    return
+
   directory_v8 = core_dir + "/Common/3dParty"
 
   if is_xp:
@@ -1896,22 +1936,35 @@ def check_module_version(actual_version, clear_func):
 def set_sysroot_env(platform):
   global ENV_BEFORE_SYSROOT
   ENV_BEFORE_SYSROOT = dict(os.environ)
+
   if "linux" != host_platform():
     return
+  if config.option("sysroot") == "":
+    return
+
   path = config.option("sysroot_" + platform)
-  if path != "":
-    os.environ['PATH'] = path + "/usr/bin:" + get_env("PATH")
-    os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib(platform)
-    os.environ['CC'] = config.get_custom_sysroot_bin(platform) + "/gcc"
-    os.environ['CXX'] = config.get_custom_sysroot_bin(platform) + "/g++"
-    os.environ['CFLAGS'] = "--sysroot=" + path
-    os.environ['CXXFLAGS'] = "--sysroot=" + path
-    check_python()
-    
+  sysroot_path_bin = config.get_custom_sysroot_bin(platform)
+  compiler_gcc_prefix = get_compiler_gcc_prefix(platform)
+  
+  os.environ['PATH'] = sysroot_path_bin + ":" + get_env("PATH")
+  os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib(platform)
+
+  os.environ['CC'] = compiler_gcc_prefix + "gcc"
+  os.environ['CXX'] = compiler_gcc_prefix + "g++"
+  os.environ['AR'] = compiler_gcc_prefix + "ar"
+  os.environ['RANLIB'] = compiler_gcc_prefix + "ranlib"
+  
+  os.environ['CFLAGS'] = "--sysroot=" + path
+  os.environ['CXXFLAGS'] = "--sysroot=" + path
+  os.environ['LDFLAGS'] = "--sysroot=" + path
+
+  check_python()
+  return
+
 def restore_sysroot_env():
   os.environ.clear()
   os.environ.update(ENV_BEFORE_SYSROOT)
-    
+
 def check_python():
   if ("linux" != host_platform()):
     return
@@ -2000,7 +2053,7 @@ def create_artifacts_qemu_win_arm():
   if config.option("qemu-win-arm64-dir") == "":
     print("For deploying win_arm64 on non arm host you should provide qemu-win-arm64-dir. More info in tools/win/qemu/README.md")
     return
-    
+
   old_curr_dir = os.path.abspath(os.curdir)
   qemu_dir = os.path.abspath(config.option("qemu-win-arm64-dir"))
 
@@ -2015,7 +2068,7 @@ def create_x2t_js_cache(dir, product, platform):
     doctrenderer_lib = "libdoctrenderer.dylib" if is_file(dir + "/libdoctrenderer.dylib") else "doctrenderer.framework/doctrenderer"
     if os.path.getsize(dir + "/" + doctrenderer_lib) < 5*1024*1024:
       return
-  
+
   if ((platform == "linux_arm64") and not is_os_arm()):
     cmd_in_dir_qemu(platform, dir, "./x2t", ["-create-js-snapshots"], True)
     return

scripts/config.py

@@ -90,7 +90,7 @@ def parse():
       dst_dir_amd64 = dst_dir + "/ubuntu16-amd64-sysroot"
       dst_dir_arm64 = dst_dir + "/ubuntu16-arm64-sysroot"
       if not base.is_dir(dst_dir_amd64) or not base.is_dir(dst_dir_arm64):
-        base.cmd_in_dir(dst_dir, "python3", ["./fetch.py"])
+        base.cmd_in_dir(dst_dir, "python3", ["./fetch.py", "all"])
       options["sysroot_linux_64"] = dst_dir_amd64
       options["sysroot_linux_arm64"] = dst_dir_arm64
     else:
@@ -125,11 +125,6 @@ def parse():
   if not "sdkjs-plugin-server" in options:
     options["sdkjs-plugin-server"] = "default"
 
-  if not "arm64-toolchain-bin" in options and not "sysroot" in options:
-    options["arm64-toolchain-bin"] = "/usr/bin"
-  else:
-    options["arm64-toolchain-bin"] = get_custom_sysroot_bin("linux_arm64")
-
   if check_option("platform", "ios"):
     if not check_option("config", "no_bundle_xcframeworks"):
       if not check_option("config", "bundle_xcframeworks"):
@@ -230,12 +225,22 @@ def is_mobile_platform():
   return False
 
 def get_custom_sysroot_bin(platform):
-  return option("sysroot_" + platform) + "/usr/bin"
+  use_platform = platform
+  if "linux_arm64" == platform and not base.is_os_arm():
+    # use cross compiler
+    use_platform = "linux_64"
 
-def get_custom_sysroot_lib(platform):
-  if ("linux_64" == platform):
+  return option("sysroot_" + use_platform) + "/usr/bin"
+
+def get_custom_sysroot_lib(platform, isNatural=False):
+  use_platform = platform
+  if "linux_arm64" == platform and not base.is_os_arm() and not isNatural:
+    # use cross compiler
+    use_platform = "linux_64"
+
+  if ("linux_64" == use_platform):
     return option("sysroot_linux_64") + "/usr/lib/x86_64-linux-gnu"
-  if ("linux_arm64" == platform):
+  if ("linux_arm64" == use_platform):
     return option("sysroot_linux_arm64") + "/usr/lib/aarch64-linux-gnu"
   return ""
 

scripts/core_common/modules/boost.py

@@ -138,14 +138,14 @@ def make():
   if (-1 != config.option("platform").find("android")) and not base.is_dir("../build/android"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"])
 
-  if (-1 != config.option("platform").find("mac")) and not base.is_dir("../build/mac_64"):
+  if config.check_option("platform", "mac_64") and not base.is_dir("../build/mac_64"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"], "mac_64")
     directory_build = base_dir + "/build/mac_64/lib"
     base.delete_file(directory_build + "/libboost_system.a")
     base.delete_file(directory_build + "/libboost_system.dylib")
     base.copy_files(directory_build + "/mac_64/*.a", directory_build)
 
-  if (-1 != config.option("platform").find("mac_arm64")) and not base.is_dir("../build/mac_arm64"):
+  if config.check_option("platform", "mac_arm64") and not base.is_dir("../build/mac_arm64"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"], "mac_arm64")
     directory_build = base_dir + "/build/mac_arm64/lib"
     base.delete_file(directory_build + "/libboost_system.a")

scripts/core_common/modules/boost_qt.py

@@ -14,19 +14,8 @@ def make(src_dir, modules, build_platform="android", qmake_addon=""):
 
   print("boost-headers...")
   
-  # for b2 checks
-  if config.option("sysroot") != "":
-    base.set_sysroot_env(build_platform)
-    sysroot_path = config.option("sysroot_" + build_platform)
-    b2_addon = "cflags=\"--sysroot=" + sysroot_path + "\""
-    b2_addon = "cxxflags=\"--sysroot=" + sysroot_path + "\""
-    b2_addon = "linkflags=\"--sysroot=" + sysroot_path + "\""
-    
-  base.cmd("./bootstrap.sh", ["--with-libraries=system"])   
-  base.cmd("./b2", ["--prefix=./../build/" + build_platform, "headers", "install", b2_addon])
-  
-  if config.option("sysroot") != "":
-    base.restore_sysroot_env()
+  base.cmd("./bootstrap.sh", ["--with-libraries=system"]) 
+  base.cmd("./b2", ["--prefix=./../build/" + build_platform, "headers", "install"])
   
   for module in modules:
     print("boost-module: " + module + " ...")

scripts/core_common/modules/cef.py

@@ -21,7 +21,7 @@ def make():
   os.chdir(base_dir)
 
   base.check_module_version("2", clear_module)
-  platforms = ["win_64", "win_32", "win_64_xp", "win_32_xp", "linux_64", "linux_32", "mac_64", "mac_arm64", "win_arm64"]
+  platforms = ["win_64", "win_32", "win_64_xp", "win_32_xp", "linux_64", "linux_32", "mac_64", "mac_arm64", "win_arm64", "linux_arm64"]
 
   for platform in platforms:
     if not config.check_option("platform", platform):

scripts/core_common/modules/heif.py

@@ -10,6 +10,7 @@ import config
 # libs versions
 X265_VERSION = "4.1"
 DE265_VERSION = "1.0.16"
+AOM_VERSION = "3.12.0"
 # 1.18.2 - the latest version of libheif supporting C++11 builds (as for now)
 HEIF_VERSION = "1.18.2"
 
@@ -26,30 +27,6 @@ LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/s
 
 OLD_ENV = dict()
 
-# get custom sysroot vars as str
-def setup_custom_sysroot_env(platform) -> str:
-  sysroot_path = config.option("sysroot_" + platform)
-  sysroot_path_bin = config.get_custom_sysroot_bin(platform)
-
-  env_vars = []
-  env_vars += ['LD_LIBRARY_PATH=\"' + config.get_custom_sysroot_lib(platform) + "\""]
-  env_vars += ['PATH=\"' + sysroot_path + "/usr/bin:" + base.get_env("PATH") + "\""]
-
-  env_vars += ['CC=\"'     + sysroot_path_bin + "/gcc\""]
-  env_vars += ['CXX=\"'    + sysroot_path_bin + "/g++\""]
-  env_vars += ['AR=\"'     + sysroot_path_bin + "/ar\""]
-  env_vars += ['RABLIB=\"' + sysroot_path_bin + "/ranlib\""]
-
-  env_vars += ['CFLAGS=\"'   + "--sysroot=" + sysroot_path + "\""]
-  env_vars += ['CXXFLAGS=\"' + "--sysroot=" + sysroot_path + "\""]
-  env_vars += ['LDFLAGS=\"'  + "--sysroot=" + sysroot_path + "\""]
-
-  env_str = ""
-  for env_var in env_vars:
-    env_str += env_var + " "
-
-  return env_str
-
 def get_vs_version():
   vs_version = "14 2015"
   if config.option("vs-version") == "2019":
@@ -132,16 +109,20 @@ def build_with_cmake(platform, cmake_args, build_type):
       cmake_args_ext += get_cmake_args_android("x86_64", "21")
 
   # env setup for custom sysroot
-  env_str = setup_custom_sysroot_env(platform) if config.option("sysroot") != "" else ""
+  if config.option("sysroot") != "":
+    base.set_sysroot_env("linux_arm64")
 
   # run cmake
-  base.cmd(env_str + "cmake", cmake_args + cmake_args_ext)
+  base.cmd("cmake", cmake_args + cmake_args_ext)
 
   # build
   if "Unix Makefiles" in cmake_args_ext:
-    base.cmd(env_str + "make", ["-j4"])
+    base.cmd("make", ["-j4"])
   else:
     base.cmd("cmake", ["--build", ".", "--config", build_type])
+
+  if config.option("sysroot") != "":
+    base.restore_sysroot_env()
   return
 
 # general make function that calls `build_func` callback for configured platform(s) with specified cmake arguments
@@ -299,6 +280,52 @@ def make_de265(base_dir, build_type):
   make_common(build_de265, cmake_args)
   return
 
+def make_aom(base_dir, build_type):
+  # fetch lib repo
+  if not base.is_dir("aom"):
+    fetch_repo("https://aomedia.googlesource.com/aom", f"v{AOM_VERSION}")
+
+  # prepare cmake args
+  cmake_dir = base_dir + "/aom"
+  cmake_args = [
+    cmake_dir,
+    "-DCMAKE_BUILD_TYPE=" + build_type,
+    "-DBUILD_SHARED_LIBS=OFF",            # do not build shared libs
+    "-DENABLE_SDL=OFF",                   # disable SDL
+    "-DENABLE_DECODER=ON",                # enable AOM V1 decoder (for AVIF image format)
+    "-DENABLE_ENCODER=ON",                # enable AOM V1 encoder (for AVIF image format)
+    "-DENABLE_TESTS=OFF",                 # do not build tests
+    "-DENABLE_DOCS=OFF",                  # do not build docs
+    "-DENABLE_EXAMPLES=OFF",              # do not build examples
+    "-DENABLE_TOOLS=OFF",                 # do not build lib tools
+  ]
+
+  # lib build function
+  def build_aom(platform, cmake_args):
+    # check if target lib has already been built
+    build_dir = get_build_dir(base_dir, "aom", platform, build_type)
+    if platform.find("win") != -1:
+      target_lib = os.path.join(build_dir, build_type, "aom.lib")
+    else:
+      target_lib = os.path.join(build_dir, "aom.a")
+    if base.is_file(target_lib):
+      return
+    # go to the build directory
+    base.create_dir(build_dir)
+    os.chdir(build_dir)
+    # run build
+    build_with_cmake(platform, cmake_args, build_type)
+    # for ios copy target library from the default build path
+    if platform.find("ios") != -1:
+      xcode_sdk = get_xcode_sdk(platform)
+      base.copy_file(f"/{build_type}-{xcode_sdk}/aom.a", build_dir)
+    # reset directory
+    os.chdir(base_dir)
+    return
+  
+  make_common(build_aom, cmake_args)
+  return
+
 def make_heif(base_dir, build_type):
   # fetch lib repo
   if not base.is_dir("libheif"):
@@ -323,8 +350,8 @@ def make_heif(base_dir, build_type):
     "-DCMAKE_BUILD_TYPE=" + build_type,
     "-DBUILD_SHARED_LIBS=OFF",                        # do not build shared libs
     "-DWITH_LIBSHARPYUV=OFF",                         # do not build libsharpyuv (for RGB <--> YUV color space conversions)
-    "-DWITH_AOM_DECODER=OFF",                         # do not build AOM V1 decoder (for AVIF image format)
-    "-DWITH_AOM_ENCODER=OFF",                         # do not build AOM V1 encoder (for AVIF image format)
+    "-DWITH_AOM_DECODER=ON",                          # enable AOM V1 decoder (for AVIF image format)
+    "-DWITH_AOM_ENCODER=ON",                          # enable AOM V1 encoder (for AVIF image format)
     "-DWITH_GDK_PIXBUF=OFF",                          # do not build gdk-pixbuf plugin (UNIX only)
     "-DWITH_GNOME=OFF",                               # do not build gnome plugin (Linux only)
     "-DWITH_EXAMPLES=OFF",                            # do not build examples
@@ -351,19 +378,23 @@ def make_heif(base_dir, build_type):
     # add paths to dependent libraries and includes to cmake args
     de265_build_dir = get_build_dir(base_dir, "libde265", platform, build_type)
     x265_build_dir = get_build_dir(base_dir, "x265_git", platform, build_type)
+    aom_build_dir = get_build_dir(base_dir, "aom", platform, build_type)
     cmake_args_ext = [
       f"-DLIBDE265_INCLUDE_DIR={de265_build_dir}",
-      f"-DX265_INCLUDE_DIR={x265_build_dir}"
+      f"-DX265_INCLUDE_DIR={x265_build_dir}",
+      f"-DAOM_INCLUDE_DIR={base_dir}/aom"
     ]
     if platform.find("win") != -1:
       cmake_args_ext += [
         f"-DLIBDE265_LIBRARY={de265_build_dir}/libde265/{build_type}/libde265.lib",
-        f"-DX265_LIBRARY={x265_build_dir}/{build_type}/x265-static.lib"
+        f"-DX265_LIBRARY={x265_build_dir}/{build_type}/x265-static.lib",
+        f"-DAOM_LIBRARY={aom_build_dir}/{build_type}/aom.lib"
       ]
     else:
       cmake_args_ext += [
         f"-DLIBDE265_LIBRARY={de265_build_dir}/libde265/libde265.a",
-        f"-DX265_LIBRARY={x265_build_dir}/libx265.a"
+        f"-DX265_LIBRARY={x265_build_dir}/libx265.a",
+        f"-DAOM_LIBRARY={aom_build_dir}/aom.a"
       ]
     # run build
     build_with_cmake(platform, cmake_args + cmake_args_ext, build_type)
@@ -379,6 +410,8 @@ def make_heif(base_dir, build_type):
   return
 
 def clear_module():
+  if base.is_dir("aom"):
+    base.delete_dir_with_access_error("aom")
   if base.is_dir("libde265"):
     base.delete_dir_with_access_error("libde265")
   if base.is_dir("x265_git"):
@@ -409,6 +442,8 @@ def make():
   make_x265(base_dir, build_type)
   # build decoder library
   make_de265(base_dir, build_type)
+  # build decoder/encoder library for AVIF image format
+  make_aom(base_dir, build_type)
 
   # build libheif
   make_heif(base_dir, build_type)

scripts/core_common/modules/icu.py

@@ -35,7 +35,7 @@ def make():
   old_cur = os.getcwd()
   os.chdir(base_dir)
 
-  base.check_module_version("7", clear_module)
+  base.check_module_version("8", clear_module)
 
   if (-1 != config.option("platform").find("android")):
     icu_android.make()
@@ -163,9 +163,11 @@ def make():
     if config.check_option("platform", "linux_arm64") and not base.is_dir(base_dir + "/linux_arm64") and not base.is_os_arm():
       base.create_dir(base_dir + "/icu/linux_arm64")
       os.chdir(base_dir + "/icu/linux_arm64")
-      base_arm_tool_dir = config.option('arm64-toolchain-bin') + '/' + base.get_prefix_cross_compiler_arm64()
+      compiler_gcc_prefix = base.get_compiler_gcc_prefix("linux_arm64")
+      if config.option("sysroot") != "":
+        base.set_sysroot_env("linux_arm64")
       base.cmd("./../source/configure", ["--host=arm-linux", "--prefix=" + base_dir + "/icu/linux_arm64_install", "--with-cross-build=" + base_dir + "/icu/cross_build",
-        "CC=" + base_arm_tool_dir + "gcc", "CXX=" + base_arm_tool_dir + "g++", "AR=" + base_arm_tool_dir + "ar", "RANLIB=" + base_arm_tool_dir + "ranlib"])
+        "CC=" + compiler_gcc_prefix + "gcc", "CXX=" + compiler_gcc_prefix + "g++", "AR=" + compiler_gcc_prefix + "ar", "RANLIB=" + compiler_gcc_prefix + "ranlib"])
       base.cmd("make", ["-j4"])
       base.cmd("make", ["install"], True)
       base.create_dir(base_dir + "/linux_arm64")
@@ -173,6 +175,8 @@ def make():
       base.copy_file(base_dir + "/icu/linux_arm64_install/lib/libicudata.so." + icu_major + "." + icu_minor, base_dir + "/linux_arm64/build/libicudata.so." + icu_major)
       base.copy_file(base_dir + "/icu/linux_arm64_install/lib/libicuuc.so." + icu_major + "." + icu_minor, base_dir + "/linux_arm64/build/libicuuc.so." + icu_major)
       base.copy_dir(base_dir + "/icu/linux_arm64_install/include", base_dir + "/linux_arm64/build/include")
+      if config.option("sysroot") != "":
+        base.restore_sysroot_env()
 
       os.chdir("../..")
 

scripts/core_common/modules/icu_mac.py

@@ -41,7 +41,7 @@ if not base.is_dir(current_dir + "/mac_cross_64"):
   old_env = change_icu_defs("x86_64")
 
   base.cmd("../icu/source/runConfigureICU", ["MacOSX",
-    "--prefix=" + current_dir + "/mac_cross_64", "--enable-static"])
+    "--prefix=" + current_dir + "/mac_64_install", "--enable-static"])
 
   base.cmd("make", ["-j4"])
   base.cmd("make", ["install"], True)
@@ -58,7 +58,7 @@ addon = []
 if not base.is_os_arm():
   addon = ["--host=aarch64-apple-darwin"]
 
-base.cmd("./configure", ["--prefix=" + current_dir + "/mac_arm_64",
+base.cmd("./configure", ["--prefix=" + current_dir + "/mac_arm64_install",
   "--with-cross-build=" + current_dir + "/mac_cross_64", "--enable-static", "VERBOSE=1"] + addon)
 
 base.cmd("make", ["-j4"])
@@ -80,25 +80,26 @@ base.create_dir(current_dir + "/mac_64/build")
 base.create_dir(current_dir + "/mac_arm64")
 base.create_dir(current_dir + "/mac_arm64/build")
 
-base.copy_dir(current_dir + "/mac_cross_64/include", current_dir + "/mac_64/build/include")
+base.copy_dir(current_dir + "/mac_64_install/include", current_dir + "/mac_64/build/include")
 # copy shared libs
-base.copy_file(current_dir + "/mac_cross_64/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicudata." + icu_major + ".dylib")
-base.copy_file(current_dir + "/mac_cross_64/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicuuc." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_64_install/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicudata." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_64_install/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicuuc." + icu_major + ".dylib")
 # copy static libs
-base.copy_file(current_dir + "/mac_cross_64/lib/libicudata.a", current_dir + "/mac_64/build")
-base.copy_file(current_dir + "/mac_cross_64/lib/libicui18n.a", current_dir + "/mac_64/build")
-base.copy_file(current_dir + "/mac_cross_64/lib/libicuuc.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_64_install/lib/libicudata.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_64_install/lib/libicui18n.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_64_install/lib/libicuuc.a", current_dir + "/mac_64/build")
 
-base.copy_dir(current_dir + "/mac_arm_64/include", current_dir + "/mac_arm64/build/include")
+base.copy_dir(current_dir + "/mac_arm64_install/include", current_dir + "/mac_arm64/build/include")
 # copy shared libs
-base.copy_file(current_dir + "/mac_arm_64/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicudata." + icu_major + ".dylib")
-base.copy_file(current_dir + "/mac_arm_64/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicuuc." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_arm64_install/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicudata." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_arm64_install/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicuuc." + icu_major + ".dylib")
 # copy static libs
-base.copy_file(current_dir + "/mac_arm_64/lib/libicudata.a", current_dir + "/mac_arm64/build")
-base.copy_file(current_dir + "/mac_arm_64/lib/libicui18n.a", current_dir + "/mac_arm64/build")
-base.copy_file(current_dir + "/mac_arm_64/lib/libicuuc.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm64_install/lib/libicudata.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm64_install/lib/libicui18n.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm64_install/lib/libicuuc.a", current_dir + "/mac_arm64/build")
 
 base.delete_dir(current_dir + "/mac_cross_64")
-base.delete_dir(current_dir + "/mac_arm_64")
+base.delete_dir(current_dir + "/mac_64_install")
+base.delete_dir(current_dir + "/mac_arm64_install")
 
 os.chdir(current_dir_old)

scripts/core_common/modules/openssl.py

@@ -118,15 +118,15 @@ def make():
     if (base.is_os_arm()):
       base.copy_dir("../build/linux_64", "../build/linux_arm64")
     else:
-      cross_compiler_arm64 = config.option("arm64-toolchain-bin")
-      if ("" == cross_compiler_arm64):
-        cross_compiler_arm64 = "/usr/bin"
-      cross_compiler_arm64_prefix = cross_compiler_arm64 + "/" + base.get_prefix_cross_compiler_arm64()
-      base.cmd("./Configure", ["linux-aarch64", "--cross-compile-prefix=" + cross_compiler_arm64_prefix, "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
+      if config.option("sysroot") != "":
+        base.set_sysroot_env("linux_arm64")
+      base.cmd("./Configure", ["linux-aarch64", "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden")
       base.cmd("make", [], True)
       base.cmd("make", ["install"], True)
+      if config.option("sysroot") != "":
+        base.restore_sysroot_env()
 
   if (-1 != config.option("platform").find("mac")) and not base.is_dir("../build/mac_64"):
     base.cmd("./Configure", ["enable-md2", "no-shared", "no-asm", "darwin64-x86_64-cc", "--prefix=" + old_cur_dir + "/build/mac_64", "--openssldir=" + old_cur_dir + "/build/mac_64", "-mmacosx-version-min=10.11"])

scripts/deploy_builder.py

@@ -47,6 +47,7 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "DocxRenderer")
+    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "StarMathConverter")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", root_dir + "/cmap.bin")
 
     if ("ios" == platform):

scripts/deploy_core.py

@@ -42,6 +42,7 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "DocxRenderer")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "hunspell")
+    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "StarMathConverter")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", archive_dir + "/cmap.bin")
     base.copy_exe(core_build_dir + "/bin/" + platform_postfix, archive_dir, "x2t")
 

scripts/deploy_desktop.py

@@ -72,6 +72,7 @@ def make():
     base.copy_lib(build_libraries_path, root_dir + "/converter", "IWorkFile")
     base.copy_lib(build_libraries_path, root_dir + "/converter", "HWPFile")
     base.copy_lib(build_libraries_path, root_dir + "/converter", "DocxRenderer")
+    base.copy_lib(build_libraries_path, root_dir + "/converter", "StarMathConverter")
 
     if ("ios" == platform):
       base.copy_lib(build_libraries_path, root_dir + "/converter", "x2t")
@@ -186,8 +187,6 @@ def make():
         base.copy_file(git_dir + "/desktop-apps/win-linux/extras/projicons/" + apps_postfix + "/projicons.exe", root_dir + "/DesktopEditors.exe")
         if not isWindowsXP:
           base.copy_file(git_dir + "/desktop-apps/win-linux/extras/update-daemon/" + apps_postfix + "/updatesvc.exe", root_dir + "/updatesvc.exe")
-        else:
-          base.copy_file(git_dir + "/desktop-apps/win-linux/extras/online-installer/" + apps_postfix + "/online-installer.exe", root_dir + "/online-installer.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/" + apps_postfix + "/DesktopEditors.exe", root_dir + "/editors.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/res/icons/desktopeditors.ico", root_dir + "/app.ico")
       elif (0 == platform.find("linux")):
@@ -317,8 +316,24 @@ def make():
       themes_params = []
       if ("" != config.option("themesparams")):
         themes_params = ["--params=\"" + config.option("themesparams") + "\""]
-      base.cmd_exe(root_dir + "/converter/allfontsgen", ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""], True)
-      base.cmd_exe(root_dir + "/converter/allthemesgen", ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params, True)
+
+      params_allfontsgen = ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""]
+      params_allthemesgen = ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params
+      if (0 == platform.find("linux_arm") and not base.is_os_arm()):
+        x2t_origin = ""
+        if (config.option("sysroot") != ""):
+          x2t_origin = base.create_qemu_wrapper(root_dir + "/converter/x2t", platform)
+ 
+        base.cmd_in_dir_qemu(platform, root_dir + "/converter", "./allfontsgen", params_allfontsgen, True)
+        base.cmd_in_dir_qemu(platform, root_dir + "/converter", "./allthemesgen", params_allthemesgen, True)
+
+        if "" != x2t_origin:
+          base.delete_file(root_dir + "/converter/x2t")
+          base.move_file(x2t_origin, root_dir + "/converter/x2t")
+      else:        
+        base.cmd_exe(root_dir + "/converter/allfontsgen", params_allfontsgen, True)
+        base.cmd_exe(root_dir + "/converter/allthemesgen", params_allthemesgen, True)
+
       base.delete_file(root_dir + "/converter/AllFonts.js")
       base.delete_file(root_dir + "/converter/font_selection.bin")
       base.delete_file(root_dir + "/converter/fonts.log")
@@ -330,4 +345,4 @@ def make():
     if not isUseJSC:
       base.delete_file(root_dir + "/editors/sdkjs/slide/sdk-all.cache")
 
-  return
+  return

scripts/deploy_mobile.py

@@ -65,6 +65,7 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "DocxRenderer")
+    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "StarMathConverter")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", root_dir + "/cmap.bin")
 
     if (0 == platform.find("win") or 0 == platform.find("linux") or 0 == platform.find("mac")):

scripts/deploy_server.py

@@ -93,6 +93,7 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "DocxRenderer")
+    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "StarMathConverter")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", converter_dir + "/cmap.bin")
     base.copy_exe(core_build_dir + "/bin/" + platform_postfix, converter_dir, "x2t")
 

scripts/develop/dependence.py

@@ -111,7 +111,8 @@ def check_dependencies():
   if (host_platform == 'windows'):
     checksResult.append(check_nodejs())
 
-  if (config.option("sql-type") == 'mysql' and host_platform == 'windows'):
+  sql_type = config.option("sql-type")
+  if (sql_type == 'mysql' and host_platform == 'windows'):
     checksResult.append(check_mysqlServer())
   else:
     checksResult.append(check_postgreSQL())
@@ -300,9 +301,21 @@ def check_rabbitmq():
       print('RabbitMQ is installed')
       return dependence
   elif (host_platform == 'linux'):
-    result = base.run_command('service rabbitmq-server status')['stdout']
-    if (result != ''):
-      print('Installed RabbitMQ is valid')
+    result = ''
+    
+    # Prefer systemctl for systemd
+    systemctl_result = base.run_command('systemctl status rabbitmq-server')
+    if systemctl_result['returncode'] == 0 and systemctl_result['stdout']:
+      result = systemctl_result['stdout']
+    
+    # Fallback to service for SysV
+    if result == '':
+      command_result = base.run_command('service rabbitmq-server status')
+      if command_result['returncode'] == 0 and command_result['stdout']:
+        result = command_result['stdout']
+    
+    if result != '':
+      print('RabbitMQ is installed')
       return dependence
 
   print('RabbitMQ not found')
@@ -517,8 +530,9 @@ def check_mysqlServer():
   if (host_platform != 'windows'):
     result = os.system(mysqlLoginSrt + ' -e "exit"')
     if (result == 0):
-      connectionResult = base.run_command(connectionString)['stdout']
-      if (connectionResult.find('port') != -1 and connectionResult.find(config.option("db-port")) != -1):
+      connectionResult = base.run_command(connectionString)
+      expected_port = config.option("db-port")
+      if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
         print('MySQL configuration is valid')
         dependence.sqlPath = 'mysql'
         return dependence
@@ -533,13 +547,15 @@ def check_mysqlServer():
       continue
 
     mysql_full_name = 'MySQL Server ' + info['Version'] + ' '
-
-    connectionResult = base.run_command_in_dir(get_mysql_path_to_bin(info['Location']), connectionString)['stdout']
-    if (connectionResult.find('port') != -1 and connectionResult.find(config.option("db-port")) != -1):
+    mysql_bin_path = get_mysql_path_to_bin(info['Location'])
+    connectionResult = base.run_command_in_dir(mysql_bin_path, connectionString)
+    
+    expected_port = config.option("db-port")
+    if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
       print(mysql_full_name + 'configuration is valid')
       dependence.sqlPath = info['Location']
       return dependence
-    print(mysql_full_name + 'configuration is not valid:' + connectionResult)
+    print(mysql_full_name + 'configuration is not valid')
     # if path exists, then further removal and installation fails(according to startup statistics). it is better to fix issue manually.
     return dependence
 
@@ -632,8 +648,8 @@ def get_postrgre_path_to_bin(postgrePath = ''):
   return postgrePath
 def get_postgreLoginSrting(userName):
   if (host_platform == 'windows'):
-    return 'psql -U' + userName + ' '
-  return 'PGPASSWORD="' + config.option("db-pass") + '" psql -U' + userName + ' -hlocalhost '
+    return 'psql -U ' + userName + ' -h localhost '
+  return 'PGPASSWORD="' + config.option("db-pass") + '" psql -U ' + userName + ' -h localhost '
 def get_postgreSQLInfoByFlag(flag):
   arrInfo = []
 
@@ -667,9 +683,10 @@ def check_postgreSQL():
 
   if (host_platform == 'linux'):
     result = os.system(postgreLoginSrt + ' -c "\q"')
-    connectionResult = base.run_command(connectionString)['stdout']
+    connectionResult = base.run_command(connectionString)
+    expected_port = config.option("db-port")
 
-    if (result != 0 or connectionResult.find(config.option("db-port")) == -1):
+    if (result != 0 or connectionResult['stdout'].find(expected_port) == -1):
       print('Valid PostgreSQL not found!')
       dependence.append_install('PostgreSQL')
       dependence.append_uninstall('PostgreSQL')
@@ -680,18 +697,20 @@ def check_postgreSQL():
 
   arrInfo = get_postgreSQLInfo()
   base.set_env('PGPASSWORD', config.option("db-pass"))
+  
   for info in arrInfo:
     if (base.is_dir(info['Location']) == False):
       continue
     
     postgre_full_name = 'PostgreSQL ' + info['Version'][:2] + ' '
-    connectionResult = base.run_command_in_dir(get_postrgre_path_to_bin(info['Location']), connectionString)['stdout']
-
-    if (connectionResult.find(config.option("db-port")) != -1):
+    postgre_bin_path = get_postrgre_path_to_bin(info['Location'])
+    connectionResult = base.run_command_in_dir(postgre_bin_path, connectionString)
+    
+    expected_port = config.option("db-port")
+    if (connectionResult['stdout'].find(expected_port) != -1):
       print(postgre_full_name + 'configuration is valid')
       dependence.sqlPath = info['Location']
       return dependence
-    print(postgre_full_name + 'configuration is not valid')
 
   print('Valid PostgreSQL not found')
 
@@ -704,6 +723,8 @@ def check_postgreSQL():
   return dependence
 def check_postgreConfig(postgrePath = ''):
   result = True
+  base.print_info('Checking PostgreSQL configuration')
+  
   if (host_platform == 'windows'):
     base.set_env('PGPASSWORD', config.option("db-pass"))
 
@@ -711,53 +732,78 @@ def check_postgreConfig(postgrePath = ''):
   dbUser = config.option("db-user")
   dbName = config.option("db-name")
   dbPass = config.option("db-pass")
+  
   postgre_path_to_bin = get_postrgre_path_to_bin(postgrePath)
   postgreLoginRoot = get_postgreLoginSrting(rootUser)
   postgreLoginDbUser = get_postgreLoginSrting(dbUser)
   creatdb_path = base.get_script_dir() + "/../../server/schema/postgresql/createdb.sql"
 
-  if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "\du ' + dbUser + '"')['stdout'].find(dbUser) != -1):
-    print('User ' + dbUser + ' is exist')
+  # Check if user exists
+  user_check_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "\du ' + dbUser + '"')
+  
+  if (user_check_result['stdout'].find(dbUser) != -1):
+    # User exists, check password
     if (os.system(postgreLoginDbUser + '-c "\q"') != 0):
-      print('Invalid user password!')
-      base.print_info('Changing password...')
+      print('Invalid user password, changing...')
       result = change_userPass(dbUser, dbPass, postgre_path_to_bin) and result
   else:
-    print('User ' + dbUser + ' not exist!')
-    base.print_info('Creating ' + dbName + ' user...')
+    print('Creating user ' + dbUser + '...')
     result = create_postgreUser(dbUser, dbPass, postgre_path_to_bin) and result
 
-  if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"')['stdout'].find(config.option("db-name")) == -1):
-    print('Database ' + dbName + ' not found')
-    base.print_info('Creating ' + dbName + ' database...')
-    result = create_postgreDb(dbName, postgre_path_to_bin) and configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
+  # Check if database exists
+  db_check_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"')
+  
+  if (db_check_result['stdout'].find(dbName) == -1):
+    print('Creating database ' + dbName + '...')
+    create_result = create_postgreDb(dbName, postgre_path_to_bin)
+    
+    if create_result:
+      # Grant privileges to user on database and schema
+      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"')
+      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"')
+      
+      configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
+      result = create_result and configure_result
+    else:
+      result = False
   else:
-    if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "SELECT pg_size_pretty(pg_database_size(' + "'" + dbName + "'" + '));"')['stdout'].find('7559 kB') != -1):
-      print('Database ' + dbName + ' not configured')
-      base.print_info('Configuring ' + dbName + ' database...')
-      result = configureDb(dbName, creatdb_path, postgre_path_to_bin) and result
-    print('Database ' + dbName + ' is valid')
-
-  if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "\l+ ' + dbName + '"')['stdout'].find(dbUser +'=CTc/' + rootUser) == -1):
-    print('User ' + dbUser + ' has no database privileges!')
-    base.print_info('Setting database privileges for user ' + dbUser + '...')
-    result = set_dbPrivilegesForUser(dbUser, dbName, postgre_path_to_bin) and result
-  print('User ' + dbUser + ' has database privileges')
-
+    # Database exists - check if tables need to be created
+    table_count_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "SELECT count(*) FROM information_schema.tables WHERE table_schema = \'public\';"')
+    
+    needs_configure = False
+    
+    if table_count_result['stdout'].find(' 0') != -1:
+      # No tables - need to configure
+      needs_configure = True
+    
+    if needs_configure:
+      # Grant privileges and configure
+      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"')
+      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"')
+      
+      configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
+      result = configure_result and result
+  
   return result
 def create_postgreDb(dbName, postgre_path_to_bin = ''):
   postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"') != 0):
+  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"')
+  if (result['returncode'] != 0):
+    print('Database creation failed!')
     return False
   return True
 def set_dbPrivilegesForUser(userName, dbName, postgre_path_to_bin = ''):
   postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"') != 0):
+  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"')
+  if (result['returncode'] != 0):
+    print('Grant privileges failed!')
     return False
   return True
 def create_postgreUser(userName, userPass, postgre_path_to_bin = ''):
   postgreLoginRoot = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"') != 0):
+  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"')
+  if (result['returncode'] != 0):
+    print('User creation failed!')
     return False
   return True
 def change_userPass(userName, userPass, postgre_path_to_bin = ''):
@@ -766,13 +812,24 @@ def change_userPass(userName, userPass, postgre_path_to_bin = ''):
     return False
   return True
 def configureDb(userName, dbName, scriptPath, postgre_path_to_bin = ''):
-  print('Execution ' + scriptPath)
-  postgreLoginSrt = get_postgreLoginSrting(userName)
-
-  code = base.exec_command_in_dir(postgre_path_to_bin, postgreLoginSrt + ' -d ' + dbName + ' -f "' + scriptPath + '"')
-  if (code != 0):
-    print('Execution failed!')
+  print('Executing ' + scriptPath)
+  
+  if not base.is_file(scriptPath):
+    print('ERROR: Script file does not exist!')
     return False
+  
+  postgreLoginSrt = get_postgreLoginSrting(userName)
+  full_command = postgreLoginSrt + ' -d ' + dbName + ' -f "' + scriptPath + '"'
+  
+  # Use run_command_in_dir to capture output
+  result = base.run_command_in_dir(postgre_path_to_bin, full_command)
+  
+  if (result['returncode'] != 0):
+    print('Execution failed!')
+    if result['stderr']:
+      print('Error: ' + result['stderr'])
+    return False
+  
   print('Execution completed')
   return True
 def uninstall_postgresql():

scripts/package_builder.py

@@ -170,7 +170,7 @@ def make_wheel():
 
   utils.delete_dir("python")
   utils.copy_dir("../onlyoffice/build_tools/packaging/docbuilder/resources", "python")
-  utils.copy_dir(builder_dir, "python/docbuilder/lib")
+  utils.copy_dir(builder_dir, "python/docbuilder/lib", True, True)
 
   desktop_dir = "../desktop-apps/macos/build/ONLYOFFICE.app/Contents/Resources/converter"
   if utils.is_macos() and "desktop" in common.targets and utils.is_exist(desktop_dir):
@@ -204,7 +204,11 @@ def make_wheel():
     utils.delete_file("docbuilder.net.dll")
     utils.delete_file("docbuilder.jni.dll")
   elif utils.is_macos():
-    utils.delete_file("libdocbuilder.jni.dylib")
+    if (utils.is_file("libdocbuilder.jni.dylib")):
+      utils.delete_file("libdocbuilder.jni.dylib")
+    if (utils.is_dir("docbuilder.jni.framework")):
+      utils.delete_file("docbuilder.jni.framework")
+    utils.remove_all_symlinks(".")
   elif utils.is_linux():
     utils.delete_file("libdocbuilder.jni.so")
 

scripts/package_desktop.py

@@ -77,9 +77,6 @@ def make_windows():
     make_prepare("xp")
     make_zip("xp")
     make_inno("xp")
-  # Disable build online installer
-  # if common.platform == "windows_x86_xp":
-  #  make_online()
 
   utils.set_cwd(common.workspace_dir)
   return
@@ -173,18 +170,6 @@ def make_advinst(edition = "opensource"):
     utils.set_summary("desktop advinst " + edition + " deploy", ret)
   return
 
-def make_online():
-  online_file = utils.glob_file("OnlineInstaller-" + package_version + "*.exe")
-  utils.log_h2("desktop online installer build")
-  ret = utils.is_file(online_file)
-  utils.set_summary("desktop online installer build", ret)
-
-  if common.deploy and ret:
-    utils.log_h2("desktop online installer deploy")
-    ret = s3_upload([online_file], "desktop/win/online/")
-    utils.set_summary("desktop online installer deploy", ret)
-  return
-
 #
 # macOS
 #
@@ -348,9 +333,12 @@ def make_linux():
     if common.deploy:
       for t in branding.desktop_make_targets:
         utils.log_h2("desktop " + edition + " " + t["make"] + " deploy")
-        ret = s3_upload(
-          [i for i in utils.glob_path(t["src"]) if "enterprise-help" not in i],
-          t["dst"])
+        uploads = []
+        for f in utils.glob_path(t["src"]):
+          if "help" in f and not \
+            ("x86_64" in common.platform and edition == "opensource"): continue
+          uploads.append(f)
+        ret = s3_upload(uploads, t["dst"])
         utils.set_summary("desktop " + edition + " " + t["make"] + " deploy", ret)
 
   utils.set_cwd(common.workspace_dir)

scripts/package_utils.py

@@ -201,12 +201,12 @@ def copy_files(src, dst, override=True, verbose=True):
       copy_files(file + "/*", dst + "/" + file_name, override)
   return
 
-def copy_dir(src, dst, verbose=True):
+def copy_dir(src, dst, verbose=True, symlinks=False):
   if verbose:
     log("- copy_dir:")
     log("    src: " + src)
     log("    dst: " + dst)
-  shutil.copytree(src, dst)
+  shutil.copytree(src, dst, symlinks=symlinks)
   return
 
 def copy_dir_content(src, dst, filter_include = "", filter_exclude = "", verbose=True):
@@ -262,6 +262,20 @@ def delete_files(src, verbose=True):
       shutil.rmtree(path, ignore_errors=True)
   return
 
+def remove_all_symlinks(dir):
+  for root, dirs, files in os.walk(dir, topdown=True, followlinks=False):
+    for name in files:
+      path = os.path.join(root, name)
+      if os.path.islink(path):
+        os.unlink(path)
+    
+    for name in list(dirs):
+      path = os.path.join(root, name)
+      if os.path.islink(path):
+        os.unlink(path)
+        dirs.remove(name)
+  return
+
 def set_summary(target, status):
   common.summary.append({target: status})
   return

scripts/qmake.py

@@ -102,8 +102,11 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
       build_params.append("linux-clang-libc++")
       
     if "" != config.option("sysroot"):
-      os.environ['QMAKE_CUSTOM_SYSROOT'] = config.option("sysroot_" + platform)
-      #os.environ['PKG_CONFIG_PATH'] = config.get_custom_sysroot_lib(platform) + "/pkgconfig"
+      sysroot_path = config.option("sysroot_" + platform)
+      os.environ['QMAKE_CUSTOM_SYSROOT'] = sysroot_path
+      os.environ['QMAKE_CUSTOM_SYSROOT_BIN'] = config.get_custom_sysroot_bin(platform)
+      os.environ['PKG_CONFIG_PATH'] = config.get_custom_sysroot_lib(platform, True) + "/pkgconfig"
+      os.environ['PKG_CONFIG_SYSROOT_DIR'] = sysroot_path
       
     base.cmd_exe(qmake_app, build_params)
     

sln.json

@@ -13,9 +13,11 @@
     "core/UnicodeConverter/UnicodeConverter.pro",
     "core/Common/kernel.pro",
     "core/Common/Network/network.pro",
-    
+
+    "core/OdfFile/Reader/Converter/StarMath2OOXML/StarMath2OOXML.pro",
+
     "core/DesktopEditor/graphics/pro/graphics.pro",
-    
+
     "core/PdfFile/PdfFile.pro",
     "core/DjVuFile/DjVuFile.pro",
     "core/XpsFile/XpsFile.pro",
@@ -27,7 +29,7 @@
 
     "core/Apple/IWork.pro",
 
-    "core/DocxRenderer/DocxRenderer.pro",   
+    "core/DocxRenderer/DocxRenderer.pro",
 
     "core/DesktopEditor/doctrenderer/doctrenderer.pro",
 
@@ -79,11 +81,11 @@
   "multimedia" : [
     "[win,linux]desktop-sdk/ChromiumBasedEditors/videoplayerlib/videoplayerlib.pro"
   ],
-  
+
   "desktop" : [
     "core",
     "multimedia",
-    
+
     "core/DesktopEditor/xmlsec/src/ooxmlsignature.pro",
 
     "desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore.pro",
@@ -91,7 +93,7 @@
 
     "[win,linux]desktop-sdk/ChromiumBasedEditors/lib/qt_wrapper/qtascdocumentscore.pro",
     "[win,linux]desktop-apps/win-linux/ASCDocumentEditor.pro",
-    
+
     "[win]desktop-apps/win-linux/extras/projicons/ProjIcons.pro",
     "[win,!win_xp]desktop-apps/win-linux/extras/update-daemon/UpdateDaemon.pro"
   ],

tools/linux/deps.py

@@ -68,7 +68,7 @@ def install_deps():
     print("OK")
     base.cmd("sudo", ["apt-get", "-y", "install", "npm", "yarn"], True)
   base.cmd("sudo", ["npm", "install", "-g", "grunt-cli"])
-  base.cmd("sudo", ["npm", "install", "-g", "@yao-pkg/pkg"])
+  base.cmd("sudo", ["npm", "install", "-g", "@yao-pkg/pkg@6.11.0"])
 
   # java
   java_error = base.cmd("sudo", ["apt-get", "-y", "install", "openjdk-11-jdk"], True)

tools/linux/sysroot/custom-sysroot.toolchain.cmake

@@ -1,4 +1,19 @@
-set(CMAKE_C_FLAGS $ENV{CFLAGS})
-set(CMAKE_CXX_FLAGS $ENV{CXXFLAGS})
-set(CMAKE_C_LINKER_FLAGS $ENV{LDFLAGS})
-set(CMAKE_CXX_LINKER_FLAGS $ENV{LDFLAGS})
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+set(CMAKE_MAKE_PROGRAM "/usr/bin/make" CACHE FILEPATH "" FORCE)
+
+set(CMAKE_C_COMPILER $ENV{CC})
+set(CMAKE_CXX_COMPILER $ENV{CXX})
+set(CMAKE_AR $ENV{AR})
+set(CMAKE_RANLIB $ENV{RANLIB})
+
+set(CMAKE_C_FLAGS "$ENV{CFLAGS}" CACHE STRING "" FORCE)
+set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS}" CACHE STRING "" FORCE)
+set(CMAKE_EXE_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "" FORCE)
+set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "" FORCE)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

tools/linux/sysroot/fetch.py

@@ -13,11 +13,186 @@ SYSROOTS = {
   "arm64": "ubuntu16-arm64-sysroot.tar.gz",
 }
 
+def patch_linker_scripts(sysroot_path, arch):
+  """Fix absolute paths in linker scripts to use sysroot-relative paths"""
+  
+  # Determine directories to patch
+  lib_dirs = []
+  
+  if arch == "arm64":
+    lib_dirs = [
+      os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
+    ]
+  elif arch == "amd64":
+    lib_dirs = [
+      os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu"),
+      os.path.join(sysroot_path, "usr/aarch64-linux-gnu/lib")
+    ]
+  else:
+    return
+  
+  total_patched = 0
+  
+  for lib_dir in lib_dirs:
+    if not os.path.exists(lib_dir):
+      print(f"Warning: {lib_dir} not found, skipping")
+      continue
+    
+    print(f"Patching linker scripts in {lib_dir}...")
+    patched_count = 0
+    
+    for filename in os.listdir(lib_dir):
+      if not filename.endswith(".so"):
+        continue
+      
+      filepath = os.path.join(lib_dir, filename)
+      if not os.path.isfile(filepath):
+        continue
+      
+      # Check if it's a text file (linker script)
+      try:
+        with open(filepath, 'r') as f:
+          content = f.read()
+        
+        # Skip if not a linker script
+        if "GROUP" not in content and "INPUT" not in content:
+          continue
+          
+        original_content = content
+        
+        # STEP 1: Normalize all /usr/lib paths to /lib
+        # ORDER MATTERS - do longest paths first to avoid partial matches
+        
+        # For aarch64
+        content = content.replace("/usr/aarch64-linux-gnu/lib/", "/lib/aarch64-linux-gnu/")
+        content = content.replace("/usr/lib/aarch64-linux-gnu/", "/lib/aarch64-linux-gnu/")
+        
+        # For x86_64  
+        content = content.replace("/usr/x86_64-linux-gnu/lib/", "/lib/x86_64-linux-gnu/")
+        content = content.replace("/usr/lib/x86_64-linux-gnu/", "/lib/x86_64-linux-gnu/")
+        
+        # STEP 2: Add = prefix for sysroot-relative paths
+        content = content.replace("/lib/aarch64-linux-gnu/", "=/lib/aarch64-linux-gnu/")
+        content = content.replace("/lib/x86_64-linux-gnu/", "=/lib/x86_64-linux-gnu/")
+        
+        # Write back only if changed
+        if content != original_content:
+          with open(filepath, 'w') as f:
+            f.write(content)
+          
+          print(f"  Patched: {filename}")
+          patched_count += 1
+      except Exception as e:
+        # Not a text file or other error, skip
+        pass
+    
+    total_patched += patched_count
+    print(f"Patched {patched_count} linker scripts in {lib_dir}")
+  
+  print(f"Total patched: {total_patched} linker scripts")
+  
+  # Create symlinks from /lib to /usr/lib for library resolution
+  create_lib_symlinks(sysroot_path, arch)
+  
+  # Fix absolute symlinks to relative ones
+  fix_absolute_symlinks(sysroot_path, arch)
+
+
+def create_lib_symlinks(sysroot_path, arch):
+  """Create symlinks from /lib to /usr/lib for library resolution"""
+  print(f"Creating library symlinks in {sysroot_path}...")
+  
+  if arch == "arm64":
+    lib_symlink_dir = os.path.join(sysroot_path, "lib/aarch64-linux-gnu")
+    lib_target_dir = os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
+  elif arch == "amd64":
+    lib_symlink_dir = os.path.join(sysroot_path, "lib/x86_64-linux-gnu")
+    lib_target_dir = os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu")
+  else:
+    return
+  
+  # Create /lib/{arch} directory
+  os.makedirs(lib_symlink_dir, exist_ok=True)
+  
+  if not os.path.exists(lib_target_dir):
+    print(f"  Warning: Target directory {lib_target_dir} does not exist")
+    return
+  
+  symlink_count = 0
+  
+  # Create symlinks for all files in /usr/lib/{arch}
+  for filename in os.listdir(lib_target_dir):
+    target = os.path.join(lib_target_dir, filename)
+    link = os.path.join(lib_symlink_dir, filename)
+    
+    # Skip if symlink already exists
+    if os.path.exists(link) or os.path.islink(link):
+      continue
+    
+    # Create relative symlink
+    rel_target = os.path.relpath(target, lib_symlink_dir)
+    try:
+      os.symlink(rel_target, link)
+      symlink_count += 1
+    except OSError as e:
+      print(f"  Warning: Could not create symlink {link}: {e}")
+  
+  print(f"Created {symlink_count} symlinks in {lib_symlink_dir}")
+
+
+def fix_absolute_symlinks(sysroot_path, arch):
+  """Fix absolute symlinks in /usr/lib to use relative paths"""
+  print(f"Fixing absolute symlinks in {sysroot_path}...")
+  
+  if arch == "arm64":
+    lib_dir = os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
+  elif arch == "amd64":
+    lib_dir = os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu")
+  else:
+    return
+  
+  if not os.path.exists(lib_dir):
+    print(f"  Warning: {lib_dir} not found")
+    return
+  
+  fixed_count = 0
+  
+  # Find all .so symlinks pointing to /lib/
+  for filename in os.listdir(lib_dir):
+    if not filename.endswith(".so"):
+      continue
+    
+    filepath = os.path.join(lib_dir, filename)
+    
+    # Check if it's a symlink
+    if not os.path.islink(filepath):
+      continue
+    
+    # Get symlink target
+    target = os.readlink(filepath)
+    
+    # Check if it's an absolute path starting with /lib/
+    if target.startswith("/lib/"):
+      # Convert to relative path: /lib/... -> ../../../lib/...
+      relative_target = os.path.join("../../..", target[1:])  # Remove leading /
+      
+      # Remove old symlink and create new one
+      os.unlink(filepath)
+      os.symlink(relative_target, filepath)
+      
+      print(f"  Fixed: {filename} -> {relative_target}")
+      fixed_count += 1
+  
+  print(f"Fixed {fixed_count} absolute symlinks")
+
 def download_and_extract(name):
   archive = SYSROOTS[name]
   base.download(URL + archive, "./" + archive)
   base.cmd("tar", ["-xzf", "./" + archive])
 
+  sysroot_name = archive.replace(".tar.gz", "")
+  patch_linker_scripts(sysroot_name, name)
+
 def main():
   if len(sys.argv) != 2:
     print("Usage: fetch.py [amd64|arm64|all]")