apps/FastDeploy
1
0
Fork 0
mirror of https://github.com/PaddlePaddle/FastDeploy.git synced 2025-10-05 00:33:03 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[Android] support fastdeploy build with static deps(60Mb->29~31Mb) (#1176)

Browse Source 
* [Android] support fastdeploy build with static deps(70Mb->17~19Mb)

* [Android] support fastdeploy build with static deps(60Mb->29~30Mb)

* fixed ci

* fixed ci

* [staticlib] support fd android static lib

* [static] optimize bundle_static_library func

* [staticlib] add api_helpers.h -> staticlib headers

* [staticlib] add api_helpers.h -> staticlib headers

* [staticlib] add api_helpers.h -> staticlib headers

* [staticlib] Fixed Paddle Lite paddle_use_kernels.h to support fd armv7 static lib

* [staticlib] Add strip -> fd static lib target

* [staticlib] optimize bundle_static_library func

* [staticlib] add strip for fd static lib on  mac osx

* [staticlib] move api_helpers -> lite/option

* [staticlib] optimize bundle_static_library

* [staticlib] add Android limit
This commit is contained in:
DefTruth
2023-01-30 19:39:56 +08:00
committed by GitHub
parent 595ca69251
commit 2613e9c5d0
19 changed files with 918 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
CMakeLists.txt
View File

