diff --git a/GreenScreen/CMakeLists.txt b/GreenScreen/CMakeLists.txt
index 92e9dd207016af67363b4db8e66e0e9c2a598d05..15d3da0db0ab0a326284bc6a7dad215e179d1309 100644
--- a/GreenScreen/CMakeLists.txt
+++ b/GreenScreen/CMakeLists.txt
@@ -1,154 +1,185 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required (VERSION 3.10)
-# Project setup
+# Set the project name and version
set (ProjectName GreenScreen)
set (Version 2.0.0)
-project(${ProjectName} VERSION ${Version})
-# Detect OS and architecture
-if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
- message(FATAL_ERROR "Unsupported architecture. Only x64 or aarch64 (arm64) is supported.")
-else()
- set (ARCH $CMAKE_SYSTEM_PROCESSOR)
-endif()
-
-if(WIN32)
- set(DISTRIBUTION "x64-windows")
-elseif(APPLE)
- set(DISTRIBUTION "${ARCH}-apple-darwin")
-elseif(ANDROID)
- set(DISTRIBUTION "android")
-else()
- set(DISTRIBUTION "x86_64-linux-gnu")
-endif()
+project (${ProjectName} VERSION ${Version})
+
+# Set default options
+option (DEBUG "Build in debug mode" OFF)
-# Paths setup
-set (JAMI_PLUGINS_PATH ${PROJECT_SOURCE_DIR}/.. )
-set (DAEMON ${JAMI_PLUGINS_PATH}/daemon)
-set (DAEMON_SRC ${DAEMON}/src)
+# Set platform to build for
+set (PLATFORM_TYPE $ENV{PLATFORM_TYPE}) # can be LINUX or ANDROID
+if (PLATFORM_TYPE STREQUAL "ANDROID")
+ set (PLATFORM $ENV{ANDROID_ABI}) # can be arm64-v8a, armeabi-v7a or x86_64
+elseif(PLATFORM_TYPE STREQUAL "LINUX")
+ set (PLATFORM x86_64-linux-gnu) # can be x86_64-linux-gnu
+else()
+ message(FATAL_ERROR "Platform type not supported for now")
+endif ()
+
+# set compilation flags based on platform
+if (PLATFORM STREQUAL "x86_64-linux-gnu")
+ set (CONTRIB_PLATFORM x86_64-linux-gnu)
+elseif (PLATFORM STREQUAL "arm64-v8a")
+ set (CONTRIB_PLATFORM aarch64-linux-android)
+elseif (PLATFORM STREQUAL "armeabi-v7a")
+ set (CONTRIB_PLATFORM arm-linux-androideabi)
+elseif (PLATFORM STREQUAL "x86_64")
+ set (CONTRIB_PLATFORM x86_64-linux-android)
+endif ()
+
+# Set variables
+set (CMAKE_CXX_STANDARD 17)
+set (CMAKE_CXX_STANDARD_REQUIRED True)
+set (DAEMON ${PROJECT_SOURCE_DIR}/../daemon)
set (CONTRIB_PATH ${DAEMON}/contrib)
-set (PLUGINS_LIB ${JAMI_PLUGINS_PATH}/lib)
-set (JPL_DIRECTORY ${PROJECT_BINARY_DIR}/jpl)
-set (JPL_FILE_NAME ${ProjectName}.jpl)
-set (SDK_PATH ${JAMI_PLUGINS_PATH}/SDK)
-set (PLUGIN_OUTPUT_DIR ${JPL_DIRECTORY}/lib/${DISTRIBUTION})
-
-message(Distribution:\ ${DISTRIBUTION})
-message(Building:\ ${ProjectName} ${Version})
-message(Build\ path:\ ${PROJECT_BINARY_DIR})
-message(JPL\ assembling\ path:\ ${JPL_DIRECTORY})
-message(JPL\ path:\ ${JAMI_PLUGINS_PATH}/build/${DISTRIBUTION}/${JPL_FILE_NAME})
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /DMSGPACK_NO_BOOST /MT")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /DMSGPACK_NO_BOOST /MTd")
-
-set(plugin_SRC
+set (PLUGINS_LIB ${PROJECT_SOURCE_DIR}/../lib)
+set (CONTRIB_ROOT_PATH ${CONTRIB_PATH}/${CONTRIB_PLATFORM})
+set (CMAKE_BUILD_RPATH "$ORIGIN")
+set (SDK_PATH ${PROJECT_SOURCE_DIR}/../SDK)
+set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-Bsymbolic")
+set (CMAKE_POSITION_INDEPENDENT_CODE ON)
+set (ONNX_PATH ${CONTRIB_ROOT_PATH})
+
+# Set platform specific variables
+if (PLATFORM_TYPE STREQUAL "ANDROID")
+ set (OpenCV_DIR ${CONTRIB_PATH}/native-${CONTRIB_PLATFORM}/opencv/build)
+ set (ONNX_SO_PATH ${CONTRIB_PATH}/native-${CONTRIB_PLATFORM}/onnx/build/Linux/Release/libonnxruntime.so)
+elseif (PLATFORM_TYPE STREQUAL "LINUX")
+ set (ONNX_SO_PATH ${CONTRIB_ROOT_PATH}/lib/onnxruntime/cpu/libonnxruntime.so)
+endif ()
+
+find_package (PkgConfig REQUIRED)
+list (APPEND PKG_CONFIG_EXECUTABLE "--static")
+
+list (APPEND CMAKE_FIND_ROOT_PATH ${CONTRIB_ROOT_PATH})
+set (CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH)
+list (APPEND CMAKE_PREFIX_PATH ${CONTRIB_ROOT_PATH})
+
+# Find required packages
+pkg_search_module (avformat REQUIRED IMPORTED_TARGET libavformat)
+pkg_search_module (avdevice REQUIRED IMPORTED_TARGET libavdevice)
+pkg_search_module (avfilter REQUIRED IMPORTED_TARGET libavfilter)
+pkg_search_module (avcodec REQUIRED IMPORTED_TARGET libavcodec)
+pkg_search_module (swresample REQUIRED IMPORTED_TARGET libswresample)
+pkg_search_module (swscale REQUIRED IMPORTED_TARGET libswscale)
+pkg_search_module (avutil REQUIRED IMPORTED_TARGET libavutil)
+
+find_package (OpenCV 4 REQUIRED)
+message ("OpenCV_LIBS: ${OpenCV_LIBS}")
+message ("OpenCV_INCLUDE: ${OpenCV_INCLUDE_DIRS}")
+
+add_definitions (-DMSGPACK_NO_BOOST)
+
+if (DEBUG)
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fsanitize=address -Wall -Wextra -Wno-unused-parameter")
+ add_definitions (-D__DEBUG__)
+else ()
+ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall -Wextra -Wno-unused-parameter")
+endif ()
+
+# Source files
+set (plugin_SRC
main.cpp
+ VideoSubscriber.cpp
pluginMediaHandler.cpp
pluginProcessor.cpp
- VideoSubscriber.cpp
+ ${PLUGINS_LIB}/common.cpp
${PLUGINS_LIB}/accel.cpp
${PLUGINS_LIB}/frameUtils.cpp
${PLUGINS_LIB}/frameFilter.cpp
)
-set(plugin_HDR
- VideoSubscriber.h
- pluginMediaHandler.h
- pluginProcessor.h
- ${PLUGINS_LIB}/accel.h
- ${PLUGINS_LIB}/frameScaler.h
- ${PLUGINS_LIB}/frameUtils.h
- ${PLUGINS_LIB}/pluglog.h
- ${PLUGINS_LIB}/frameFilter.h
-)
-
# Create shared library
-add_library(${ProjectName} SHARED ${plugin_SRC} ${plugin_HDR})
-
-# Find packages
-find_package(OpenCV REQUIRED)
-#onnxruntime is not supported by find_package yet, use https://medium.com/@massimilianoriva96/onnxruntime-integration-with-ubuntu-and-cmake-5d7af482136a
-find_package(onnxruntime REQUIRED)
-find_package(Python3 3.6 REQUIRED COMPONENTS Interpreter)
-
-list(APPEND EXTRA_LIBS ${OpenCV_LIBS} ${onnxruntime_LIBS})
-list(APPEND EXTRA_INCLUDES ${OpenCV_INCLUDE_DIRS} ${onnxruntime_INCLUDE_DIRS})
+add_library (${ProjectName} SHARED ${plugin_SRC})
# Include directories
-target_include_directories(${ProjectName} PUBLIC
- ${PROJECT_BINARY_DIR}
+target_include_directories (${ProjectName} PUBLIC
${PROJECT_SOURCE_DIR}
+ ${DAEMON}/src
+ ${CONTRIB_PATH}/${CONTRIB_PLATFORM}/include
+ ${CONTRIB_PATH}/${CONTRIB_PLATFORM}/include/opencv4
+ ${ONNX_PATH}/include/onnxruntime/session
+ ${ONNX_PATH}/include/onnxruntime/providers/cuda
${PLUGINS_LIB}
- ${DAEMON_SRC}
- ${CONTRIB_PATH}
- ${CONTRIB_PATH}/build/fmt/include
- ${CONTRIB_PATH}/build/opendht/include
- ${CONTRIB_PATH}/build/msgpack-c/include
- ${FFMPEG}/include
- ${EXTRA_INCLUDES}
- ${onnxruntime_INCLUDE_DIRS}/onnxruntime/include
-)
-
-# Link directories and libraries
-target_link_directories(${ProjectName} PUBLIC
- ${CONTRIB_PATH}
- ${CONTRIB_PATH}/build/fmt/msvc/Release
- ${FFMPEG}/bin
)
-target_link_libraries(${ProjectName} PUBLIC ${EXTRA_LIBS} ${onnxruntime_LIBRARY} swscale avutil )
-
-# Android-specific flags
-if(ANDROID)
- set(CMAKE_ANDROID_ARCH_ABI arm64-v8a) # Set the desired ABI
- set(CMAKE_ANDROID_STL_TYPE c++_shared) # Use C++ shared library
- set(CMAKE_ANDROID_NDK_TOOLCHAIN_FILE ${CONTRIB_PATH}/build/cmake/android.toolchain.cmake)
- set(CMAKE_ANDROID_STL_INCLUDE_DIR ${CONTRIB_PATH}/sysroot/usr/include)
- set(CMAKE_ANDROID_STL_LIBRARIES ${CONTRIB_PATH}/sysroot/usr/lib)
-endif()
-
-if(CMAKE_CXX_FLAGS_DEBUG)
- set(OUTPUT "${ProjectName}")
- set(CLANG_OPTS "-g -fsanitize=address")
- set(EXTRA_DEBUG_LIBRARIES "-lyaml-cpp")
- set(EXTRA_DEFINES "-D__DEBUG__")
-else()
- add_custom_command(
- TARGET ${ProjectName}
- PRE_BUILD
- COMMAND ${Python3_EXECUTABLE} ${SDK_PATH}/jplManipulation.py --preassemble --plugin=${ProjectName}
- COMMENT "Assembling Plugin files"
+if (PLATFORM_TYPE STREQUAL "ANDROID")
+ target_include_directories (${ProjectName} PUBLIC
+ ${ONNX_PATH}/include/onnxruntime/providers/nnapi
)
-endif()
-
-add_custom_command(
- TARGET ${ProjectName}
- PRE_BUILD
- COMMAND ${Python3_EXECUTABLE} ${SDK_PATH}/jplManipulation.py --preassemble --plugin=${ProjectName}
- COMMENT "Assembling Plugin files"
+endif ()
+
+# Link directories
+link_directories (
+ ${CONTRIB_PATH}/${CONTRIB_PLATFORM}/lib
+ ${CONTRIB_PATH}/${CONTRIB_PLATFORM}/lib/opencv4/3rdparty
+ ${ONNX_PATH}/lib/onnxruntime/${ONNX_LIBS}
+ $ENV{CUDA_HOME}/lib64
)
-# Copy shared library to jpl directory
-add_custom_command(
- TARGET ${ProjectName}
- POST_BUILD
- COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${ProjectName}> ${PLUGIN_OUTPUT_DIR}
- COMMENT "Copying output file to jpl directory"
+# Libraries to link
+set (LINK_LIBS
+ ${OpenCV_LIBS}
+ PkgConfig::avformat
+ PkgConfig::avdevice
+ PkgConfig::avfilter
+ PkgConfig::avcodec
+ PkgConfig::swresample
+ PkgConfig::swscale
+ PkgConfig::avutil
+ ${ONNX_SO_PATH}
)
-add_custom_command(
- TARGET ${ProjectName}
- POST_BUILD
- COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/modelSRC/mModel.onnx ${JPL_DIRECTORY}/data/model/
- COMMENT "Copying onnx model to jpl directory"
-)
+# Link libraries to the target
+target_link_libraries (${ProjectName} PUBLIC ${LINK_LIBS} )
-add_custom_command(
- TARGET ${ProjectName}
- POST_BUILD
- COMMAND ${Python3_EXECUTABLE} ${SDK_PATH}/jplManipulation.py --assemble --plugin=${ProjectName}
- COMMENT "Generating JPL archive"
+set_target_properties (${ProjectName} PROPERTIES
+ LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/jpl/lib/${PLATFORM}"
)
+
+# JPL manipulation commands for copying runtime files and generating JPL archive
+if (PLATFORM_TYPE STREQUAL "ANDROID")
+ add_custom_command (
+ TARGET ${ProjectName}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/modelSRC/mModel.onnx ${PROJECT_BINARY_DIR}/jpl/data/model/mModel.onnx
+ COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/modelSRC/mModel.ort ${PROJECT_BINARY_DIR}/jpl/data/model/mModel.ort
+ COMMAND ${CMAKE_COMMAND} -E copy ${ONNX_SO_PATH} ${PROJECT_BINARY_DIR}/jpl/lib/${PLATFORM}/libonnxruntime.so
+ COMMENT "Copying runtime files"
+ )
+ add_custom_command (
+ TARGET ${ProjectName}
+ PRE_BUILD
+ COMMAND ${Python3_EXECUTABLE} ${SDK_PATH}/jplManipulation.py --preassemble --plugin=${ProjectName} --distribution=android
+ COMMENT "Assembling Plugin files"
+ )
+ add_custom_command (
+ TARGET ${ProjectName}
+ POST_BUILD
+ COMMAND ${Python3_EXECUTABLE} ${SDK_PATH}/jplManipulation.py --assemble --plugin=${ProjectName} --distribution=android
+ COMMENT "Generating JPL archive"
+ )
+elseif (PLATFORM_TYPE STREQUAL "LINUX")
+ add_custom_command (
+ TARGET ${ProjectName}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/modelSRC/mModel.onnx ${PROJECT_BINARY_DIR}/jpl/data/model/mModel.onnx
+ COMMAND ${CMAKE_COMMAND} -E copy ${ONNX_SO_PATH} ${PROJECT_BINARY_DIR}/jpl/lib/${PLATFORM}/libonnxruntime.so.1.16.3
+ COMMENT "Copying runtime files"
+ )
+ add_custom_command (
+ TARGET ${ProjectName}
+ PRE_BUILD
+ COMMAND ${Python3_EXECUTABLE} ${SDK_PATH}/jplManipulation.py --preassemble --plugin=${ProjectName} --distribution=x86_64-linux-gnu
+ COMMENT "Assembling Plugin files"
+ )
+ add_custom_command (
+ TARGET ${ProjectName}
+ POST_BUILD
+ COMMAND ${Python3_EXECUTABLE} ${SDK_PATH}/jplManipulation.py --assemble --plugin=${ProjectName} --distribution=x86_64-linux-gnu
+ COMMENT "Generating JPL archive"
+ )
+endif ()
diff --git a/GreenScreen/build.md b/GreenScreen/build.md
index e89c2b1c82cb4fa8a859f229b2982fdb7ddec30f..60396cfcfa89414f27cfc2c14ed1017ad5c31c2b 100644
--- a/GreenScreen/build.md
+++ b/GreenScreen/build.md
@@ -1,23 +1,212 @@
-# How to build the GreenScreen plugin
+# Jami Plugin Build Process
-## Libraries
-You will need the opencv library that you can build with : https://docs.jami.net/fr/jami-extensions/how-to-build.html#opencv-4-1-1
+This document outlines the steps to build a Jami plugin, specifically the `GreenScreen` plugin.
+For signing it, please reffer to `jami-plugins/sign.md`
-You will need the ONNXRuntime library with cmake integration (tu use find_package(onnxruntime)) that you can find here : https://medium.com/@massimilianoriva96/onnxruntime-integration-with-ubuntu-and-cmake-5d7af482136a
+You can build it for Linux architectures (`x86_64-linux-gnu`) and also for Android architectures (`arm64-v8a`, `armeabi-v7a`, `x86_64`). The example provided uses `arm64-v8a`, but feel free to replace it with the desired architecture.
-## JPL archive
-Then, go to the GreenScreen folder and run
+## Requirements:
+
+- `git`
+- `docker`
+
+Building the plugin directly on your computer is not recommended for compatibility reasons.
+
+## Step 1: Clone Jami Repositories
+
+Clone the Jami plugin and daemon repositories:
+
+```bash
+git clone https://review.jami.net/jami-plugins
+cd jami-plugins
+```
+
+For the daemon:
+
+```bash
+git submodule update --init --recursive
+```
+
+The structure should look like this:
+
+```
+|-jami-plugins
+ |-GreenScreen
+ |-build.md
+ |-CMakeLists.txt
+ |-data
+ |-modelSRC
+ |-mModel.onnx
+ |-mModel.ort
+ |-*.cpp
+ |-*.h
+ |-daemon
+ |-contrib
+ |-SDK
+ |jplManipulation.py
+ |-docker
+ |-Dockerfile_ubuntu_20.04
+ |-Dockerfile_android
+ |-sign.md
+```
+
+## Step 2: Build Docker Image
+
+Build the Docker image using the provided Dockerfile:
+
+### Linux:
+```bash
+docker build -f docker/Dockerfile_ubuntu_20.04 -t <DockerNameToReplace> .
+```
+
+### Android:
+```bash
+docker build -f docker/Dockerfile_android -t <DockerNameToReplace> .
+```
+
+## Step 3: Run Docker and Compile Dependencies
+
+Run the following Docker command to start building dependencies:
+> The dependencies are the libraries you will include in your plugin
+
+### Linux:
+```bash
+docker run -t --rm \
+ -v $(pwd):/root/jami/:rw \
+ -w /root/ \
+ -e BATCH_MODE=1 \
+ <DockerNameToReplace> /bin/bash -c "
+ cd ./jami/daemon/contrib
+ mkdir -p native
+ cd native
+ ../bootstrap --disable-x264 --enable-ffmpeg --disable-dhtnet \
+ --disable-webrtc-audio-processing --disable-argon2 \
+ --disable-asio --enable-fmt --disable-gcrypt --disable-gmp \
+ --disable-gnutls --disable-gpg-error --disable-gsm \
+ --disable-http_parser --disable-jack --disable-jsoncpp \
+ --disable-libarchive --disable-libressl --enable-msgpack \
+ --disable-natpmp --disable-nettle --enable-opencv --enable-opendht \
+ --disable-pjproject --disable-portaudio --disable-restinio \
+ --disable-secp256k1 --disable-speex --disable-speexdsp --disable-upnp \
+ --disable-uuid --disable-yaml-cpp --enable-onnx --enable-opus && make list
+ make fetch opencv opencv_contrib
+ make -j24
+"
+```
+
+### Android:
+```bash
+docker run -t --rm \
+ -v $(pwd):/home/gradle/plugins:rw \
+ -w /home/gradle \
+ -e BATCH_MODE=1 \
+ <DockerNameToReplace> /bin/bash -c "
+ cd ./plugins/contrib
+ ANDROID_ABI='arm64-v8a' sh build-dependencies.sh
+ "
+```
+> **Note:** The build process for the `contrib` dependencies (particularly ONNX) may take a long time (~20 minutes).
+
+## Step 4: Build the Plugin
+
+Use the following command to build the `GreenScreen` plugin:
+
+### Linux:
+```bash
+docker run -t --rm \
+ -v $(pwd):/root/jami/:rw \
+ -w /root/ \
+ -e BATCH_MODE=1 \
+ <DockerNameToReplace> /bin/bash -c "
+ cd jami
+ PLATFORM_TYPE="LINUX" python3 build-plugin.py --projects='GreenScreen' --distribution=ubuntu
+"
+```
+> **Note:** If OpenCV fails to build due to a missing `libade.a`, create an empty file to bypass the issue:
+
+```bash
+sudo touch ./daemon/contrib/x86_64-linux-gnu/lib/opencv4/3rdparty/libade.a
+```
+
+### Android:
+```bash
+docker run -t --rm \
+ -v $(pwd):/home/gradle/plugins:rw \
+ -w /home/gradle \
+ -e BATCH_MODE=1 \
+ <DockerNameToReplace> /bin/bash -c "
+ export DAEMON=/home/gradle/plugins
+ cd ./plugins
+ PLATFORM_TYPE="ANDROID" ANDROID_ABI="arm64-v8a" python3 build-plugin.py --projects=GreenScreen --distribution=android
+ "
+```
+
+## Step 5: Change Ownership of the Built Plugin
+
+The default user in the Docker container who built the plugin is `root`. To manipulate the plugin, change the ownership of the output files to the current user:
+
+### Linux:
+```bash
+sudo chown ${USER}:${USER} build/
+sudo chown ${USER}:${USER} build/x86_64-linux-gnu/
+sudo chown ${USER}:${USER} build/x86_64-linux-gnu/GreenScreen.jpl
+```
+
+### Android:
```bash
-mkdir build-local
-cd build-local
-cmake ..
-cmake --build .
+sudo chown ${USER}:${USER} build/
+sudo chown ${USER}:${USER} build/android/
+sudo chown ${USER}:${USER} build/android/GreenScreen.jpl
```
-Then you will find your GreenScreen.jpl in jami-plugins/build/\<your distribution\>/
-It's the archive of your new jpl folder in build-local
+# You have now successfully built your plugin!
+## To add it to Jami, you now need to sign it by referring to `jami-plugins/sign.md`.
+
+## Additional documentation:
+
+### For a better understanding of plugins, here is what you should know:
+
+The plugins are designed to be compatible for everyone. This is challenging because there are many different systems, and each user may have different libraries installed.
+
+### About plugin building:
+The file used for the compilation is the `CMakelists.txt` in GreenScreen.
+It assembles the files, create the library and call the SDK scripts to manipulate the jpl.
+
+### About JPL Archive:
+In your folder `build/<distribution>`, you have the JPL archive, the Jami Plugin format.
+
+You can extract it like a zip, or view it before compression in your folder `jami-plugins/GreenScreen/build-local/jpl`.
+Inside, you'll find your libraries in `jpl/lib/<arch>`.
+You will find the `libGreenScreen.so`, and as in every plugin, you'll have `lib<PluginName>.so`.
+In GreenScreen, you will also find `libonnxruntime.so`, the ONNX library needed to use ONNX Runtime.
+
+### About Libraries:
+
+Libraries are built using `GreenScreen/CMakeLists.txt`.
+
+If you want your plugin to work on other computers, you need to understand that the plugin library (`libGreenScreen.so`) contains every needed library, linking them dynamically for system libraries and statically for additional libraries like OpenCV.
+
+System libraries must be dynamically linked because the user is supposed to have them installed, and statically linking them might cause compatibility issues.
+
+However, users won’t have every additional library at the required version, so you need to include the exact version in your plugin by statically linking it.
+
+Some useful commands:
+- See the linked shared libraries with `ldd libGreenScreen.so`.
+ > Helps verify that every dynamic library is found on the system.
+ > However, you can't see which library is statically linked, but you can verify if a symbol is defined.
+
+- See symbols in the library: `nm libGreenScreen.so | grep <YourSymbol>`.
+ > Helps with missing symbols during loading in Jami. "U" means undefined, and "T" means they are in the text section. See `man nm` for details.
+
+- Symbols can be hard to read. You can demangle them with `c++filt <YourSymbol>`.
+ > The symbols represent the low-level names of the functions.
+
+### About plugin's code
+
+The plugin is mainly in c++, located in the `jami-plugins/GreenScreen` folder.
+The media handler file is used to interact with jami's API (chat, audio and video).
+> e.g. receiving the frames of the video stream before transformation and sending the transformed frames.
-## Sign it
+The media subscriber file is used to modify the object received.
+> e.g. draw a mask over the background using opencv
-You still need to sign it in order to add it into jami
-Find documentation about it in jami-plugins/sign.md
diff --git a/GreenScreen/data/preferences.json b/GreenScreen/data/preferences.json
index ef1a50b25ad3aecbf6e8c8178e82d9700621d956..af038f7cff7e94486f4ca95385ff494534b1d5f7 100644
--- a/GreenScreen/data/preferences.json
+++ b/GreenScreen/data/preferences.json
@@ -8,6 +8,14 @@
"scope": "plugin,Foreground Segmentation",
"dependsOn": "!blur"
},
+ {
+ "type": "Switch",
+ "key": "acceleration",
+ "title": "{{acceleration_title}}",
+ "summary": "{{acceleration_summary}}",
+ "defaultValue": "1",
+ "scope": "plugin"
+ },
{
"type": "Switch",
"key": "blur",
diff --git a/SDK/certificate_requirements.txt b/SDK/certificate_requirements.txt
index 93e33077a804cf4e6b5f168771b67410ec2cb5a6..3dbe2e9c70edc4036f9731aa81bce7186faeb2e3 100644
--- a/SDK/certificate_requirements.txt
+++ b/SDK/certificate_requirements.txt
@@ -4,3 +4,4 @@ fs==2.4.12
pyOpenSSL==23.2.0
msgpack==1.0.5
zipp==1.0.0
+requests==2.31.0
diff --git a/SDK/jplManipulation.py b/SDK/jplManipulation.py
old mode 100644
new mode 100755
diff --git a/build-plugin.py b/build-plugin.py
index f9d8275b4fb847b18e8588ea3951ea4c7a3d00fb..e4d932d514362fb4749ad9ae4227cca417fc800c 100755
--- a/build-plugin.py
+++ b/build-plugin.py
@@ -36,7 +36,7 @@ IOS_DISTRIBUTION_NAME = "ios"
OSX_DISTRIBUTION_NAME = "osx"
ANDROID_DISTRIBUTION_NAME = "android"
WIN32_DISTRIBUTION_NAME = "win32"
-UBUNTU_DISTRIBUTION_NAME = "ubuntu"
+UNIX_DISTRIBUTION_NAME = "unix"
def parse():
parser = argparse.ArgumentParser(description='Builds Plugins projects')
@@ -75,7 +75,7 @@ def validate_args(parsed_args):
# Filter unsupported distributions.
supported_distros = [
- ANDROID_DISTRIBUTION_NAME, UBUNTU_DISTRIBUTION_NAME,
+ ANDROID_DISTRIBUTION_NAME, UNIX_DISTRIBUTION_NAME,
WIN32_DISTRIBUTION_NAME, OSX_DISTRIBUTION_NAME
]
@@ -119,7 +119,7 @@ def choose_distribution():
return 'Unknown'
-def buildPlugin(pluginPath):
+def buildPlugin(pluginPath, distribution, arch=None):
# Change the current working directory to pluginPath
os.chdir(pluginPath)
@@ -131,7 +131,12 @@ def buildPlugin(pluginPath):
os.chdir('build-local')
# Prepare build-local
- os.system('cmake ..')
+ if distribution == ANDROID_DISTRIBUTION_NAME:
+ abi=os.environ["ANDROID_ABI"]
+ ndk=os.environ["ANDROID_NDK"]
+ os.system(f'cmake .. -DCMAKE_TOOLCHAIN_FILE={ndk}/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=24 -DANDROID_ABI={abi}')
+ else:
+ os.system(f'cmake ..')
# Run the cmake build command
os.system('cmake --build .')
@@ -142,7 +147,7 @@ def main():
for i, plugin in enumerate(args.projects):
os.chdir(currentDir + "/" + plugin)
- buildPlugin(currentDir + "/" + plugin)
+ buildPlugin(currentDir + "/" + plugin, args.distribution)
if __name__ == "__main__":
main()
diff --git a/contrib/build-dependencies.sh b/contrib/build-dependencies.sh
index 74a7f0bcadfce190d2b0efd7a61770332eed706d..3f9065ae77ac17186db318292359ef9824a5067c 100755
--- a/contrib/build-dependencies.sh
+++ b/contrib/build-dependencies.sh
@@ -116,4 +116,7 @@ cd ${CONTRIB_DIR}
make list
make fetch
export PATH="$PATH:$CONTRIB_SYSROOT/bin"
-make $MAKEFLAGS .ffmpeg .fmt .opencv .onnx .freetype
+make $MAKEFLAGS .ffmpeg .fmt .msgpack .opencv .opendht .onnx .opus .freetype
+
+echo "Contribs built: .ffmpeg .fmt .msgpack .opencv .opendht .onnx .opus .freetype"
+echo "\033[1;32mContribs built successfully \033[1;0m"
diff --git a/docker/Dockerfile_android b/docker/Dockerfile_android
new file mode 100644
index 0000000000000000000000000000000000000000..1cb522da7c3098da0c67702b9780ba0b3985e3bf
--- /dev/null
+++ b/docker/Dockerfile_android
@@ -0,0 +1,91 @@
+FROM gradle:jdk17-jammy
+
+ENV LANG en_US.utf8
+ENV LC_ALL en_US.utf8
+ENV DEBIAN_FRONTEND noninteractive
+
+# Script dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+ apt-transport-https \
+ ca-certificates \
+ gnupg \
+ software-properties-common \
+ wget
+
+# Jami build dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+ asciidoc \
+ autoconf \
+ autogen \
+ automake \
+ autopoint \
+ bc \
+ bison \
+ build-essential \
+ bzip2 \
+ cmake \
+ curl \
+ doxygen \
+ gettext \
+ git \
+ lib32stdc++6 \
+ lib32z1 \
+ libpcre2-dev \
+ libpcre3 \
+ libpcre3-dev \
+ libtool \
+ locales \
+ m4 \
+ nasm \
+ ninja-build \
+ pkg-config \
+ python-is-python3 \
+ ruby \
+ ruby-dev \
+ ssh \
+ unzip \
+ yasm \
+ zip \
+ && locale-gen $LANG $LC_ALL && update-locale $LANG $LC_ALL
+
+# CMake 3.26
+ADD contrib/install-cmake.sh /opt/install-cmake.sh
+RUN /opt/install-cmake.sh
+
+# Swig
+#RUN wget -O /tmp/swig.tar.gz https://github.com/swig/swig/archive/v4.2.1.tar.gz && \
+# tar xzf /tmp/swig.tar.gz -C /opt && \
+# cd /opt/swig-4.2.1/ && ./autogen.sh && ./configure && make && make install && \
+# cd .. && rm -rf /opt/swig-4.2.1 /tmp/swig.tar.gz
+
+# Install Fastlane
+RUN gem install fastlane -NV
+
+# Install Commandlinetools.
+ENV ANDROID_SDK_ROOT=/opt/android
+ARG ANDROID_CMD="commandlinetools-linux-11076708_latest.zip"
+RUN wget https://dl.google.com/android/repository/${ANDROID_CMD} -P /tmp && \
+ unzip -d $ANDROID_SDK_ROOT /tmp/$ANDROID_CMD && \
+ mkdir -p $ANDROID_SDK_ROOT/cmdline-tools/tools && cd $ANDROID_SDK_ROOT/cmdline-tools && mv NOTICE.txt source.properties bin lib tools/ && \
+ cd $ANDROID_SDK_ROOT/cmdline-tools/tools && ls
+ENV PATH "$PATH:$ANDROID_SDK_ROOT/cmdline-tools/tools:$ANDROID_SDK_ROOT/cmdline-tools/tools/bin:$ANDROID_SDK_ROOT/emulator:$ANDROID_SDK_ROOT/tools/bin:$ANDROID_SDK_ROOT/platform-tools:$ANDROID_SDK_ROOT/build-tools/${BUILD_TOOLS}"
+
+# Install android SDK libraries, NDK.
+ARG API_LEVEL="34"
+ARG BUILD_TOOLS="34.0.0"
+RUN sdkmanager --update
+RUN yes Y | sdkmanager --licenses
+RUN sdkmanager --channel=1 --no_https "platforms;android-${API_LEVEL}" \
+ 'extras;android;m2repository' \
+ 'extras;google;m2repository' \
+ 'ndk;26.3.11579264' \
+ "build-tools;${BUILD_TOOLS}"
+ENV ANDROID_SDK=${ANDROID_SDK_ROOT}
+ENV ANDROID_NDK=${ANDROID_SDK_ROOT}/ndk/26.3.11579264
+
+# Define environment variables.
+ENV JAVA_HOME=/opt/java/openjdk/
+ENV ANDROID_HOME=/opt/android
+ENV PATH="$PATH:/opt/java/openjdk/bin:$ANDROID_SDK_ROOT/cmdline-tools/tools:$ANDROID_SDK_ROOT/cmdline-tools/tools/bin:$ANDROID_SDK_ROOT/emulator:$ANDROID_SDK_ROOT/tools/bin:$ANDROID_SDK_ROOT/platform-tools:$ANDROID_SDK_ROOT/build-tools/${BUILD_TOOLS}"
+
+CMD [ "/bin/bash" ]
\ No newline at end of file
diff --git a/docker/Dockerfile_ubuntu_20.04 b/docker/Dockerfile_ubuntu_20.04
index 16cf4ed47e3d17229a83555cbd8eb13f241ed98f..488cd489cfcc802d35a6cc67b7fb488befe38f93 100644
--- a/docker/Dockerfile_ubuntu_20.04
+++ b/docker/Dockerfile_ubuntu_20.04
@@ -1,6 +1,8 @@
FROM ubuntu:20.04
+ENV DISABLE_PIPEWIRE=true
ENV DEBIAN_FRONTEND noninteractive
+ENV WITH_FREETYPE=1
# Speed up mk-build-deps
RUN apt-get clean && \
@@ -30,7 +32,7 @@ RUN apt-get clean && \
libcanberra-gtk3-dev \
libclutter-gtk-1.0-dev \
libclutter-1.0-dev \
- libfreetype-dev \
+ libfreetype6-dev \
libglib2.0-dev \
libgtk-3-dev \
libnotify-dev \
@@ -53,11 +55,6 @@ RUN apt-get clean && \
libspeex-dev \
libspeexdsp-dev \
uuid-dev \
- libavcodec-dev \
- libavutil-dev \
- libavformat-dev \
- libswscale-dev \
- libavdevice-dev \
libopus-dev \
libudev-dev \
libgsm1-dev \
@@ -78,18 +75,15 @@ RUN apt-get clean && \
lcov gcovr \
libxcb-shape0-dev \
ninja-build \
- libsystemd-dev
-
-ENV DISABLE_PIPEWIRE=true
-RUN apt-get install -y python3 python3-pip python3-setuptools \
- python3-wheel
-
-RUN ls -la /usr/include/c++/8/charconv
+ libsystemd-dev \
+ python3 \
+ python3-pip \
+ python3-setuptools \
+ python3-wheel
# CMake 3.26
ADD contrib/install-cmake.sh /opt/install-cmake.sh
RUN /opt/install-cmake.sh
RUN chown 1001:1001 /root
-ENV WITH_FREETYPE=1
WORKDIR /root
diff --git a/sign.md b/sign.md
index ae2bafe2f76aeccc5f307344f22fce80be0a0f76..4f4ed9f562028bab8cd70f49f3621d63cdbc044c 100644
--- a/sign.md
+++ b/sign.md
@@ -1,8 +1,9 @@
+
# Certifying and Adding Your Plugin to Jami
To add your plugin built on Jami, you need to certify it by signing it with keys and certificates.
-First, you will generate a unique developer key and certificate, which will be used to create a certificate for each plugin. Then, you will sign your plugin archive (.jpl) using the plugin’s certificate key.
+First, you will generate a unique developer key and certificate, which will be used to create a certificate for each plugin. Then, you will sign your jami plugin archive (.jpl) using the plugin’s certificate key.
After that, you will be able to add your signed plugin to Jami.
@@ -20,7 +21,6 @@ Install the necessary dependencies in a Python environment:
cd jami-plugins/SDK
pip install -r requirements.txt
pip install -r certificate_requirements.txt
-pip install requests
```
## Create the Developer Key and Certificate
@@ -52,7 +52,7 @@ openssl x509 -in ../certificate/<CertificateName.crt> -text -noout
Sign your plugin archive using the created certificate:
```bash
-python3 ./certKey.py --plugin sign --issuer ../certificate/<YourPlugin> --path ../build/<your distribution>/<YourPlugin.jpl> ../build/<your distribution>/signed/<YourPluginSigned>
+python3 ./certKey.py --plugin sign --issuer ../certificate/<YourPlugin> --path ../build/<your distribution>/<YourPlugin.jpl> ../build/<YourDistribution>/signed/<YourPluginSigned>
```
## Complete example with developer=Alexandre, plugin=AudioFilter, distribution=x86_64-linux-gnu:
@@ -67,13 +67,15 @@ python3 ./certKey.py --plugin sign --issuer ../certificate/AudioFilter --path ..
## Display the Signed Files
-Verify that the signed file is generated correctly:
+
+Verify that the signed archive is generated correctly:
```bash
-ls ../build/<your distribution>/signed
+ls ../build/<YourDistribution>/signed
```
## Add Your Plugin to Jami
You can now add your signed `.jpl` archive to Jami.
+>**Note:** On Android, the application verifies that your plugin is not self-signed but signed by the root SFL store CA. To disable this verification, you can set `force=true` in `JamiPluginManager::installPlugin` in `daemon/src/plugin/jamipluginmanager.cpp`. This will bypass the validity check but you still need to sign it.