Revision control

++ # Copyright (C) 2022 The Qt Company Ltd.
++ # SPDX-License-Identifier: BSD-3-Clause
++
++ include(FindPackageHandleStandardArgs)
++
++ if (NOT FFmpeg_FIND_COMPONENTS)
++ set(FFmpeg_FIND_COMPONENTS AVCODEC AVFORMAT AVUTIL SWSCALE SWRESAMPLE)
++ endif ()
++
++ if (QT_DEPLOY_FFMPEG AND BUILD_SHARED_LIBS)
++ set(shared_libs_desired TRUE)
++ endif()
++
++ if(IOS)
++ set(QT_FFMPEG_SHARED_LIBRARY_SUFFIX ".xcframework")
++ else()
++ set(QT_FFMPEG_SHARED_LIBRARY_SUFFIX "${CMAKE_SHARED_LIBRARY_SUFFIX}")
++ endif()
++
++ # finds FFmpeg libs, including symlinks, for the specified component.
++ macro(find_shared_libs_for_component _component)
++ # the searching pattern is pretty rough but it seems to be sufficient to gather dynamic libs
++ get_filename_component(name_we ${${_component}_LIBRARY} NAME_WE)
++
++ if (WIN32)
++ get_filename_component(dir_name ${${_component}_LIBRARY_DIR} NAME)
++ if (${dir_name} STREQUAL "lib" AND EXISTS "${${_component}_LIBRARY_DIR}/../bin")
++ # llvm-mingv builds aux ffmpeg static libs like lib/libavutil.dll.a and cmake finds
++ # only them even though the folder bin/ contains proper *.dll and *.lib.
++
++ string(REGEX REPLACE "^lib" "" name_we "${name_we}")
++ set(shared_lib_pattern "../bin/${name_we}*${QT_FFMPEG_SHARED_LIBRARY_SUFFIX}")
++ else()
++ set(shared_lib_pattern "${name_we}*${QT_FFMPEG_SHARED_LIBRARY_SUFFIX}")
++ endif()
++
++ else()
++ set(shared_lib_pattern "${name_we}*${QT_FFMPEG_SHARED_LIBRARY_SUFFIX}*")
++ endif()
++
++ file(GLOB ${_component}_SHARED_LIBRARIES "${${_component}_LIBRARY_DIR}/${shared_lib_pattern}")
++ endmacro()
++
++ #
++ ### Macro: set_component_found
++ #
++ # Marks the given component as found if both *_LIBRARY_NAME AND *_INCLUDE_DIRS is present.
++ #
++ macro(set_component_found _component)
++ if (${_component}_LIBRARY_NAME AND ${_component}_INCLUDE_DIR)
++ # message(STATUS " - ${_component} found.")
++ set(${_component}_FOUND TRUE)
++ set(${CMAKE_FIND_PACKAGE_NAME}_${_component}_FOUND TRUE)
++ else ()
++ # message(STATUS " - ${_component} not found.")
++ endif ()
++ endmacro()
++
++ find_package(PkgConfig QUIET)
++ if (FFMPEG_DIR)
++ if(NOT EXISTS "${FFMPEG_DIR}" OR NOT IS_DIRECTORY "${FFMPEG_DIR}")
++ message(FATAL_ERROR "Explicitly set FFmpeg directory '${FFMPEG_DIR}' is invalid")
++ endif()
++ endif()
++ if (NOT PKG_CONFIG_FOUND AND NOT FFMPEG_DIR)
++ set(FFMPEG_DIR "/usr/local")
++ endif()
++ #
++ ### Macro: find_component
++ #
++ # Checks for the given component by invoking pkgconfig and then looking up the libraries and
++ # include directories.
++ #
++ macro(find_component _component _pkgconfig _library _header)
++ if (FFMPEG_DIR)
++ set(backup_cmake_find_root_path "${CMAKE_FIND_ROOT_PATH}")
++ list(PREPEND CMAKE_FIND_ROOT_PATH "${FFMPEG_DIR}")
++ elseif(PKG_CONFIG_FOUND)
++ # use pkg-config to get the directories and then use these values
++ # in the FIND_PATH() and FIND_LIBRARY() calls
++ pkg_check_modules(PC_${_component} ${_pkgconfig})
++ endif()
++
++ if (${_component}_INCLUDE_DIR AND NOT EXISTS ${${_component}_INCLUDE_DIR})
++ message(STATUS "Cached include dir ${${_component}_INCLUDE_DIR} doesn't exist")
++ unset(${_component}_INCLUDE_DIR CACHE)
++ endif()
++
++ find_path(${_component}_INCLUDE_DIR ${_header}
++ HINTS
++ ${PC_${_component}_INCLUDEDIR}
++ ${PC_${_component}_INCLUDE_DIRS}
++ ${PC_FFMPEG_INCLUDE_DIRS}
++ PATHS
++ ${FFMPEG_DIR}
++ PATH_SUFFIXES
++ ffmpeg include
++ )
++ if (${_component}_INCLUDE_DIR)
++ mark_as_advanced(${_component}_INCLUDE_DIR)
++ endif()
++
++ if (shared_libs_desired AND NOT WIN32)
++ set(CMAKE_FIND_LIBRARY_SUFFIXES "${QT_FFMPEG_SHARED_LIBRARY_SUFFIX};${CMAKE_STATIC_LIBRARY_SUFFIX}")
++ endif()
++
++ if (${_component}_LIBRARY AND NOT EXISTS ${${_component}_LIBRARY})
++ message(STATUS "Cached library ${${_component}_LIBRARY} doesn't exist")
++ unset(${_component}_LIBRARY CACHE)
++ endif()
++
++ # On iOS we use .xcframework for shared libraries, but this is not
++ # picked up by standard find_library behavior because .xcframework
++ # files count as directories. We first search for shared libraries
++ # on iOS, then we fallback to regular search if we can't find them.
++ if (IOS)
++ find_path(${_component}_LIBRARY
++ NAMES lib${_library}${QT_FFMPEG_SHARED_LIBRARY_SUFFIX}
++ PATHS
++ ${FFMPEG_DIR}
++ PATH_SUFFIXES
++ lib bin
++ )
++ # There is a quirk here where find_path will return the parent
++ # directory of the target directory if it's found. We append the
++ # specific filename.
++ if (${_component}_LIBRARY)
++ set(${_component}_LIBRARY "${${_component}_LIBRARY}/lib${_library}${QT_FFMPEG_SHARED_LIBRARY_SUFFIX}")
++ endif()
++ endif()
++
++ if (NOT ${_component}_LIBRARY)
++ find_library(${_component}_LIBRARY
++ NAMES ${PC_${_component}_LIBRARIES} ${_library}
++ HINTS
++ ${PC_${_component}_LIBDIR}
++ ${PC_${_component}_LIBRARY_DIRS}
++ ${PC_FFMPEG_LIBRARY_DIRS}
++ PATHS
++ ${FFMPEG_DIR}
++ PATH_SUFFIXES
++ lib bin
++ )
++ endif()
++
++ if(FFMPEG_DIR)
++ set(CMAKE_FIND_ROOT_PATH "${backup_cmake_find_root_path}")
++ endif()
++
++ if (${_component}_LIBRARY)
++ get_filename_component(${_component}_LIBRARY_DIR ${${_component}_LIBRARY} DIRECTORY)
++ get_filename_component(${_component}_LIBRARY_NAME ${${_component}_LIBRARY} NAME)
++
++ # On Windows, shared linking goes through 'integration' static libs, so we should look for shared ones anyway
++ # On Unix, we gather symlinks as well so that we could install them.
++ if (WIN32 OR ${${_component}_LIBRARY_NAME} MATCHES "\\${QT_FFMPEG_SHARED_LIBRARY_SUFFIX}$")
++ find_shared_libs_for_component(${_component})
++ endif()
++
++ mark_as_advanced(${_component}_LIBRARY)
++ endif()
++
++ set(${_component}_CFLAGS ${PC_${_component}_CFLAGS} ${PC_${_component}_CFLAGS_OTHER})
++
++ if (${_component}_INCLUDE_DIR AND ${_component}_LIBRARY)
++ set_component_found(${_component})
++ endif()
++ endmacro()
++
++ # Clear the previously cached variables, because they are recomputed every time
++ # the Find script is included.
++ unset(FFMPEG_INCLUDE_DIRS CACHE)
++ unset(FFMPEG_SHARED_LIBRARIES CACHE)
++ unset(FFMPEG_STUBS CACHE)
++ unset(FFMPEG_USES_OPENSSL CACHE)
++
++ # Check for components.
++ foreach (_component ${FFmpeg_FIND_COMPONENTS})
++ string(TOLOWER ${_component} library)
++ find_component(${_component} "lib${library}" ${library} "lib${library}/${library}.h")
++
++ if (${_component}_FOUND)
++ list(APPEND FFMPEG_LIBRARIES ${${_component}_LIBRARY_NAME})
++ list(APPEND FFMPEG_DEFINITIONS ${${_component}_DEFINITIONS})
++ list(APPEND FFMPEG_INCLUDE_DIRS ${${_component}_INCLUDE_DIR})
++ list(APPEND FFMPEG_LIBRARY_DIRS ${${_component}_LIBRARY_DIR})
++
++ if (${_component}_SHARED_LIBRARIES)
++ list(APPEND FFMPEG_SHARED_LIBRARIES ${${_component}_SHARED_LIBRARIES})
++ list(APPEND FFMPEG_SHARED_COMPONENTS ${_component})
++ else()
++ list(APPEND FFMPEG_STATIC_COMPONENTS ${_component})
++ endif()
++
++ mark_as_advanced(${_component}_LIBRARY_NAME ${_component}_DEFINITIONS ${_component}_INCLUDE_DIR
++ ${_component}_LIBRARY_DIR ${_component}_SHARED_LIBRARIES)
++ endif()
++ endforeach()
++
++
++ function(qt_internal_multimedia_try_add_dynamic_resolve_dependency _component dep)
++ set(dynamic_resolve_added FALSE PARENT_SCOPE)
++
++ if (NOT QT_FEATURE_library)
++ return()
++ endif()
++
++ if (NOT ANDROID AND NOT LINUX)
++ return()
++ endif()
++
++ set(supported_stubs "ssl|crypto|va|va-drm|va-x11")
++ set(stub_prefix "Qt${PROJECT_VERSION_MAJOR}FFmpegStub-")
++
++ # If FFmpeg pulls in OpenSSL directly (-lssl) the libraries are needed at runtime.
++ # If they're pulled through the stubs they're not strictly needed but can end up
++ # being used anyway.
++ if (${dep} MATCHES "^(${stub_prefix})?(ssl|crypto)$")
++ set(FFMPEG_USES_OPENSSL TRUE CACHE INTERNAL "")
++ endif()
++
++ if (${dep} MATCHES "^${stub_prefix}(${supported_stubs})$")
++ string(REPLACE "${stub_prefix}" "" dep "${dep}")
++ set(FFMPEG_STUBS ${FFMPEG_STUBS} ${dep} CACHE INTERNAL "")
++ set(dynamic_resolve_added TRUE PARENT_SCOPE)
++ endif()
++ endfunction()
++
++ # Function parses package config file to find the static library dependencies
++ # and adds them to the target library.
++ function(__ffmpeg_internal_set_dependencies _component)
++ string(TOLOWER ${_component} lib)
++
++ if (WIN32)
++ set(PC_FILE ${${_component}_LIBRARY_DIR}/../lib/pkgconfig/lib${lib}.pc)
++ else()
++ set(PC_FILE ${${_component}_LIBRARY_DIR}/pkgconfig/lib${lib}.pc)
++ endif()
++
++ if(EXISTS ${PC_FILE})
++ file(READ ${PC_FILE} pcfile)
++
++ set(prefix_l "(^| )\\-l")
++ set(suffix_lib "\\.lib($| )")
++ set(framework_regex "-framework [A-Za-z0-9_]*")
++
++ string(REGEX REPLACE ".*Libs:([^\n\r]+).*" "\\1" out "${pcfile}")
++ string(REGEX MATCHALL "${prefix_l}[^ ]+" libs_dependency ${out})
++ string(REGEX MATCHALL "[^ ]+${suffix_lib}" libs_dependency_lib ${out})
++ string(REGEX MATCHALL "${framework_regex}" framework_dependencies ${out})
++
++ foreach(dependency IN LISTS libs_dependency)
++ string(REGEX REPLACE ${prefix_l} "" dependency ${dependency})
++ if(NOT ${lib} STREQUAL ${dependency})
++ qt_internal_multimedia_try_add_dynamic_resolve_dependency(${_component} ${dependency})
++ if(NOT dynamic_resolve_added)
++ target_link_libraries(FFmpeg::${lib} INTERFACE ${dependency})
++ endif()
++ endif()
++ endforeach()
++
++ foreach(dependency IN LISTS libs_dependency_lib)
++ string(STRIP "${dependency}" dependency)
++ target_link_libraries(FFmpeg::${lib} INTERFACE ${dependency})
++ endforeach()
++
++ # we don't link private dependencies, but just populate the FFMPEG_STUBS
++ string(REGEX REPLACE ".*Libs.private:([^\n\r]+).*" "\\1" out "${pcfile}")
++ string(REGEX MATCHALL "${prefix_l}[^ ]+" libs_private_dependency ${out})
++ string(REGEX MATCHALL "[^ ]+${suffix_lib}" libs_private_dependency_lib ${out})
++
++ foreach(dependency IN LISTS libs_private_dependency)
++ string(REGEX REPLACE ${prefix_l} "" dependency ${dependency})
++ qt_internal_multimedia_try_add_dynamic_resolve_dependency(${_component} ${dependency})
++ endforeach()
++
++ foreach(dependency IN LISTS framework_dependencies)
++ target_link_libraries(FFmpeg::${lib} INTERFACE "${dependency}")
++ endforeach()
++ else()
++ message(WARNING "FFmpeg pc file ${PC_FILE} is not found")
++ endif()
++ endfunction()
++
++ # Check for cached results. If there are skip the costly part.
++ #if (NOT FFMPEG_LIBRARIES)
++
++ # Check if the required components were found and add their stuff to the FFMPEG_* vars.
++
++
++ foreach (_component ${FFmpeg_FIND_COMPONENTS})
++ if (${_component}_FOUND)
++ string(TOLOWER ${_component} _lowerComponent)
++ set(_target FFmpeg::${_lowerComponent})
++ if (NOT TARGET ${_target})
++ add_library(${_target} INTERFACE IMPORTED)
++ target_compile_options(${_target} INTERFACE "${${_component}_CFLAGS}")
++ target_include_directories(${_target} INTERFACE "${${_component}_INCLUDE_DIR}")
++ target_link_libraries(${_target} INTERFACE "${${_component}_LIBRARY}")
++
++ __ffmpeg_internal_set_dependencies(${_component})
++ if (UNIX AND NOT APPLE)
++ target_link_options(${_target} INTERFACE "-Wl,--exclude-libs=lib${_lowerComponent}")
++ endif ()
++ endif()
++ endif()
++ endforeach ()
++
++ # Build the include path with duplicates removed.
++ list(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
++ list(REMOVE_DUPLICATES FFMPEG_LIBRARY_DIRS)
++ list(REMOVE_DUPLICATES FFMPEG_SHARED_LIBRARIES)
++ list(REMOVE_DUPLICATES FFMPEG_STUBS)
++
++ message(STATUS "FFmpeg shared libs: ${FFMPEG_SHARED_LIBRARIES}")
++ message(STATUS "FFmpeg stubs: ${FFMPEG_STUBS}")
++ message(STATUS "FFmpeg built with OpenSSL: ${FFMPEG_USES_OPENSSL}")
++
++ # cache the vars.
++ set(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS} CACHE STRING "The FFmpeg include directories." FORCE)
++ set(FFMPEG_SHARED_LIBRARIES ${FFMPEG_SHARED_LIBRARIES} CACHE STRING "The FFmpeg dynamic libraries." FORCE)
++ set(FFMPEG_STUBS ${FFMPEG_STUBS} CACHE STRING "The FFmpeg stubs." FORCE)
++
++ mark_as_advanced(FFMPEG_INCLUDE_DIRS)
++ mark_as_advanced(FFMPEG_SHARED_LIBRARIES)
++ mark_as_advanced(FFMPEG_STUBS)
++
++ # endif ()
++
++ list(LENGTH FFMPEG_LIBRARY_DIRS DIRS_COUNT)
++ if (${DIRS_COUNT} GREATER 1)
++ message(WARNING "One ffmpeg library dir is expected, found dirs: ${FFMPEG_LIBRARY_DIRS}")
++ endif()
++
++ if(FFMPEG_SHARED_COMPONENTS AND FFMPEG_STATIC_COMPONENTS)
++ message(WARNING
++ "Only static or shared components are expected\n"
++ " static components: ${FFMPEG_STATIC_COMPONENTS}\n"
++ " shared components: ${FFMPEG_SHARED_COMPONENTS}")
++ endif()
++
++ if (shared_libs_desired AND NOT FFMPEG_SHARED_COMPONENTS)
++ message(WARNING
++ "Shared FFmpeg libs are desired as QT_DEPLOY_FFMPEG=TRUE, but haven't been found!\n"
++ "Remove QT_DEPLOY_FFMPEG or set the proper path to shared FFmpeg via FFMPEG_DIR.")
++ endif()
++
++ # Compile the list of required vars
++ set(_FFmpeg_REQUIRED_VARS FFMPEG_LIBRARIES FFMPEG_INCLUDE_DIRS)
++ foreach (_component ${FFmpeg_FIND_COMPONENTS})
++ list(APPEND _FFmpeg_REQUIRED_VARS ${_component}_LIBRARY ${_component}_INCLUDE_DIR)
++ endforeach ()
++
++ set(FIND_FFMPEG_HELP_STRING
++ [=[FFMPEG_DIR CMake variable is not correct.
++ Make sure that the FFMPEG_DIR CMake variable is set to a path that
++ contains FFmpeg 'lib' and 'include' directories and that the FFmpeg
++ installation is built with the avformat, avcodec, swresample,
++ swscale, and avutil libraries. To resolve the issue, please delete
++ CMakeCache.txt and run configure again with the correct FFMPEG_DIR
++ CMake variable set.
++ ]=])
++
++ # Give a nice error message if some of the required vars are missing.
++ find_package_handle_standard_args(FFmpeg
++ REQUIRED_VARS ${_FFmpeg_REQUIRED_VARS}
++ HANDLE_COMPONENTS
++ REASON_FAILURE_MESSAGE
++ ${FIND_FFMPEG_HELP_STRING}
++ )