@@ -48,8 +48,8 @@ endif()
if(ANDROID)
# To reduce the volume of the library
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g0 -Ofast -ffunction-sections -fdata-sections")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g0 -Ofast -ffunction-sections -fdata-sections")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g0 -Ofast -ffast-math -ffunction-sections -fdata-sections")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g0 -Ofast -ffast-math -ffunction-sections -fdata-sections")
endif()
############################# Basic Options for FastDeploy ################################
@@ -74,10 +74,14 @@ option(WITH_KUNLUNXIN "Whether to compile for KunlunXin XPU deploy." OFF)
option(WITH_TESTING "Whether to compile with unittest." OFF)
############################# Options for Android cross compiling #########################
option(WITH_OPENCV_STATIC "Use OpenCV static lib for Android." OFF)
option(WITH_LITE_STATIC "Use Paddle Lite static lib for Android." OFF)
option(WITH_OPENMP "Use OpenMP support for Android." OFF)
if(ANDROID)
option(WITH_OPENCV_STATIC "Whether to use OpenCV static lib for Android." OFF)
option(WITH_LITE_STATIC "Whether to use OpenCV Paddle Lite static lib for Android." OFF)
option(WITH_FLYCV_STATIC "Whether to use OpenCV FlyCV static lib for Android." OFF)
option(WITH_OPENMP "Whether to use OpenCV OpenMP support for Android." OFF)
option(WITH_JAVA "Whether to build jni lib for Android." OFF)
option(WITH_STATIC_LIB "Whether to build FastDeploy static lib." OFF)
endif()
# Whether to build fastdeploy with vision/text/... examples, only for testings.
option(BUILD_EXAMPLES "Whether to build fastdeploy with vision examples" OFF)
@@ -198,6 +202,9 @@ endif()
if(ENABLE_LITE_BACKEND)
add_definitions(-DENABLE_LITE_BACKEND)
if(WITH_LITE_STATIC)
add_definitions(-DWITH_LITE_STATIC)
endif()
include(${PROJECT_SOURCE_DIR}/cmake/paddlelite.cmake)
list(APPEND ALL_DEPLOY_SRCS ${DEPLOY_LITE_SRCS})
list(APPEND DEPEND_LIBS external_paddle_lite)
@@ -372,7 +379,7 @@ if(ENABLE_VISION)
if(ENABLE_FLYCV)
add_definitions(-DENABLE_FLYCV)
include(${PROJECT_SOURCE_DIR}/cmake/flycv.cmake)
list(APPEND DEPEND_LIBS external_flycv)
list(APPEND DEPEND_LIBS ${FLYCV_LIBRARIES})
endif()
if(ENABLE_CVCUDA)
@@ -402,7 +409,6 @@ if(ENABLE_PADDLE2ONNX)
list(APPEND DEPEND_LIBS external_paddle2onnx)
endif(ENABLE_PADDLE2ONNX)
configure_file(${PROJECT_SOURCE_DIR}/FastDeploy.cmake.in ${PROJECT_SOURCE_DIR}/FastDeploy.cmake @ONLY)
configure_file(${PROJECT_SOURCE_DIR}/python/fastdeploy/c_lib_wrap.py.in ${PROJECT_SOURCE_DIR}/python/fastdeploy/c_lib_wrap.py)
configure_file(${PROJECT_SOURCE_DIR}/python/scripts/process_libraries.py.in ${PROJECT_SOURCE_DIR}/python/scripts/process_libraries.py)
@@ -454,16 +460,40 @@ endif()
if(ANDROID)
find_library(log-lib log)
list(APPEND DEPEND_LIBS ${log-lib})
if(WITH_OPENMP)
find_package(OpenMP)
if(OpenMP_CXX_FOUND)
list(APPEND DEPEND_LIBS OpenMP::OpenMP_CXX)
if(WITH_LITE_STATIC)
# need omp for static Paddle Lite lib
set(WITH_OPENMP ON CACHE BOOL "Force WITH_OPENMP=ON while WITH_LITE_STATIC=ON" FORCE)
message(STATUS "Force WITH_OPENMP=${WITH_OPENMP} while WITH_LITE_STATIC=ON")
endif()
if(WITH_OPENMP)
include(${PROJECT_SOURCE_DIR}/cmake/openmp.cmake)
endif()
endif()
target_link_libraries(${LIBRARY_NAME} ${DEPEND_LIBS})
################################ JNI & STATIC LIB: FastDeploy Android JNI & STATIC Lib ###############################
if(ANDROID AND WITH_JAVA)
include(${PROJECT_SOURCE_DIR}/cmake/fastdeploy_jni.cmake)
endif()
if(ANDROID AND WITH_STATIC_LIB)
# Here, we use a dummy target (fastdelpoy_dummy)
# to form a build dependency tree for fastdeploy_static lib.
add_library(fastdelpoy_dummy STATIC ${ALL_DEPLOY_SRCS})
# Still add ${DEPEND_LIBS} for cmake to form link_libraries
# property tree for a static library.
target_link_libraries(fastdelpoy_dummy ${DEPEND_LIBS})
# Build fastdelpoy_dummy when the third-party
# libraries (opencv, paddle lite, flycv) are ready.
add_dependencies(fastdelpoy_dummy ${LIBRARY_NAME})
# Add WITH_STATIC_LIB compile definitions, see lite_backend.cc.
target_compile_definitions(fastdelpoy_dummy PRIVATE WITH_STATIC_LIB)
target_compile_definitions(fastdelpoy_dummy PRIVATE WITH_STATIC_LIB_AT_COMPILING)
bundle_static_library(fastdelpoy_dummy fastdeploy_static bundle_fastdeploy)
endif()
##################################### Examples ####################################
if(WIN32)
if(ENABLE_VISION)
if("${CMAKE_GENERATOR}" STREQUAL "Ninja")
@@ -507,10 +537,34 @@ if(WIN32)
RUNTIME DESTINATION lib
)
elseif(ANDROID)
if(WITH_STATIC_LIB)
install(
FILES
${CMAKE_CURRENT_BINARY_DIR}/libfastdeploy_static.a
DESTINATION lib/${ANDROID_ABI}
)
else()
install(
TARGETS ${LIBRARY_NAME}
LIBRARY DESTINATION lib/${ANDROID_ABI}
)
endif()
# Install omp into fastdeploy lib dir if WITH_OPENMP=ON
# and WITH_LITE_STATIC=OFF.
if(WITH_OPENMP AND (NOT WITH_LITE_STATIC) AND OpenMP_CXX_FOUND AND ENABLE_OPENMP_SHARED)
install(
FILES
${OpenMP_CXX_LIBRARIES}
DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/${ANDROID_ABI}
)
endif()
# install Android JNI lib
if(WITH_JAVA)
install(
TARGETS fastdeploy_jni
LIBRARY DESTINATION jni/${ANDROID_ABI}
)
endif()
else()
install(
TARGETS ${LIBRARY_NAME}
@@ -524,10 +578,70 @@ install(
PATTERN "*.h"
PATTERN "${PROJECT_SOURCE_DIR}/${CSRCS_DIR_NAME}/fastdeploy/runtime/backends/*/*.h"
)
if(NOT ANDROID)
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs
)
else()
# opencv/flycv always needs to be provided to users because our api
# explicitly depends on opencv's and flycv's api in headers.
# The headers and libs of opencv must be install.
if(ENABLE_VISION)
if(WITH_OPENCV_STATIC AND WITH_STATIC_LIB)
# Only need to install headers while building
# FastDeploy static lib. (TODO:qiuyanjun)
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/opencv/sdk/native/jni/include
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install/opencv/sdk/native/jni
)
else()
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/opencv
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
)
endif()
endif()
# only need flycv's headers (may also install libs? TODO:qiuyanjun)
if(ENABLE_FLYCV)
if(WITH_FLYCV_STATIC)
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/flycv/include
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install/flycv
)
else()
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/flycv
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
)
endif()
endif()
# fast_tokenizer's static lib is not avaliable now!
# may support some days later(TODO:qiuyanjun)
if(ENABLE_TEXT)
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/fast_tokenizer
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
)
endif()
# some libs may not to install while in static mode
if(ENABLE_LITE_BACKEND)
if(WITH_LITE_STATIC)
if(WITH_STATIC_LIB)
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/paddlelite/include
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install/paddlelite
)
endif()
else()
install(
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install/paddlelite
DESTINATION ${CMAKE_INSTALL_PREFIX}/third_libs/install
)
endif()
endif()
endif()
if(WIN32 AND BUILD_EXAMPLES)
get_windows_path(_tmp_install_dir ${CMAKE_CURRENT_BINARY_DIR}/third_libs/install)
@@ -550,13 +664,16 @@ install(
${PROJECT_SOURCE_DIR}/FastDeploy.cmake
${PROJECT_SOURCE_DIR}/cmake/FastDeployConfig.cmake
${PROJECT_SOURCE_DIR}/cmake/utils.cmake
${PROJECT_SOURCE_DIR}/cmake/openmp.cmake
DESTINATION ${CMAKE_INSTALL_PREFIX}
)
if(NOT ANDROID)
install(
DIRECTORY ${PROJECT_SOURCE_DIR}/examples
DESTINATION ${CMAKE_INSTALL_PREFIX}
)
endif()
install(
FILES ${PROJECT_SOURCE_DIR}/cmake/gflags.cmake

126
FastDeploy.cmake.in Executable file → Normal file
View File

@@ -21,6 +21,9 @@ set(PADDLEINFERENCE_VERSION @PADDLEINFERENCE_VERSION@)
set(OPENVINO_VERSION @OPENVINO_VERSION@)
set(WITH_LITE_STATIC @WITH_LITE_STATIC@)
set(WITH_OPENCV_STATIC @WITH_OPENCV_STATIC@)
set(WITH_FLYCV_STATIC @WITH_FLYCV_STATIC@)
set(WITH_OPENMP @WITH_OPENMP@)
set(WITH_JAVA @WITH_JAVA@)
set(OPENCV_FILENAME @OPENCV_FILENAME@)
set(OPENVINO_FILENAME @OPENVINO_FILENAME@)
set(PADDLELITE_FILENAME @PADDLELITE_FILENAME@)
@@ -30,6 +33,10 @@ set(ORT_DIRECTORY "@ORT_DIRECTORY@")
set(OPENVINO_DIRECTORY "@OPENVINO_DIRECTORY@")
set(RKNN2_TARGET_SOC "@RKNN2_TARGET_SOC@")
set(WITH_KUNLUNXIN @WITH_KUNLUNXIN@)
# Whether to use FastDeploy static lib. The default
# value for this option is determined by the SDK
# build-time options.
set(WITH_STATIC_LIB @WITH_STATIC_LIB@)
set(FASTDEPLOY_LIBS "")
set(FASTDEPLOY_INCS "")
@@ -45,10 +52,38 @@ if(NOT MSVC)
add_definitions(-D_GLIBCXX_USE_CXX11_ABI=1)
endif(NOT MSVC)
# Set FastDeploy static lib definitions
if(WITH_LITE_STATIC)
add_definitions(-DWITH_LITE_STATIC)
endif()
if(WITH_STATIC_LIB)
add_definitions(-DWITH_STATIC_LIB)
# add_definitions(-DWITH_STATIC_WARNING)
endif()
# Still need omp while using FastDeploy static lib.
# This is due to the use of openmp for Paddle Lite's
# static library.
if(ANDROID AND WITH_STATIC_LIB AND WITH_LITE_STATIC)
include(${CMAKE_CURRENT_LIST_DIR}/openmp.cmake)
endif()
if(ANDROID)
add_library(fastdeploy STATIC IMPORTED GLOBAL)
set_property(TARGET fastdeploy PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/lib${LIBRARY_NAME}.so)
if(WITH_STATIC_LIB)
set_property(TARGET fastdeploy PROPERTY IMPORTED_LOCATION
${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/lib${LIBRARY_NAME}_static.a)
else()
set_property(TARGET fastdeploy PROPERTY IMPORTED_LOCATION
${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/lib${LIBRARY_NAME}.so)
endif()
list(APPEND FASTDEPLOY_LIBS fastdeploy)
if(WITH_OPENMP AND (NOT WITH_LITE_STATIC))
add_library(fastdeploy_omp STATIC IMPORTED GLOBAL)
set_property(TARGET fastdeploy_omp PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/lib/${ANDROID_ABI}/libomp.so)
list(APPEND FASTDEPLOY_LIBS fastdeploy_omp)
endif()
else()
find_library(FDLIB ${LIBRARY_NAME} ${CMAKE_CURRENT_LIST_DIR}/lib NO_DEFAULT_PATH)
list(APPEND FASTDEPLOY_LIBS ${FDLIB})
@@ -108,7 +143,11 @@ endif()
if(ENABLE_LITE_BACKEND)
set(LITE_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${PADDLELITE_FILENAME})
if(ANDROID)
if(NOT WITH_LITE_STATIC)
if(WITH_LITE_STATIC)
if(WITH_STATIC_LIB)
list(APPEND FASTDEPLOY_INCS ${LITE_DIR}/include)
endif()
else()
add_library(paddle_full_api_shared STATIC IMPORTED GLOBAL)
set_property(TARGET paddle_full_api_shared PROPERTY IMPORTED_LOCATION ${LITE_DIR}/lib/${ANDROID_ABI}/libpaddle_full_api_shared.so)
list(APPEND FASTDEPLOY_LIBS paddle_full_api_shared)
@@ -169,6 +208,7 @@ if(ENABLE_VISION)
else()
if(ANDROID)
set(OpenCV_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${OPENCV_FILENAME}/sdk/native/jni)
set(OpenCV_NATIVE_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${OPENCV_FILENAME}/sdk/native)
else()
set(OpenCV_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/${OPENCV_FILENAME})
if(WIN32)
@@ -179,9 +219,18 @@ if(ENABLE_VISION)
message(STATUS "The path of OpenCV is ${OpenCV_DIR}.")
if(ANDROID)
if(WITH_OPENCV_STATIC)
if(WITH_STATIC_LIB)
# Only need the headers of opencv while using FastDeploy static lib.
list(APPEND FASTDEPLOY_INCS ${OpenCV_DIR}/include)
else()
find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
list(APPEND FASTDEPLOY_INCS ${OpenCV_INCLUDE_DIRS})
list(APPEND FASTDEPLOY_LIBS ${OpenCV_LIBS})
# For now, we still need to link OpenCV static libs.
# Users may use some of opencv's apis, but they may
# not have been compiled into fastdeploy.
# list(APPEND FASTDEPLOY_LIBS ${OpenCV_LIBS})
list(APPEND FASTDEPLOY_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs)
endif()
else()
set(OpenCV_INCLUDE_DIRS ${OpenCV_DIR}/include)
get_filename_component(OpenCV_NATIVE_DIR ${OpenCV_DIR} DIRECTORY)
@@ -211,9 +260,26 @@ if(ENABLE_VISION)
include_directories(${CMAKE_CURRENT_LIST_DIR}/third_libs/install/flycv/include)
set(FLYCV_LIB_DIR ${CMAKE_CURRENT_LIST_DIR}/third_libs/install/flycv/lib)
if(ANDROID)
if(NOT WITH_FLYCV_STATIC)
add_library(flycv_shared STATIC IMPORTED GLOBAL)
set_property(TARGET flycv_shared PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libflycv_shared.so)
list(APPEND FASTDEPLOY_LIBS flycv_shared)
else()
# This code may be needed later. Therefore, I choose to
# comment it rather than delete it. (TODO:qiuyanjun)
# add_library(flycv_static STATIC IMPORTED GLOBAL)
# add_library(flycv_png16 STATIC IMPORTED GLOBAL)
# add_library(flycv_turbojpeg STATIC IMPORTED GLOBAL)
# add_library(flycv_z STATIC IMPORTED GLOBAL)
# set_property(TARGET flycv_static PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libflycv_static.a)
# set_property(TARGET flycv_png16 PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libpng16.a)
# set_property(TARGET flycv_turbojpeg PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libturbojpeg.a)
# set_property(TARGET flycv_z PROPERTY IMPORTED_LOCATION ${FLYCV_LIB_DIR}/${ANDROID_ABI}/libz.a)
# list(APPEND FASTDEPLOY_LIBS flycv_static)
# list(APPEND FASTDEPLOY_LIBS flycv_png16)
# list(APPEND FASTDEPLOY_LIBS flycv_turbojpeg)
# list(APPEND FASTDEPLOY_LIBS flycv_z)
endif()
else()
find_library(FLYCV_LIB flycv_shared ${FLYCV_LIB_DIR} NO_DEFAULT_PATH)
list(APPEND FASTDEPLOY_LIBS ${FLYCV_LIB})
@@ -258,13 +324,19 @@ if(WITH_KUNLUNXIN)
list(APPEND FASTDEPLOY_LIBS -lpthread -lrt -ldl)
endif()
# log lib for Android
if(ANDROID)
find_library(log-lib log)
list(APPEND FASTDEPLOY_LIBS ${log-lib})
endif()
# Update CXX LINKER's FLAGS, reference: https://zhuanlan.zhihu.com/p/595527528
if(ANDROID AND (WITH_OPENCV_STATIC OR WITH_LITE_STATIC))
set(COMMON_LINK_FLAGS_REL "-Wl,-s,--gc-sections,-exclude-libs,ALL")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${COMMON_LINK_FLAGS_REL} -Wl,-allow-multiple-definition" CACHE INTERNAL "" FORCE)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${COMMON_LINK_FLAGS_REL} -Wl,-allow-multiple-definition" CACHE INTERNAL "" FORCE)
endif()
remove_duplicate_libraries(FASTDEPLOY_LIBS)
# Print compiler information
@@ -276,6 +348,14 @@ message(STATUS " System : ${CMAKE_SYSTEM_NAME}")
message(STATUS " C++ compiler : ${CMAKE_CXX_COMPILER}")
message(STATUS " C++ compiler version : ${CMAKE_CXX_COMPILER_VERSION}")
message(STATUS " CXX flags : ${CMAKE_CXX_FLAGS}")
message(STATUS " EXE linker flags : ${CMAKE_EXE_LINKER_FLAGS}")
message(STATUS " Shared linker flags : ${CMAKE_SHARED_LINKER_FLAGS}")
get_directory_property(tmp DIRECTORY ${PROJECT_SOURCE_DIR} COMPILE_DEFINITIONS)
message(STATUS " Compile definitions : ${tmp}")
message(STATUS " CMAKE_PREFIX_PATH : ${CMAKE_PREFIX_PATH}")
message(STATUS " CMAKE_INSTALL_PREFIX : ${CMAKE_INSTALL_PREFIX}")
message(STATUS " CMAKE_MODULE_PATH : ${CMAKE_MODULE_PATH}")
message(STATUS "")
message(STATUS " WITH_GPU : ${WITH_GPU}")
message(STATUS " ENABLE_ORT_BACKEND : ${ENABLE_ORT_BACKEND}")
message(STATUS " ENABLE_RKNPU2_BACKEND : ${ENABLE_RKNPU2_BACKEND}")
@@ -315,10 +395,15 @@ if(ANDROID)
message(STATUS " ANDROID_ABI : ${ANDROID_ABI}")
message(STATUS " ANDROID_PLATFORM : ${ANDROID_PLATFORM}")
message(STATUS " ANDROID_NDK : ${ANDROID_NDK}")
message(STATUS " ANDROID_NDK_MAJOR : ${ANDROID_NDK_MAJOR}")
message(STATUS " WITH_STATIC_LIB: : ${WITH_STATIC_LIB}")
message(STATUS " WITH_OPENCV_STATIC: : ${WITH_OPENCV_STATIC}")
message(STATUS " WITH_FLYCV_STATIC: : ${WITH_FLYCV_STATIC}")
if(ENABLE_LITE_BACKEND)
message(STATUS " WITH_LITE_STATIC : ${WITH_LITE_STATIC}")
endif()
message(STATUS " WITH_OPENMP: : ${WITH_OPENMP}")
message(STATUS " WITH_JAVA: : ${WITH_JAVA}")
endif()
message(STATUS " DEPENDENCY_LIBS : ${FASTDEPLOY_LIBS}")
@@ -330,6 +415,11 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
endif()
function(install_fastdeploy_libraries DESTINATION_DIR)
# No dynamic libs need to install while using
# FastDeploy static lib.
if(WITH_STATIC_LIB)
return()
endif()
set(DYN_LIB_SUFFIX "*.so*")
if(WIN32)
set(DYN_LIB_SUFFIX "*.dll")
@@ -343,28 +433,48 @@ function(install_fastdeploy_libraries DESTINATION_DIR)
else()
message(FATAL_ERROR "Please set FastDeploy_DIR/FASTDEPLOY_INSTALL_DIR before call install_fastdeploy_libraries.")
endif()
file(GLOB_RECURSE ALL_NEED_DYN_LIBS ${DYN_SEARCH_DIR}/${DYN_LIB_SUFFIX})
file(GLOB_RECURSE ALL_NEED_DYN_LIBS ${DYN_SEARCH_DIR}/lib/${DYN_LIB_SUFFIX})
file(GLOB_RECURSE ALL_DEPS_DYN_LIBS ${DYN_SEARCH_DIR}/third_libs/${DYN_LIB_SUFFIX})
if(ENABLE_VISION)
# OpenCV
if(ANDROID)
file(GLOB_RECURSE ALL_OPENCV_DYN_LIBS ${OpenCV_NATIVE_DIR}/libs/${DYN_LIB_SUFFIX})
else()
file(GLOB_RECURSE ALL_OPENCV_DYN_LIBS ${OpenCV_DIR}/${DYN_LIB_SUFFIX})
list(REMOVE_ITEM ALL_NEED_DYN_LIBS ${ALL_OPENCV_DYN_LIBS})
# Only Install the necessary libraries
endif()
list(REMOVE_ITEM ALL_DEPS_DYN_LIBS ${ALL_OPENCV_DYN_LIBS})
if(NOT WITH_OPENCV_STATIC)
if(WIN32)
file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/x64/vc15/bin/${DYN_LIB_SUFFIX})
elseif(ANDROID)
file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/libs/${ANDROID_ABI}/${DYN_LIB_SUFFIX})
file(GLOB OPENCV_DYN_LIBS ${OpenCV_NATIVE_DIR}/libs/${ANDROID_ABI}/${DYN_LIB_SUFFIX})
else() # linux/mac
file(GLOB OPENCV_DYN_LIBS ${OpenCV_DIR}/lib/${DYN_LIB_SUFFIX})
endif()
file(INSTALL ${OPENCV_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
endif()
# FlyCV
if(ENABLE_FLYCV)
file(GLOB_RECURSE ALL_FLYCV_DYN_LIBS ${FLYCV_LIB_DIR}/${DYN_LIB_SUFFIX})
list(REMOVE_ITEM ALL_DEPS_DYN_LIBS ${ALL_FLYCV_DYN_LIBS})
if(NOT WITH_FLYCV_STATIC)
file(INSTALL ${ALL_FLYCV_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
endif()
endif()
endif()
if(ENABLE_OPENVINO_BACKEND)
# need plugins.xml for openvino backend
set(OPENVINO_RUNTIME_BIN_DIR ${OPENVINO_DIR}/bin)
file(GLOB OPENVINO_PLUGIN_XML ${OPENVINO_RUNTIME_BIN_DIR}/*.xml)
file(INSTALL ${OPENVINO_PLUGIN_XML} DESTINATION ${DESTINATION_DIR})
endif()
# Install other libraries
file(INSTALL ${ALL_NEED_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
file(INSTALL ${ALL_DEPS_DYN_LIBS} DESTINATION ${DESTINATION_DIR})
endfunction()

52
cmake/fastdeploy_jni.cmake Normal file
View File

@@ -0,0 +1,52 @@
# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
if(WITH_JAVA)
set(JNI_SRCS_FOUND OFF)
if(NOT ANDROID)
message(FATAL_ERROR "Only support jni lib for Android now!")
else()
set(JNI_SRCS_DIR "${PROJECT_SOURCE_DIR}/java/android/fastdeploy/src/main/cpp")
include_directories(${JNI_SRCS_DIR})
file(GLOB JNI_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/*.cc)
file(GLOB JNI_VISION_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/vision/*.cc)
file(GLOB JNI_PIPELINE_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/pipeline/*.cc)
file(GLOB JNI_TEXT_SRCS ${JNI_SRCS_DIR}/fastdeploy_jni/text/*.cc)
list(APPEND JNI_SRCS ${JNI_VISION_SRCS} ${JNI_PIPELINE_SRCS} ${JNI_TEXT_SRCS})
set(JNI_SRCS_FOUND ON CACHE BOOL "JNI SRCS Flags" FORCE)
endif()
if(JNI_SRCS_FOUND)
# Here, we use a dummy target (fastdelpoy_dummy)
# to form a build dependency tree for fastdeploy_jni lib.
add_library(fastdelpoy_jni_dummy STATIC ${ALL_DEPLOY_SRCS})
# Build fastdelpoy_jni_dummy when the third-party
# libraries (opencv, paddle lite, flycv) are ready.
add_dependencies(fastdelpoy_jni_dummy ${LIBRARY_NAME})
target_compile_definitions(fastdelpoy_jni_dummy PRIVATE WITH_JAVA)
if(TARGET fastdelpoy_jni_dummy)
add_library(fastdeploy_jni SHARED ${JNI_SRCS})
target_link_libraries(fastdeploy_jni fastdelpoy_jni_dummy ${DEPEND_LIBS}
jnigraphics GLESv2 EGL)
add_dependencies(fastdeploy_jni fastdelpoy_jni_dummy)
# Strip debug C++ symbol table
set_target_properties(fastdeploy_jni PROPERTIES COMPILE_FLAGS
"-fvisibility=hidden -fvisibility-inlines-hidden -fdata-sections -ffunction-sections")
set_target_properties(fastdeploy_jni PROPERTIES LINK_FLAGS ${COMMON_LINK_FLAGS})
set_target_properties(fastdeploy_jni PROPERTIES LINK_FLAGS_RELEASE ${COMMON_LINK_FLAGS_REL})
set_target_properties(fastdeploy_jni PROPERTIES LINK_FLAGS_MINSIZEREL ${COMMON_LINK_FLAGS_REL})
endif()
else()
message(FATAL_ERROR "Can not found Android JNI_SRCS!")
endif()
endif()

25
cmake/flycv.cmake
View File

@@ -54,9 +54,15 @@ elseif(APPLE)
"${FLYCV_INSTALL_DIR}/lib/libflycv.dylib"
CACHE FILEPATH "flycv compile library." FORCE)
elseif(ANDROID)
if(WITH_FLYCV_STATIC)
set(FLYCV_COMPILE_LIB
"${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libflycv_static.a"
CACHE FILEPATH "flycv compile library." FORCE)
else()
set(FLYCV_COMPILE_LIB
"${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libflycv_shared.so"
CACHE FILEPATH "flycv compile library." FORCE)
endif()
else()
set(FLYCV_COMPILE_LIB
"${FLYCV_INSTALL_DIR}/lib/libflycv_shared.so"
@@ -134,3 +140,22 @@ add_library(external_flycv STATIC IMPORTED GLOBAL)
set_property(TARGET external_flycv PROPERTY IMPORTED_LOCATION
${FLYCV_COMPILE_LIB})
add_dependencies(external_flycv ${FLYCV_PROJECT})
set(FLYCV_LIBRARIES external_flycv)
if(ANDROID AND WITH_FLYCV_STATIC)
add_library(external_flycv_png16 STATIC IMPORTED GLOBAL)
add_library(external_flycv_turbojpeg STATIC IMPORTED GLOBAL)
add_library(external_flycv_z STATIC IMPORTED GLOBAL)
set_property(TARGET external_flycv_png16 PROPERTY IMPORTED_LOCATION
"${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libpng16.a")
set_property(TARGET external_flycv_turbojpeg PROPERTY IMPORTED_LOCATION
"${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libturbojpeg.a")
set_property(TARGET external_flycv_z PROPERTY IMPORTED_LOCATION
"${FLYCV_INSTALL_DIR}/lib/${ANDROID_ABI}/libz.a")
add_dependencies(external_flycv_png16 ${FLYCV_PROJECT})
add_dependencies(external_flycv_turbojpeg ${FLYCV_PROJECT})
add_dependencies(external_flycv_z ${FLYCV_PROJECT})
list(APPEND FLYCV_LIBRARIES external_flycv_png16)
list(APPEND FLYCV_LIBRARIES external_flycv_turbojpeg)
list(APPEND FLYCV_LIBRARIES external_flycv_z)
endif()

6
cmake/opencv.cmake
View File

@@ -118,7 +118,8 @@ if(OPENCV_DIRECTORY)
set(OpenCV_DIR ${OPENCV_DIRECTORY})
find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
include_directories(${OpenCV_INCLUDE_DIRS})
list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
# list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
list(APPEND DEPEND_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs)
else()
set(OpenCV_INCLUDE_DIRS ${OPENCV_DIRECTORY}/include)
get_filename_component(OpenCV_NATIVE_DIR ${OPENCV_DIRECTORY} DIRECTORY)
@@ -151,7 +152,8 @@ else()
remove_redundant_opencv_android_abi_libraries(${OpenCV_DIR})
find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
include_directories(${OpenCV_INCLUDE_DIRS})
list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
# list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
list(APPEND DEPEND_LIBS opencv_core opencv_video opencv_highgui opencv_imgproc opencv_imgcodecs)
else()
# Installing OpenCV shared lib to FastDeploy third_libs/install dir.
download_and_decompress(${OPENCV_URL} ${CMAKE_CURRENT_BINARY_DIR}/${OPENCV_FILENAME}${COMPRESSED_SUFFIX} ${THIRD_PARTY_PATH}/install)

72
cmake/openmp.cmake Normal file
View File

@@ -0,0 +1,72 @@
# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
if(NOT WITH_OPENMP)
message(FATAL_ERROR "Please set WITH_OPENMP=ON before inclue openmp.cmake")
endif()
if(ANDROID)
if(NOT ANDROID_TOOLCHAIN MATCHES "clang")
message(FATAL_ERROR "Currently, only support clang toolchain while cross compiling FastDeploy for Android with OpenMP support, but found ${ANDROID_TOOLCHAIN}.")
endif()
find_package(OpenMP REQUIRED)
set(ENABLE_OPENMP_SHARED ON CACHE BOOL "" FORCE)
if(WITH_LITE_STATIC)
# Can use static/shared omp lib if WITH_LITE_STATIC=ON
if(OPENMP_FOUND OR OpenMP_CXX_FOUND)
add_definitions(-DWITH_OPENMP)
if(${ANDROID_NDK_MAJOR})
if(${ANDROID_NDK_MAJOR} GREATER 20)
set(ENABLE_OPENMP_SHARED OFF CACHE BOOL "" FORCE)
message(STATUS "ANDROID_NDK_MAJOR ${ANDROID_NDK_MAJOR} GREATER 20")
set(OPENMP_LINK_FLAGS "-fopenmp -static-openmp")
else()
set(OPENMP_LINK_FLAGS "-fopenmp")
endif()
endif()
else()
message(FATAL_ERROR "Could not found OpenMP!")
endif()
else()
if(OPENMP_FOUND OR OpenMP_CXX_FOUND)
add_definitions(-DWITH_OPENMP)
# Can only use shared omp lib if WITH_LITE_STATIC=OFF
set(OPENMP_LINK_FLAGS "-fopenmp")
else()
message(FATAL_ERROR "Could not found OpenMP!")
endif()
endif()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OPENMP_LINK_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${OPENMP_LINK_FLAGS}")
message(STATUS "Found OpenMP ${OpenMP_VERSION} ${OpenMP_CXX_VERSION}")
message(STATUS "OpenMP C flags: ${OpenMP_C_FLAGS}")
message(STATUS "OpenMP CXX flags: ${OpenMP_CXX_FLAGS}")
message(STATUS "OpenMP EXE LINKER flags: ${OPENMP_LINK_FLAGS}")
message(STATUS "OpenMP OpenMP_CXX_LIB_NAMES: ${OpenMP_CXX_LIB_NAMES}")
message(STATUS "OpenMP OpenMP_CXX_LIBRARIES: ${OpenMP_CXX_LIBRARIES}")
message(STATUS "ENABLE_OPENMP_SHARED: ${ENABLE_OPENMP_SHARED}")
elseif(WIN32)
message(FATAL_ERROR "WITH_OPENMP=ON option is not support for WIN32 now!")
elseif(APPLE)
message(FATAL_ERROR "WITH_OPENMP=ON option is not support for APPLE now!")
elseif(IOS)
message(FATAL_ERROR "WITH_OPENMP=ON option is not support for IOS now!")
else()
message(FATAL_ERROR "WITH_OPENMP=ON option is not support for Linux now!")
endif()

11
cmake/paddlelite.cmake
View File

@@ -37,9 +37,6 @@ set(CMAKE_BUILD_RPATH "${CMAKE_BUILD_RPATH}" "${PADDLELITE_LIB_DIR}")
set(PADDLELITE_URL_PREFIX "https://bj.bcebos.com/fastdeploy/third_libs")
if(ANDROID)
if(WITH_LITE_STATIC)
message(FATAL_ERROR "Doesn't support WTIH_LITE_STATIC=ON for Paddle Lite now.")
endif()
# check ABI, toolchain
if((NOT ANDROID_ABI MATCHES "armeabi-v7a") AND (NOT ANDROID_ABI MATCHES "arm64-v8a"))
message(FATAL_ERROR "FastDeploy with Paddle Lite only support armeabi-v7a, arm64-v8a now.")
@@ -53,9 +50,9 @@ if(NOT PADDLELITE_URL)
if(WIN32 OR APPLE OR IOS)
message(FATAL_ERROR "Doesn't support windows/mac/ios platform with backend Paddle Lite now.")
elseif(ANDROID)
set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-latest-dev.tgz")
set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-latest-dev1.tgz")
if(ANDROID_ABI MATCHES "arm64-v8a")
set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-fp16-latest-dev.tgz")
set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-fp16-latest-dev1.tgz")
endif()
else() # Linux
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
@@ -70,10 +67,10 @@ if(WIN32 OR APPLE OR IOS)
message(FATAL_ERROR "Doesn't support windows/mac/ios platform with backend Paddle Lite now.")
elseif(ANDROID AND WITH_LITE_STATIC)
set(PADDLELITE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_api_full_bundled.a")
set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_api_light_bundled.a")
set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_full_api_shared.so")
else()
set(PADDLELITE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_full_api_shared.so")
set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_light_api_shared.so")
set(PADDLELITE_REMOVE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_api_full_bundled.a")
endif()
include_directories(${PADDLELITE_INC_DIR})

10
cmake/summary.cmake
View File

@@ -21,6 +21,8 @@ function(fastdeploy_summary)
message(STATUS " C++ compiler : ${CMAKE_CXX_COMPILER}")
message(STATUS " C++ compiler version : ${CMAKE_CXX_COMPILER_VERSION}")
message(STATUS " CXX flags : ${CMAKE_CXX_FLAGS}")
message(STATUS " EXE linker flags : ${CMAKE_EXE_LINKER_FLAGS}")
message(STATUS " Shared linker flags : ${CMAKE_SHARED_LINKER_FLAGS}")
message(STATUS " Build type : ${CMAKE_BUILD_TYPE}")
get_directory_property(tmp DIRECTORY ${PROJECT_SOURCE_DIR} COMPILE_DEFINITIONS)
message(STATUS " Compile definitions : ${tmp}")
@@ -64,13 +66,15 @@ function(fastdeploy_summary)
message(STATUS " ANDROID_ABI : ${ANDROID_ABI}")
message(STATUS " ANDROID_PLATFORM : ${ANDROID_PLATFORM}")
message(STATUS " ANDROID_NDK : ${ANDROID_NDK}")
message(STATUS " ANDROID_NDK_VERSION : ${CMAKE_ANDROID_NDK_VERSION}")
message(STATUS " ANDROID_NDK_MAJOR : ${ANDROID_NDK_MAJOR}")
message(STATUS " WITH_STATIC_LIB: : ${WITH_STATIC_LIB}")
message(STATUS " WITH_OPENCV_STATIC: : ${WITH_OPENCV_STATIC}")
message(STATUS " WITH_FLYCV_STATIC: : ${WITH_FLYCV_STATIC}")
if(ENABLE_LITE_BACKEND)
message(STATUS " WITH_LITE_STATIC : ${WITH_LITE_STATIC}")
message(STATUS " WITH_LITE_FULL_API : ${WITH_LITE_FULL_API}")
message(STATUS " WITH_LITE_FP16 : ${WITH_LITE_FP16}")
endif()
message(STATUS " WITH_OPENMP: : ${WITH_OPENMP}")
message(STATUS " WITH_JAVA: : ${WITH_JAVA}")
endif()
if (${BUILD_FASTDEPLOY_PYTHON})
message(STATUS " Python executable : ${PYTHON_EXECUTABLE}")

146
cmake/utils.cmake
View File

@@ -73,3 +73,149 @@ function(get_osx_architecture)
set(CURRENT_OSX_ARCH ${CMAKE_HOST_SYSTEM_PROCESSOR} PARENT_SCOPE)
endif()
endfunction()
# A fake target to include all the libraries and tests the fastdeploy module depends.
add_custom_target(fd_compile_deps COMMAND echo 1)
# A function to grep LINK_ONLY dependencies from INTERFACE_LINK_LIBRARIES
function(regrex_link_only_libraries OUTPUT_DEPS PUBLIC_DEPS)
string(JOIN "#" _public_deps ${PUBLIC_DEPS})
string(REPLACE "$<LINK_ONLY:" "" _public_deps ${_public_deps})
string(REPLACE ">" "" _public_deps ${_public_deps})
string(REPLACE "#" ";" _public_deps ${_public_deps})
set(${OUTPUT_DEPS} ${_public_deps} PARENT_SCOPE)
endfunction()
# Bundle several static libraries into one. This function is modified from Paddle Lite.
# reference: https://github.com/PaddlePaddle/Paddle-Lite/blob/develop/cmake/lite.cmake#L252
function(bundle_static_library tgt_name bundled_tgt_name fake_target)
list(APPEND static_libs ${tgt_name})
add_dependencies(fd_compile_deps ${fake_target})
# Set redundant static libs here, protobuf is already available
# in the Paddle Lite static library. So, we don't need protobuf
# in opencv. And there is no need for opencv_dnn, opencv_ml,
# opencv_flann and some other modules. Therefore, we chose
# to discard these redundant modules.
set(REDUNDANT_STATIC_LIBS opencv_dnn opencv_calib3d opencv_photo
opencv_flann opencv_objdetect opencv_stitching opencv_gapi
opencv_ml libprotobuf)
function(_recursively_collect_dependencies input_target)
list(FIND REDUNDANT_STATIC_LIBS ${input_target} _input_redunant_id)
if(${_input_redunant_id} GREATER 0)
return()
endif()
set(_input_link_libraries LINK_LIBRARIES)
# https://cmake.org/cmake/help/latest/prop_tgt/TYPE.html
get_target_property(_input_type ${input_target} TYPE)
# In OpenCVModules.cmake, they set the deps of modules
# (opencv_core,...) as INTERFACE_LINK_LIBRARIES. The
# 'Type' of opencv static lib is set as 'STATIC_LIBRARY'.
if ((${_input_type} STREQUAL "INTERFACE_LIBRARY")
OR (${_input_type} STREQUAL "STATIC_LIBRARY"))
set(_input_link_libraries INTERFACE_LINK_LIBRARIES)
endif()
get_target_property(_public_dependencies ${input_target} ${_input_link_libraries})
regrex_link_only_libraries(public_dependencies "${_public_dependencies}")
foreach(dependency IN LISTS public_dependencies)
if(TARGET ${dependency})
get_target_property(alias ${dependency} ALIASED_TARGET)
if (TARGET ${alias})
set(dependency ${alias})
endif()
get_target_property(_type ${dependency} TYPE)
list(FIND REDUNDANT_STATIC_LIBS ${dependency} _deps_redunant_id)
if (${_type} STREQUAL "STATIC_LIBRARY" AND
(NOT (${_deps_redunant_id} GREATER 0)))
list(APPEND static_libs ${dependency})
endif()
get_property(library_already_added
GLOBAL PROPERTY _${tgt_name}_static_bundle_${dependency})
if (NOT library_already_added)
set_property(GLOBAL PROPERTY _${tgt_name}_static_bundle_${dependency} ON)
if(NOT (${_deps_redunant_id} GREATER 0))
_recursively_collect_dependencies(${dependency})
endif()
endif()
endif()
endforeach()
set(static_libs ${static_libs} PARENT_SCOPE)
endfunction()
_recursively_collect_dependencies(${tgt_name})
list(REMOVE_DUPLICATES static_libs)
list(REMOVE_ITEM static_libs ${REDUNDANT_STATIC_LIBS})
message(STATUS "WITH_STATIC_LIB=${WITH_STATIC_LIB}, Found all needed static libs from dependecy tree: ${static_libs}")
message(STATUS "Exclude some redundant static libs: ${REDUNDANT_STATIC_LIBS}")
set(bundled_tgt_full_name
${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${bundled_tgt_name}${CMAKE_STATIC_LIBRARY_SUFFIX})
message(STATUS "Use bundled_tgt_full_name: ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${bundled_tgt_name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
if(WIN32)
message(FATAL_ERROR "Not support FastDeploy static lib for windows now.")
endif()
add_custom_target(${fake_target} ALL COMMAND ${CMAKE_COMMAND} -E echo "Building fake_target ${fake_target}")
add_dependencies(${fake_target} ${tgt_name})
# add_dependencies(${fake_target} fastdelpoy_dummy)
if(NOT IOS AND NOT APPLE)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in
"CREATE ${bundled_tgt_full_name}\n" )
foreach(tgt IN LISTS static_libs)
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in
"ADDLIB $<TARGET_FILE:${tgt}>\n")
endforeach()
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in "SAVE\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in "END\n")
file(GENERATE
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar
INPUT ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar.in)
set(ar_tool ${CMAKE_AR})
if (CMAKE_INTERPROCEDURAL_OPTIMIZATION)
set(ar_tool ${CMAKE_CXX_COMPILER_AR})
endif()
message(STATUS "Found ar_tool: ${ar_tool}")
add_custom_command(
TARGET ${fake_target} PRE_BUILD
COMMAND rm -f ${bundled_tgt_full_name}
COMMAND ${ar_tool} -M < ${CMAKE_CURRENT_BINARY_DIR}/${bundled_tgt_name}.ar
COMMENT "Bundling ${bundled_tgt_name}"
COMMAND ${CMAKE_STRIP} --strip-unneeded ${CMAKE_CURRENT_BINARY_DIR}/lib${bundled_tgt_name}.a
COMMENT "Stripped unneeded debug symbols in ${bundled_tgt_name}"
DEPENDS ${tgt_name}
VERBATIM)
else()
foreach(lib ${static_libs})
set(libfiles ${libfiles} $<TARGET_FILE:${lib}>)
endforeach()
add_custom_command(
TARGET ${fake_target} PRE_BUILD
COMMAND rm -f ${bundled_tgt_full_name}
COMMAND /usr/bin/libtool -static -o ${bundled_tgt_full_name} ${libfiles}
COMMENT "Bundling ${bundled_tgt_name}"
COMMAND ${CMAKE_STRIP} -S ${CMAKE_CURRENT_BINARY_DIR}/lib${bundled_tgt_name}.a
COMMENT "Stripped unneeded debug symbols in ${bundled_tgt_name}"
DEPENDS ${tgt_name}
)
endif()
add_library(${bundled_tgt_name} STATIC IMPORTED GLOBAL)
set_property(TARGET ${bundled_tgt_name} PROPERTY IMPORTED_LOCATION
${bundled_tgt_full_name})
add_dependencies(${bundled_tgt_name} ${fake_target})
add_dependencies(${bundled_tgt_name} ${tgt_name})
endfunction()

2
fastdeploy/core/fd_tensor.cc
View File

@@ -380,6 +380,8 @@ FDTensor::FDTensor(const Scalar& scalar) {
case FDDataType::FP64:
(reinterpret_cast<double*>(Data()))[0] = scalar.to<double>();
break;
default:
break;
}
}

17
fastdeploy/runtime/backends/lite/lite_backend.cc
View File

@@ -13,6 +13,23 @@
// limitations under the License.
#include "fastdeploy/runtime/backends/lite/lite_backend.h"
// https://github.com/PaddlePaddle/Paddle-Lite/issues/8290
// When compiling the FastDeploy dynamic library, namely,
// WITH_STATIC_LIB=OFF, and depending on the Paddle Lite
// static library, you need to include the fake registration
// codes of Paddle Lite. When you compile the FastDeploy static
// library and depends on the Paddle Lite static library,
// WITH_STATIC_LIB=ON, you do not need to include the fake
// registration codes for Paddle Lite, but wait until you
// use the FastDeploy static library.
#if (defined(WITH_LITE_STATIC) && (!defined(WITH_STATIC_LIB)))
#warning You are compiling the FastDeploy dynamic library with \
Paddle Lite static lib We will automatically add some registration \
codes for ops, kernels and passes for Paddle Lite.
#include "paddle_use_ops.h" // NOLINT
#include "paddle_use_kernels.h" // NOLINT
#include "paddle_use_passes.h" // NOLINT
#endif
#include <cstring>

18
fastdeploy/runtime/backends/lite/option.h
View File

@@ -15,11 +15,29 @@
#pragma once
#include "fastdeploy/core/fd_type.h"
// https://github.com/PaddlePaddle/Paddle-Lite/issues/8290
#if (defined(WITH_LITE_STATIC) && defined(WITH_STATIC_LIB))
// Whether to output some warning messages when using the
// FastDepoy static library, default OFF. These messages
// are only reserve for debugging.
#if defined(WITH_STATIC_WARNING)
#warning You are using the FastDeploy static library. \
We will automatically add some registration codes for \
ops, kernels and passes for Paddle Lite.
#endif
#if !defined(WITH_STATIC_LIB_AT_COMPILING)
#include "paddle_use_ops.h" // NOLINT
#include "paddle_use_kernels.h" // NOLINT
#include "paddle_use_passes.h" // NOLINT
#endif
#endif
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <map>
namespace fastdeploy {
/*! Paddle Lite power mode for mobile device. */

2
java/android/app/src/main/java/com/baidu/paddle/fastdeploy/app/examples/segmentation/SegmentationWelcomeActivity.java
View File

@@ -20,7 +20,7 @@ public class SegmentationWelcomeActivity extends Activity {
);
getWindow().setStatusBarColor(Color.TRANSPARENT);
}
setContentView(R.layout.super_resolution_welcome);
setContentView(R.layout.segmentation_welcome);
}
public void startActivity(View view) {

4
java/android/fastdeploy/build.gradle
View File

@@ -28,7 +28,7 @@ android {
externalNativeBuild {
cmake {
path "src/main/cpp/CMakeLists.txt"
version "3.10.2"
version "3.22.1"
}
}
sourceSets {
@@ -36,7 +36,7 @@ android {
jniLibs.srcDirs = ['libs']
}
}
ndkVersion '20.1.5948944'
ndkVersion '25.1.8937393'
}
dependencies {

5
java/android/fastdeploy/src/main/cpp/CMakeLists.txt
View File

@@ -2,7 +2,7 @@
# documentation: https://d.android.com/studio/projects/add-native-code.html
# Sets the minimum version of CMake required to build the native library.
cmake_minimum_required(VERSION 3.10.2)
cmake_minimum_required(VERSION 3.22.1)
# Declares and names the project.
project("fastdeploy_jni")
@@ -15,12 +15,11 @@ project("fastdeploy_jni")
set(FastDeploy_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../libs/fastdeploy-android-latest-shared-dev")
find_package(FastDeploy REQUIRED)
# include_directories(.)
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
include_directories(${FastDeploy_INCLUDE_DIRS})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math -Ofast -Os -DNDEBUG -fomit-frame-pointer -fno-asynchronous-unwind-tables -fno-unwind-tables")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math -Ofast -DNDEBUG -fomit-frame-pointer -fno-asynchronous-unwind-tables -fno-unwind-tables")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden -fdata-sections -ffunction-sections")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,-z,nocopyreloc")

26
scripts/android/build_android_aar.sh
View File

@@ -29,9 +29,12 @@ fi
# remove old package
echo "[INFO] --- Packing ${CXX_PACKAGE_NAME} package ..."
if [ -d "${CXX_PACKAGE_NAME}" ]; then
echo "[INFO] --- Removed old package done !"
rm ${CXX_PACKAGE_NAME}.tgz
rm -rf ${CXX_PACKAGE_NAME}
echo "[INFO] --- Removed old ${CXX_PACKAGE_NAME} done !"
if [ -f "${CXX_PACKAGE_NAME}.tgz" ]; then
rm ${CXX_PACKAGE_NAME}.tgz
echo "[INFO] --- Removed old ${CXX_PACKAGE_NAME} done !"
fi
fi
# package latest c++ sdk
@@ -39,11 +42,28 @@ mkdir ${CXX_PACKAGE_NAME}
echo "[INFO] --- Collecting package contents ..."
cp -r ${ARMV7_CXX_PACKAGE_NAME}/* ${CXX_PACKAGE_NAME}/
cp -r ${ARMV8_CXX_PACKAGE_NAME}/* ${CXX_PACKAGE_NAME}/
# Fix Paddle Lite headers to support FastDeploy static lib
SDK_LITE_INCLUDE_DIR=${CXX_PACKAGE_NAME}/third_libs/install/paddlelite/include
ARMV7_LITE_INCLUDE_DIR=${ARMV7_CXX_PACKAGE_NAME}/third_libs/install/paddlelite/include
ARMV8_LITE_INCLUDE_DIR=${ARMV8_CXX_PACKAGE_NAME}/third_libs/install/paddlelite/include
rm ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
cat ${ARMV8_LITE_INCLUDE_DIR}/paddle_use_kernels.h | head -n 3 >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
echo "#if (defined(__aarch64__) || defined(_M_ARM64))" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
cat ${ARMV8_LITE_INCLUDE_DIR}/paddle_use_kernels.h | grep -v "#" | grep "USE" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
echo "#else" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
cat ${ARMV7_LITE_INCLUDE_DIR}/paddle_use_kernels.h | grep -v "#" | grep "USE" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
echo "#endif" >> ${SDK_LITE_INCLUDE_DIR}/paddle_use_kernels.h
echo "[INFO] --- Fixed Paddle Lite paddle_use_kernels.h to support FastDeploy static lib."
if [ -d "${CXX_PACKAGE_NAME}/examples" ]; then
rm -rf ${CXX_PACKAGE_NAME}/examples
fi
echo "[INFO] --- Removed examples files ..."
echo "[INFO] --- Removing static .a files: "
find ${CXX_PACKAGE_NAME}/third_libs/install/ -name "*.a"
static_files=$(find ${CXX_PACKAGE_NAME}/third_libs/install/ -name "*.a")
if [ ${#static_files[@]} -gt 10 ]; then
echo "${#static_files[@]}: ${static_files}"
rm $(find ${CXX_PACKAGE_NAME}/third_libs/install/ -name "*.a")
fi
echo "[INFO] --- Taring ${CXX_PACKAGE_NAME}.tgz package ..."
tar -zcvf ${CXX_PACKAGE_NAME}.tgz ${CXX_PACKAGE_NAME}/* >> ${BUILT_PACKAGE_DIR}/pkg.log 2>&1
echo "[INFO] --- Package ${CXX_PACKAGE_NAME}.tgz done ! Package size info: "

120
scripts/android/build_android_cpp_with_static_deps.sh Executable file
View File

@@ -0,0 +1,120 @@
#!/bin/bash
set -e
set +x
# -------------------------------------------------------------------------------
# mutable global variables
# -------------------------------------------------------------------------------
TOOLCHAIN=clang # gcc/clang toolchain
# -------------------------------------------------------------------------------
# readonly global variables
# -------------------------------------------------------------------------------
readonly ROOT_PATH=$(pwd)
readonly ANDROID_ABI=$1
readonly ANDROID_PLATFORM="android-$2"
readonly BUILD_ROOT=build/Android
readonly BUILD_DIR=${BUILD_ROOT}/${ANDROID_ABI}-api-$2
# -------------------------------------------------------------------------------
# tasks
# -------------------------------------------------------------------------------
__make_build_dir() {
if [ ! -d "${BUILD_DIR}" ]; then
echo "-- [INFO] BUILD_DIR: ${BUILD_DIR} not exists, setup manually ..."
if [ ! -d "${BUILD_ROOT}" ]; then
mkdir -p "${BUILD_ROOT}" && echo "-- [INFO] Created ${BUILD_ROOT} !"
fi
mkdir -p "${BUILD_DIR}" && echo "-- [INFO] Created ${BUILD_DIR} !"
else
echo "-- [INFO] Found BUILD_DIR: ${BUILD_DIR}"
fi
}
__check_cxx_envs() {
if [ $LDFLAGS ]; then
echo "-- [INFO] Found LDFLAGS: ${LDFLAGS}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset LDFLAGS
fi
if [ $CPPFLAGS ]; then
echo "-- [INFO] Found CPPFLAGS: ${CPPFLAGS}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset CPPFLAGS
fi
if [ $CPLUS_INCLUDE_PATH ]; then
echo "-- [INFO] Found CPLUS_INCLUDE_PATH: ${CPLUS_INCLUDE_PATH}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset CPLUS_INCLUDE_PATH
fi
if [ $C_INCLUDE_PATH ]; then
echo "-- [INFO] Found C_INCLUDE_PATH: ${C_INCLUDE_PATH}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset C_INCLUDE_PATH
fi
}
__set_android_ndk() {
if [ -z $ANDROID_NDK ]; then
echo "-- [INFO] ANDROID_NDK not exists, please setup manually ..."
exit 0
else
echo "-- [INFO] Found ANDROID_NDK: ${ANDROID_NDK}"
fi
if [ "$ANDROID_NDK" ]; then
NDK_VERSION=$(echo $ANDROID_NDK | egrep -o "[0-9]{2}" | head -n 1)
if [ "$NDK_VERSION" -gt 17 ]; then
TOOLCHAIN=clang
fi
echo "-- [INFO] Checked ndk version: ${NDK_VERSION}"
echo "-- [INFO] Selected toolchain: ${TOOLCHAIN}"
fi
}
__build_fastdeploy_android_shared() {
local ANDROID_STL=c++_shared # c++_static
local ANDROID_TOOLCHAIN=${TOOLCHAIN}
local TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake
local FASDEPLOY_INSTALL_DIR="${ROOT_PATH}/${BUILD_DIR}/install"
cd "${BUILD_DIR}" && echo "-- [INFO] Working Dir: ${PWD}"
cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \
-DCMAKE_BUILD_TYPE=MinSizeRel \
-DANDROID_ABI=${ANDROID_ABI} \
-DANDROID_NDK=${ANDROID_NDK} \
-DANDROID_PLATFORM=${ANDROID_PLATFORM} \
-DANDROID_STL=${ANDROID_STL} \
-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN} \
-DENABLE_ORT_BACKEND=OFF \
-DENABLE_LITE_BACKEND=ON \
-DENABLE_PADDLE2ONNX=OFF \
-DENABLE_FLYCV=ON \
-DENABLE_TEXT=OFF \
-DENABLE_VISION=ON \
-DBUILD_EXAMPLES=OFF \
-DWITH_OPENCV_STATIC=ON \
-DWITH_FLYCV_STATIC=ON \
-DWITH_LITE_STATIC=ON \
-DWITH_STATIC_LIB=ON \
-DWITH_OPENMP=ON \
-DWITH_JAVA=ON \
-DCMAKE_INSTALL_PREFIX=${FASDEPLOY_INSTALL_DIR} \
-Wno-dev ../../.. && make -j8 && make install
echo "-- [INFO][built][${ANDROID_ABI}][${BUILD_DIR}/install]"
}
main() {
__make_build_dir
__check_cxx_envs
__set_android_ndk
__build_fastdeploy_android_shared
exit 0
}
main
# Usage:
# ./scripts/android/build_android_cpp_with_static_deps.sh arm64-v8a 21
# ./scripts/android/build_android_cpp_with_static_deps.sh armeabi-v7a 21

120
scripts/android/build_android_cpp_with_static_deps_with_text_api.sh Executable file
View File

@@ -0,0 +1,120 @@
#!/bin/bash
set -e
set +x
# -------------------------------------------------------------------------------
# mutable global variables
# -------------------------------------------------------------------------------
TOOLCHAIN=clang # gcc/clang toolchain
# -------------------------------------------------------------------------------
# readonly global variables
# -------------------------------------------------------------------------------
readonly ROOT_PATH=$(pwd)
readonly ANDROID_ABI=$1
readonly ANDROID_PLATFORM="android-$2"
readonly BUILD_ROOT=build/Android
readonly BUILD_DIR=${BUILD_ROOT}/${ANDROID_ABI}-api-$2
# -------------------------------------------------------------------------------
# tasks
# -------------------------------------------------------------------------------
__make_build_dir() {
if [ ! -d "${BUILD_DIR}" ]; then
echo "-- [INFO] BUILD_DIR: ${BUILD_DIR} not exists, setup manually ..."
if [ ! -d "${BUILD_ROOT}" ]; then
mkdir -p "${BUILD_ROOT}" && echo "-- [INFO] Created ${BUILD_ROOT} !"
fi
mkdir -p "${BUILD_DIR}" && echo "-- [INFO] Created ${BUILD_DIR} !"
else
echo "-- [INFO] Found BUILD_DIR: ${BUILD_DIR}"
fi
}
__check_cxx_envs() {
if [ $LDFLAGS ]; then
echo "-- [INFO] Found LDFLAGS: ${LDFLAGS}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset LDFLAGS
fi
if [ $CPPFLAGS ]; then
echo "-- [INFO] Found CPPFLAGS: ${CPPFLAGS}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset CPPFLAGS
fi
if [ $CPLUS_INCLUDE_PATH ]; then
echo "-- [INFO] Found CPLUS_INCLUDE_PATH: ${CPLUS_INCLUDE_PATH}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset CPLUS_INCLUDE_PATH
fi
if [ $C_INCLUDE_PATH ]; then
echo "-- [INFO] Found C_INCLUDE_PATH: ${C_INCLUDE_PATH}, \c"
echo "unset it before crossing compiling ${ANDROID_ABI}"
unset C_INCLUDE_PATH
fi
}
__set_android_ndk() {
if [ -z $ANDROID_NDK ]; then
echo "-- [INFO] ANDROID_NDK not exists, please setup manually ..."
exit 0
else
echo "-- [INFO] Found ANDROID_NDK: ${ANDROID_NDK}"
fi
if [ "$ANDROID_NDK" ]; then
NDK_VERSION=$(echo $ANDROID_NDK | egrep -o "[0-9]{2}" | head -n 1)
if [ "$NDK_VERSION" -gt 17 ]; then
TOOLCHAIN=clang
fi
echo "-- [INFO] Checked ndk version: ${NDK_VERSION}"
echo "-- [INFO] Selected toolchain: ${TOOLCHAIN}"
fi
}
__build_fastdeploy_android_shared() {
local ANDROID_STL=c++_shared # c++_static
local ANDROID_TOOLCHAIN=${TOOLCHAIN}
local TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake
local FASDEPLOY_INSTALL_DIR="${ROOT_PATH}/${BUILD_DIR}/install"
cd "${BUILD_DIR}" && echo "-- [INFO] Working Dir: ${PWD}"
cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \
-DCMAKE_BUILD_TYPE=MinSizeRel \
-DANDROID_ABI=${ANDROID_ABI} \
-DANDROID_NDK=${ANDROID_NDK} \
-DANDROID_PLATFORM=${ANDROID_PLATFORM} \
-DANDROID_STL=${ANDROID_STL} \
-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN} \
-DENABLE_ORT_BACKEND=OFF \
-DENABLE_LITE_BACKEND=ON \
-DENABLE_PADDLE2ONNX=OFF \
-DENABLE_FLYCV=ON \
-DENABLE_TEXT=ON \
-DENABLE_VISION=ON \
-DBUILD_EXAMPLES=OFF \
-DWITH_OPENCV_STATIC=ON \
-DWITH_FLYCV_STATIC=ON \
-DWITH_LITE_STATIC=ON \
-DWITH_STATIC_LIB=OFF \
-DWITH_OPENMP=ON \
-DWITH_JAVA=ON \
-DCMAKE_INSTALL_PREFIX=${FASDEPLOY_INSTALL_DIR} \
-Wno-dev ../../.. && make -j8 && make install
echo "-- [INFO][built][${ANDROID_ABI}][${BUILD_DIR}/install]"
}
main() {
__make_build_dir
__check_cxx_envs
__set_android_ndk
__build_fastdeploy_android_shared
exit 0
}
main
# Usage:
# ./scripts/android/build_android_cpp_with_static_deps_with_text_api.sh arm64-v8a 21
# ./scripts/android/build_android_cpp_with_static_deps_with_text_api.sh armeabi-v7a 21