From 1db47e6cd94f46f0b0edd2e2e61308e9f1518070 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 13:33:55 +0100 Subject: [PATCH 01/72] Add CI workflow to build Csound 7 plugins Builds the 7.x plugins on ubuntu, macos and windows runners against a Csound 7 development install built from source. Also track the missing 7.x/CMakeLists.txt needed by the build. --- .github/workflows/plugins_build_7.yml | 225 +++++++++++++++++++ 7.x/CMakeLists.txt | 298 ++++++++++++++++++++++++++ 2 files changed, 523 insertions(+) create mode 100644 .github/workflows/plugins_build_7.yml create mode 100644 7.x/CMakeLists.txt diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml new file mode 100644 index 0000000..e335e98 --- /dev/null +++ b/.github/workflows/plugins_build_7.yml @@ -0,0 +1,225 @@ +name: Csound 7 plugins build + +permissions: + contents: read + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +on: + push: + branches: + - develop + - master + pull_request: + branches: + - develop + - master + workflow_dispatch: + +env: + CSOUND_VERSION: 7.0.0-beta.18 + +jobs: + linux: + name: Linux (ubuntu-latest) + runs-on: ubuntu-latest + steps: + - name: Checkout source + uses: actions/checkout@v4 + + - name: Install Csound build dependencies + run: | + sudo apt-get update + sudo apt-get install -y \ + build-essential cmake pkg-config \ + libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ + flex bison + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v4 + with: + path: ~/csound-install + key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} + + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + git clone --depth 1 --branch "$CSOUND_VERSION" \ + https://github.com/csound/csound.git "$RUNNER_TEMP/csound" + cmake -S "$RUNNER_TEMP/csound" -B "$RUNNER_TEMP/csound-build" \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX="$HOME/csound-install" \ + -DBUILD_TESTS=OFF \ + -DINSTALL_PYTHON_INTERFACE=OFF + cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(nproc)" + cmake --install "$RUNNER_TEMP/csound-build" + + - name: Configure plugin build + run: | + echo "CSOUND_INCLUDE_DIR_HINT=$HOME/csound-install/include/csound" >> "$GITHUB_ENV" + echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/lib" >> "$GITHUB_ENV" + + - name: Build plugins + run: | + cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ + -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ + -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" + cmake --build build --parallel "$(nproc)" + + - name: Upload plugins + uses: actions/upload-artifact@v4 + with: + name: csound7-plugins-linux + path: build/src/py/*.so + if-no-files-found: error + + macos: + name: macOS (macos-latest) + runs-on: macos-latest + steps: + - name: Checkout source + uses: actions/checkout@v4 + + - name: Install Csound build dependencies + env: + HOMEBREW_NO_AUTO_UPDATE: 1 + run: | + brew install cmake ninja pkg-config bison flex libsndfile + echo "$(brew --prefix bison)/bin" >> "$GITHUB_PATH" + echo "$(brew --prefix flex)/bin" >> "$GITHUB_PATH" + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v4 + with: + path: ~/csound-install + key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} + + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + git clone --depth 1 --branch "$CSOUND_VERSION" \ + https://github.com/csound/csound.git "$RUNNER_TEMP/csound" + cmake -S "$RUNNER_TEMP/csound" -B "$RUNNER_TEMP/csound-build" -G Ninja \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX="$HOME/csound-install" \ + -DCS_FRAMEWORK_DEST="$HOME/csound-install/Frameworks" \ + -DCMAKE_PREFIX_PATH="$(brew --prefix)" \ + -DBUILD_TESTS=OFF \ + -DBUILD_STATIC_LIBRARY=OFF \ + -DBUILD_VIRTUAL_KEYBOARD=OFF \ + -DBUILD_JAVA_INTERFACE=OFF \ + -DBUILD_PYTHON_INTERFACE=OFF \ + -DINSTALL_PYTHON_INTERFACE=OFF \ + -DBUILD_LUA_INTERFACE=OFF \ + -DBUILD_CSBEATS=OFF \ + -DUSE_LIBSAMPLERATE=OFF \ + -DUSE_CURL=OFF \ + -DUSE_GETTEXT=OFF \ + -DUSE_JACK=OFF \ + -DUSE_PORTAUDIO=OFF \ + -DUSE_PORTMIDI=OFF \ + -DUSE_MP3=OFF + cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(sysctl -n hw.ncpu)" + cmake --install "$RUNNER_TEMP/csound-build" + + - name: Configure plugin build + run: | + framework="$HOME/csound-install/Frameworks/CsoundLib64.framework" + headers="$framework/Versions/7.0/Headers" + if [ ! -f "$headers/csound.h" ]; then + headers="$framework/Headers" + fi + echo "CSOUND_INCLUDE_DIR_HINT=$headers" >> "$GITHUB_ENV" + echo "CSOUND_FRAMEWORK_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" + echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" + + - name: Build plugins + run: | + cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ + -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ + -DCSOUND_FRAMEWORK_DIR_HINT="$CSOUND_FRAMEWORK_DIR_HINT" \ + -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" + cmake --build build --parallel "$(sysctl -n hw.ncpu)" + + - name: Upload plugins + uses: actions/upload-artifact@v4 + with: + name: csound7-plugins-macos + path: build/src/py/*.dylib + if-no-files-found: error + + windows: + name: Windows (windows-latest) + runs-on: windows-latest + defaults: + run: + shell: pwsh + steps: + - name: Checkout source + uses: actions/checkout@v4 + + - name: Install Csound build dependencies + run: choco install -y winflexbison3 + + - name: Clone Csound (with vcpkg) + run: | + git clone --recursive --depth 1 --branch "$env:CSOUND_VERSION" ` + https://github.com/csound/csound.git csound + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v4 + with: + path: ${{ runner.temp }}\csound-install + key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} + + - name: Bootstrap vcpkg + if: steps.cache-csound.outputs.cache-hit != 'true' + run: .\csound\vcpkg\bootstrap-vcpkg.bat -disableMetrics + + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + cmake -S csound -B csound-build -A x64 ` + -DUSE_VCPKG=ON ` + -DCMAKE_INSTALL_PREFIX="$env:RUNNER_TEMP\csound-install" ` + -DBUILD_TESTS=OFF ` + -DBUILD_STATIC_LIBRARY=OFF ` + -DBUILD_VIRTUAL_KEYBOARD=OFF ` + -DBUILD_JAVA_INTERFACE=OFF ` + -DBUILD_PYTHON_INTERFACE=OFF ` + -DINSTALL_PYTHON_INTERFACE=OFF ` + -DBUILD_LUA_INTERFACE=OFF ` + -DBUILD_CSBEATS=OFF + cmake --build csound-build --config Release --parallel + cmake --install csound-build --config Release + + - name: Configure plugin build + run: | + $install = Join-Path $env:RUNNER_TEMP 'csound-install' + $header = Get-ChildItem -Path $install -Recurse -File -Filter 'csound.h' | + Select-Object -First 1 + $lib = Get-ChildItem -Path $install -Recurse -File -Filter 'csound64.lib' | + Select-Object -First 1 + if (-not $header) { throw "csound.h not found under $install" } + if (-not $lib) { throw "csound64.lib not found under $install" } + "CSOUND_INCLUDE_DIR_HINT=$($header.DirectoryName)" >> $env:GITHUB_ENV + "CSOUND_LIBRARY_DIR_HINT=$($lib.DirectoryName)" >> $env:GITHUB_ENV + + - name: Build plugins + run: | + cmake -S 7.x -B build -A x64 ` + -DCSOUND_INCLUDE_DIR_HINT="$env:CSOUND_INCLUDE_DIR_HINT" ` + -DCSOUND_LIBRARY_DIR_HINT="$env:CSOUND_LIBRARY_DIR_HINT" + cmake --build build --config Release --parallel + + - name: Upload plugins + uses: actions/upload-artifact@v4 + with: + name: csound7-plugins-windows + path: build/src/py/Release/*.dll + if-no-files-found: error diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt new file mode 100644 index 0000000..ea4bf9a --- /dev/null +++ b/7.x/CMakeLists.txt @@ -0,0 +1,298 @@ +cmake_minimum_required(VERSION 3.5) +cmake_policy(SET CMP0077 NEW) + +option(USE_VCPKG "Use VCPKG to download and manage dependencies" OFF) + +if (USE_VCPKG) + # Detect correct triplet based on CMake env + if (WIN32) + set(VCPKG_HOST_TRIPLET "x64-windows-csound" CACHE STRING "") + set(VCPKG_TARGET_TRIPLET "x64-windows-csound") + set(CSOUND_INCLUDE_DIR_HINT "C:/Program Files/Csound6_x64") + elseif(APPLE) + set(VCPKG_HOST_TRIPLET "x64-osx" CACHE STRING "") + set(VCPKG_TARGET_TRIPLET "x64-osx") + elseif (UNIX) + set(VCPKG_HOST_TRIPLET "x64-linux" CACHE STRING "") + set(VCPKG_TARGET_TRIPLET "x64-linux") + endif() + + set(VCPKG_FEATURE_FLAGS versions) + set(X_VCPKG_APPLOCAL_DEPS_INSTALL ON) + set(VCPKG_OVERLAY_TRIPLETS ${CMAKE_CURRENT_SOURCE_DIR}/) + set(VCPKG_OVERLAY_PORTS ${CMAKE_CURRENT_SOURCE_DIR}/) + set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake + CACHE STRING "Vcpkg toolchain file") +endif() + +project(Csound-plugins) + +if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") + set(CMAKE_COMPILER_IS_CLANG 1) +endif() + +set(APIVERSION "7.0") + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_MACOSX_RPATH 1) +set(CMAKE_VERBOSE_MAKEFILE ON) +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/") + +find_package(CSOUND) + +if(NOT CSOUND_INCLUDE_DIRS) + message(FATAL_ERROR "Csound header files are required") +endif() + +include(TestBigEndian) +include(CheckFunctionExists) +include(CheckCCompilerFlag) +include(CheckCXXCompilerFlag) + +### COMPILER OPTIMIZATION FLAGS +option(USE_COMPILER_OPTIMIZATIONS "Use the default Csound compiler optimization flags" ON) +if(USE_COMPILER_OPTIMIZATIONS) + include(${CMAKE_SOURCE_DIR}/cmake/CompilerOptimizations.cmake) +endif() + +##/Library/Frameworks/CsoundLib64.framework/Versions/Current/Resources/Opcodes64 + +if(APPLE) + message(STATUS "Building on OSX") + set(OSX_VERSION " ") +endif() + +## USER OPTIONS ## +# Optional targets, they should all default to ON (check_deps will disable them if not possible to build) +option(USE_DOUBLE "Set to use double-precision floating point for audio samples." ON) +option(USE_LRINT "Use lrint/lrintf for converting floating point values to integers." ON) +option(BUILD_RELEASE "Build for release" ON) +option(USE_GIT_COMMIT "Show the git commit in version information" ON) +option(REQUIRE_PTHREADS "For non-Windows systems, set whether Csound will use threads or not" ON) + +# in Release configuration, set NDEBUG +if(${CMAKE_BUILD_TYPE} MATCHES "Release") + message("-----> Release mode") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNDEBUG") +elseif(${CMAKE_BUILD_TYPE} MATCHES "Debug") + message("-----> Debug mode") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBETA") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBETA") +endif() + +# set -Werror if in Debug configuration +if(NOT MSVC AND NOT WASM) + set(CMAKE_CXX_FLAGS_RELEASE "-O3 ") + set(CMAKE_C_FLAGS_RELEASE "-O3 ") + if(${CMAKE_BUILD_TYPE} MATCHES "Debug") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wno-missing-field-initializers") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wno-missing-field-initializers") + endif() +endif() + +if(NOT MSVC AND REQUIRE_PTHREADS) + # Use ladder of if's to support older CMake versions (i.e., travis) + find_library(PTHREAD_LIBRARY winpthread-1) + + if(NOT PTHREAD_LIBRARY) + find_library(PTHREAD_LIBRARY pthread) + endif() + + if(NOT PTHREAD_LIBRARY) + find_library(PTHREAD_LIBRARY pthreadGC2) + endif() + + if(NOT (PTHREAD_LIBRARY OR HAIKU)) + # pthreads are built in to Haiku + message(STATUS "Csound requires the pthread library") + endif() + + #FIXME this variable is for required include directories, possible bug + list(APPEND CMAKE_REQUIRED_INCLUDES pthread.h) + if (NOT HAIKU) + set(CMAKE_REQUIRED_LIBRARIES pthread) + endif() +endif() + +if(CMAKE_SYSTEM_NAME MATCHES "Linux") + set(LINUX YES) +else() + set(LINUX NO) +endif() + +set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}) +check_c_compiler_flag(-fvisibility=hidden HAS_VISIBILITY_HIDDEN) +check_cxx_compiler_flag(-fvisibility=hidden HAS_CXX_VISIBILITY_HIDDEN) + +if (HAS_VISIBILITY_HIDDEN) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") +endif() + +if (HAS_CXX_VISIBILITY_HIDDEN) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") +endif() + +check_c_compiler_flag(-std=gnu99 HAS_GNU99) +if (HAS_GNU99) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99") +endif() + +if (HAS_CXX_VISIBILITY_HIDDEN) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") +endif() + +if(LINUX) + option(USE_LIB64 "Set to on to set installation directory for libraries to lib64" OFF) + + if(USE_LIB64) + set(LIBRARY_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib64") + add_definitions("-DLIB64") + else() + set(LIBRARY_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib") + endif() + + message(STATUS "LIBRARY INSTALL DIR: ${LIBRARY_INSTALL_DIR}") +endif() + +# plugin install directories (CS_USER_PLUGIN on MacOs/Windows) +if(USE_DOUBLE) + message(STATUS "Building with 64-bit floats") + if(APPLE) + set(PLUGIN_INSTALL_DIR "$ENV{HOME}/Library/csound/${APIVERSION}/plugins64") + elseif(LINUX) + set(PLUGIN_INSTALL_DIR "${LIBRARY_INSTALL_DIR}/csound/plugins64-${APIVERSION}") + elseif(MSVC) + set(PLUGIN_INSTALL_DIR "$ENV{LOCALAPPDATA}/csound/${APIVERSION}/plugins64") + endif() +else() + message(STATUS "Building with 32-bit floats") + if(APPLE) + set(PLUGIN_INSTALL_DIR "$ENV{HOME}/Library/csound/${APIVERSION}/plugins") + elseif(LINUX) + set(PLUGIN_INSTALL_DIR "${LIBRARY_INSTALL_DIR}/csound/plugins-${APIVERSION}") + elseif(MSVC) + set(PLUGIN_INSTALL_DIR "$ENV{LOCALAPPDATA}/csound/${APIVERSION}/plugins") + endif() +endif() + +message("-- Csound headers: ${CSOUND_INCLUDE_DIR}") +if(APPLE) + message("-- Csound framework: ${CSOUND_FRAMEWORK}") +endif() +message("-- Plugins to be installed at: ${PLUGIN_INSTALL_DIR}") + +# Checks if dependencies for an enabled target are fulfilled. +# If FAIL_MISSING is true and the dependencies are not fulfilled, +# it will abort the cmake run. +# If FAIL_MISSING is false, it will set the option to OFF. +# If the target is not enabled, it will do nothing. +# example: check_deps(BUILD_NEW_PARSER FLEX_EXECUTABLE BISON_EXECUTABLE) +function(check_deps option) + if(${option}) + set(i 1) + while( ${i} LESS ${ARGC} ) + set(dep ${ARGV${i}}) + if(NOT ${dep}) + if(FAIL_MISSING) + message(FATAL_ERROR + "${option} is enabled, but ${dep}=\"${${dep}}\"") + else() + message(STATUS "${dep}=\"${${dep}}\", so disabling ${option}") + set(${option} OFF PARENT_SCOPE) + # Set it in the local scope too + set(${option} OFF) + endif() + endif() + math(EXPR i "${i}+1") + endwhile() + endif() + if(${option}) + message(STATUS "${option} is enabled.") + else() + message(STATUS "${option} is disabled.") + endif() +endfunction(check_deps) + +# Utility function to make plugins. All plugin targets should use this as it +# sets up output directory set in top-level CmakeLists.txt +# and adds the appropriate install target +# +# libname - name of library to produce +# srcs - list of src files (must be quoted if a list) +# extralibs (OPTIONAL) - extra libraries to link the plugin to +# +# NB - this was moved here as it needs some VARS defined above +# for setting up the framework +function(make_plugin libname srcs) + if(APPLE) + add_library(${libname} SHARED ${srcs}) + else() + add_library(${libname} MODULE ${srcs}) + endif() + + set(i 2) + while( ${i} LESS ${ARGC} ) + target_link_libraries(${libname} PRIVATE ${ARGV${i}}) + math(EXPR i "${i}+1") + endwhile() + + install(TARGETS ${libname} + LIBRARY DESTINATION "${PLUGIN_INSTALL_DIR}" + ARCHIVE DESTINATION "${PLUGIN_INSTALL_DIR}" ) +endfunction(make_plugin) + +#checking pthread functions +if(REQUIRE_PTHREADS AND (PTHREAD_LIBRARY OR HAIKU)) + + #list(APPEND libcsound_CFLAGS -DHAVE_PTHREAD) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHAVE_PTHREAD") + + check_function_exists(pthread_spin_lock PTHREAD_SPIN_LOCK_EXISTS) + check_function_exists(pthread_barrier_init PTHREAD_BARRIER_INIT_EXISTS) + + if(PTHREAD_SPIN_LOCK_EXISTS) + list(APPEND libcsound_CFLAGS -DHAVE_PTHREAD_SPIN_LOCK) + endif() + + if(PTHREAD_BARRIER_INIT_EXISTS) + list(APPEND libcsound_CFLAGS -DHAVE_PTHREAD_BARRIER_INIT) + endif() +endif() + +# Linux does not have a separate libintl, it is part of libc +set(LIBINTL_AVAIL (LIBINTL_LIBRARY OR LINUX)) + +if(LINUX) + message(STATUS "Building on Linux.") + add_definitions(-DLINUX -DPIPES -DNO_FLTK_THREADS -D_GNU_SOURCE -DHAVE_SOCKETS) + list(APPEND libcsound_LIBS ${MATH_LIBRARY} dl) + + find_library(LIBRT_LIBRARY rt) + + if(LIBRT_LIBRARY) + list(APPEND libcsound_LIBS ${LIBRT_LIBRARY}) + message(STATUS " ADDING LIBRT LIBRARY: ${LIBRT_LIBRARY}.") + endif() + + find_library(LIBEXECINFO_LIBRARY execinfo) + + if(LIBEXECINFO_LIBRARY) + list(APPEND libcsound_LIBS ${LIBEXECINFO_LIBRARY}) + message(STATUS " ADDING LIBEXECINFO LIBRARY: ${LIBEXECINFO_LIBRARY}.") + endif() +endif() + +if(APPLE AND NOT IOS) + add_definitions(-DMACOSX -DPIPES -DNO_FLTK_THREADS -DHAVE_SOCKETS) + find_library(ACCELERATE_LIBRARY Accelerate) + find_path(VECLIB_PATH "Accelerate/Accelerate.h") + include_directories(${VECLIB_PATH}) + list(APPEND libcsound_LIBS ${MATH_LIBRARY} dl ${ACCELERATE_LIBRARY}) +endif() + +if(WIN32) + add_definitions(-DWIN32) +endif() + +add_subdirectory(./src/py) From d8744df97d5f2e783b9ef10f41b0351309282991 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 14:07:08 +0100 Subject: [PATCH 02/72] Port chua and linear_algebra opcodes to the Csound 7 API Add the chua and linear_algebra plugins under 7.x/src and wire them into the 7.x CMake build. Adapted for Csound 7: OENTRY/AppendOpcode no longer take a thread argument, opcode methods return int32_t, deinit is passed in the registration instead of RegisterDeinitCallback, and MYFLT is replaced by cs_float. The removed CSOUND table accessors are replaced with csound->FTFind() in the table conversion opcodes. --- 7.x/CMakeLists.txt | 2 + 7.x/src/chua/CMakeLists.txt | 28 + 7.x/src/chua/ChuaOscillator.cpp | 630 +++ 7.x/src/chua/OpcodeBase.hpp | 499 +++ 7.x/src/linear_algebra/CMakeLists.txt | 17 + 7.x/src/linear_algebra/OpcodeBase.hpp | 499 +++ 7.x/src/linear_algebra/linear_algebra.cpp | 4773 +++++++++++++++++++++ 7 files changed, 6448 insertions(+) create mode 100644 7.x/src/chua/CMakeLists.txt create mode 100644 7.x/src/chua/ChuaOscillator.cpp create mode 100644 7.x/src/chua/OpcodeBase.hpp create mode 100644 7.x/src/linear_algebra/CMakeLists.txt create mode 100644 7.x/src/linear_algebra/OpcodeBase.hpp create mode 100644 7.x/src/linear_algebra/linear_algebra.cpp diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index ea4bf9a..a57a49a 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -295,4 +295,6 @@ if(WIN32) add_definitions(-DWIN32) endif() +add_subdirectory(./src/chua) +add_subdirectory(./src/linear_algebra) add_subdirectory(./src/py) diff --git a/7.x/src/chua/CMakeLists.txt b/7.x/src/chua/CMakeLists.txt new file mode 100644 index 0000000..f690fd9 --- /dev/null +++ b/7.x/src/chua/CMakeLists.txt @@ -0,0 +1,28 @@ +# Build chuap opcodes +option(BUILD_CHUA_OPCODES "Build the chua opcodes" ON) + +if(USE_VCPKG) + find_package(Eigen3 CONFIG REQUIRED) +else() + find_package(EIGEN3) +endif() + +check_deps(BUILD_CHUA_OPCODES EIGEN3_FOUND) + +if(BUILD_CHUA_OPCODES AND EIGEN3_FOUND) + make_plugin(chua ChuaOscillator.cpp) + target_include_directories(chua PRIVATE ${EIGEN3_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(chua PRIVATE BUILD_PLUGINS) + + if(USE_VCPKG) + target_link_libraries(chua PRIVATE Eigen3::Eigen) + else() + target_link_libraries(chua PRIVATE ${EIGEN_LIBRARIES}) + endif() + + if(APPLE) + set_target_properties(chua PROPERTIES + COMPILE_FLAGS "-Wno-unused-local-typedef" + ) + endif() +endif() diff --git a/7.x/src/chua/ChuaOscillator.cpp b/7.x/src/chua/ChuaOscillator.cpp new file mode 100644 index 0000000..9d7a42c --- /dev/null +++ b/7.x/src/chua/ChuaOscillator.cpp @@ -0,0 +1,630 @@ +/* + + Copyright 2008 Michael Gogins + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ +// function TimeSeries = +// chuacc(L,R0,C2,G,Ga,Gb,C1,E,x0,y0,z0,dataset_size,step_size) +// %0.00945,7.5,2e-007,0.00105,0,-0.00121,1.5e-008,1.76e-005,0,-0.1,0.1,2500,5e-6 +// % Syntax: +// TimeSeries=chua(L,R0,C2,G,Ga,Gb,C1,E,x0,y0,z0,dataset_size,step_size) +// % ______________________________________ +// % +// % Chua's oscillator is described by a set of three +// % ordinary differential equations called Chua's equations: +// % +// % dI3 R0 1 +// % --- = - -- I3 - - V2 +// % dt L L +// % +// % dV2 1 G +// % --- = -- I3 - -- (V2 - V1) +// % dt C2 C2 +// % +// % dV1 G 1 +// % --- = -- (V2 - V1) - -- f(V1) +// % dt C1 C1 +// % +// % where +// % +// % f(V1) = Gb V1 + - (Ga - Gb)(|V1 + E| - |V1 - E|) +// % +// % A solution of these equations (I3,V2,V1)(t) starting from an +// % initial state (I3,V2,V1)(0) is called a trajectory of Chua's +// % oscillator. +// % +// % This function uses a RungeKutta integration method optimised for the chua +// % paradigm +// % +// % Reference: +// % ABC - Adventures in Bifurication & Chaos ... Prof M.P Kennedy 1993 +// % +// % James McEvoy, Tom Murray +// % +// % University e-mail: 99375940@student.ucc.ie +// % Lifetime e-mail: sacevoy@eircom.net +// % Homepage: http://www.sacevoy.com +// % +// % 2 Nov 2002 +// % Models Initial Variables +// %------------------------- +// %Initial Conditions set by x0,y0,z0 +// TimeSeries = [x0, y0, z0]'; % models initial conditions +// %x0 = I3, y0 = V2, z0 = V1 from datafiles +// % Optimized Runge-Kutta Variables +// %-------------------------------- +// h = step_size; %*(G/C2); +// h2 = (h)*(.5); +// h6 = (h)/(6); +// sys_variables(9:12) = [1.76e-005,0,-0.00121,0]; +// k1 = [0 0 0]'; +// k2 = [0 0 0]'; +// k3 = [0 0 0]'; +// k4 = [0 0 0]'; +// M = [0 0 0]'; +// % Calculate Time Series +// %---------------------- +// % values have to be switched around +// M(1) = TimeSeries(3); %V1 +// M(2) = TimeSeries(2); %V2 +// M(3) = TimeSeries(1); %I3 + +// for i=1:dataset_size +// % Runge Kutta +// % Round One +// k1(1) = (G*(M(2) - M(1)) - gnor(M(1),sys_variables))/C1; +// k1(2) = (G*(M(1) - M(2)) + M(3))/C2; +// k1(3) = (-(M(2) + R0*M(3)))/L; +// % Round Two +// k2(1) = (G*(M(2) + h2*k1(2) - (M(1) + h2*k1(1))) - gnor(M(1) + +// h2*k1(1),sys_variables))/C1; +// k2(2) = (G*(M(1) + h2*k1(1) - (M(2) + h2*k1(2))) + M(3) + h2*k1(3))/C2; +// k2(3) = (-(M(2) + h2*k1(2) + R0*(M(3) + h2*k1(3))))/L; +// % Round Three +// k3(1) = (G*(M(2) + h2*k2(2) - (M(1) + h2*k2(1))) - gnor(M(1) + +// h2*k2(1),sys_variables))/C1; +// k3(2) = (G*(M(1) + h2*k2(1) - (M(2) + h2*k2(2))) + M(3) + h2*k2(3))/C2; +// k3(3) = (-(M(2) + h2*k2(2) + R0*(M(3) + h2*k2(3))))/L; +// % Round Four +// k4(1) = (G*(M(2) + h*k3(2) - (M(1) + h*k3(1))) - gnor(M(1) + +// h*k3(1),sys_variables))/C1; +// k4(2) = (G*(M(1) + h*k3(1) - (M(2) + h*k3(2))) + M(3) + h*k3(3))/C2; +// k4(3) = (-(M(2) + h*k3(2) + R0*(M(3) + h*k3(3))))/L; +// %Finishes integration and assigns values to M(1), +// M = M + (k1 + 2*k2 + 2*k3 + k4)*(h6); +// %M(2) and M(3) +// TimeSeries(3,i+1) = M(1); %TimeSeries 3 is V1 +// TimeSeries(2,i+1) = M(2); %TimeSeries 2 is V2 +// TimeSeries(1,i+1) = M(3); %TimeSeries 1 is I3 +// i=i+1; +// end +// %gnor Calculates the cubic nonlinearity +// function gnor = gnor(x,sys_variables) +// a = sys_variables(9); +// b = sys_variables(10); +// c = sys_variables(11); +// d = sys_variables(12); +// gnor = a*(x.^3) + b*(x.^2) + c*x + d; + +#include "OpcodeBase.hpp" +#include +#include + +using namespace csound; + +class ChuasOscillatorCubic : public OpcodeNoteoffBase { +public: + // OUTPUTS + cs_float *I3; + cs_float *V2; + cs_float *V1; + // INPUTS + // % L,R0,C2,G,Ga,Gb,E,C1,a,b,c,d + // sys_variables = [system_vars(5:12),system_vars(23:26)]; + // % x0,y0,z0,dataset_size,step_size + // integ_variables = [system_vars(14:16),system_vars(1:2)]; + // function TimeSeries = chuacc(L,R0,C2,G,Ga,Gb,C1,E,x0,y0,z0, + // dataset_size,step_size) + // Circuit elements. + cs_float *L_; + cs_float *R0_; + cs_float *C2_; + cs_float *G_; + // Omit Ga, not used with cubic nonlinearity. + // Omit Gb, not used with cubic nonlinearity. + cs_float *C1_; + // Omit E, not used with cubic nonlinearity. + // Initial values... + // %x0 = I3, y0 = V2, z0 = V1 from datafiles + cs_float *I3_; + cs_float *V2_; + cs_float *V1_; + cs_float *step_size_; + // STATE + // Runge-Kutta step sizes. + cs_float h; + cs_float h2; + cs_float h6; + // Runge-Kutta slopes. + Eigen::VectorXd k1; + Eigen::VectorXd k2; + Eigen::VectorXd k3; + Eigen::VectorXd k4; + // Temporary value. + Eigen::VectorXd M; + // Polynomial for nonlinear element. + cs_float a; + cs_float b; + cs_float c; + cs_float d; + size_t ksmps; + +public: + int32_t init(CSOUND *csound) { + // h = step_size; %*(G/C2); + h = *step_size_; + // h2 = (h)*(.5); + h2 = h / 2.0; + // h6 = (h)/(6); + h6 = h / 6.0; + // NOTE: The original MATLAB code uses 1-based indexing. + // Although the MATLAB vectors are columns, + // these are rows; it doesn't matter here. + // k1 = [0 0 0]'; + k1.resize(4); + // k2 = [0 0 0]'; + k2.resize(4); + // k3 = [0 0 0]'; + k3.resize(4); + // k4 = [0 0 0]'; + k4.resize(4); + // M = [0 0 0]'; + M.resize(4); + // % values have to be switched around + // M(1) = TimeSeries(3); %V1 + M(1) = *V1_; + // M(2) = TimeSeries(2); %V2 + M(2) = *V2_; + // M(3) = TimeSeries(1); %I3 + M(3) = *I3_; + // sys_variables(9:12) = [1.76e-005,0,-0.00121,0]; + a = 1.76e-5; + b = 0.0; + c = -0.00121; + d = 0.0; + ksmps = opds.insdshead->ksmps; + warn(csound, "ChuasOscillatorCubic::init: L: %f R0: %f C2: %f G: %f" + " C1: %f V1: %f V2: %f I3: %f step: %f\n", + *L_, *R0_, *C2_, *G_, *C1_, M(1), M(2), M(3), h); + warn(csound, "ChuasOscillatorCubic::init: a: %f b: %f c: %f d: %f\n", a, + b, c, d); + return OK; + } + int32_t noteoff(CSOUND *csound) { + warn(csound, "ChuasOscillatorCubic::noteoff\n"); + k1.resize(0); + k2.resize(0); + k3.resize(0); + k4.resize(0); + M.resize(0); + return OK; + } + static int32_t noteoff_(CSOUND *csound, void *opcode) { + return ((ChuasOscillatorCubic *)opcode)->noteoff(csound); + } + int32_t kontrol(CSOUND *csound) { + // NOTE: MATLAB code goes into eigen3 C++ code pretty straightforwardly, + // probaby by design. This is very handy and should prevent mistakes. + // Start with aliases for the Csound inputs, in order + // to preserve the clarity of the original code. + uint32_t offset = opds.insdshead->ksmps_offset; + uint32_t early = opds.insdshead->ksmps_no_end; + uint32_t nsmps = opds.insdshead->ksmps; + if (UNLIKELY(offset)) { + memset(I3, '\0', offset * sizeof(cs_float)); + memset(V1, '\0', offset * sizeof(cs_float)); + memset(V2, '\0', offset * sizeof(cs_float)); + } + if (UNLIKELY(early)) { + memset(&I3[nsmps - early], '\0', early * sizeof(cs_float)); + memset(&V1[nsmps - early], '\0', early * sizeof(cs_float)); + memset(&V2[nsmps - early], '\0', early * sizeof(cs_float)); + } + cs_float &L = *L_; + cs_float &R0 = *R0_; + cs_float &C2 = *C2_; + cs_float &G = *G_; + cs_float &C1 = *C1_; + // Recompute Runge-Kutta step sizes if necessary. + if (h != *step_size_) { + // h = step_size; %*(G/C2); + h = *step_size_; + // h2 = (h)*(.5); + h2 = h / 2.0; + // h6 = (h)/(6); + h6 = h / 6.0; + } + // Standard 4th-order Runge-Kutta integration. + for (size_t i = 0; i < ksmps; i++) { + // TimeSeries(3,i+1) = M(1); %TimeSeries 3 is V1 + // TimeSeries(2,i+1) = M(2); %TimeSeries 2 is V2 + // TimeSeries(1,i+1) = M(3); %TimeSeries 1 is I3 + V1[i] = M(1); + V2[i] = M(2); + I3[i] = M(3); + // std::printf("%4d V1: %f V2: %f I3: %f\n", i, V1[i], V2[i], I3[i]); + // Runge Kutta + // Round One + k1(1) = (G * (M(2) - M(1)) - gnor(M(1))) / C1; + k1(2) = (G * (M(1) - M(2)) + M(3)) / C2; + k1(3) = (-1.0 * (M(2) + R0 * M(3))) / L; + // Round Two + k2(1) = (G * (M(2) + h2 * k1(2) - (M(1) + h2 * k1(1))) - + gnor(M(1) + h2 * k1(1))) / + C1; + k2(2) = + (G * (M(1) + h2 * k1(1) - (M(2) + h2 * k1(2))) + M(3) + h2 * k1(3)) / + C2; + k2(3) = (-(M(2) + h2 * k1(2) + R0 * (M(3) + h2 * k1(3)))) / L; + // Round Three + k3(1) = (G * (M(2) + h2 * k2(2) - (M(1) + h2 * k2(1))) - + gnor(M(1) + h2 * k2(1))) / + C1; + k3(2) = + (G * (M(1) + h2 * k2(1) - (M(2) + h2 * k2(2))) + M(3) + h2 * k2(3)) / + C2; + k3(3) = (-(M(2) + h2 * k2(2) + R0 * (M(3) + h2 * k2(3)))) / L; + // Round Four + k4(1) = (G * (M(2) + h * k3(2) - (M(1) + h * k3(1))) - + gnor(M(1) + h * k3(1))) / + C1; + k4(2) = + (G * (M(1) + h * k3(1) - (M(2) + h * k3(2))) + M(3) + h * k3(3)) / C2; + k4(3) = (-(M(2) + h * k3(2) + R0 * (M(3) + h * k3(3)))) / L; + // Finishes integration and assigns values to M + M = M + (k1 + 2 * k2 + 2 * k3 + k4) * (h6); + } + return OK; + } + cs_float gnor(cs_float x) { // Odd to use std::pow here for integer powers when + // there is intpow function + return (a * std::pow(x, FL(3.0))) + (b * std::pow(x, FL(2.0))) + (c * x) + + d; + } +}; + +// %%%%%%%%%%%%%%%%%%%%%% +// % SubFunction (James)% +// %%%%%%%%%%%%%%%%%%%%%% +// function TimeSeries = chua(sys_variables,integ_variables) +// % Syntax: TimeSeries=chua(sys_variables,integ_variables) +// % sys_variables = [L,R0,C2,G,Ga,Gb,E,C1]; +// % integ_variables = [x0,y0,z0,dataset_size,step_size]; +// % Models Initial Variables +// %------------------------- +// L = sys_variables(1); +// R0 = sys_variables(2); +// C2 = sys_variables(3); +// G = sys_variables(4); +// Ga = sys_variables(5); +// Gb = sys_variables(6); +// E = sys_variables(7); +// C1 = sys_variables(8); +// x0 = integ_variables(1); +// y0 = integ_variables(2); +// z0 = integ_variables(3); +// dataset_size = integ_variables(4); +// step_size = integ_variables(5); +// TimeSeries = [x0, y0, z0]'; % models initial conditions +// % Optimized Runge-Kutta Variables +// %-------------------------------- +// h = step_size*G/C2; +// h2 = (h)*(.5); +// h6 = (h)/(6); +// anor = Ga/G; +// bnor = Gb/G; +// bnorplus1 = bnor + 1; +// alpha = C2/C1; +// beta = C2/(L*G*G); +// gammaloc = (R0*C2)/(L*G); +// bh = beta*h; +// bh2 = beta*h2; +// ch = gammaloc*h; +// ch2 = gammaloc*h2; +// omch2 = 1 - ch2; +// k1 = [0 0 0]'; +// k2 = [0 0 0]'; +// k3 = [0 0 0]'; +// k4 = [0 0 0]'; +// M = [0 0 0]'; +// % Calculate Time Series +// %---------------------- +// M(1) = TimeSeries(3)/E; +// M(2) = TimeSeries(2)/E; +// M(3) = TimeSeries(1)/(E*G); +// for i=1:dataset_size +// % Runge Kutta +// % Round One +// k1(1) = alpha*(M(2) - bnorplus1*M(1) - (.5)*(anor - bnor)*(abs(M(1) + 1) +// - abs(M(1) - +// 1))); +// k1(2) = M(1) - M(2) + M(3); +// k1(3) = -beta*M(2) - gammaloc*M(3); +// % Round Two +// temp = M(1) + h2*k1(1); +// k2(1) = alpha*(M(2) + h2*k1(2) - bnorplus1*temp - +// (.5)*(anor - bnor)*(abs(temp + 1) - abs(temp - 1))); +// k2(2) = k1(2) + h2*(k1(1) - k1(2) + k1(3)); +// k2(3) = omch2*k1(3) - bh2*k1(2); +// % Round Three +// temp = M(1) + h2*k2(1); +// k3(1) = alpha*(M(2) + h2*k2(2) - bnorplus1*temp - +// (.5)*(anor - bnor)*(abs(temp + 1) - abs(temp - 1))); +// k3(2) = k1(2) + h2*(k2(1) - k2(2) + k2(3)); +// k3(3) = k1(3) - bh2*k2(2) - ch2*k2(3); +// % Round Four +// temp = M(1) + h*k3(1); +// k4(1) = alpha*(M(2) + h*k3(2) - bnorplus1*temp - +// (.5)*(anor - bnor)*(abs(temp + 1) - abs(temp - 1))); +// k4(2) = k1(2) + h*(k3(1) - k3(2) + k3(3)); +// k4(3) = k1(3) - bh*k3(2) - ch*k3(3); +// M = M + (k1 + 2*k2 + 2*k3 + k4)*(h6); +// TimeSeries(3,i+1) = E*M(1); +// TimeSeries(2,i+1) = E*M(2); +// TimeSeries(1,i+1) = (E*G)*M(3); +// i=i+1; +// end + +class ChuasOscillatorPiecewise + : public OpcodeNoteoffBase { +public: + // OUTPUTS + cs_float *I3; + cs_float *V2; + cs_float *V1; + // INPUTS + // sys_variables = system_vars(5:12); % L,R0,C2,G,Ga,Gb,E,C1 + // % x0,y0,z0,dataset_size,step_size + // integ_variables = [system_vars(14:16),system_vars(1:2)]; + // function TimeSeries = chuacc(L,R0,C2,G,Ga,Gb,C1,E,x0,y0,z0, + // dataset_size,step_size) + // Circuit elements. + cs_float *L_; + cs_float *R0_; + cs_float *C2_; + cs_float *G_; + cs_float *Ga_; + cs_float *Gb_; + cs_float *E_; + cs_float *C1_; + // Initial values... + cs_float *I3_; + cs_float *V2_; + cs_float *V1_; + cs_float *step_size_; + // STATE + // Runge-Kutta step sizes. + cs_float h; + cs_float h2; + cs_float h6; + // Runge-Kutta slopes. + Eigen::VectorXd k1; + Eigen::VectorXd k2; + Eigen::VectorXd k3; + Eigen::VectorXd k4; + // Temporary value. + Eigen::VectorXd M; + // Other variables. + cs_float step_size; + cs_float anor; + cs_float bnor; + cs_float bnorplus1; + cs_float alpha; + cs_float beta; + cs_float gammaloc; + cs_float bh; + cs_float bh2; + cs_float ch; + cs_float ch2; + cs_float omch2; + cs_float temp; + size_t ksmps; + int32_t init(CSOUND *csound) { + // NOTE: The original MATLAB code uses 1-based indexing. + // Although the MATLAB vectors are columns, + // these are rows; it doesn't matter here. + // k1 = [0 0 0]'; + k1.resize(4); + // k2 = [0 0 0]'; + k2.resize(4); + // k3 = [0 0 0]'; + k3.resize(4); + // k4 = [0 0 0]'; + k4.resize(4); + // M = [0 0 0]'; + M.resize(4); + // M(1) = TimeSeries(3)/E; + M(1) = *V1_ / *E_; + // M(2) = TimeSeries(2)/E; + M(2) = *V2_ / *E_; + // M(3) = TimeSeries(1)/(E*G); + M(3) = *I3_ / (*E_ * *G_); + ksmps = opds.insdshead->ksmps; + warn(csound, "ChuasOscillatorPiecewise::init: L: %f R0: %f C2: %f G: " + "%f Ga: %f Gb: %f E: %f C1: %f iI3: %f iV2:" + " %f iV1: %f step: %f\n", + *L_, *R0_, *C2_, *G_, *Ga_, *Gb_, *E_, *C1_, *I3_, *V2_, *V1_, + step_size); + return OK; + } + int32_t noteoff(CSOUND *csound) { + warn(csound, "ChuasOscillatorPiecewise::noteoff\n"); + k1.resize(0); + k2.resize(0); + k3.resize(0); + k4.resize(0); + M.resize(0); + return OK; + } + static int32_t noteoff_(CSOUND *csound, void *opcode) { + return ((ChuasOscillatorPiecewise *)opcode)->noteoff(csound); + } + int32_t kontrol(CSOUND *csound) { + // NOTE: MATLAB code goes into eigen3 C++ code pretty straightforwardly, + // probaby by design. This is very handy and should prevent mistakes. + // Start with aliases for the Csound inputs, in order + // to preserve the clarity of the original code. + uint32_t offset = opds.insdshead->ksmps_offset; + uint32_t early = opds.insdshead->ksmps_no_end; + if (UNLIKELY(offset)) { + memset(I3, '\0', offset * sizeof(cs_float)); + memset(V1, '\0', offset * sizeof(cs_float)); + memset(V2, '\0', offset * sizeof(cs_float)); + } + if (UNLIKELY(early)) { + ksmps -= early; + memset(&I3[ksmps], '\0', early * sizeof(cs_float)); + memset(&V1[ksmps], '\0', early * sizeof(cs_float)); + memset(&V2[ksmps], '\0', early * sizeof(cs_float)); + } + cs_float &L = *L_; + cs_float &R0 = *R0_; + cs_float &C2 = *C2_; + cs_float &G = *G_; + cs_float &Ga = *Ga_; + cs_float &Gb = *Gb_; + cs_float &E = *E_; + cs_float &C1 = *C1_; + // Recompute Runge-Kutta stuff every kperiod in case kontrol variables + // have changed. + step_size = *step_size_; + // h = step_size*G/C2; + h = step_size * G / C2; + // h2 = (h)*(.5); + h2 = h / 2.0; + // h6 = (h)/(6); + h6 = h / 6.0; + // anor = Ga/G; + anor = Ga / G; + // bnor = Gb/G; + bnor = Gb / G; + // bnorplus1 = bnor + 1; + bnorplus1 = bnor + 1.0; + // alpha = C2/C1; + alpha = C2 / C1; + // beta = C2/(L*G*G); + beta = C2 / (L * G * G); + // gammaloc = (R0*C2)/(L*G); + gammaloc = (R0 * C2) / (L * G); + // bh = beta*h; + bh = beta * h; + // bh2 = beta*h2; + bh2 = beta * h2; + // ch = gammaloc*h; + ch = gammaloc * h; + // ch2 = gammaloc*h2; + ch2 = gammaloc * h2; + // omch2 = 1 - ch2; + omch2 = 1.0 - ch2; + // Standard 4th-order Runge-Kutta integration. + for (size_t i = offset; i < ksmps; i++) { + // Stage 1. + k1(1) = alpha * (M(2) - bnorplus1 * M(1) - + (.5) * (anor - bnor) * (abs(M(1) + 1) - abs(M(1) - 1))); + k1(2) = M(1) - M(2) + M(3); + k1(3) = -beta * M(2) - gammaloc * M(3); + // Stage 2. + temp = M(1) + h2 * k1(1); + k2(1) = alpha * (M(2) + h2 * k1(2) - bnorplus1 * temp - + (.5) * (anor - bnor) * (abs(temp + 1) - abs(temp - 1))); + k2(2) = k1(2) + h2 * (k1(1) - k1(2) + k1(3)); + k2(3) = omch2 * k1(3) - bh2 * k1(2); + // Stage 3. + temp = M(1) + h2 * k2(1); + k3(1) = alpha * (M(2) + h2 * k2(2) - bnorplus1 * temp - + (.5) * (anor - bnor) * (abs(temp + 1) - abs(temp - 1))); + k3(2) = k1(2) + h2 * (k2(1) - k2(2) + k2(3)); + k3(3) = k1(3) - bh2 * k2(2) - ch2 * k2(3); + // Stage 4. + temp = M(1) + h * k3(1); + k4(1) = alpha * (M(2) + h * k3(2) - bnorplus1 * temp - + (.5) * (anor - bnor) * (abs(temp + 1) - abs(temp - 1))); + k4(2) = k1(2) + h * (k3(1) - k3(2) + k3(3)); + k4(3) = k1(3) - bh * k3(2) - ch * k3(3); + M = M + (k1 + 2 * k2 + 2 * k3 + k4) * (h6); + // TimeSeries(3,i+1) = E*M(1); + V1[i] = E * M(1); + // TimeSeries(2,i+1) = E*M(2); + V2[i] = E * M(2); + // TimeSeries(1,i+1) = (E*G)*M(3); + I3[i] = (E * G) * M(3); + // warn(csound, "%4d V1: %f V2: %f I3: %f\n", i, V1[i], V2[i], I3[i]); + } + return OK; + } +}; + +extern "C" { +OENTRY oentries[] = { + // { + // (char*)"chuac", + // sizeof(ChuasOscillatorCubic), + // 0, + // // kL, kR0, kC2, kG, kC1, iI3, iV2, iV1, + // kstep_size + // // 0.00945, 7.5, 2e-007, 0.00105, 1.5e-008, 0, -0.1, 0.1, 5e-6 + // (char*)"aaa", + // (char*)"kkkkkiiik", + // (SUBR) ChuasOscillatorCubic::init_, + // (SUBR) ChuasOscillatorCubic::kontrol_, + // (SUBR) ChuasOscillatorCubic::deinit_, + // }, + { + (char *)"chuap", sizeof(ChuasOscillatorPiecewise), 0, + // kL, kR0, kC2, kG, kGa, kGb, kE, kC1, + // iI3, iV2, iV1, kstep_size + // 0.00945, 7.5, 2e-007, 0.00105, 0, -0.00121, 1.76e-005, + // 1.5e-008, + // 0, -0.1, 0.1, 5e-6 + (char *)"aaa", (char *)"kkkkkkkkiiik", + (SUBR)ChuasOscillatorPiecewise::init_, + (SUBR)ChuasOscillatorPiecewise::kontrol_, + (SUBR)ChuasOscillatorPiecewise::deinit_, + }, + { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }}; + +PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { return 0; } + +PUBLIC int32_t csoundModuleInit(CSOUND *csound) { + int32_t status = 0; + for (OENTRY *oentry = &oentries[0]; oentry->opname; oentry++) { + status |= csound->AppendOpcode( + csound, oentry->opname, oentry->dsblksiz, oentry->flags, + oentry->outypes, oentry->intypes, + (int32_t (*)(CSOUND *, void *))oentry->init, + (int32_t (*)(CSOUND *, void *))oentry->perf, + (int32_t (*)(CSOUND *, void *))oentry->deinit); + } + return status; +} + +PUBLIC int32_t csoundModuleDestroy(CSOUND *csound) { return 0; } +} diff --git a/7.x/src/chua/OpcodeBase.hpp b/7.x/src/chua/OpcodeBase.hpp new file mode 100644 index 0000000..49a724f --- /dev/null +++ b/7.x/src/chua/OpcodeBase.hpp @@ -0,0 +1,499 @@ +/* + OpcodeBase.hpp: + + Copyright (C) 2005, 2009, 2017 by Istva Varga, Victor Lazzarini and + Michael Gogins + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA +*/ +#pragma once + +/** + * There is a conflict between the preprocessor definition "_CR" in the + * standard C++ library and in Csound. To work around this, undefine "_CR" and + * include ALL standard library include files BEFORE including ANY Csound + * include files. + */ +#if defined(_CR) +#undef _CR +#endif + +#include +#include +#include +#if !(defined(__wasi__)) +#include +#endif +#include +#include +#include "interlocks.h" +#ifdef BUILD_PLUGINS +#include "csdl.h" +#else +#include "csoundCore.h" +#endif + +/** + * Template base class, or pseudo-virtual base class, + * for writing Csound opcodes in C++. + * Derive opcode implementation classes like this: + * + * DerivedClass : public OpcodeBase + * { + * public: + * // All output fields must be declared first as cs_float *: + * cs_float *aret1; + * // All input fields must be declared next as cs_float *: + * cs_float *iarg1; + * cs_float *karg2; + * cs_float *aarg3; + * // All internal state variables must be declared after that: + * size_t state1; + * double state2; + * cs_float state3; + * // If the opcode shares data protect it by creating one or more void + * // *mutex member pointers: + * void *mutex1; + * void *mutex2; + * // and create them usind csound->Create_Mutex() in csoundModuleCreate + * // and destroy them using csound->DeleteMutex(mutex) + * // csoundModuleDestroy, and lock them using LockGuard guard(mutex). + * int32_t init(); + * int32_t kontrol(); + * int32_t audio; + * int32_t noteoff(); + * void deinit(); + * }; + */ + +namespace csound { + + static bool diagnostics_enabled = false; + + /** + * Use this to guard against data races in opcode functions. The mutex should + * be created by csound->Create_Mutex() in csoundModuleCreate(), and should + * be destroyed by csound->DeleteMutex() in csoundModuleDestroy(). + * + * If data is shared between opcode instances, the mutex should be global to + * the opcode library; if data is shared between threads for a single instance, + * the mutex should belong to the opcode instance. + */ + struct LockGuard { + LockGuard(CSOUND *csound_, void *mutex_) : csound(csound_), mutex(mutex_) + { + csound->LockMutex(mutex); + } + ~LockGuard() + { + csound->UnlockMutex(mutex); + } + CSOUND *csound; + void *mutex; + }; + + /** + * Use this to store a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + + template int32_t CreateGlobalPointer(CSOUND *csound, const char *name, T *pointer) + { + T **pointer_to_pointer = 0; + int32_t result = csound->CreateGlobalVariable(csound, name, sizeof(pointer_to_pointer)); + pointer_to_pointer = static_cast(csound->QueryGlobalVariable(csound, name)); + *pointer_to_pointer = pointer; + return result; + } + + /** + * Retrieve a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + template T *QueryGlobalPointer(CSOUND *csound, const char *name, T*& pointer) + { + T **pointer_to_pointer = static_cast(csound->QueryGlobalVariableNoCheck(csound, name)); + if (pointer_to_pointer != 0) { + pointer = *pointer_to_pointer; + } else { + pointer = 0; + } + return pointer; + } + + template + class OpcodeBase + { + public: + int32_t init(CSOUND *csound) + { + return NOTOK; + } + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + int32_t kontrol(CSOUND *csound) + { + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + OPDS opds; + }; + + template + class OpcodeNoteoffBase + { + public: + int32_t init(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + + static int32_t deinit_(CSOUND *csound, void *opcode) + { + if (!csound->GetReinitFlag(csound) && !csound->GetTieFlag(csound)) { + return noteoff_(csound, opcode); + } + return OK; + } + + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + + int32_t kontrol(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + int32_t noteoff(CSOUND *csound) + { + return OK; + } + static int32_t noteoff_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->noteoff(csound); + } + OPDS opds; + }; + + +#if (__cplusplus >= 201103L) && !(defined(__wasi__)) && !defined(BARE_METAL) + // #pragma message("Defining heap_object_manager_t.") + /** + * The memory of non-POD C++ or C objects allocated on the heap by Csound + * plugins is managed not by Csound, but by the plugin module. This class + * performs that function. + * + * As long as all memory is allocated in or after csoundModuleCreate and + * de-allocated in csoundModuleDestroy, all will be well. The danger however + * is that memory leaks will occur if allocations are not matched with + * de-allocations, or worse, that crashes will occur if any objects are + * deleted twice or de-referenced after deletion. + * + * So, the plugin should manage a collection of all heap-allocated objects, + * keyed first off the Csound instance, and second off an object handle; and + * all such objects must be accessed only by handle, from this collection. + * + * In csoundModuleDestroy, all objects for the calling instance of Csound + * should be de-allocated, and the sub-collection for that instance should + * also be de-allocated. + * + * If then there are no more sub-collections for other instances of Csound, + * the entire contents of the collection should be de-allocated. + * + * This should be done as a singleton, and in a thread-safe way. + * + * There might still be a problem if any of the heap-allocated objects, + * themselves, have global static members, perhaps created by some external + * dependency. + * + * Please note, objects O in the declaration below must not be std::shared_ptr + * objects. Deletion of objects herein must be unconditional. Rather, the + * objects passed are raw pointers to instances of class O. + */ + template class heap_object_manager_t { + private: + std::map> objects_; + std::recursive_mutex mutex; + heap_object_manager_t(){}; + ~heap_object_manager_t(){}; + public: + static heap_object_manager_t &instance() { + static heap_object_manager_t singleton; + return singleton; + } + std::map> &objects() { + std::lock_guard lock(mutex); + return objects_; + } + /** + * Returns a list of pointers to all objects allocated for this + * instance of Csound. + */ + std::vector &objects_for_csound(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects()[csound]; + return objects_for_csound_; + } + /** + * Returns the handle for the object; if the object has not yet been + * stored, inserts it into the list of object pointers for this + * instance of Csound; otherwise, returns the handle of the stored + * object pointer. + */ + int32_t handle_for_object(CSOUND *csound, O *object) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + auto iterator = std::find(objects_for_csound_.begin(), objects_for_csound_.end(), object); + if (iterator == objects_for_csound_.end()) { + int32_t handle = objects_for_csound_.size(); + objects_for_csound_.push_back(object); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object %p: new object handle: %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return handle; + } else { + int32_t handle = static_cast(iterator - objects_for_csound_.begin()); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object: existing object handle: %d\n", handle); + return handle; + } + } + /** + * Returns the object pointer for the handle; + * if the object pointer has not been stored by + * handle, returns a null pointer. + */ + O *object_for_handle(CSOUND *csound, int32_t handle) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + if (handle >= objects_for_csound_.size()) { + return nullptr; + } + O *object = objects_for_csound_[handle]; + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::object_for_handle: %p %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return object; + } + /** + * First destroys all objects created by the calling + * instance of Csound, then destroys the list of + * object pointers for this instance of Csound. + */ + void module_destroy(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + for (int32_t i = 0, n = objects_for_csound_.size(); i < n; ++i) { + delete objects_for_csound_[i]; + objects_for_csound_[i] = nullptr; + } + objects_for_csound_.clear(); + objects().erase(csound); + } + }; + +#endif + +} diff --git a/7.x/src/linear_algebra/CMakeLists.txt b/7.x/src/linear_algebra/CMakeLists.txt new file mode 100644 index 0000000..b68c133 --- /dev/null +++ b/7.x/src/linear_algebra/CMakeLists.txt @@ -0,0 +1,17 @@ +option(BUILD_LINEAR_ALGEBRA_OPCODES "Build the linear algebra opcodes" ON) + +find_package(GMM) +check_deps(BUILD_LINEAR_ALGEBRA_OPCODES GMM_FOUND) + +if(BUILD_LINEAR_ALGEBRA_OPCODES AND GMM_FOUND) + make_plugin(linear_algebra linear_algebra.cpp) + target_include_directories(linear_algebra PRIVATE ${GMM_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) + target_compile_options(linear_algebra PRIVATE "-DGMM_VERSION") + target_compile_definitions(linear_algebra PRIVATE BUILD_PLUGINS) + + if (MSVC) + target_compile_options(linear_algebra PRIVATE "/D_SCL_SECURE_NO_DEPRECATE") + endif() + + message(STATUS "Building linear algebra opcodes") +endif() diff --git a/7.x/src/linear_algebra/OpcodeBase.hpp b/7.x/src/linear_algebra/OpcodeBase.hpp new file mode 100644 index 0000000..49a724f --- /dev/null +++ b/7.x/src/linear_algebra/OpcodeBase.hpp @@ -0,0 +1,499 @@ +/* + OpcodeBase.hpp: + + Copyright (C) 2005, 2009, 2017 by Istva Varga, Victor Lazzarini and + Michael Gogins + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA +*/ +#pragma once + +/** + * There is a conflict between the preprocessor definition "_CR" in the + * standard C++ library and in Csound. To work around this, undefine "_CR" and + * include ALL standard library include files BEFORE including ANY Csound + * include files. + */ +#if defined(_CR) +#undef _CR +#endif + +#include +#include +#include +#if !(defined(__wasi__)) +#include +#endif +#include +#include +#include "interlocks.h" +#ifdef BUILD_PLUGINS +#include "csdl.h" +#else +#include "csoundCore.h" +#endif + +/** + * Template base class, or pseudo-virtual base class, + * for writing Csound opcodes in C++. + * Derive opcode implementation classes like this: + * + * DerivedClass : public OpcodeBase + * { + * public: + * // All output fields must be declared first as cs_float *: + * cs_float *aret1; + * // All input fields must be declared next as cs_float *: + * cs_float *iarg1; + * cs_float *karg2; + * cs_float *aarg3; + * // All internal state variables must be declared after that: + * size_t state1; + * double state2; + * cs_float state3; + * // If the opcode shares data protect it by creating one or more void + * // *mutex member pointers: + * void *mutex1; + * void *mutex2; + * // and create them usind csound->Create_Mutex() in csoundModuleCreate + * // and destroy them using csound->DeleteMutex(mutex) + * // csoundModuleDestroy, and lock them using LockGuard guard(mutex). + * int32_t init(); + * int32_t kontrol(); + * int32_t audio; + * int32_t noteoff(); + * void deinit(); + * }; + */ + +namespace csound { + + static bool diagnostics_enabled = false; + + /** + * Use this to guard against data races in opcode functions. The mutex should + * be created by csound->Create_Mutex() in csoundModuleCreate(), and should + * be destroyed by csound->DeleteMutex() in csoundModuleDestroy(). + * + * If data is shared between opcode instances, the mutex should be global to + * the opcode library; if data is shared between threads for a single instance, + * the mutex should belong to the opcode instance. + */ + struct LockGuard { + LockGuard(CSOUND *csound_, void *mutex_) : csound(csound_), mutex(mutex_) + { + csound->LockMutex(mutex); + } + ~LockGuard() + { + csound->UnlockMutex(mutex); + } + CSOUND *csound; + void *mutex; + }; + + /** + * Use this to store a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + + template int32_t CreateGlobalPointer(CSOUND *csound, const char *name, T *pointer) + { + T **pointer_to_pointer = 0; + int32_t result = csound->CreateGlobalVariable(csound, name, sizeof(pointer_to_pointer)); + pointer_to_pointer = static_cast(csound->QueryGlobalVariable(csound, name)); + *pointer_to_pointer = pointer; + return result; + } + + /** + * Retrieve a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + template T *QueryGlobalPointer(CSOUND *csound, const char *name, T*& pointer) + { + T **pointer_to_pointer = static_cast(csound->QueryGlobalVariableNoCheck(csound, name)); + if (pointer_to_pointer != 0) { + pointer = *pointer_to_pointer; + } else { + pointer = 0; + } + return pointer; + } + + template + class OpcodeBase + { + public: + int32_t init(CSOUND *csound) + { + return NOTOK; + } + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + int32_t kontrol(CSOUND *csound) + { + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + OPDS opds; + }; + + template + class OpcodeNoteoffBase + { + public: + int32_t init(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + + static int32_t deinit_(CSOUND *csound, void *opcode) + { + if (!csound->GetReinitFlag(csound) && !csound->GetTieFlag(csound)) { + return noteoff_(csound, opcode); + } + return OK; + } + + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + + int32_t kontrol(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + int32_t noteoff(CSOUND *csound) + { + return OK; + } + static int32_t noteoff_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->noteoff(csound); + } + OPDS opds; + }; + + +#if (__cplusplus >= 201103L) && !(defined(__wasi__)) && !defined(BARE_METAL) + // #pragma message("Defining heap_object_manager_t.") + /** + * The memory of non-POD C++ or C objects allocated on the heap by Csound + * plugins is managed not by Csound, but by the plugin module. This class + * performs that function. + * + * As long as all memory is allocated in or after csoundModuleCreate and + * de-allocated in csoundModuleDestroy, all will be well. The danger however + * is that memory leaks will occur if allocations are not matched with + * de-allocations, or worse, that crashes will occur if any objects are + * deleted twice or de-referenced after deletion. + * + * So, the plugin should manage a collection of all heap-allocated objects, + * keyed first off the Csound instance, and second off an object handle; and + * all such objects must be accessed only by handle, from this collection. + * + * In csoundModuleDestroy, all objects for the calling instance of Csound + * should be de-allocated, and the sub-collection for that instance should + * also be de-allocated. + * + * If then there are no more sub-collections for other instances of Csound, + * the entire contents of the collection should be de-allocated. + * + * This should be done as a singleton, and in a thread-safe way. + * + * There might still be a problem if any of the heap-allocated objects, + * themselves, have global static members, perhaps created by some external + * dependency. + * + * Please note, objects O in the declaration below must not be std::shared_ptr + * objects. Deletion of objects herein must be unconditional. Rather, the + * objects passed are raw pointers to instances of class O. + */ + template class heap_object_manager_t { + private: + std::map> objects_; + std::recursive_mutex mutex; + heap_object_manager_t(){}; + ~heap_object_manager_t(){}; + public: + static heap_object_manager_t &instance() { + static heap_object_manager_t singleton; + return singleton; + } + std::map> &objects() { + std::lock_guard lock(mutex); + return objects_; + } + /** + * Returns a list of pointers to all objects allocated for this + * instance of Csound. + */ + std::vector &objects_for_csound(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects()[csound]; + return objects_for_csound_; + } + /** + * Returns the handle for the object; if the object has not yet been + * stored, inserts it into the list of object pointers for this + * instance of Csound; otherwise, returns the handle of the stored + * object pointer. + */ + int32_t handle_for_object(CSOUND *csound, O *object) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + auto iterator = std::find(objects_for_csound_.begin(), objects_for_csound_.end(), object); + if (iterator == objects_for_csound_.end()) { + int32_t handle = objects_for_csound_.size(); + objects_for_csound_.push_back(object); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object %p: new object handle: %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return handle; + } else { + int32_t handle = static_cast(iterator - objects_for_csound_.begin()); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object: existing object handle: %d\n", handle); + return handle; + } + } + /** + * Returns the object pointer for the handle; + * if the object pointer has not been stored by + * handle, returns a null pointer. + */ + O *object_for_handle(CSOUND *csound, int32_t handle) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + if (handle >= objects_for_csound_.size()) { + return nullptr; + } + O *object = objects_for_csound_[handle]; + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::object_for_handle: %p %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return object; + } + /** + * First destroys all objects created by the calling + * instance of Csound, then destroys the list of + * object pointers for this instance of Csound. + */ + void module_destroy(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + for (int32_t i = 0, n = objects_for_csound_.size(); i < n; ++i) { + delete objects_for_csound_[i]; + objects_for_csound_[i] = nullptr; + } + objects_for_csound_.clear(); + objects().erase(csound); + } + }; + +#endif + +} diff --git a/7.x/src/linear_algebra/linear_algebra.cpp b/7.x/src/linear_algebra/linear_algebra.cpp new file mode 100644 index 0000000..60e9ca1 --- /dev/null +++ b/7.x/src/linear_algebra/linear_algebra.cpp @@ -0,0 +1,4773 @@ +/* + linear_algebra.cpp: + + Copyright (C) 2008 by Michael Gogins + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + +/** + * L I N E A R A L G E B R A O P C O D E S F O R C S O U N D + * Michael Gogins + * + * These opcodes implement many linear algebra operations, + * from scalar, vector, and matrix arithmetic up to + * and including QR based eigenvalue decompositions. + * The opcodes are designed for digital signal processing, + * and of course other mathematical operations, + * in the Csound orchestra language. + * + * The numerical implementation uses the gmm++ library + * from http://home.gna.org/getfem/gmm_intro. + * + * NOTE: SDFT must be #defined in order to build and use these opcodes. + * + * For applications with f-sig variables, array arithmetic must be + * performed only when the f-sig is "current," because f-rate + * is some fraction of k-rate; currency can be determined with the + * la_k_current_f opcode. + * + * For applications using assignments between real vectors and + * a-rate variables, array arithmetic must be performed only when the + * vectors are "current", because the size of the vector may be + * some integral multiple of ksmps; currency can be determined + * by means of the la_k_current_vr opcode. + * + * Linear Algebra Data Types + * ------------------------- + * + * Mathematical Type Code Corresponding Csound Type or Types + * ----------------- ---- ------------------------------------------------- + * real scalar r i-rate or k-rate variable + * complex scalar c pair of i-rate or k-rate variables, e.g. "kr, ki" + * real vector vr i-rate variable holding address of array + * a a-rate variable + * t function table number + * complex vector vc i-rate variable holding address of array + * f fsig variable + * real matrix mr i-rate variable holding address of array + * complex matrix mc i-rate variable holding address of array + * + * All arrays are 0-based; the first index iterates rows to give columns, + * the second index iterates columns to give elements. + * + * All arrays are general and dense; banded, Hermitian, symmetric + * and sparse routines are not implemented. + * + * An array can be of type code vr, vc, mr, or mc + * and is stored in an i-rate object. + * In orchestra code, an array is passed as a + * cs_float i-rate variable that contains the address + * of the array object, which is actually stored + * in the allocator opcode instance. + * Although array variables are i-rate, of course + * their values and even shapes may change at i-rate or k-rate. + * + * All operands must be pre-allocated; except for the creation + * opcodes, no opcode ever allocates any arrays. + * This is true even if the array appears on the + * left-hand side of an opcode! However, some operations + * may reshape arrays to hold results. + * + * Arrays are automatically deallocated when their instrument + * is deallocated. + * + * Not only for more efficient performance, + * but also to make it easier to remember opcode names, + * the performance rate, output value types, operation names, + * and input value types are deterministically + * encoded into the opcode name: + * 1. "la" for "linear algebra opcode family". + * 2. "i" or "k" for performance rate. + * 3. Type code(s) (see above table) for output value(s), + * but only if the type is not implicit from the input values. + * 4. Operation name: common mathematical name + * (preferred) or abbreviation. + * 5. Type code(s) for input values, if not implicit. + * + * For details, see the gmm++ documentation at + * http://download.gna.org/getfem/doc/gmmuser.pdf. + * + * Array Creation + * -------------- + * + * ivr la_i_vr_create irows + * ivc la_i_vc_create irows + * imr la_i_mr_create irows, icolumns [, + odiagonal] + * imc la_i_mc_create irows, icolumns + [, odiagonal_r, + odiagonal_i] + * + * Array Introspection + * ------------------- + * + * irows la_i_size_vr ivr + * irows la_i_size_vc ivc + * irows, icolumns la_i_size_mr imr + * irows, icolumns la_i_size_mc imc + * + * kfiscurrent la_k_current_f fsig + * kvriscurrent la_k_current_vr ivr + * + * la_i_print_vr ivr + * la_i_print_vc ivc + * la_i_print_mr imr + * la_i_print_mc imc + * + * Array Assignment and Conversion + * ------------------------------- + * + * ivr la_i_assign_vr ivr + * ivr la_k_assign_vr ivr + * ivc la_i_assign_vc ivc + * ivc la_k_assign_vc ivr + * imr la_i_assign_mr imr + * imr la_k_assign_mr imr + * imc la_i_assign_mc imc + * imc la_k_assign_mc imr + * + * NOTE: Assignments from tables or fsigs will resize vectors. + * Assignments to or from asigs are incremental -- ksmps + * frames are copied each kperiod and the array index + * wraps around as required. + * + * ivr la_k_assign_a asig + * ivr la_i_assign_t itablenumber + * ivr la_k_assign_t itablenumber + * ivc la_k_assign_f fsig + * + * asig la_k_a_assign ivr + * itablenum la_i_t_assign ivr + * itablenum la_k_t_assign ivr + * fsig la_k_f_assign ivc + * + * Fill Arrays with Random Elements + * -------------------------------- + * + * ivr la_i_random_vr [ifill_fraction] + * ivr la_k_random_vr [kfill_fraction] + * ivc la_i_random_vc [ifill_fraction] + * ivc la_k_random_vc [kfill_fraction] + * imr la_i_random_mr [ifill_fraction] + * imr la_k_random_mr [kfill_fraction] + * imc la_i_random_mc [ifill_fraction] + * imc la_k_random_mc [kfill_fraction] + * + * Array Element Access + * -------------------- + * + * ivr la_i_vr_set irow, ivalue + * kvr la_k_vr_set krow, kvalue + * ivc la_i_vc_set irow, ivalue_r, ivalue_i + * kvc la_k_vc_set krow, kvalue_r, kvalue_i + * imr la_i mr_set irow, icolumn, ivalue + * kmr la_k mr_set krow, kcolumn, ivalue + * imc la_i_mc_set irow, icolumn, ivalue_r, + ivalue_i + * kmc la_k_mc_set krow, kcolumn, kvalue_r, + kvalue_i + * + * ivalue la_i_get_vr ivr, irow + * kvalue la_k_get_vr ivr, krow, + * ivalue_r, ivalue_i la_i_get_vc ivc, irow + * kvalue_r, kvalue_i la_k_get_vc ivc, krow + * ivalue la_i_get_mr imr, irow, icolumn + * kvalue la_k_get_mr imr, krow, kcolumn + * ivalue_r, ivalue_i la_i_get_mc imc, irow, icolumn + * kvalue_r, kvalue_i la_k_get_mc imc, krow, kcolumn + * + * Single Array Operations + * ----------------------- + * + * imr la_i_transpose_mr imr + * imr la_k_transpose_mr imr + * imc la_i_transpose_mc imc + * imc la_k_transpose_mc imc + + * ivr la_i_conjugate_vr ivr + * ivr la_k_conjugate_vr ivr + * ivc la_i_conjugate_vc ivc + * ivc la_k_conjugate_vc ivc + * imr la_i_conjugate_mr imr + * imr la_k_conjugate_mr imr + * imc la_i_conjugate_mc imc + * imc la_k_conjugate_mc imc + * + * Scalar Operations + * ----------------- + * + * ir la_i_norm1_vr ivr + * kr la_k_norm1_vr ivc + * ir la_i_norm1_vc ivc + * kr la_k_norm1_vc ivc + * ir la_i_norm1_mr imr + * kr la_k_norm1_mr imr + * ir la_i_norm1_mc imc + * kr la_k_norm1_mc imc + * + * ir la_i_norm_euclid_vr ivr + * kr la_k_norm_euclid_vr ivr + * ir la_i_norm_euclid_vc ivc + * kr la_k_norm_euclid_vc ivc + * ir la_i_norm_euclid_mr mvr + * kr la_k_norm_euclid_mr mvr + * ir la_i_norm_euclid_mc mvc + * kr la_k_norm_euclid_mc mvc + * + * ir la_i_distance_vr ivr + * kr la_k_distance_vr ivr + * ir la_i_distance_vc ivc + * kr la_k_distance_vc ivc + * + * ir la_i_norm_max imr + * kr la_k_norm_max imc + * ir la_i_norm_max imr + * kr la_k_norm_max imc + * + * ir la_i_norm_inf_vr ivr + * kr la_k_norm_inf_vr ivr + * ir la_i_norm_inf_vc ivc + * kr la_k_norm_inf_vc ivc + * ir la_i_norm_inf_mr imr + * kr la_k_norm_inf_mr imr + * ir la_i_norm_inf_mc imc + * kr la_k_norm_inf_mc imc + * + * ir la_i_trace_mr imr + * kr la_k_trace_mr imr + * ir, ii la_i_trace_mc imc + * kr, ki la_k_trace_mc imc + * + * ir la_i_lu_det imr + * kr la_k_lu_det imr + * ir la_i_lu_det imc + * kr la_k_lu_det imc + * + * Elementwise Array-Array Operations + * ---------------------------------- + * + * ivr la_i_add_vr ivr_a, ivr_b + * ivc la_k_add_vc ivc_a, ivc_b + * imr la_i_add_mr imr_a, imr_b + * imc la_k_add_mc imc_a, imc_b + * + * ivr la_i_subtract_vr ivr_a, ivr_b + * ivc la_k_subtract_vc ivc_a, ivc_b + * imr la_i_subtract_mr imr_a, imr_b + * imc la_k_subtract_mc imc_a, imc_b + * + * ivr la_i_multiply_vr ivr_a, ivr_b + * ivc la_k_multiply_vc ivc_a, ivc_b + * imr la_i_multiply_mr imr_a, imr_b + * imc la_k_multiply_mc imc_a, imc_b + * + * ivr la_i_divide_vr ivr_a, ivr_b + * ivc la_k_divide_vc ivc_a, ivc_b + * imr la_i_divide_mr imr_a, imr_b + * imc la_k_divide_mc imc_a, imc_b + * + * Inner Products + * -------------- + * + * ir la_i_dot_vr ivr_a, ivr_b + * kr la_k_dot_vr ivr_a, ivr_b + * ir, ii la_i_dot_vc ivc_a, ivc_b + * kr, ki la_k_dot_vc ivc_a, ivc_b + * + * imr la_i_dot_mr imr_a, imr_b + * imr la_k_dot_mr imr_a, imr_b + * imc la_i_dot_mc imc_a, imc_b + * imc la_k_dot_mc imc_a, imc_b + * + * ivr la_i_dot_mr_vr imr_a, ivr_b + * ivr la_k_dot_mr_vr imr_a, ivr_b + * ivc la_i_dot_mc_vc imc_a, ivc_b + * ivc la_k_dot_mc_vc imc_a, ivc_b + * + * Matrix Inversion + * ---------------- + * + * imr, icondition la_i_invert_mr imr + * imr, kcondition la_k_invert_mr imr + * imc, icondition la_i_invert_mc imc + * imc, kcondition la_k_invert_mc imc + * + * Matrix Decompositions and Solvers + * --------------------------------- + * + * ivr la_i_upper_solve_mr imr [, j_1_diagonal] + * ivr la_k_upper_solve_mr imr [, j_1_diagonal] + * ivc la_i_upper_solve_mc imc [, j_1_diagonal] + * ivc la_k_upper_solve_mc imc [, j_1_diagonal] + * + * ivr la_i_lower_solve_mr imr [, j_1_diagonal] + * ivr la_k_lower_solve_mr imr [, j_1_diagonal] + * ivc la_i_lower_solve_mc imc [, j_1_diagonal] + * ivc la_k_lower_solve_mc imc [, j_1_diagonal] + * + * imr, ivr_pivot, isize la_i_lu_factor_mr imr + * imr, ivr_pivot, ksize la_k_lu_factor_mr imr + * imc, ivr_pivot, isize la_i_lu_factor_mc imc + * imc, ivr_pivot, ksize la_k_lu_factor_mc imc + * + * ivr_x la_i_lu_solve_mr imr, ivr_b + * ivr_x la_k_lu_solve_mr imr, ivr_b + * ivc_x la_i_lu_solve_mc imc, ivc_b + * ivc_x la_k_lu_solve_mc imc, ivc_b + * + * imr_q, imr_r la_i_qr_factor_mr imr + * imr_q, imr_r la_k_qr_factor_mr imr + * imc_q, imc_r la_i_qr_factor_mc imc + * imc_q, imc_r la_k_qr_factor_mc imc + * + * ivr_eig_vals la_i_qr_eigen_mr imr, i_tolerance + * ivr_eig_vals la_k_qr_eigen_mr imr, k_tolerance + * ivr_eig_vals la_i_qr_eigen_mc imc, i_tolerance + * ivr_eig_vals la_k_qr_eigen_mc imc, k_tolerance + * + * NOTE: Matrix must be Hermitian in order to compute eigenvectors. + * + * ivr_eig_vals, imr_eig_vecs la_i_qr_sym_eigen_mr imr, i_tolerance + * ivr_eig_vals, imr_eig_vecs la_k_qr_sym_eigen_mr imr, k_tolerance + * ivc_eig_vals, imc_eig_vecs la_i_qr_sym_eigen_mc imc, i_tolerance + * ivc_eig_vals, imc_eig_vecs la_k_qr_sym_eigen_mc imc, k_tolerance + * + */ + +extern "C" { +// a-rate, k-rate, FUNC, SPECDAT +#include +// PVSDAT +#include +} + +#ifdef ST +#undef ST +#endif + +#ifdef WR +#undef WR +#endif + +#include "OpcodeBase.hpp" +#include +#include +#include +#include + +using namespace csound; + +static std::ostream &operator<<(std::ostream &o, const std::vector &m) { + gmm::write(o, m); + return o; +} + +static std::ostream &operator<<(std::ostream &o, + const std::vector> &m) { + gmm::write(o, m); + return o; +} + +/** + * Template union for safely and efficiently + * typecasting the value of a cs_float variable + * to the address of an array, and vice versa. + */ +template struct ArrayCaster { + union { + A *a; + F f; + }; +}; + +/** + * Safely and efficiently typecast the address + * of an array to the value of a cs_float variable. + */ +template void tof(A *a, F *f) { + ArrayCaster arrayCaster; + arrayCaster.a = a; + *f = arrayCaster.f; +}; + +/** + * Safely and efficiently typecast the value of a + * a cs_float variable to the address of an array. + */ +template void toa(F *f, A *&a) { + ArrayCaster arrayCaster; + arrayCaster.f = *f; + a = arrayCaster.a; +}; + +class la_i_vr_create_t : public OpcodeNoteoffBase { +public: + cs_float *i_vr; + cs_float *i_rows; + std::vector vr; + int32_t init(CSOUND *) { + vr.resize(size_t(*i_rows)); + tof(this, i_vr); + return OK; + } + int32_t noteoff(CSOUND *) { + vr.resize(0); + return OK; + } +}; + +class la_i_vc_create_t : public OpcodeNoteoffBase { +public: + cs_float *i_vc; + cs_float *i_rows; + std::vector> vc; + int32_t init(CSOUND *) { + vc.resize(size_t(*i_rows)); + tof(this, i_vc); + return OK; + } + int32_t noteoff(CSOUND *) { + vc.resize(0); + return OK; + } +}; + +class la_i_mr_create_t : public OpcodeNoteoffBase { +public: + cs_float *i_mr; + cs_float *i_rows; + cs_float *i_columns; + cs_float *o_diagonal; + gmm::dense_matrix mr; + int32_t init(CSOUND *) { + gmm::resize(mr, size_t(*i_rows), size_t(*i_columns)); + if (*o_diagonal) { + for (size_t i = 0, n = size_t(*i_rows); i < n; ++i) { + mr(i, i) = *o_diagonal; + } + } + tof(this, i_mr); + return OK; + } + int32_t noteoff(CSOUND *) { + mr.resize(0, 0); + return OK; + } +}; + +class la_i_mc_create_t : public OpcodeNoteoffBase { +public: + cs_float *i_mc; + cs_float *i_rows; + cs_float *i_columns; + cs_float *o_diagonal_r; + cs_float *o_diagonal_i; + gmm::dense_matrix> mc; + int32_t init(CSOUND *) { + gmm::resize(mc, size_t(*i_rows), size_t(*i_columns)); + if (*o_diagonal_r || *o_diagonal_i) { + for (size_t i = 0, n = size_t(*i_rows); i < n; ++i) { + mc(i, i) = std::complex(*o_diagonal_r, *o_diagonal_i); + } + } + tof(this, i_mc); + return OK; + } + int32_t noteoff(CSOUND *) { + mc.resize(0, 0); + return OK; + } +}; + +class la_i_size_vr_t : public OpcodeBase { +public: + cs_float *i_size; + cs_float *i_vr; + int32_t init(CSOUND *) { + la_i_vr_create_t *array = 0; + toa(i_vr, array); + *i_size = (cs_float)gmm::vect_size(array->vr); + return OK; + } +}; + +class la_i_size_vc_t : public OpcodeBase { +public: + cs_float *i_size; + cs_float *i_vc; + int32_t init(CSOUND *) { + la_i_vc_create_t *array = 0; + toa(i_vc, array); + *i_size = (cs_float)gmm::vect_size(array->vc); + return OK; + } +}; + +class la_i_size_mr_t : public OpcodeBase { +public: + cs_float *i_rows; + cs_float *i_columns; + cs_float *i_mr; + int32_t init(CSOUND *) { + la_i_mr_create_t *array = 0; + toa(i_mr, array); + *i_rows = (cs_float)gmm::mat_nrows(array->mr); + *i_columns = (cs_float)gmm::mat_ncols(array->mr); + return OK; + } +}; + +class la_i_size_mc_t : public OpcodeBase { +public: + cs_float *i_rows; + cs_float *i_columns; + cs_float *i_mc; + int32_t init(CSOUND *) { + la_i_mc_create_t *array = 0; + toa(i_mc, array); + *i_rows = (cs_float)gmm::mat_nrows(array->mc); + *i_columns = (cs_float)gmm::mat_ncols(array->mc); + return OK; + } +}; + +/** + * Return 1 if the input f-sig is current + * (i.e., if its value might change in the next kperiod); + * return 0 if the input f-sig is not current. + * + * Example: + * + * kcurrent la_k_current_f fsig + * if (kcurrent == 1.0) then + * ; arithmetic on fsig here... + * endif + */ +class la_k_current_f_t : public OpcodeBase { +public: + cs_float *k_current; + PVSDAT *f_sig; + size_t last_frame; + int32_t init(CSOUND *) { + last_frame = f_sig->framecount; + return OK; + } + int32_t kontrol(CSOUND *) { + if (last_frame < f_sig->framecount) { + last_frame = f_sig->framecount; + *k_current = 1.0; + } else { + *k_current = 0.0; + } + return OK; + } +}; + +/** + * Return 1 if the real vector is current (i.e., its + * current index equals 0); return 0 if the input + * real vector is not current. A real vector is current + * in the very first kperiod of performance, + * and at each subsequent kperiod where ksmps has + * accumulated past the end of the vector and + * has wrapped back to index 0. For this to be + * possible, the size of the vector must be an integral + * multiple of ksmps. + * + * Example: + * + * ; FIRST, assignments from a-rate variables to vectors. + * kcurrent la_k_current_vr ivr + * if (kcurrent == 1.0) then + * ; SECOND, arithmetic with current vectors. + * endif + * ; THIRD, assignments from vectors to a-rate variables. + */ + +class la_k_current_vr_t : public OpcodeBase { +public: + cs_float *k_current; + cs_float *rhs_ivr; + la_i_vr_create_t *rhs; + size_t ksmps; + size_t vector_size; + int32_t init(CSOUND *csound) { + rhs = 0; + toa(rhs_ivr, rhs); + ksmps = opds.insdshead->ksmps; + vector_size = gmm::vect_size(rhs->vr); + return OK; + } + int32_t kontrol(CSOUND *csound) { + size_t frame_count = opds.insdshead->kcounter * ksmps; + size_t index = frame_count % vector_size; + if (index == 0) { + *k_current = 1.0; + } else { + *k_current = 0.0; + } + return OK; + } +}; + +class la_i_print_vr_t : public OpcodeBase { +public: + cs_float *i_vr; + int32_t init(CSOUND *csound) { + la_i_vr_create_t *array = 0; + toa(i_vr, array); + std::ostringstream stream; + stream << array->vr << std::endl; + csound->Message(csound, "%s", stream.str().c_str()); + return OK; + } +}; + +class la_i_print_vc_t : public OpcodeBase { +public: + cs_float *i_vc; + int32_t init(CSOUND *csound) { + la_i_vc_create_t *array = 0; + toa(i_vc, array); + std::ostringstream stream; + stream << array->vc << std::endl; + csound->Message(csound, "%s", stream.str().c_str()); + return OK; + } +}; + +class la_i_print_mr_t : public OpcodeBase { +public: + cs_float *i_mr; + int32_t init(CSOUND *csound) { + la_i_mr_create_t *array = 0; + toa(i_mr, array); + std::ostringstream stream; + stream << array->mr << std::endl; + csound->Message(csound, "%s", stream.str().c_str()); + return OK; + } +}; + +class la_i_print_mc_t : public OpcodeBase { +public: + cs_float *i_mc; + int32_t init(CSOUND *csound) { + la_i_mc_create_t *array = 0; + toa(i_mc, array); + std::ostringstream stream; + stream << array->mc << std::endl; + csound->Message(csound, "%s", stream.str().c_str()); + return OK; + } +}; + +class la_i_assign_vr_t : public OpcodeBase { +public: + cs_float *i_vr_lhs; + cs_float *i_vr_rhs; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_vr_lhs, lhs); + toa(i_vr_rhs, rhs); + gmm::copy(rhs->vr, lhs->vr); + return OK; + } +}; + +class la_k_assign_vr_t : public OpcodeBase { +public: + cs_float *i_vr_lhs; + cs_float *i_vr_rhs; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_vr_lhs, lhs); + toa(i_vr_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::copy(rhs->vr, lhs->vr); + return OK; + } +}; + +class la_i_assign_vc_t : public OpcodeBase { +public: + cs_float *i_vc_lhs; + cs_float *i_vc_rhs; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_vc_lhs, lhs); + toa(i_vc_rhs, rhs); + gmm::copy(rhs->vc, lhs->vc); + return OK; + } +}; + +class la_k_assign_vc_t : public OpcodeBase { +public: + cs_float *i_vc_lhs; + cs_float *i_vc_rhs; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_vc_lhs, lhs); + toa(i_vc_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::copy(rhs->vc, lhs->vc); + return OK; + } +}; + +class la_i_assign_mr_t : public OpcodeBase { +public: + cs_float *i_mr_lhs; + cs_float *i_mr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_mr_lhs, lhs); + toa(i_mr_rhs, rhs); + gmm::copy(rhs->mr, lhs->mr); + return OK; + } +}; + +class la_k_assign_mr_t : public OpcodeBase { +public: + cs_float *i_mr_lhs; + cs_float *i_mr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_mr_lhs, lhs); + toa(i_mr_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::copy(rhs->mr, lhs->mr); + return OK; + } +}; + +class la_i_assign_mc_t : public OpcodeBase { +public: + cs_float *i_mc_lhs; + cs_float *i_mc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_mc_lhs, lhs); + toa(i_mc_rhs, rhs); + gmm::copy(rhs->mc, lhs->mc); + return OK; + } +}; + +class la_k_assign_mc_t : public OpcodeBase { +public: + cs_float *i_mc_lhs; + cs_float *i_mc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *csound) { + toa(i_mc_lhs, lhs); + toa(i_mc_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::copy(rhs->mc, lhs->mc); + return OK; + } +}; + +class la_k_assign_a_t : public OpcodeBase { +public: + cs_float *i_vr; + cs_float *a_a; + la_i_vr_create_t *lhs; + size_t ksmps; + size_t vector_size; + int32_t init(CSOUND *csound) { + toa(i_vr, lhs); + ksmps = opds.insdshead->ksmps; + vector_size = gmm::vect_size(lhs->vr); + return OK; + } + int32_t kontrol(CSOUND *csound) { + uint32_t offset = opds.insdshead->ksmps_offset; + uint32_t early = opds.insdshead->ksmps_no_end; + size_t frame_count = opds.insdshead->ksmps * ksmps; + size_t array_i = frame_count % vector_size; + if (UNLIKELY(early)) + ksmps -= early; + for (size_t i = offset; i < ksmps; ++i, ++array_i) { + lhs->vr[array_i] = a_a[i]; + } + return OK; + } +}; + +class la_i_assign_t_t : public OpcodeBase { +public: + cs_float *i_vr; + cs_float *i_tablenumber; + la_i_vr_create_t *lhs; + int tablenumber; + int n; + int32_t init(CSOUND *csound) { + toa(i_vr, lhs); + tablenumber = int(std::floor(*i_tablenumber)); + cs_float tn = (cs_float)tablenumber; + FUNC *ftp = csound->FTFind(csound, &tn); + n = ftp != NULL ? (int)ftp->flen : 0; + gmm::resize(lhs->vr, n); + for (int i = 0; i < n; ++i) { + lhs->vr[i] = ftp->ftable[i]; + } + return OK; + } +}; + +class la_k_assign_t_t : public OpcodeBase { +public: + cs_float *i_vr; + cs_float *i_tablenumber; + la_i_vr_create_t *lhs; + int tablenumber; + int n; + int32_t init(CSOUND *csound) { + toa(i_vr, lhs); + tablenumber = int(std::floor(*i_tablenumber)); + cs_float tn = (cs_float)tablenumber; + FUNC *ftp = csound->FTFind(csound, &tn); + n = ftp != NULL ? (int)ftp->flen : 0; + gmm::resize(lhs->vr, n); + return OK; + } + int32_t kontrol(CSOUND *csound) { + cs_float tn = (cs_float)tablenumber; + FUNC *ftp = csound->FTFind(csound, &tn); + if (ftp != NULL) { + for (int i = 0; i < n; ++i) { + lhs->vr[i] = ftp->ftable[i]; + } + } + return OK; + } +}; + +class la_k_assign_f_t : public OpcodeBase { +public: + cs_float *i_vc; + PVSDAT *f_fsig; + la_i_vc_create_t *lhs; + int n; + std::complex *f; + int32_t init(CSOUND *csound) { + toa(i_vc, lhs); + n = f_fsig->N; + // std::complex has the same layout as CMPLX. + f = (std::complex *)f_fsig->frame.auxp; + gmm::resize(lhs->vc, n); + return OK; + } + int32_t kontrol(CSOUND *csound) { + for (int i = 0; i < n; ++i) { + lhs->vc[i] = f[i]; + } + return OK; + } +}; + +class la_k_a_assign_t : public OpcodeBase { +public: + cs_float *a_a; + cs_float *i_vr; + la_i_vr_create_t *rhs; + size_t ksmps; + int32_t init(CSOUND *csound) { + toa(i_vr, rhs); + ksmps = opds.insdshead->ksmps; + return OK; + } + int32_t kontrol(CSOUND *csound) { + uint32_t offset = opds.insdshead->ksmps_offset; + uint32_t early = opds.insdshead->ksmps_no_end; + memset(a_a, '\0', offset * sizeof(cs_float)); + size_t frameCount = opds.insdshead->kcounter * opds.insdshead->ksmps; + size_t vectorSize = gmm::vect_size(rhs->vr); + size_t array_i = frameCount % vectorSize; + if (UNLIKELY(early)) + ksmps -= early; + for (size_t i = 0; i < ksmps; ++i, ++array_i) { + a_a[i] = rhs->vr[array_i]; + } + return OK; + } +}; + +class la_i_t_assign_t : public OpcodeBase { +public: + cs_float *i_tablenumber; + cs_float *i_vr; + la_i_vr_create_t *rhs; + int tablenumber; + int n; + int32_t init(CSOUND *csound) { + toa(i_vr, rhs); + tablenumber = int(std::floor(*i_tablenumber)); + cs_float tn = (cs_float)tablenumber; + FUNC *ftp = csound->FTFind(csound, &tn); + n = ftp != NULL ? (int)ftp->flen : 0; + gmm::resize(rhs->vr, n); + for (int i = 0; i < n; ++i) { + ftp->ftable[i] = rhs->vr[i]; + } + return OK; + } +}; + +class la_k_t_assign_t : public OpcodeBase { +public: + cs_float *i_tablenumber; + cs_float *i_vr; + la_i_vr_create_t *rhs; + int tablenumber; + int n; + int32_t init(CSOUND *csound) { + toa(i_vr, rhs); + tablenumber = int(std::floor(*i_tablenumber)); + cs_float tn = (cs_float)tablenumber; + FUNC *ftp = csound->FTFind(csound, &tn); + n = ftp != NULL ? (int)ftp->flen : 0; + gmm::resize(rhs->vr, n); + return OK; + } + int32_t kontrol(CSOUND *csound) { + cs_float tn = (cs_float)tablenumber; + FUNC *ftp = csound->FTFind(csound, &tn); + if (ftp != NULL) { + for (int i = 0; i < n; ++i) { + ftp->ftable[i] = rhs->vr[i]; + } + } + return OK; + } +}; + +class la_k_f_assign_t : public OpcodeBase { +public: + PVSDAT *f_fsig; + cs_float *i_vc; + la_i_vc_create_t *rhs; + int n; + std::complex *f; + int32_t init(CSOUND *csound) { + toa(i_vc, rhs); + n = f_fsig->N; + // std::complex has the same layout as CMPLX. + f = (std::complex *)f_fsig->frame.auxp; + gmm::resize(rhs->vc, n); + return OK; + } + int32_t kontrol(CSOUND *csound) { + for (int i = 0; i < n; ++i) { + f[i] = rhs->vc[i]; + } + return OK; + } +}; + +class la_i_random_vr_t : public OpcodeBase { +public: + cs_float *i_vr_lhs; + cs_float *i_fraction; + la_i_vr_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_vr_lhs, lhs); + gmm::fill_random(lhs->vr, *i_fraction); + return OK; + } +}; + +class la_k_random_vr_t : public OpcodeBase { +public: + cs_float *i_vr_lhs; + cs_float *i_fraction; + la_i_vr_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_vr_lhs, lhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::fill_random(lhs->vr, *i_fraction); + return OK; + } +}; + +class la_i_random_vc_t : public OpcodeBase { +public: + cs_float *i_vc_lhs; + cs_float *i_fraction; + la_i_vc_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_vc_lhs, lhs); + gmm::fill_random(lhs->vc, *i_fraction); + return OK; + } +}; + +class la_k_random_vc_t : public OpcodeBase { +public: + cs_float *i_vc_lhs; + cs_float *i_fraction; + la_i_vc_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_vc_lhs, lhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::fill_random(lhs->vc, *i_fraction); + return OK; + } +}; + +class la_i_random_mr_t : public OpcodeBase { +public: + cs_float *i_mr_lhs; + cs_float *i_fraction; + la_i_mr_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_mr_lhs, lhs); + gmm::fill_random(lhs->mr, *i_fraction); + return OK; + } +}; + +class la_k_random_mr_t : public OpcodeBase { +public: + cs_float *i_mr_lhs; + cs_float *i_fraction; + la_i_mr_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_mr_lhs, lhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::fill_random(lhs->mr, *i_fraction); + return OK; + } +}; + +class la_i_random_mc_t : public OpcodeBase { +public: + cs_float *i_mc_lhs; + cs_float *i_fraction; + la_i_mc_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_mc_lhs, lhs); + gmm::fill_random(lhs->mc, *i_fraction); + return OK; + } +}; + +class la_k_random_mc_t : public OpcodeBase { +public: + cs_float *i_mc_lhs; + cs_float *i_fraction; + la_i_mc_create_t *lhs; + int32_t init(CSOUND *csound) { + toa(i_mc_lhs, lhs); + return OK; + } + int32_t kontrol(CSOUND *csound) { + gmm::fill_random(lhs->mc, *i_fraction); + return OK; + } +}; + +class la_i_vr_set_t : public OpcodeBase { +public: + cs_float *i_vr; + cs_float *i_row; + cs_float *i_value; + la_i_vr_create_t *vr; + int32_t init(CSOUND *) { + toa(i_vr, vr); + vr->vr[size_t(*i_row)] = *i_value; + return OK; + } +}; + +class la_k_vr_set_t : public OpcodeBase { +public: + cs_float *i_vr; + cs_float *k_row; + cs_float *k_value; + la_i_vr_create_t *vr; + int32_t init(CSOUND *) { + toa(i_vr, vr); + return OK; + } + int32_t kontrol(CSOUND *) { + vr->vr[size_t(*k_row)] = *k_value; + return OK; + } +}; + +class la_i_vc_set_t : public OpcodeBase { +public: + cs_float *i_vc; + cs_float *i_row; + cs_float *i_value_r; + cs_float *i_value_i; + la_i_vc_create_t *vc; + int32_t init(CSOUND *) { + toa(i_vc, vc); + vc->vc[size_t(*i_row)] = std::complex(*i_value_r, *i_value_i); + return OK; + } +}; + +class la_k_vc_set_t : public OpcodeBase { +public: + cs_float *i_vc; + cs_float *k_row; + cs_float *k_value_r; + cs_float *k_value_i; + la_i_vc_create_t *vc; + int32_t init(CSOUND *) { + toa(i_vc, vc); + return OK; + } + int32_t kontrol(CSOUND *) { + vc->vc[size_t(*k_row)] = std::complex(*k_value_r, *k_value_i); + return OK; + } +}; + +class la_i_mr_set_t : public OpcodeBase { +public: + cs_float *i_mr; + cs_float *i_row; + cs_float *i_column; + cs_float *i_value; + la_i_mr_create_t *mr; + int32_t init(CSOUND *) { + toa(i_mr, mr); + mr->mr(size_t(*i_row), size_t(*i_column)) = *i_value; + return OK; + } +}; + +class la_k_mr_set_t : public OpcodeBase { +public: + cs_float *i_mr; + cs_float *k_row; + cs_float *k_column; + cs_float *k_value; + la_i_mr_create_t *mr; + int32_t init(CSOUND *) { + toa(i_mr, mr); + return OK; + } + int32_t kontrol(CSOUND *) { + mr->mr(size_t(*k_row), size_t(*k_column)) = *k_value; + return OK; + } +}; + +class la_i_mc_set_t : public OpcodeBase { +public: + cs_float *i_mc; + cs_float *i_row; + cs_float *i_column; + cs_float *i_value_r; + cs_float *i_value_i; + la_i_mc_create_t *mc; + int32_t init(CSOUND *) { + toa(i_mc, mc); + mc->mc(size_t(*i_row), size_t(*i_column)) = + std::complex(*i_value_r, *i_value_i); + return OK; + } +}; + +class la_k_mc_set_t : public OpcodeBase { +public: + cs_float *i_mc; + cs_float *k_row; + cs_float *k_column; + cs_float *k_value_r; + cs_float *k_value_i; + la_i_mc_create_t *mc; + int32_t init(CSOUND *) { + toa(i_mc, mc); + return OK; + } + int32_t kontrol(CSOUND *) { + mc->mc(size_t(*k_row), size_t(*k_column)) = + std::complex(*k_value_r, *k_value_i); + return OK; + } +}; + +class la_i_get_vr_t : public OpcodeBase { +public: + cs_float *i_value; + cs_float *i_vr; + cs_float *i_row; + la_i_vr_create_t *vr; + int32_t init(CSOUND *) { + toa(i_vr, vr); + *i_value = vr->vr[size_t(*i_row)]; + return OK; + } +}; + +class la_k_get_vr_t : public OpcodeBase { +public: + cs_float *k_value; + cs_float *i_vr; + cs_float *k_row; + la_i_vr_create_t *vr; + int32_t init(CSOUND *) { + toa(i_vr, vr); + return OK; + } + int32_t kontrol(CSOUND *) { + *k_value = vr->vr[size_t(*k_row)]; + return OK; + } +}; + +class la_i_get_vc_t : public OpcodeBase { +public: + cs_float *i_value_r; + cs_float *i_value_i; + cs_float *i_vc; + cs_float *i_row; + la_i_vc_create_t *vc; + int32_t init(CSOUND *) { + toa(i_vc, vc); + const std::complex &lhs = vc->vc[size_t(*i_row)]; + *i_value_r = lhs.real(); + *i_value_i = lhs.imag(); + return OK; + } +}; + +class la_k_get_vc_t : public OpcodeBase { +public: + cs_float *k_value_r; + cs_float *k_value_i; + cs_float *i_vc; + cs_float *k_row; + la_i_vc_create_t *vc; + int32_t init(CSOUND *) { + toa(i_vc, vc); + return OK; + } + int32_t kontrol(CSOUND *) { + const std::complex &lhs = vc->vc[size_t(*k_row)]; + *k_value_r = lhs.real(); + *k_value_i = lhs.imag(); + return OK; + } +}; + +class la_i_get_mr_t : public OpcodeBase { +public: + cs_float *i_value; + cs_float *i_mr; + cs_float *i_row; + cs_float *i_column; + la_i_mr_create_t *mr; + int32_t init(CSOUND *) { + toa(i_mr, mr); + *i_value = mr->mr(size_t(*i_row), size_t(*i_column)); + return OK; + } +}; + +class la_k_get_mr_t : public OpcodeBase { +public: + cs_float *k_value; + cs_float *i_mr; + cs_float *k_row; + cs_float *k_column; + la_i_mr_create_t *mr; + int32_t init(CSOUND *) { + toa(i_mr, mr); + return OK; + } + int32_t kontrol(CSOUND *) { + *k_value = mr->mr(size_t(*k_row), size_t(*k_column)); + return OK; + } +}; + +class la_i_get_mc_t : public OpcodeBase { +public: + cs_float *i_value_r; + cs_float *i_value_i; + cs_float *i_mc; + cs_float *i_row; + cs_float *i_column; + la_i_mc_create_t *mc; + int32_t init(CSOUND *) { + toa(i_mc, mc); + const std::complex &lhs = mc->mc(size_t(*i_row), size_t(*i_column)); + *i_value_r = lhs.real(); + *i_value_i = lhs.imag(); + return OK; + } +}; + +class la_k_get_mc_t : public OpcodeBase { +public: + cs_float *k_value_r; + cs_float *k_value_i; + cs_float *i_mc; + cs_float *k_row; + cs_float *k_column; + la_i_mc_create_t *mc; + int32_t init(CSOUND *) { + toa(i_mc, mc); + return OK; + } + int32_t kontrol(CSOUND *) { + const std::complex &lhs = mc->mc(size_t(*k_row), size_t(*k_column)); + *k_value_r = lhs.real(); + *k_value_i = lhs.imag(); + return OK; + } +}; + +class la_i_transpose_mr_t : public OpcodeBase { +public: + cs_float *imr_lhs; + cs_float *imr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(imr_lhs, lhs); + toa(imr_rhs, rhs); + gmm::copy(gmm::transposed(rhs->mr), lhs->mr); + return OK; + } +}; + +class la_k_transpose_mr_t : public OpcodeBase { +public: + cs_float *imr_lhs; + cs_float *imr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(imr_lhs, lhs); + toa(imr_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(gmm::transposed(rhs->mr), lhs->mr); + return OK; + } +}; + +class la_i_transpose_mc_t : public OpcodeBase { +public: + cs_float *imc_lhs; + cs_float *imc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(imc_lhs, lhs); + toa(imc_rhs, rhs); + gmm::copy(gmm::transposed(rhs->mc), lhs->mc); + return OK; + } +}; + +class la_k_transpose_mc_t : public OpcodeBase { +public: + cs_float *imc_lhs; + cs_float *imc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(imc_lhs, lhs); + toa(imc_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(gmm::transposed(rhs->mc), lhs->mc); + return OK; + } +}; + +class la_i_conjugate_vr_t : public OpcodeBase { +public: + cs_float *ivr_lhs; + cs_float *ivr_rhs; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(ivr_lhs, lhs); + toa(ivr_rhs, rhs); + gmm::copy(gmm::conjugated(rhs->vr), lhs->vr); + return OK; + } +}; + +class la_k_conjugate_vr_t : public OpcodeBase { +public: + cs_float *ivr_lhs; + cs_float *ivr_rhs; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(ivr_lhs, lhs); + toa(ivr_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(gmm::conjugated(rhs->vr), lhs->vr); + return OK; + } +}; + +class la_i_conjugate_vc_t : public OpcodeBase { +public: + cs_float *ivc_lhs; + cs_float *ivc_rhs; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(ivc_lhs, lhs); + toa(ivc_rhs, rhs); + gmm::copy(gmm::conjugated(rhs->vc), lhs->vc); + return OK; + } +}; + +class la_k_conjugate_vc_t : public OpcodeBase { +public: + cs_float *ivc_lhs; + cs_float *ivc_rhs; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(ivc_lhs, lhs); + toa(ivc_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(gmm::conjugated(rhs->vc), lhs->vc); + return OK; + } +}; + +class la_i_conjugate_mr_t : public OpcodeBase { +public: + cs_float *imr_lhs; + cs_float *imr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(imr_lhs, lhs); + toa(imr_rhs, rhs); + gmm::copy(gmm::conjugated(rhs->mr), lhs->mr); + return OK; + } +}; + +class la_k_conjugate_mr_t : public OpcodeBase { +public: + cs_float *imr_lhs; + cs_float *imr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(imr_lhs, lhs); + toa(imr_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(gmm::conjugated(rhs->mr), lhs->mr); + return OK; + } +}; + +class la_i_conjugate_mc_t : public OpcodeBase { +public: + cs_float *imc_lhs; + cs_float *imc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(imc_lhs, lhs); + toa(imc_rhs, rhs); + gmm::copy(gmm::conjugated(rhs->mc), lhs->mc); + return OK; + } +}; + +class la_k_conjugate_mc_t : public OpcodeBase { +public: + cs_float *imc_lhs; + cs_float *imc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(imc_lhs, lhs); + toa(imc_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(gmm::conjugated(rhs->mc), lhs->mc); + return OK; + } +}; + +class la_i_norm1_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm1(rhs->vr); + return OK; + } +}; + +class la_k_norm1_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm1(rhs->vr); + return OK; + } +}; + +class la_i_norm1_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm1(rhs->vc); + return OK; + } +}; + +class la_k_norm1_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm1(rhs->vc); + return OK; + } +}; + +class la_i_norm1_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norm1(rhs->mr); + return OK; + } +}; + +class la_k_norm1_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norm1(rhs->mr); + return OK; + } +}; + +class la_i_norm1_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norm1(rhs->mc); + return OK; + } +}; + +class la_k_norm1_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norm1(rhs->mc); + return OK; + } +}; + +class la_i_norm_euclid_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm2(rhs->vr); + return OK; + } +}; + +class la_k_norm_euclid_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm2(rhs->vr); + return OK; + } +}; + +class la_i_norm_euclid_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm2(rhs->vc); + return OK; + } +}; + +class la_k_norm_euclid_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norm2(rhs->vc); + return OK; + } +}; + +class la_i_norm_euclid_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_euclidean_norm(rhs->mr); + return OK; + } +}; + +class la_k_norm_euclid_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_euclidean_norm(rhs->mr); + return OK; + } +}; + +class la_i_norm_euclid_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_euclidean_norm(rhs->mc); + return OK; + } +}; + +class la_k_norm_euclid_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_euclidean_norm(rhs->mc); + return OK; + } +}; + +class la_i_distance_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_1_; + cs_float *rhs_2_; + la_i_vr_create_t *rhs_1; + la_i_vr_create_t *rhs_2; + int32_t init(CSOUND *) { + toa(rhs_1_, rhs_1); + toa(rhs_2_, rhs_2); + *lhs = gmm::vect_dist2(rhs_1->vr, rhs_2->vr); + return OK; + } +}; + +class la_k_distance_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_1_; + cs_float *rhs_2_; + la_i_vr_create_t *rhs_1; + la_i_vr_create_t *rhs_2; + int32_t init(CSOUND *) { + toa(rhs_1_, rhs_1); + toa(rhs_2_, rhs_2); + return OK; + } + int32_t kontrol(CSOUND *) { + *lhs = gmm::vect_dist2(rhs_1->vr, rhs_2->vr); + return OK; + } +}; + +class la_i_distance_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_1_; + cs_float *rhs_2_; + la_i_vc_create_t *rhs_1; + la_i_vc_create_t *rhs_2; + int32_t init(CSOUND *) { + toa(rhs_1_, rhs_1); + toa(rhs_2_, rhs_2); + *lhs = gmm::vect_dist2(rhs_1->vc, rhs_2->vc); + return OK; + } +}; + +class la_k_distance_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_1_; + cs_float *rhs_2_; + la_i_vc_create_t *rhs_1; + la_i_vc_create_t *rhs_2; + int32_t init(CSOUND *) { + toa(rhs_1_, rhs_1); + toa(rhs_2_, rhs_2); + return OK; + } + int32_t kontrol(CSOUND *) { + *lhs = gmm::vect_dist2(rhs_1->vc, rhs_2->vc); + return OK; + } +}; + +class la_i_norm_max_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_maxnorm(rhs->mr); + return OK; + } +}; + +class la_k_norm_max_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_maxnorm(rhs->mr); + return OK; + } +}; + +class la_i_norm_max_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_maxnorm(rhs->mc); + return OK; + } +}; + +class la_k_norm_max_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_maxnorm(rhs->mc); + return OK; + } +}; + +class la_i_norm_inf_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norminf(rhs->vr); + return OK; + } +}; + +class la_k_norm_inf_vr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norminf(rhs->vr); + return OK; + } +}; + +class la_i_norm_inf_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norminf(rhs->vc); + return OK; + } +}; + +class la_k_norm_inf_vc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_vc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::vect_norminf(rhs->vc); + return OK; + } +}; + +class la_i_norm_inf_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norminf(rhs->mr); + return OK; + } +}; + +class la_k_norm_inf_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norminf(rhs->mr); + return OK; + } +}; + +class la_i_norm_inf_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norminf(rhs->mc); + return OK; + } +}; + +class la_k_norm_inf_mc_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_norminf(rhs->mc); + return OK; + } +}; + +class la_i_trace_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_trace(rhs->mr); + return OK; + } +}; + +class la_k_trace_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::mat_trace(rhs->mr); + return OK; + } +}; + +class la_i_trace_mc_t : public OpcodeBase { +public: + cs_float *lhs_r; + cs_float *lhs_i; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + const std::complex &lhs = gmm::mat_trace(rhs->mc); + *lhs_r = lhs.real(); + *lhs_i = lhs.imag(); + return OK; + } +}; + +class la_k_trace_mc_t : public OpcodeBase { +public: + cs_float *lhs_r; + cs_float *lhs_i; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + const std::complex &lhs = gmm::mat_trace(rhs->mc); + *lhs_r = lhs.real(); + *lhs_i = lhs.imag(); + return OK; + } +}; + +class la_i_lu_det_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::lu_det(rhs->mr); + return OK; + } +}; + +class la_k_lu_det_mr_t : public OpcodeBase { +public: + cs_float *lhs; + cs_float *rhs_; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + *lhs = gmm::lu_det(rhs->mr); + return OK; + } +}; + +class la_i_lu_det_mc_t : public OpcodeBase { +public: + cs_float *lhs_r; + cs_float *lhs_i; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + const std::complex &lhs = gmm::lu_det(rhs->mc); + *lhs_r = lhs.real(); + *lhs_i = lhs.imag(); + return OK; + } +}; + +class la_k_lu_det_mc_t : public OpcodeBase { +public: + cs_float *lhs_r; + cs_float *lhs_i; + cs_float *rhs_; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + toa(rhs_, rhs); + const std::complex &lhs = gmm::lu_det(rhs->mc); + *lhs_r = lhs.real(); + *lhs_i = lhs.imag(); + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a += b. + */ +class la_i_add_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] + rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a += b. + */ +class la_k_add_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] + rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a += b. + */ +class la_i_add_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] + rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a += b. + */ +class la_k_add_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] + rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A += B. + */ +class la_i_add_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mr); + size_t columnN = gmm::mat_ncols(rhs_a->mr); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) + rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A += B. + */ +class la_k_add_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mr); + columnN = gmm::mat_ncols(rhs_a->mr); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) + rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A += B. + */ +class la_i_add_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mc); + size_t columnN = gmm::mat_ncols(rhs_a->mc); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) + rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise addition. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A += B. + */ +class la_k_add_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mc); + columnN = gmm::mat_ncols(rhs_a->mc); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) + rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a -= b. + */ +class la_i_subtract_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] - rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a -= b. + */ +class la_k_subtract_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] - rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a -= b. + */ +class la_i_subtract_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] - rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a -= b. + */ +class la_k_subtract_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] - rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A -= B. + */ +class la_i_subtract_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mr); + size_t columnN = gmm::mat_ncols(rhs_a->mr); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) - rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A -= B. + */ +class la_k_subtract_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mr); + columnN = gmm::mat_ncols(rhs_a->mr); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) - rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A -= B. + */ +class la_i_subtract_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mc); + size_t columnN = gmm::mat_ncols(rhs_a->mc); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) - rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise subtraction. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A -= B. + */ +class la_k_subtract_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mc); + columnN = gmm::mat_ncols(rhs_a->mc); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) - rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_i_multiply_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] * rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_k_multiply_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] * rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_i_multiply_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] * rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_k_multiply_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] * rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A *= B. + */ +class la_i_multiply_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mr); + size_t columnN = gmm::mat_ncols(rhs_a->mr); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) * rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A *= B. + */ +class la_k_multiply_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mr); + columnN = gmm::mat_ncols(rhs_a->mr); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) * rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A *= B. + */ +class la_i_multiply_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mc); + size_t columnN = gmm::mat_ncols(rhs_a->mc); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) * rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A *= B. + */ +class la_k_multiply_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mc); + columnN = gmm::mat_ncols(rhs_a->mc); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) * rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a /= b. + */ +class la_i_divide_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] / rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a /= b. + */ +class la_k_divide_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vr.size(); i < n; ++i) { + lhs->vr[i] = rhs_a->vr[i] / rhs_b->vr[i]; + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a /= b. + */ +class la_i_divide_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] / rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a /= b. + */ +class la_k_divide_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t i = 0, n = rhs_a->vc.size(); i < n; ++i) { + lhs->vc[i] = rhs_a->vc[i] / rhs_b->vc[i]; + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A /= B. + */ +class la_i_divide_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mr); + size_t columnN = gmm::mat_ncols(rhs_a->mr); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) / rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A /= B. + */ +class la_k_divide_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mr); + columnN = gmm::mat_ncols(rhs_a->mr); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mr(rowI, columnI) = + rhs_a->mr(rowI, columnI) / rhs_b->mr(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A /= B. + */ +class la_i_divide_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + size_t rowN = gmm::mat_nrows(rhs_a->mc); + size_t columnN = gmm::mat_ncols(rhs_a->mc); + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) / rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise division. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform A /= B. + */ +class la_k_divide_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + size_t rowN; + size_t columnN; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + rowN = gmm::mat_nrows(rhs_a->mc); + columnN = gmm::mat_ncols(rhs_a->mc); + return OK; + } + int32_t kontrol(CSOUND *) { + for (size_t rowI = 0; rowI < rowN; ++rowI) { + for (size_t columnI = 0; columnI < columnN; ++columnI) { + lhs->mc(rowI, columnI) = + rhs_a->mc(rowI, columnI) / rhs_b->mc(rowI, columnI); + } + } + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_i_dot_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + *lhs_ = gmm::vect_sp(rhs_a->vr, rhs_b->vr); + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_k_dot_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + *lhs_ = gmm::vect_sp(rhs_a->vr, rhs_b->vr); + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_i_dot_vc_t : public OpcodeBase { +public: + cs_float *lhs_r; + cs_float *lhs_i; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + std::complex lhs = gmm::vect_sp(rhs_a->vc, rhs_b->vc); + *lhs_r = lhs.real(); + *lhs_i = lhs.imag(); + return OK; + } +}; + +/** + * Elementwise multiplication. + * The array on the left-hand side can also appear + * on the right-hand side in order to perform a *= b. + */ +class la_k_dot_vc_t : public OpcodeBase { +public: + cs_float *lhs_r; + cs_float *lhs_i; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + std::complex lhs = gmm::vect_sp(rhs_a->vc, rhs_b->vc); + *lhs_r = lhs.real(); + *lhs_i = lhs.imag(); + return OK; + } +}; + +class la_i_dot_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + gmm::mult(rhs_a->mr, rhs_b->mr, lhs->mr); + return OK; + } +}; + +class la_k_dot_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_mr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + gmm::mult(rhs_a->mr, rhs_b->mr, lhs->mr); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::mult(rhs_a->mr, rhs_b->mr, lhs->mr); + return OK; + } +}; + +class la_i_dot_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + gmm::mult(rhs_a->mc, rhs_b->mc, lhs->mc); + return OK; + } +}; + +class la_k_dot_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_mc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::mult(rhs_a->mc, rhs_b->mc, lhs->mc); + return OK; + } +}; + +class la_i_dot_mr_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + gmm::mult(rhs_a->mr, rhs_b->vr, lhs->vr); + return OK; + } +}; + +class la_k_dot_mr_vr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs; + la_i_mr_create_t *rhs_a; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::mult(rhs_a->mr, rhs_b->vr, lhs->vr); + return OK; + } +}; + +class la_i_dot_mc_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + gmm::mult(rhs_a->mc, rhs_b->vc, lhs->vc); + return OK; + } +}; + +class la_k_dot_mc_vc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_a_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs; + la_i_mc_create_t *rhs_a; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_a_, rhs_a); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::mult(rhs_a->mc, rhs_b->vc, lhs->vc); + return OK; + } +}; + +class la_i_invert_mr_t : public OpcodeBase { +public: + cs_float *imr_lhs; + cs_float *icondition; + cs_float *imr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(imr_lhs, lhs); + toa(imr_rhs, rhs); + gmm::copy(rhs->mr, lhs->mr); + *icondition = gmm::lu_inverse(lhs->mr); + return OK; + } +}; + +class la_k_invert_mr_t : public OpcodeBase { +public: + cs_float *imr_lhs; + cs_float *kcondition; + cs_float *imr_rhs; + la_i_mr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(imr_lhs, lhs); + toa(imr_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(rhs->mr, lhs->mr); + *kcondition = gmm::lu_inverse(lhs->mr); + return OK; + } +}; + +class la_i_invert_mc_t : public OpcodeBase { +public: + cs_float *imc_lhs; + cs_float *icondition_r; + cs_float *icondition_i; + cs_float *imc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(imc_lhs, lhs); + toa(imc_rhs, rhs); + gmm::copy(rhs->mc, lhs->mc); + std::complex condition = gmm::lu_inverse(lhs->mc); + *icondition_r = condition.real(); + *icondition_i = condition.imag(); + return OK; + } +}; + +class la_k_invert_mc_t : public OpcodeBase { +public: + cs_float *imc_lhs; + cs_float *kcondition_r; + cs_float *kcondition_i; + cs_float *imc_rhs; + la_i_mc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(imc_lhs, lhs); + toa(imc_rhs, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::copy(rhs->mc, lhs->mc); + std::complex condition = gmm::lu_inverse(lhs->mc); + *kcondition_r = condition.real(); + *kcondition_i = condition.imag(); + return OK; + } +}; + +class la_i_upper_solve_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + gmm::upper_tri_solve(rhs->mr, lhs->vr, bool(*is_unit)); + return OK; + } +}; + +class la_k_upper_solve_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::upper_tri_solve(rhs->mr, lhs->vr, bool(*is_unit)); + return OK; + } +}; + +class la_i_upper_solve_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + gmm::upper_tri_solve(rhs->mc, lhs->vc, bool(*is_unit)); + return OK; + } +}; + +class la_k_upper_solve_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::upper_tri_solve(rhs->mc, lhs->vc, bool(*is_unit)); + return OK; + } +}; + +class la_i_lower_solve_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + gmm::lower_tri_solve(rhs->mr, lhs->vr, bool(*is_unit)); + return OK; + } +}; + +class la_k_lower_solve_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vr_create_t *lhs; + la_i_mr_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::lower_tri_solve(rhs->mr, lhs->vr, bool(*is_unit)); + return OK; + } +}; + +class la_i_lower_solve_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + gmm::lower_tri_solve(rhs->mc, lhs->vc, bool(*is_unit)); + return OK; + } +}; + +class la_k_lower_solve_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *rhs_; + cs_float *is_unit; + la_i_vc_create_t *lhs; + la_i_mc_create_t *rhs; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::lower_tri_solve(rhs->mc, lhs->vc, bool(*is_unit)); + return OK; + } +}; + +class la_i_lu_factor_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *pivot_; + cs_float *isize; + cs_float *rhs_; + la_i_mr_create_t *lhs; + la_i_vr_create_t *pivot; + la_i_mr_create_t *rhs; +#if defined(GMM_VERSION) + gmm::lapack_ipvt pivot__; +#else + std::vector pivot__; +#endif + size_t pivot_size; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, pivot); + toa(rhs_, rhs); + pivot_size = gmm::mat_nrows(rhs->mr); + pivot__.resize(pivot_size); + gmm::copy(rhs->mr, lhs->mr); + *isize = gmm::lu_factor(lhs->mr, pivot__); + for (size_t i = 0; i < pivot_size; ++i) { +#if defined(GMM_VERSION) + pivot->vr[i] = pivot__.get(i); +#else + pivot->vr[i] = pivot__[i]; +#endif + } + return OK; + } +}; + +class la_k_lu_factor_mr_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *pivot_; + cs_float *ksize; + cs_float *rhs_; + la_i_mr_create_t *lhs; + la_i_vr_create_t *pivot; + la_i_mr_create_t *rhs; +#if defined(GMM_VERSION) + gmm::lapack_ipvt pivot__; +#else + std::vector pivot__; +#endif + size_t pivot_size; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, pivot); + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + pivot_size = gmm::mat_nrows(rhs->mr); + pivot__.resize(pivot_size); + gmm::copy(rhs->mr, lhs->mr); + *ksize = gmm::lu_factor(lhs->mr, pivot__); + for (size_t i = 0; i < pivot_size; ++i) { +#if defined(GMM_VERSION) + pivot->vr[i] = pivot__.get(i); +#else + pivot->vr[i] = pivot__[i]; +#endif + } + return OK; + } +}; + +class la_i_lu_factor_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *pivot_; + cs_float *isize; + cs_float *rhs_; + la_i_mc_create_t *lhs; + la_i_vr_create_t *pivot; + la_i_mc_create_t *rhs; +#if defined(GMM_VERSION) + gmm::lapack_ipvt pivot__; +#else + std::vector pivot__; +#endif + size_t pivot_size; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, pivot); + toa(rhs_, rhs); + pivot_size = gmm::mat_nrows(rhs->mc); + pivot__.resize(pivot_size); + gmm::copy(rhs->mc, lhs->mc); + *isize = gmm::lu_factor(lhs->mc, pivot__); + for (size_t i = 0; i < pivot_size; ++i) { +#if defined(GMM_VERSION) + pivot->vr[i] = pivot__.get(i); +#else + pivot->vr[i] = pivot__[i]; +#endif + } + return OK; + } +}; + +class la_k_lu_factor_mc_t : public OpcodeBase { +public: + cs_float *lhs_; + cs_float *pivot_; + cs_float *ksize; + cs_float *rhs_; + la_i_mc_create_t *lhs; + la_i_vr_create_t *pivot; + la_i_mc_create_t *rhs; +#if defined(GMM_VERSION) + gmm::lapack_ipvt pivot__; +#else + std::vector pivot__; +#endif + size_t pivot_size; + int32_t init(CSOUND *) { + toa(lhs_, lhs); + toa(rhs_, pivot); + toa(rhs_, rhs); + return OK; + } + int32_t kontrol(CSOUND *) { + pivot_size = gmm::mat_nrows(rhs->mc); + pivot__.resize(pivot_size); + gmm::copy(rhs->mc, lhs->mc); + *ksize = gmm::lu_factor(lhs->mc, pivot__); + for (size_t i = 0; i < pivot_size; ++i) { +#if defined(GMM_VERSION) + pivot->vr[i] = pivot__.get(i); +#else + pivot->vr[i] = pivot__[i]; +#endif + } + return OK; + } +}; + +class la_i_lu_solve_mr_t : public OpcodeBase { +public: + cs_float *lhs_x_; + cs_float *rhs_A_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs_x; + la_i_mr_create_t *rhs_A; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_x_, lhs_x); + toa(rhs_A_, rhs_A); + toa(rhs_b_, rhs_b); + gmm::lu_solve(rhs_A->mr, lhs_x->vr, rhs_b->vr); + return OK; + } +}; + +class la_k_lu_solve_mr_t : public OpcodeBase { +public: + cs_float *lhs_x_; + cs_float *rhs_A_; + cs_float *rhs_b_; + la_i_vr_create_t *lhs_x; + la_i_mr_create_t *rhs_A; + la_i_vr_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_x_, lhs_x); + toa(rhs_A_, rhs_A); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::lu_solve(rhs_A->mr, lhs_x->vr, rhs_b->vr); + return OK; + } +}; + +class la_i_lu_solve_mc_t : public OpcodeBase { +public: + cs_float *lhs_x_; + cs_float *rhs_A_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs_x; + la_i_mc_create_t *rhs_A; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_x_, lhs_x); + toa(rhs_A_, rhs_A); + toa(rhs_b_, rhs_b); + gmm::lu_solve(rhs_A->mc, lhs_x->vc, rhs_b->vc); + return OK; + } +}; + +class la_k_lu_solve_mc_t : public OpcodeBase { +public: + cs_float *lhs_x_; + cs_float *rhs_A_; + cs_float *rhs_b_; + la_i_vc_create_t *lhs_x; + la_i_mc_create_t *rhs_A; + la_i_vc_create_t *rhs_b; + int32_t init(CSOUND *) { + toa(lhs_x_, lhs_x); + toa(rhs_A_, rhs_A); + toa(rhs_b_, rhs_b); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::lu_solve(rhs_A->mc, lhs_x->vc, rhs_b->vc); + return OK; + } +}; + +class la_i_qr_factor_mr_t : public OpcodeBase { +public: + cs_float *lhs_Q_; + cs_float *lhs_R_; + cs_float *rhs_A_; + la_i_mr_create_t *lhs_Q; + la_i_mr_create_t *lhs_R; + la_i_mr_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_Q_, lhs_Q); + toa(lhs_R_, lhs_R); + toa(rhs_A_, rhs_A); + gmm::qr_factor(rhs_A->mr, lhs_Q->mr, lhs_R->mr); + return OK; + } +}; + +class la_k_qr_factor_mr_t : public OpcodeBase { +public: + cs_float *lhs_Q_; + cs_float *lhs_R_; + cs_float *rhs_A_; + la_i_mr_create_t *lhs_Q; + la_i_mr_create_t *lhs_R; + la_i_mr_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_Q_, lhs_Q); + toa(lhs_R_, lhs_R); + toa(rhs_A_, rhs_A); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::qr_factor(rhs_A->mr, lhs_Q->mr, lhs_R->mr); + return OK; + } +}; + +class la_i_qr_factor_mc_t : public OpcodeBase { +public: + cs_float *lhs_Q_; + cs_float *lhs_R_; + cs_float *rhs_A_; + la_i_mc_create_t *lhs_Q; + la_i_mc_create_t *lhs_R; + la_i_mc_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_Q_, lhs_Q); + toa(lhs_R_, lhs_R); + toa(rhs_A_, rhs_A); + gmm::qr_factor(rhs_A->mc, lhs_Q->mc, lhs_R->mc); + return OK; + } +}; + +class la_k_qr_factor_mc_t : public OpcodeBase { +public: + cs_float *lhs_Q_; + cs_float *lhs_R_; + cs_float *rhs_A_; + la_i_mc_create_t *lhs_Q; + la_i_mc_create_t *lhs_R; + la_i_mc_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_Q_, lhs_Q); + toa(lhs_R_, lhs_R); + toa(rhs_A_, rhs_A); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::qr_factor(rhs_A->mc, lhs_Q->mc, lhs_R->mc); + return OK; + } +}; + +class la_i_qr_eigen_mr_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *rhs_A_; + cs_float *itolerance; + la_i_vr_create_t *lhs_eigenvalues; + la_i_mr_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(rhs_A_, rhs_A); + gmm::implicit_qr_algorithm(rhs_A->mr, lhs_eigenvalues->vr, + double(*itolerance)); + return OK; + } +}; + +class la_k_qr_eigen_mr_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *rhs_A_; + cs_float *ktolerance; + la_i_vr_create_t *lhs_eigenvalues; + la_i_mr_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(rhs_A_, rhs_A); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::implicit_qr_algorithm(rhs_A->mr, lhs_eigenvalues->vr, + double(*ktolerance)); + return OK; + } +}; + +class la_i_qr_eigen_mc_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *rhs_A_; + cs_float *itolerance; + la_i_vc_create_t *lhs_eigenvalues; + la_i_mc_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(rhs_A_, rhs_A); + gmm::implicit_qr_algorithm(rhs_A->mc, lhs_eigenvalues->vc, + double(*itolerance)); + return OK; + } +}; + +class la_k_qr_eigen_mc_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *rhs_A_; + cs_float *ktolerance; + la_i_vc_create_t *lhs_eigenvalues; + la_i_mc_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(rhs_A_, rhs_A); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::implicit_qr_algorithm(rhs_A->mc, lhs_eigenvalues->vc, + double(*ktolerance)); + return OK; + } +}; + +class la_i_qr_sym_eigen_mr_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *lhs_eigenvectors_; + cs_float *rhs_A_; + cs_float *itolerance; + la_i_vr_create_t *lhs_eigenvalues; + la_i_mr_create_t *lhs_eigenvectors; + la_i_mr_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(lhs_eigenvectors_, lhs_eigenvectors); + toa(rhs_A_, rhs_A); + gmm::implicit_qr_algorithm(rhs_A->mr, lhs_eigenvalues->vr, + lhs_eigenvectors->mr, double(*itolerance)); + return OK; + } +}; + +class la_k_qr_sym_eigen_mr_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *lhs_eigenvectors_; + cs_float *rhs_A_; + cs_float *ktolerance; + la_i_vr_create_t *lhs_eigenvalues; + la_i_mr_create_t *lhs_eigenvectors; + la_i_mr_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(lhs_eigenvectors_, lhs_eigenvectors); + toa(rhs_A_, rhs_A); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::implicit_qr_algorithm(rhs_A->mr, lhs_eigenvalues->vr, + lhs_eigenvectors->mr, double(*ktolerance)); + return OK; + } +}; + +class la_i_qr_sym_eigen_mc_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *lhs_eigenvectors_; + cs_float *rhs_A_; + cs_float *itolerance; + la_i_vc_create_t *lhs_eigenvalues; + la_i_mc_create_t *lhs_eigenvectors; + la_i_mc_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(lhs_eigenvectors_, lhs_eigenvectors); + toa(rhs_A_, rhs_A); + gmm::implicit_qr_algorithm(rhs_A->mc, lhs_eigenvalues->vc, + lhs_eigenvectors->mc, double(*itolerance)); + return OK; + } +}; + +class la_k_qr_sym_eigen_mc_t : public OpcodeBase { +public: + cs_float *lhs_eigenvalues_; + cs_float *lhs_eigenvectors_; + cs_float *rhs_A_; + cs_float *ktolerance; + la_i_vc_create_t *lhs_eigenvalues; + la_i_mc_create_t *lhs_eigenvectors; + la_i_mc_create_t *rhs_A; + int32_t init(CSOUND *) { + toa(lhs_eigenvalues_, lhs_eigenvalues); + toa(lhs_eigenvectors_, lhs_eigenvectors); + toa(rhs_A_, rhs_A); + return OK; + } + int32_t kontrol(CSOUND *) { + gmm::implicit_qr_algorithm(rhs_A->mc, lhs_eigenvalues->vc, + lhs_eigenvectors->mc, double(*ktolerance)); + return OK; + } +}; + +extern "C" { + +PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { return 0; } + +PUBLIC int32_t csoundModuleInit(CSOUND *csound) { + int32_t status = 0; + status |= csound->AppendOpcode( + csound, "la_i_vr_create", sizeof(la_i_vr_create_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_vr_create_t::init_, + (int32_t (*)(CSOUND *, void *))0, + (int32_t (*)(CSOUND *, void *)) & la_i_vr_create_t::deinit_); + status |= csound->AppendOpcode( + csound, "la_i_vc_create", sizeof(la_i_vr_create_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_vc_create_t::init_, + (int32_t (*)(CSOUND *, void *))0, + (int32_t (*)(CSOUND *, void *)) & la_i_vc_create_t::deinit_); + status |= csound->AppendOpcode( + csound, "la_i_mr_create", sizeof(la_i_mr_create_t), 0, "i", "iio", + (int32_t (*)(CSOUND *, void *)) & la_i_mr_create_t::init_, + (int32_t (*)(CSOUND *, void *))0, + (int32_t (*)(CSOUND *, void *)) & la_i_mr_create_t::deinit_); + status |= csound->AppendOpcode( + csound, "la_i_mc_create", sizeof(la_i_mc_create_t), 0, "i", "iioo", + (int32_t (*)(CSOUND *, void *)) & la_i_mc_create_t::init_, + (int32_t (*)(CSOUND *, void *))0, + (int32_t (*)(CSOUND *, void *)) & la_i_mc_create_t::deinit_); + status |= csound->AppendOpcode( + csound, "la_i_size_vr", sizeof(la_i_size_vr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_size_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_size_vc", sizeof(la_i_size_vc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_size_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_size_mr", sizeof(la_i_size_mr_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_size_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_size_mc", sizeof(la_i_size_mc_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_size_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_current_f", sizeof(la_k_current_f_t), 0, "k", "f", + (int32_t (*)(CSOUND *, void *)) & la_k_current_f_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_current_f_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_current_vr", sizeof(la_k_current_vr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_current_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_current_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_print_vr", sizeof(la_i_print_vr_t), 0, "", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_print_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_print_vc", sizeof(la_i_print_vc_t), 0, "", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_print_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_print_mr", sizeof(la_i_print_mr_t), 0, "", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_print_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_print_mc", sizeof(la_i_print_mc_t), 0, "", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_print_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_assign_vr", sizeof(la_i_assign_vr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_assign_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_assign_vr", sizeof(la_k_assign_vr_t), 0, "i", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_assign_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_assign_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_assign_vc", sizeof(la_i_assign_vc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_assign_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_assign_vc", sizeof(la_k_assign_vc_t), 0, "i", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_assign_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_assign_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_assign_mr", sizeof(la_i_assign_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_assign_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_assign_mr", sizeof(la_k_assign_mr_t), 0, "i", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_assign_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_assign_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_assign_mc", sizeof(la_i_assign_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_assign_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_assign_mc", sizeof(la_k_assign_mc_t), 0, "i", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_assign_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_assign_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_assign_a", sizeof(la_k_assign_a_t), 0, "i", "a", + (int32_t (*)(CSOUND *, void *)) & la_k_assign_a_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_assign_a_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_assign_t", sizeof(la_i_assign_t_t), TR, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_assign_t_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_i_assign_t_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_assign_t", sizeof(la_k_assign_t_t), TR, "i", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_assign_t_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_assign_t_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_assign_f", sizeof(la_k_assign_f_t), 0, "i", "f", + (int32_t (*)(CSOUND *, void *)) & la_k_assign_f_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_assign_f_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_a_assign", sizeof(la_k_a_assign_t), 0, "a", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_a_assign_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_a_assign_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_t_assign", sizeof(la_i_t_assign_t), TW, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_t_assign_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_t_assign", sizeof(la_k_t_assign_t), TW, "i", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_t_assign_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_t_assign_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_f_assign", sizeof(la_k_f_assign_t), 0, "f", "p", + (int32_t (*)(CSOUND *, void *)) & la_k_f_assign_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_f_assign_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_random_vr", sizeof(la_i_random_vr_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_i_random_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_random_vr", sizeof(la_k_random_vr_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_k_random_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_random_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_random_vc", sizeof(la_i_random_vc_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_i_random_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_random_vc", sizeof(la_k_random_vc_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_k_random_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_random_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_random_mr", sizeof(la_i_random_mr_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_i_random_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_random_mr", sizeof(la_k_random_mr_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_k_random_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_random_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_random_mc", sizeof(la_i_random_mc_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_i_random_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_random_mc", sizeof(la_k_random_mc_t), 0, "i", "p", + (int32_t (*)(CSOUND *, void *)) & la_k_random_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_random_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_vr_set", sizeof(la_i_vr_set_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_vr_set_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_vr_set", sizeof(la_k_vr_set_t), 0, "i", "kk", + (int32_t (*)(CSOUND *, void *)) & la_k_vr_set_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_vr_set_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_vc_set", sizeof(la_i_vc_set_t), 0, "i", "iii", + (int32_t (*)(CSOUND *, void *)) & la_i_vc_set_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_vc_set", sizeof(la_k_vc_set_t), 0, "i", "kkk", + (int32_t (*)(CSOUND *, void *)) & la_k_vc_set_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_vc_set_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_mr_set", sizeof(la_i_mr_set_t), 0, "i", "iii", + (int32_t (*)(CSOUND *, void *)) & la_i_mr_set_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_mr_set", sizeof(la_k_mr_set_t), 0, "i", "kkk", + (int32_t (*)(CSOUND *, void *)) & la_k_mr_set_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_mr_set_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_mc_set", sizeof(la_i_mc_set_t), 0, "i", "iiii", + (int32_t (*)(CSOUND *, void *)) & la_i_mc_set_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_mc_set", sizeof(la_k_mc_set_t), 0, "i", "kkkk", + (int32_t (*)(CSOUND *, void *)) & la_k_mc_set_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_mc_set_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + + status |= csound->AppendOpcode( + csound, "la_i_get_vr", sizeof(la_i_get_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_get_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_get_vr", sizeof(la_k_get_vr_t), 0, "k", "ik", + (int32_t (*)(CSOUND *, void *)) & la_k_get_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_get_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_get_vc", sizeof(la_i_get_vc_t), 0, "ii", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_get_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_get_vc", sizeof(la_k_get_vc_t), 0, "kk", "ik", + (int32_t (*)(CSOUND *, void *)) & la_k_get_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_get_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_get_mr", sizeof(la_i_get_mr_t), 0, "i", "iii", + (int32_t (*)(CSOUND *, void *)) & la_i_get_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_get_mr", sizeof(la_k_get_mr_t), 0, "k", "ikk", + (int32_t (*)(CSOUND *, void *)) & la_k_get_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_get_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_get_mc", sizeof(la_i_get_mc_t), 0, "ii", "iii", + (int32_t (*)(CSOUND *, void *)) & la_i_get_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_get_mc", sizeof(la_k_get_mc_t), 0, "kk", "ikk", + (int32_t (*)(CSOUND *, void *)) & la_k_get_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_get_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_transpose_mr", sizeof(la_i_transpose_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_transpose_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_transpose_mr", sizeof(la_k_transpose_mr_t), 0, "i", "k", + (int32_t (*)(CSOUND *, void *)) & la_k_transpose_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_transpose_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_transpose_mc", sizeof(la_i_transpose_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_transpose_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_transpose_mc", sizeof(la_k_transpose_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_transpose_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_transpose_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_conjugate_vr", sizeof(la_i_conjugate_vr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_conjugate_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_conjugate_vr", sizeof(la_k_conjugate_vr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_conjugate_vc", sizeof(la_i_conjugate_vc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_conjugate_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_conjugate_vc", sizeof(la_k_conjugate_vc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_conjugate_mr", sizeof(la_i_conjugate_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_conjugate_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_conjugate_mr", sizeof(la_k_conjugate_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_conjugate_mc", sizeof(la_i_conjugate_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_conjugate_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_conjugate_mc", sizeof(la_k_conjugate_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_conjugate_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm1_vr", sizeof(la_i_norm1_vr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm1_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm1_vr", sizeof(la_k_norm1_vr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm1_vc", sizeof(la_i_norm1_vc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm1_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm1_vc", sizeof(la_k_norm1_vc_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm1_mr", sizeof(la_i_norm1_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm1_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm1_mr", sizeof(la_k_norm1_mr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm1_mc", sizeof(la_i_norm1_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm1_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm1_mc", sizeof(la_k_norm1_mc_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm1_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_euclid_vr", sizeof(la_i_norm_euclid_vr_t), 0, "i", + "i", (int32_t (*)(CSOUND *, void *)) & la_i_norm_euclid_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_euclid_vr", sizeof(la_k_norm_euclid_vr_t), 0, "k", + "i", (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_euclid_vc", sizeof(la_i_norm_euclid_vc_t), 0, "i", + "i", (int32_t (*)(CSOUND *, void *)) & la_i_norm_euclid_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_euclid_vc", sizeof(la_k_norm_euclid_vc_t), 0, "k", + "i", (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_euclid_mr", sizeof(la_i_norm_euclid_mr_t), 0, "i", + "i", (int32_t (*)(CSOUND *, void *)) & la_i_norm_euclid_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_euclid_mr", sizeof(la_k_norm_euclid_mr_t), 0, "k", + "i", (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_euclid_mc", sizeof(la_i_norm_euclid_mc_t), 0, "i", + "i", (int32_t (*)(CSOUND *, void *)) & la_i_norm_euclid_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_euclid_mc", sizeof(la_k_norm_euclid_mc_t), 0, "k", + "i", (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_euclid_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_distance_vr", sizeof(la_i_distance_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_distance_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_distance_vr", sizeof(la_k_distance_vr_t), 0, "k", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_distance_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_distance_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_distance_vc", sizeof(la_i_distance_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_distance_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_distance_vc", sizeof(la_k_distance_vc_t), 0, "k", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_distance_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_distance_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_max_mr", sizeof(la_i_norm_max_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm_max_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_max_mr", sizeof(la_k_norm_max_mr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm_max_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_max_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_max_mc", sizeof(la_i_norm_max_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm_max_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_max_mc", sizeof(la_k_norm_max_mc_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm_max_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_max_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_inf_vr", sizeof(la_i_norm_inf_vr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm_inf_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_inf_vr", sizeof(la_k_norm_inf_vr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_inf_vc", sizeof(la_i_norm_inf_vc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm_inf_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_inf_vc", sizeof(la_k_norm_inf_vc_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_inf_mr", sizeof(la_i_norm_inf_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm_inf_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_inf_mr", sizeof(la_k_norm_inf_mr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_norm_inf_mc", sizeof(la_i_norm_inf_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_norm_inf_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_norm_inf_mc", sizeof(la_k_norm_inf_mc_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_norm_inf_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_trace_mr", sizeof(la_i_trace_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_trace_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_trace_mr", sizeof(la_k_trace_mr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_trace_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_trace_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_trace_mc", sizeof(la_i_trace_mc_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_trace_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_trace_mc", sizeof(la_k_trace_mc_t), 0, "kk", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_trace_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_trace_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lu_det_mr", sizeof(la_i_lu_det_mr_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_lu_det_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lu_det_mr", sizeof(la_k_lu_det_mr_t), 0, "k", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_lu_det_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lu_det_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lu_det_mc", sizeof(la_i_lu_det_mc_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_lu_det_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lu_det_mc", sizeof(la_k_lu_det_mc_t), 0, "kk", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_lu_det_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lu_det_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_add_vr", sizeof(la_i_add_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_add_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_add_vr", sizeof(la_k_add_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_add_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_add_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_add_vc", sizeof(la_i_add_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_add_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_add_vc", sizeof(la_k_add_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_add_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_add_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_add_mr", sizeof(la_i_add_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_add_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_add_mr", sizeof(la_k_add_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_add_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_add_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_add_mc", sizeof(la_i_add_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_add_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_add_mc", sizeof(la_k_add_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_add_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_add_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_subtract_vr", sizeof(la_i_subtract_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_subtract_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_subtract_vr", sizeof(la_k_subtract_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_subtract_vc", sizeof(la_i_subtract_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_subtract_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_subtract_vc", sizeof(la_k_subtract_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_subtract_mr", sizeof(la_i_subtract_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_subtract_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_subtract_mr", sizeof(la_k_subtract_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_subtract_mc", sizeof(la_i_subtract_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_subtract_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_subtract_mc", sizeof(la_k_subtract_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_subtract_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_multiply_vr", sizeof(la_i_multiply_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_multiply_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_multiply_vr", sizeof(la_k_multiply_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_multiply_vc", sizeof(la_i_multiply_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_multiply_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_multiply_vc", sizeof(la_k_multiply_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_multiply_mr", sizeof(la_i_multiply_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_multiply_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_multiply_mr", sizeof(la_k_multiply_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_multiply_mc", sizeof(la_i_multiply_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_multiply_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_multiply_mc", sizeof(la_k_multiply_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_multiply_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + + status |= csound->AppendOpcode( + csound, "la_i_divide_vr", sizeof(la_i_divide_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_divide_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_divide_vr", sizeof(la_k_divide_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_divide_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_divide_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_divide_vc", sizeof(la_i_divide_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_divide_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_divide_vc", sizeof(la_k_divide_vc_t), 0, "i", "kk", + (int32_t (*)(CSOUND *, void *)) & la_k_divide_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_divide_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_divide_mr", sizeof(la_i_divide_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_divide_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_divide_mr", sizeof(la_k_divide_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_divide_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_divide_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_divide_mc", sizeof(la_i_divide_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_divide_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_divide_mc", sizeof(la_k_divide_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_divide_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_divide_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_dot_vr", sizeof(la_i_dot_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_dot_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_dot_vr", sizeof(la_k_dot_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_dot_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_dot_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_dot_vc", sizeof(la_i_dot_vc_t), 0, "ii", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_dot_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_dot_vc", sizeof(la_k_dot_vc_t), 0, "ii", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_dot_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_dot_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_dot_mr", sizeof(la_i_dot_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_dot_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_dot_mr", sizeof(la_k_dot_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_dot_mc", sizeof(la_i_dot_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_dot_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_dot_mc", sizeof(la_k_dot_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_dot_mr_vr", sizeof(la_i_dot_mr_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_dot_mr_vr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_dot_mr_vr", sizeof(la_k_dot_mr_vr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mr_vr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mr_vr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_dot_mc_vc", sizeof(la_i_dot_mc_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_dot_mc_vc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_dot_mc_vc", sizeof(la_k_dot_mc_vc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mc_vc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_dot_mc_vc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_invert_mr", sizeof(la_i_invert_mr_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_invert_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_invert_mr", sizeof(la_k_invert_mr_t), 0, "ik", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_invert_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_invert_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_invert_mc", sizeof(la_i_invert_mc_t), 0, "iii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_invert_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_invert_mc", sizeof(la_k_invert_mc_t), 0, "ikk", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_invert_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_invert_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_upper_solve_mr", sizeof(la_i_upper_solve_mr_t), 0, "i", + "io", (int32_t (*)(CSOUND *, void *)) & la_i_upper_solve_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_upper_solve_mr", sizeof(la_k_upper_solve_mr_t), 0, "i", + "iO", (int32_t (*)(CSOUND *, void *)) & la_k_upper_solve_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_upper_solve_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_upper_solve_mc", sizeof(la_i_upper_solve_mc_t), 0, "i", + "io", (int32_t (*)(CSOUND *, void *)) & la_i_upper_solve_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_upper_solve_mc", sizeof(la_k_upper_solve_mc_t), 0, "i", + "iO", (int32_t (*)(CSOUND *, void *)) & la_k_upper_solve_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_upper_solve_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lower_solve_mr", sizeof(la_i_lower_solve_mr_t), 0, "i", + "io", (int32_t (*)(CSOUND *, void *)) & la_i_lower_solve_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lower_solve_mr", sizeof(la_k_lower_solve_mr_t), 0, "i", + "iO", (int32_t (*)(CSOUND *, void *)) & la_k_lower_solve_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lower_solve_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lower_solve_mc", sizeof(la_i_lower_solve_mc_t), 0, "i", + "io", (int32_t (*)(CSOUND *, void *)) & la_i_lower_solve_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lower_solve_mc", sizeof(la_k_lower_solve_mc_t), 0, "i", + "iO", (int32_t (*)(CSOUND *, void *)) & la_k_lower_solve_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lower_solve_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lu_factor_mr", sizeof(la_i_lu_factor_mr_t), 0, "iii", + "i", (int32_t (*)(CSOUND *, void *)) & la_i_lu_factor_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lu_factor_mr", sizeof(la_k_lu_factor_mr_t), 0, "iik", + "i", (int32_t (*)(CSOUND *, void *)) & la_k_lu_factor_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lu_factor_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lu_factor_mc", sizeof(la_i_lu_factor_mc_t), 0, "iii", + "i", (int32_t (*)(CSOUND *, void *)) & la_i_lu_factor_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lu_factor_mc", sizeof(la_k_lu_factor_mc_t), 0, "i", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_lu_factor_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lu_factor_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lu_solve_mr", sizeof(la_i_lu_solve_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_lu_solve_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lu_solve_mr", sizeof(la_k_lu_solve_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_lu_solve_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lu_solve_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_lu_solve_mc", sizeof(la_i_lu_solve_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_lu_solve_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_lu_solve_mc", sizeof(la_k_lu_solve_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_k_lu_solve_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_lu_solve_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_qr_factor_mr", sizeof(la_i_qr_factor_mr_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_qr_factor_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_qr_factor_mr", sizeof(la_k_qr_factor_mr_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_qr_factor_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_qr_factor_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_qr_factor_mc", sizeof(la_i_qr_factor_mc_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_i_qr_factor_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_qr_factor_mc", sizeof(la_k_qr_factor_mc_t), 0, "ii", "i", + (int32_t (*)(CSOUND *, void *)) & la_k_qr_factor_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_qr_factor_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_qr_eigen_mr", sizeof(la_i_qr_eigen_mr_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_qr_eigen_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_qr_eigen_mr", sizeof(la_k_qr_eigen_mr_t), 0, "i", "ik", + (int32_t (*)(CSOUND *, void *)) & la_k_qr_eigen_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_qr_eigen_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_qr_eigen_mc", sizeof(la_i_qr_eigen_mc_t), 0, "i", "ii", + (int32_t (*)(CSOUND *, void *)) & la_i_qr_eigen_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_qr_eigen_mc", sizeof(la_k_qr_eigen_mc_t), 0, "i", "ik", + (int32_t (*)(CSOUND *, void *)) & la_k_qr_eigen_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_qr_eigen_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_qr_sym_eigen_mr", sizeof(la_i_qr_sym_eigen_mr_t), 0, + "ii", "ii", (int32_t (*)(CSOUND *, void *)) & la_i_qr_sym_eigen_mr_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_qr_sym_eigen_mr", sizeof(la_k_qr_sym_eigen_mr_t), 0, + "ii", "ik", (int32_t (*)(CSOUND *, void *)) & la_k_qr_sym_eigen_mr_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_qr_sym_eigen_mr_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_i_qr_sym_eigen_mc", sizeof(la_i_qr_sym_eigen_mc_t), 0, + "ii", "ii", (int32_t (*)(CSOUND *, void *)) & la_i_qr_sym_eigen_mc_t::init_, + (int32_t (*)(CSOUND *, void *))0, (int32_t (*)(CSOUND *, void *))0); + status |= csound->AppendOpcode( + csound, "la_k_qr_sym_eigen_mc", sizeof(la_k_qr_sym_eigen_mc_t), 0, + "ii", "ik", (int32_t (*)(CSOUND *, void *)) & la_k_qr_sym_eigen_mc_t::init_, + (int32_t (*)(CSOUND *, void *)) & la_k_qr_sym_eigen_mc_t::kontrol_, + (int32_t (*)(CSOUND *, void *))0); + return status; +} + +PUBLIC int32_t csoundModuleDestroy(CSOUND *csound) { return 0; } +} From a8495268528f93df6a243539505a1b15cdc099f4 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 14:45:00 +0100 Subject: [PATCH 03/72] Port fluidOpcodes to Csound 7 and add vcpkg release packaging Port the fluidsynth opcodes to the Csound 7 API (cs_float, OENTRY/AppendOpcode, StringArg2Name, GetEngineSr, tabinit, noteoff deinit), vendor gmm for linear_algebra, and set up vcpkg (submodule, vcpkg.json, overlay triplet) for macOS/Windows release packaging in CI. --- .github/workflows/plugins_build_7.yml | 64 +- .gitmodules | 3 + 7.x/CMakeLists.txt | 10 +- 7.x/cmake/Modules/FindGMM.cmake | 5 +- 7.x/src/fluidOpcodes/CMakeLists.txt | 12 + 7.x/src/fluidOpcodes/OpcodeBase.hpp | 499 ++++ 7.x/src/fluidOpcodes/fluidOpcodes.cpp | 746 ++++++ 7.x/src/linear_algebra/CMakeLists.txt | 4 + 7.x/src/linear_algebra/gmm/gmm.h | 54 + .../linear_algebra/gmm/gmm_MUMPS_interface.h | 355 +++ 7.x/src/linear_algebra/gmm/gmm_algobase.h | 223 ++ 7.x/src/linear_algebra/gmm/gmm_arch_config.h | 7 + 7.x/src/linear_algebra/gmm/gmm_blas.h | 2287 +++++++++++++++++ .../linear_algebra/gmm/gmm_blas_interface.h | 1055 ++++++++ .../linear_algebra/gmm/gmm_condition_number.h | 147 ++ 7.x/src/linear_algebra/gmm/gmm_conjugated.h | 398 +++ 7.x/src/linear_algebra/gmm/gmm_def.h | 1122 ++++++++ .../gmm/gmm_dense_Householder.h | 317 +++ 7.x/src/linear_algebra/gmm/gmm_dense_lu.h | 288 +++ .../gmm/gmm_dense_matrix_functions.h | 302 +++ 7.x/src/linear_algebra/gmm/gmm_dense_qr.h | 789 ++++++ .../linear_algebra/gmm/gmm_dense_sylvester.h | 174 ++ .../linear_algebra/gmm/gmm_domain_decomp.h | 165 ++ 7.x/src/linear_algebra/gmm/gmm_except.h | 406 +++ .../gmm/gmm_feedback_management.h | 174 ++ 7.x/src/linear_algebra/gmm/gmm_inoutput.h | 1184 +++++++++ 7.x/src/linear_algebra/gmm/gmm_interface.h | 1068 ++++++++ .../linear_algebra/gmm/gmm_interface_bgeot.h | 83 + 7.x/src/linear_algebra/gmm/gmm_iter.h | 162 ++ 7.x/src/linear_algebra/gmm/gmm_iter_solvers.h | 111 + 7.x/src/linear_algebra/gmm/gmm_kernel.h | 55 + .../linear_algebra/gmm/gmm_lapack_interface.h | 484 ++++ .../linear_algebra/gmm/gmm_least_squares_cg.h | 96 + 7.x/src/linear_algebra/gmm/gmm_matrix.h | 1195 +++++++++ .../gmm/gmm_modified_gram_schmidt.h | 127 + 7.x/src/linear_algebra/gmm/gmm_opt.h | 132 + 7.x/src/linear_algebra/gmm/gmm_precond.h | 65 + .../linear_algebra/gmm/gmm_precond_diagonal.h | 132 + .../linear_algebra/gmm/gmm_precond_ildlt.h | 241 ++ .../linear_algebra/gmm/gmm_precond_ildltt.h | 174 ++ 7.x/src/linear_algebra/gmm/gmm_precond_ilu.h | 280 ++ 7.x/src/linear_algebra/gmm/gmm_precond_ilut.h | 263 ++ .../linear_algebra/gmm/gmm_precond_ilutp.h | 284 ++ .../gmm/gmm_precond_mr_approx_inverse.h | 149 ++ 7.x/src/linear_algebra/gmm/gmm_range_basis.h | 499 ++++ 7.x/src/linear_algebra/gmm/gmm_real_part.h | 608 +++++ 7.x/src/linear_algebra/gmm/gmm_ref.h | 526 ++++ 7.x/src/linear_algebra/gmm/gmm_scaled.h | 434 ++++ .../gmm/gmm_solver_Schwarz_additive.h | 805 ++++++ 7.x/src/linear_algebra/gmm/gmm_solver_bfgs.h | 210 ++ .../linear_algebra/gmm/gmm_solver_bicgstab.h | 160 ++ 7.x/src/linear_algebra/gmm/gmm_solver_cg.h | 180 ++ .../gmm/gmm_solver_constrained_cg.h | 165 ++ 7.x/src/linear_algebra/gmm/gmm_solver_gmres.h | 173 ++ .../linear_algebra/gmm/gmm_solver_idgmres.h | 805 ++++++ 7.x/src/linear_algebra/gmm/gmm_solver_qmr.h | 210 ++ 7.x/src/linear_algebra/gmm/gmm_std.h | 352 +++ 7.x/src/linear_algebra/gmm/gmm_sub_index.h | 224 ++ 7.x/src/linear_algebra/gmm/gmm_sub_matrix.h | 406 +++ 7.x/src/linear_algebra/gmm/gmm_sub_vector.h | 565 ++++ .../gmm/gmm_superlu_interface.h | 410 +++ 7.x/src/linear_algebra/gmm/gmm_transposed.h | 244 ++ 7.x/src/linear_algebra/gmm/gmm_tri_solve.h | 222 ++ 7.x/src/linear_algebra/gmm/gmm_vector.h | 1590 ++++++++++++ .../linear_algebra/gmm/gmm_vector_to_matrix.h | 340 +++ 7.x/vcpkg | 1 + 7.x/vcpkg.json | 10 + 7.x/x64-windows-csound.cmake | 8 + 68 files changed, 25030 insertions(+), 8 deletions(-) create mode 100644 7.x/src/fluidOpcodes/CMakeLists.txt create mode 100644 7.x/src/fluidOpcodes/OpcodeBase.hpp create mode 100644 7.x/src/fluidOpcodes/fluidOpcodes.cpp create mode 100644 7.x/src/linear_algebra/gmm/gmm.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_MUMPS_interface.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_algobase.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_arch_config.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_blas.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_blas_interface.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_condition_number.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_conjugated.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_def.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_dense_Householder.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_dense_lu.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_dense_matrix_functions.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_dense_qr.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_dense_sylvester.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_domain_decomp.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_except.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_feedback_management.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_inoutput.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_interface.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_interface_bgeot.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_iter.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_iter_solvers.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_kernel.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_lapack_interface.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_least_squares_cg.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_matrix.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_modified_gram_schmidt.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_opt.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond_diagonal.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond_ildlt.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond_ildltt.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond_ilu.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond_ilut.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond_ilutp.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_precond_mr_approx_inverse.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_range_basis.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_real_part.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_ref.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_scaled.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_Schwarz_additive.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_bfgs.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_bicgstab.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_cg.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_constrained_cg.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_gmres.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_idgmres.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_solver_qmr.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_std.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_sub_index.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_sub_matrix.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_sub_vector.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_superlu_interface.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_transposed.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_tri_solve.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_vector.h create mode 100644 7.x/src/linear_algebra/gmm/gmm_vector_to_matrix.h create mode 160000 7.x/vcpkg create mode 100644 7.x/vcpkg.json create mode 100644 7.x/x64-windows-csound.cmake diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index e335e98..82f87f1 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -20,6 +20,7 @@ on: env: CSOUND_VERSION: 7.0.0-beta.18 + VCPKG_BINARY_SOURCES: "clear;files,${{ github.workspace }}/vcpkg-cache,readwrite" jobs: linux: @@ -35,6 +36,7 @@ jobs: sudo apt-get install -y \ build-essential cmake pkg-config \ libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ + libeigen3-dev libfluidsynth-dev \ flex bison - name: Cache Csound install @@ -73,7 +75,11 @@ jobs: uses: actions/upload-artifact@v4 with: name: csound7-plugins-linux - path: build/src/py/*.so + path: | + build/src/chua/*.so + build/src/linear_algebra/*.so + build/src/fluidOpcodes/*.so + build/src/py/*.so if-no-files-found: error macos: @@ -91,6 +97,19 @@ jobs: echo "$(brew --prefix bison)/bin" >> "$GITHUB_PATH" echo "$(brew --prefix flex)/bin" >> "$GITHUB_PATH" + - name: Checkout 7.x/vcpkg submodule + run: git submodule update --init 7.x/vcpkg + + - name: Set up vcpkg + run: 7.x/vcpkg/bootstrap-vcpkg.sh -disableMetrics + + - name: Cache vcpkg binary cache + uses: actions/cache@v4 + with: + path: vcpkg-cache + key: vcpkg-macos-${{ github.run_id }} + restore-keys: vcpkg-macos- + - name: Cache Csound install id: cache-csound uses: actions/cache@v4 @@ -140,16 +159,26 @@ jobs: - name: Build plugins run: | cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ + -DUSE_VCPKG=ON \ -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ -DCSOUND_FRAMEWORK_DIR_HINT="$CSOUND_FRAMEWORK_DIR_HINT" \ -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" cmake --build build --parallel "$(sysctl -n hw.ncpu)" + - name: Package plugins + run: | + mkdir -p package + cp build/src/chua/*.dylib \ + build/src/linear_algebra/*.dylib \ + build/src/fluidOpcodes/*.dylib \ + build/src/py/*.dylib package/ + ( cd package && zip -r ../csound7-plugins-macos.zip . ) + - name: Upload plugins uses: actions/upload-artifact@v4 with: name: csound7-plugins-macos - path: build/src/py/*.dylib + path: csound7-plugins-macos.zip if-no-files-found: error windows: @@ -177,10 +206,23 @@ jobs: path: ${{ runner.temp }}\csound-install key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} - - name: Bootstrap vcpkg + - name: Bootstrap vcpkg (Csound) if: steps.cache-csound.outputs.cache-hit != 'true' run: .\csound\vcpkg\bootstrap-vcpkg.bat -disableMetrics + - name: Checkout 7.x/vcpkg submodule + run: git submodule update --init 7.x/vcpkg + + - name: Bootstrap vcpkg (plugins) + run: .\7.x\vcpkg\bootstrap-vcpkg.bat -disableMetrics + + - name: Cache vcpkg binary cache + uses: actions/cache@v4 + with: + path: ${{ github.workspace }}\vcpkg-cache + key: vcpkg-windows-${{ github.run_id }} + restore-keys: vcpkg-windows- + - name: Build and install Csound if: steps.cache-csound.outputs.cache-hit != 'true' run: | @@ -213,13 +255,27 @@ jobs: - name: Build plugins run: | cmake -S 7.x -B build -A x64 ` + -DUSE_VCPKG=ON ` -DCSOUND_INCLUDE_DIR_HINT="$env:CSOUND_INCLUDE_DIR_HINT" ` -DCSOUND_LIBRARY_DIR_HINT="$env:CSOUND_LIBRARY_DIR_HINT" cmake --build build --config Release --parallel + - name: Package plugins + run: | + $package = 'package' + New-Item -ItemType Directory -Force -Path $package | Out-Null + Get-ChildItem -Path build/src -Recurse -Include *.dll | + Where-Object { $_.FullName -match 'Release' } | + Copy-Item -Destination $package + $vcpkgBin = Join-Path 'build' 'vcpkg_installed\x64-windows-csound\bin' + if (Test-Path $vcpkgBin) { + Copy-Item (Join-Path $vcpkgBin '*.dll') -Destination $package -ErrorAction SilentlyContinue + } + Compress-Archive -Path "$package\*" -DestinationPath csound7-plugins-windows.zip -Force + - name: Upload plugins uses: actions/upload-artifact@v4 with: name: csound7-plugins-windows - path: build/src/py/Release/*.dll + path: csound7-plugins-windows.zip if-no-files-found: error diff --git a/.gitmodules b/.gitmodules index c309f61..4e57bf2 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,6 @@ [submodule "vcpkg"] path = 6.x/vcpkg url = https://github.com/microsoft/vcpkg.git +[submodule "7.x/vcpkg"] + path = 7.x/vcpkg + url = https://github.com/microsoft/vcpkg.git diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index a57a49a..7c0967e 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -10,8 +10,13 @@ if (USE_VCPKG) set(VCPKG_TARGET_TRIPLET "x64-windows-csound") set(CSOUND_INCLUDE_DIR_HINT "C:/Program Files/Csound6_x64") elseif(APPLE) - set(VCPKG_HOST_TRIPLET "x64-osx" CACHE STRING "") - set(VCPKG_TARGET_TRIPLET "x64-osx") + if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "arm64") + set(VCPKG_HOST_TRIPLET "arm64-osx" CACHE STRING "") + set(VCPKG_TARGET_TRIPLET "arm64-osx") + else() + set(VCPKG_HOST_TRIPLET "x64-osx" CACHE STRING "") + set(VCPKG_TARGET_TRIPLET "x64-osx") + endif() elseif (UNIX) set(VCPKG_HOST_TRIPLET "x64-linux" CACHE STRING "") set(VCPKG_TARGET_TRIPLET "x64-linux") @@ -297,4 +302,5 @@ endif() add_subdirectory(./src/chua) add_subdirectory(./src/linear_algebra) +add_subdirectory(./src/fluidOpcodes) add_subdirectory(./src/py) diff --git a/7.x/cmake/Modules/FindGMM.cmake b/7.x/cmake/Modules/FindGMM.cmake index 1b4d359..208f798 100644 --- a/7.x/cmake/Modules/FindGMM.cmake +++ b/7.x/cmake/Modules/FindGMM.cmake @@ -10,9 +10,10 @@ if (GMM_INCLUDE_DIR) set(GMM_FOUND TRUE) else (GMM_INCLUDE_DIR) find_path(GMM_INCLUDE_DIR NAMES gmm/gmm.h - PATHS + HINTS + ${GMM_INCLUDE_PATH} + PATHS ${INCLUDE_INSTALL_DIR} - ${GMM_INCLUDE_PATH} ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(GMM DEFAULT_MSG GMM_INCLUDE_DIR) diff --git a/7.x/src/fluidOpcodes/CMakeLists.txt b/7.x/src/fluidOpcodes/CMakeLists.txt new file mode 100644 index 0000000..b8beae6 --- /dev/null +++ b/7.x/src/fluidOpcodes/CMakeLists.txt @@ -0,0 +1,12 @@ +# Build fluidsynth opcodes +option(BUILD_FLUID_OPCODES "Build the fluidsynth opcodes" ON) + +find_package(FLUIDSYNTH) +check_deps(BUILD_FLUID_OPCODES FLUIDSYNTH_FOUND) + +if(BUILD_FLUID_OPCODES AND FLUIDSYNTH_FOUND) + make_plugin(fluidOpcodes fluidOpcodes.cpp) + target_include_directories(fluidOpcodes PRIVATE ${FLUIDSYNTH_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(fluidOpcodes PRIVATE BUILD_PLUGINS) + target_link_libraries(fluidOpcodes PRIVATE ${FLUIDSYNTH_LIBRARIES}) +endif() diff --git a/7.x/src/fluidOpcodes/OpcodeBase.hpp b/7.x/src/fluidOpcodes/OpcodeBase.hpp new file mode 100644 index 0000000..49a724f --- /dev/null +++ b/7.x/src/fluidOpcodes/OpcodeBase.hpp @@ -0,0 +1,499 @@ +/* + OpcodeBase.hpp: + + Copyright (C) 2005, 2009, 2017 by Istva Varga, Victor Lazzarini and + Michael Gogins + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA +*/ +#pragma once + +/** + * There is a conflict between the preprocessor definition "_CR" in the + * standard C++ library and in Csound. To work around this, undefine "_CR" and + * include ALL standard library include files BEFORE including ANY Csound + * include files. + */ +#if defined(_CR) +#undef _CR +#endif + +#include +#include +#include +#if !(defined(__wasi__)) +#include +#endif +#include +#include +#include "interlocks.h" +#ifdef BUILD_PLUGINS +#include "csdl.h" +#else +#include "csoundCore.h" +#endif + +/** + * Template base class, or pseudo-virtual base class, + * for writing Csound opcodes in C++. + * Derive opcode implementation classes like this: + * + * DerivedClass : public OpcodeBase + * { + * public: + * // All output fields must be declared first as cs_float *: + * cs_float *aret1; + * // All input fields must be declared next as cs_float *: + * cs_float *iarg1; + * cs_float *karg2; + * cs_float *aarg3; + * // All internal state variables must be declared after that: + * size_t state1; + * double state2; + * cs_float state3; + * // If the opcode shares data protect it by creating one or more void + * // *mutex member pointers: + * void *mutex1; + * void *mutex2; + * // and create them usind csound->Create_Mutex() in csoundModuleCreate + * // and destroy them using csound->DeleteMutex(mutex) + * // csoundModuleDestroy, and lock them using LockGuard guard(mutex). + * int32_t init(); + * int32_t kontrol(); + * int32_t audio; + * int32_t noteoff(); + * void deinit(); + * }; + */ + +namespace csound { + + static bool diagnostics_enabled = false; + + /** + * Use this to guard against data races in opcode functions. The mutex should + * be created by csound->Create_Mutex() in csoundModuleCreate(), and should + * be destroyed by csound->DeleteMutex() in csoundModuleDestroy(). + * + * If data is shared between opcode instances, the mutex should be global to + * the opcode library; if data is shared between threads for a single instance, + * the mutex should belong to the opcode instance. + */ + struct LockGuard { + LockGuard(CSOUND *csound_, void *mutex_) : csound(csound_), mutex(mutex_) + { + csound->LockMutex(mutex); + } + ~LockGuard() + { + csound->UnlockMutex(mutex); + } + CSOUND *csound; + void *mutex; + }; + + /** + * Use this to store a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + + template int32_t CreateGlobalPointer(CSOUND *csound, const char *name, T *pointer) + { + T **pointer_to_pointer = 0; + int32_t result = csound->CreateGlobalVariable(csound, name, sizeof(pointer_to_pointer)); + pointer_to_pointer = static_cast(csound->QueryGlobalVariable(csound, name)); + *pointer_to_pointer = pointer; + return result; + } + + /** + * Retrieve a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + template T *QueryGlobalPointer(CSOUND *csound, const char *name, T*& pointer) + { + T **pointer_to_pointer = static_cast(csound->QueryGlobalVariableNoCheck(csound, name)); + if (pointer_to_pointer != 0) { + pointer = *pointer_to_pointer; + } else { + pointer = 0; + } + return pointer; + } + + template + class OpcodeBase + { + public: + int32_t init(CSOUND *csound) + { + return NOTOK; + } + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + int32_t kontrol(CSOUND *csound) + { + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + OPDS opds; + }; + + template + class OpcodeNoteoffBase + { + public: + int32_t init(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + + static int32_t deinit_(CSOUND *csound, void *opcode) + { + if (!csound->GetReinitFlag(csound) && !csound->GetTieFlag(csound)) { + return noteoff_(csound, opcode); + } + return OK; + } + + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + + int32_t kontrol(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + int32_t noteoff(CSOUND *csound) + { + return OK; + } + static int32_t noteoff_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->noteoff(csound); + } + OPDS opds; + }; + + +#if (__cplusplus >= 201103L) && !(defined(__wasi__)) && !defined(BARE_METAL) + // #pragma message("Defining heap_object_manager_t.") + /** + * The memory of non-POD C++ or C objects allocated on the heap by Csound + * plugins is managed not by Csound, but by the plugin module. This class + * performs that function. + * + * As long as all memory is allocated in or after csoundModuleCreate and + * de-allocated in csoundModuleDestroy, all will be well. The danger however + * is that memory leaks will occur if allocations are not matched with + * de-allocations, or worse, that crashes will occur if any objects are + * deleted twice or de-referenced after deletion. + * + * So, the plugin should manage a collection of all heap-allocated objects, + * keyed first off the Csound instance, and second off an object handle; and + * all such objects must be accessed only by handle, from this collection. + * + * In csoundModuleDestroy, all objects for the calling instance of Csound + * should be de-allocated, and the sub-collection for that instance should + * also be de-allocated. + * + * If then there are no more sub-collections for other instances of Csound, + * the entire contents of the collection should be de-allocated. + * + * This should be done as a singleton, and in a thread-safe way. + * + * There might still be a problem if any of the heap-allocated objects, + * themselves, have global static members, perhaps created by some external + * dependency. + * + * Please note, objects O in the declaration below must not be std::shared_ptr + * objects. Deletion of objects herein must be unconditional. Rather, the + * objects passed are raw pointers to instances of class O. + */ + template class heap_object_manager_t { + private: + std::map> objects_; + std::recursive_mutex mutex; + heap_object_manager_t(){}; + ~heap_object_manager_t(){}; + public: + static heap_object_manager_t &instance() { + static heap_object_manager_t singleton; + return singleton; + } + std::map> &objects() { + std::lock_guard lock(mutex); + return objects_; + } + /** + * Returns a list of pointers to all objects allocated for this + * instance of Csound. + */ + std::vector &objects_for_csound(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects()[csound]; + return objects_for_csound_; + } + /** + * Returns the handle for the object; if the object has not yet been + * stored, inserts it into the list of object pointers for this + * instance of Csound; otherwise, returns the handle of the stored + * object pointer. + */ + int32_t handle_for_object(CSOUND *csound, O *object) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + auto iterator = std::find(objects_for_csound_.begin(), objects_for_csound_.end(), object); + if (iterator == objects_for_csound_.end()) { + int32_t handle = objects_for_csound_.size(); + objects_for_csound_.push_back(object); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object %p: new object handle: %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return handle; + } else { + int32_t handle = static_cast(iterator - objects_for_csound_.begin()); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object: existing object handle: %d\n", handle); + return handle; + } + } + /** + * Returns the object pointer for the handle; + * if the object pointer has not been stored by + * handle, returns a null pointer. + */ + O *object_for_handle(CSOUND *csound, int32_t handle) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + if (handle >= objects_for_csound_.size()) { + return nullptr; + } + O *object = objects_for_csound_[handle]; + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::object_for_handle: %p %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return object; + } + /** + * First destroys all objects created by the calling + * instance of Csound, then destroys the list of + * object pointers for this instance of Csound. + */ + void module_destroy(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + for (int32_t i = 0, n = objects_for_csound_.size(); i < n; ++i) { + delete objects_for_csound_[i]; + objects_for_csound_[i] = nullptr; + } + objects_for_csound_.clear(); + objects().erase(csound); + } + }; + +#endif + +} diff --git a/7.x/src/fluidOpcodes/fluidOpcodes.cpp b/7.x/src/fluidOpcodes/fluidOpcodes.cpp new file mode 100644 index 0000000..5a33bed --- /dev/null +++ b/7.x/src/fluidOpcodes/fluidOpcodes.cpp @@ -0,0 +1,746 @@ +/** + * FLUID SYNTH OPCODES + * + * Adapts Fluidsynth to use global engines, soundFonts, and outputs + * + * Based on work by Michael Gogins and Steven Yi. License is identical to + * SOUNDFONTS VST License (listed below) + * + * Copyright (c) 2003 by Steven Yi. All rights reserved. + * + * [ORIGINAL INFORMATION BELOW] + * + * S O U N D F O N T S V S T + * + * Adapts Fluidsynth to be both a VST plugin instrument + * and a Csound plugin opcode. + * Copyright (c) 2001-2003 by Michael Gogins. All rights reserved. + * + * L I C E N S E + * + * This software is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include +#include +#include +#include +#include "OpcodeBase.hpp" +#include "csdl.h" +#include +#include + +static std::vector &fluidsynths_for_ids() { + static std::vector fluidsynths_for_ids_; + return fluidsynths_for_ids_; +} + +static void tof(fluid_synth_t *f, cs_float *a) { + auto &instances = fluidsynths_for_ids(); + instances.push_back(f); + *a = instances.size() - 1; +}; + +static void toa(cs_float *f, fluid_synth_t *&a) { + auto &instances = fluidsynths_for_ids(); + int index = *f; + a = instances[index]; +}; + +class FluidEngine : public csound::OpcodeBase { + // Outputs. + cs_float *iFluidSynth; + // Inputs. + cs_float *iChorusEnabled; + cs_float *iReverbEnabled; + cs_float *iChannelCount; + cs_float *iVoiceCount; + // State. + // fluid_synth_t *fluidSynth; + // fluid_settings_t *fluidSettings; + int32_t chorusEnabled; + int32_t reverbEnabled; + int32_t channelCount; + int32_t voiceCount; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + int32_t result = OK; + fluid_synth_t *fluidSynth = 0; + fluid_settings_t *fluidSettings = 0; + chorusEnabled = (int32_t)*iChorusEnabled; + reverbEnabled = (int32_t)*iReverbEnabled; + channelCount = (int32_t)*iChannelCount; + voiceCount = (int32_t)*iVoiceCount; + if (channelCount <= 0) { + channelCount = 256; + } else if (channelCount < 16) { + channelCount = 16; + } else if (channelCount > 256) { + channelCount = 256; + } + if (voiceCount <= 0) { + voiceCount = 4096; + } else if (voiceCount < 16) { + voiceCount = 16; + } else if (voiceCount > 4096) { + voiceCount = 4096; + } + fluidSettings = new_fluid_settings(); + if (fluidSettings != NULL) { + fluid_settings_setnum(fluidSettings, (char *)"synth.sample-rate", + (double)csound->GetEngineSr(csound)); + fluid_settings_setint(fluidSettings, (char *)"synth.midi-channels", + channelCount); + fluid_settings_setint(fluidSettings, (char *)"synth.polyphony", + voiceCount); + fluidSynth = new_fluid_synth(fluidSettings); + } + if (!fluidSynth) { + if (fluidSettings) { + delete_fluid_settings(fluidSettings); + } + result = + csound->InitError(csound, "%s", Str("error allocating fluid engine\n")); + } else { +#if (FLUIDSYNTH_VERSION_MAJOR >= 2 && FLUIDSYNTH_VERSION_MINOR >= 2) + // TODO: Change -1 to a configurable FX group? + fluid_synth_chorus_on(fluidSynth, -1, chorusEnabled); + fluid_synth_reverb_on(fluidSynth, -1, reverbEnabled); +#else + fluid_synth_set_chorus_on(fluidSynth, chorusEnabled); + fluid_synth_set_reverb_on(fluidSynth, reverbEnabled); +#endif + log(csound, "Created fluidEngine 0x%p with sampling rate = %f, " + "chorus %s, reverb %s, channels %d, voices %d.\n", + fluidSynth, (double)csound->GetEngineSr(csound), + chorusEnabled ? "on" : "off", reverbEnabled ? "on" : "off", + channelCount, voiceCount); + tof(fluidSynth, iFluidSynth); + { + void *fluid_synths_mutex = 0; + csound::QueryGlobalPointer(csound, "fluid_synths_mutex", + fluid_synths_mutex); + csound::LockGuard synthsGuard(csound, fluid_synths_mutex); + std::vector *fluid_synths = 0; + csound::QueryGlobalPointer(csound, "fluid_synths", fluid_synths); + fluid_synths->push_back(fluidSynth); + } + } + return result; + } +}; + +class FluidLoad : public csound::OpcodeBase { + // Outputs. + cs_float *iInstrumentNumber; + // Inputs. + cs_float *iFilename; + cs_float *iFluidSynth; + cs_float *iListPresets; + // State. + char *filename; + char *filepath; + fluid_synth_t *fluidSynth; + int32_t soundFontId; + int32_t listPresets; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + int32_t result = OK; + soundFontId = -1; + toa(iFluidSynth, fluidSynth); + listPresets = (int32_t)*iListPresets; + CS_TYPE *argType = GetTypeForArg(iFilename); + if (strcmp("S", argType->varTypeName) == 0) { + filename = csound->Strdup(csound, ((STRINGDAT *)iFilename)->data); + } else { + char legacy_name[MAXNAME]; + csound->StringArg2Name( + csound, legacy_name, + (IsStringCode(*iFilename) ? csound->GetArgString(csound, *iFilename) + : (char *)iFilename), + (char *)"fluid.sf2.", IsStringCode(*iFilename)); + filename = legacy_name; + } + + filepath = csound->FindInputFile(csound, filename, "SFDIR;SSDIR"); + if (filepath && fluid_is_soundfont(filepath)) { + log(csound, "Loading SoundFont: %s.\n", filepath); + soundFontId = fluid_synth_sfload(fluidSynth, filepath, 0); + log(csound, "fluidSynth: 0x%p soundFontId: %d.\n", fluidSynth, + soundFontId); + } + *iInstrumentNumber = (cs_float)soundFontId; + if (UNLIKELY(soundFontId < 0)) { + return csound->InitError(csound, Str("fluid: unable to load %s"), + filename); + } + csound->NotifyFileOpened(csound, filepath, CSFTYPE_SOUNDFONT, 0, 0); + if (soundFontId < 0) { + result = NOTOK; + } else if (listPresets) { + fluid_sfont_t *fluidSoundfont = + fluid_synth_get_sfont_by_id(fluidSynth, soundFontId); +#if FLUIDSYNTH_VERSION_MAJOR < 2 + fluid_preset_t fluidPreset; + fluidSoundfont->iteration_start(fluidSoundfont); + const OPARMS *oparms = csound->GetOParms(csound); + if (oparms->msglevel & 0x7) + while (fluidSoundfont->iteration_next(fluidSoundfont, &fluidPreset)) + { + log(csound, "SoundFont: %3d Bank: %3d Preset: %3d %s\n", + soundFontId, fluidPreset.get_banknum(&fluidPreset), + fluidPreset.get_num(&fluidPreset), + fluidPreset.get_name(&fluidPreset)); +#else + fluid_preset_t *fluidPreset; + fluid_sfont_iteration_start(fluidSoundfont); + const OPARMS *oparms = csound->GetOParms(csound); + if (oparms->msglevel & 0x7) + while ((fluidPreset = fluid_sfont_iteration_next(fluidSoundfont))) + { + log(csound, "SoundFont: %3d Bank: %3d Preset: %3d %s\n", + soundFontId, fluid_preset_get_banknum(fluidPreset), + fluid_preset_get_num(fluidPreset), + fluid_preset_get_name(fluidPreset)); +#endif + } + } + return result; + } +}; + +#include "arrays.h" + +//Rory Walsh 2018 +class FluidInfo : public csound::OpcodeBase { + // Outputs. + ARRAYDAT *outArr; + // Inputs. + cs_float *iFluidSynth; + // State. + fluid_synth_t *fluidSynth; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + std::vector programs; + char *program; + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + int32_t result = OK; + toa(iFluidSynth, fluidSynth); + fluid_sfont_t *fluidSoundfont = fluid_synth_get_sfont(fluidSynth, 0); +#if FLUIDSYNTH_VERSION_MAJOR < 2 + fluid_preset_t fluidPreset; + fluidSoundfont->iteration_start(fluidSoundfont); + const OPARMS *oparms = csound->GetOParms(csound); + if (oparms->msglevel & 0x7) + while (fluidSoundfont->iteration_next(fluidSoundfont, &fluidPreset)) + { + std::stringstream ss; + ss << "Bank: " << fluidPreset.get_banknum(&fluidPreset) << + " Preset: " << fluidPreset.get_num(&fluidPreset) << + " Name: " << fluidPreset.get_name(&fluidPreset); +#else + fluid_preset_t *fluidPreset; + fluid_sfont_iteration_start(fluidSoundfont); + const OPARMS *oparms = csound->GetOParms(csound); + if (oparms->msglevel & 0x7) + while ((fluidPreset = fluid_sfont_iteration_next(fluidSoundfont))) + { + std::stringstream ss; + ss << "Bank: " << fluid_preset_get_banknum(fluidPreset) << + " Preset: " << fluid_preset_get_num(fluidPreset) << + " Name: " << fluid_preset_get_name(fluidPreset); +#endif + programs.push_back(ss.str()); + } + + tabinit(csound, outArr, (int32_t)programs.size(), opds.insdshead); + + for (unsigned int i = 0; i < programs.size(); i++) { + program = &programs[i][0u]; + STRINGDAT *element = csound_string_array_element(outArr, i); + element->size = strlen(program) + 1; + element->data = csound->Strdup(csound, program); + element->refcount = 0; + } + + programs.clear(); + + return result; + } +}; + +class FluidProgramSelect : public csound::OpcodeBase +{ + // Inputs. + cs_float *iFluidSynth; + cs_float *iChannelNumber; + cs_float *iInstrumentNumber; + cs_float *iBankNumber; + cs_float *iPresetNumber; + // State. + fluid_synth_t *fluidSynth; + int32_t channel; + uint32_t instrument; + uint32_t bank; + uint32_t preset; + void *mutex; +public: + int32_t init(CSOUND *csound) + { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(iFluidSynth, fluidSynth); + channel = (int32_t) *iChannelNumber; + instrument = (uint32_t) *iInstrumentNumber; + bank = (uint32_t) *iBankNumber; + preset = (uint32_t) *iPresetNumber; + fluid_synth_program_select(fluidSynth, + channel, + instrument, + bank, + preset); + return OK; + } +}; + +class FluidCCI : public csound::OpcodeBase { + // Inputs. + cs_float *iFluidSynth; + cs_float *iChannelNumber; + cs_float *iControllerNumber; + cs_float *kVal; + // State. + fluid_synth_t *fluidSynth; + int32_t channel; + int32_t controller; + int32_t value; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(iFluidSynth, fluidSynth); + channel = (int32_t)*iChannelNumber; + controller = (int32_t)*iControllerNumber; + value = (int32_t)*kVal; + fluid_synth_cc(fluidSynth, channel, controller, value); + return OK; + } +}; + +class FluidCCK : public csound::OpcodeBase { + // Inputs. + cs_float *iFluidSynth; + cs_float *iChannelNumber; + cs_float *iControllerNumber; + cs_float *kVal; + // State. + fluid_synth_t *fluidSynth; + int32_t channel; + int32_t controller; + int32_t value; + int32_t priorValue; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(iFluidSynth, fluidSynth); + priorValue = -1; + return OK; + } + int32_t kontrol(CSOUND *csound) { + csound::LockGuard guard(csound, mutex); + value = (int32_t)*kVal; + if (value != priorValue) { + priorValue = value; + channel = (int32_t)*iChannelNumber; + controller = (int32_t)*iControllerNumber; + fluid_synth_cc(fluidSynth, channel, controller, value); + } + return OK; + } +}; + +class FluidNote : public csound::OpcodeNoteoffBase { + // Inputs. + cs_float *iFluidSynth; + cs_float *iChannelNumber; + cs_float *iMidiKeyNumber; + cs_float *iVelocity; + // State. + fluid_synth_t *fluidSynth; + int32_t channel; + int32_t key; + int32_t velocity; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(iFluidSynth, fluidSynth); + channel = (int32_t)*iChannelNumber; + key = (int32_t)*iMidiKeyNumber; + velocity = (int32_t)*iVelocity; + fluid_synth_noteon(fluidSynth, channel, key, velocity); + return OK; + } + int32_t noteoff(CSOUND *csound) { + csound::LockGuard guard(csound, mutex); + fluid_synth_noteoff(fluidSynth, channel, key); + return OK; + } +}; + +class FluidOut : public csound::OpcodeBase { + // Outputs. + cs_float *aLeftOut; + cs_float *aRightOut; + // Inputs. + cs_float *iFluidSynth; + // State. + fluid_synth_t *fluidSynth; + float leftSample; + float rightSample; + int32_t frame; + int32_t ksmps; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(iFluidSynth, fluidSynth); + ksmps = opds.insdshead->ksmps; + return OK; + } + int32_t audio(CSOUND *csound) { + csound::LockGuard guard(csound, mutex); + uint32_t offset = opds.insdshead->ksmps_offset; + uint32_t early = opds.insdshead->ksmps_no_end; + if (UNLIKELY(offset)) { + memset(aLeftOut, '\0', offset * sizeof(cs_float)); + memset(aRightOut, '\0', offset * sizeof(cs_float)); + } + if (UNLIKELY(early)) { + ksmps -= early; + memset(&aLeftOut[ksmps], '\0', early * sizeof(cs_float)); + memset(&aRightOut[ksmps], '\0', early * sizeof(cs_float)); + } + for (frame = offset; frame < ksmps; frame++) { + leftSample = 0.0f; + rightSample = 0.0f; + fluid_synth_write_float(fluidSynth, 1, &leftSample, 0, 1, &rightSample, 0, + 1); + aLeftOut[frame] = leftSample /* * csound->e0dbfs */; + aRightOut[frame] = rightSample /* * csound->e0dbfs */; + } + return OK; + } +}; + +class FluidAllOut : public csound::OpcodeBase { + // Outputs. + cs_float *aLeftOut; + cs_float *aRightOut; + // State. + float leftSample; + float rightSample; + int32_t frame; + int32_t ksmps; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + ksmps = opds.insdshead->ksmps; + return OK; + } + int32_t audio(CSOUND *csound) { + csound::LockGuard guard(csound, mutex); + uint32_t offset = opds.insdshead->ksmps_offset; + uint32_t early = opds.insdshead->ksmps_no_end; + if (UNLIKELY(offset)) { + memset(aLeftOut, '\0', offset * sizeof(cs_float)); + memset(aRightOut, '\0', offset * sizeof(cs_float)); + } + if (UNLIKELY(early)) { + ksmps -= early; + memset(&aLeftOut[ksmps], '\0', early * sizeof(cs_float)); + memset(&aRightOut[ksmps], '\0', early * sizeof(cs_float)); + } + std::vector *fluid_synths = 0; + csound::QueryGlobalPointer(csound, "fluid_synths", fluid_synths); + void *fluid_synths_mutex = 0; + csound::QueryGlobalPointer(csound, "fluid_synths_mutex", + fluid_synths_mutex); + csound::LockGuard synthsGuard(csound, fluid_synths_mutex); + for (frame = offset; frame < ksmps; frame++) { + aLeftOut[frame] = FL(0.0); + aRightOut[frame] = FL(0.0); + for (size_t i = 0, n = fluid_synths->size(); i < n; i++) { + fluid_synth_t *fluidSynth = (*fluid_synths)[i]; + leftSample = FL(0.0); + rightSample = FL(0.0); + fluid_synth_write_float(fluidSynth, 1, &leftSample, 0, 1, &rightSample, + 0, 1); + aLeftOut[frame] += (cs_float)leftSample /* * csound->e0dbfs */; + aRightOut[frame] += (cs_float)rightSample /* * csound->e0dbfs */; + } + } + return OK; + } +}; + +class FluidControl : public csound::OpcodeBase { + // Inputs. + cs_float *iFluidSynth; + cs_float *kMidiStatus; + cs_float *kMidiChannel; + cs_float *kMidiData1; + cs_float *kMidiData2; + cs_float *imsgs; + // State. + fluid_synth_t *fluidSynth; + int32_t midiStatus; + int32_t midiChannel; + int32_t midiData1; + int32_t midiData2; + int32_t priorMidiStatus; + int32_t priorMidiChannel; + int32_t priorMidiData1; + int32_t priorMidiData2; + int32_t printMsgs; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(iFluidSynth, fluidSynth); + priorMidiStatus = -1; + priorMidiChannel = -1; + priorMidiData1 = -1; + priorMidiData2 = -1; + printMsgs = (*imsgs == 0 ? 0 : 1); + return OK; + } + int32_t kontrol(CSOUND *csound) { + csound::LockGuard guard(csound, mutex); + midiStatus = 0xF0 & (int32_t)*kMidiStatus; + midiChannel = (int32_t)*kMidiChannel; + midiData1 = (int32_t)*kMidiData1; + midiData2 = (int32_t)*kMidiData2; + int32_t result = -1; + + if (midiData2 != priorMidiData2 || midiData1 != priorMidiData1 || + midiChannel != priorMidiChannel || midiStatus != priorMidiStatus) { + switch (midiStatus) { + case (int32_t)0x80: + noteOff: + result = fluid_synth_noteoff(fluidSynth, midiChannel, midiData1); + if (printMsgs) + csound->Message(csound, Str("result: %d\n Note off: c:%3d k:%3d\n"), + result, midiChannel, midiData1); + break; + case (int32_t)0x90: + if (!midiData2) { + goto noteOff; + } + result = + fluid_synth_noteon(fluidSynth, midiChannel, midiData1, midiData2); + if (printMsgs) + log(csound, "result: %d\nNote on: c:%3d k:%3d v:%3d\n", result, + midiChannel, midiData1, midiData2); + break; + case (int32_t)0xA0: + if (printMsgs) + log(csound, "Key pressure (not handled): " + "c:%3d k:%3d v:%3d\n", + midiChannel, midiData1, midiData2); + break; + case (int32_t)0xB0: + result = fluid_synth_cc(fluidSynth, midiChannel, midiData1, midiData2); + if (printMsgs) + log(csound, "Result: %d Control change: c:%3d c:%3d v:%3d\n", result, + midiChannel, midiData1, midiData2); + break; + case (int32_t)0xC0: + result = fluid_synth_program_change(fluidSynth, midiChannel, midiData1); + if (printMsgs) + log(csound, "Result: %d Program change: c:%3d p:%3d\n", result, + midiChannel, midiData1); + break; + case (int32_t)0xD0: + if (printMsgs) + log(csound, "After touch (not handled): c:%3d v:%3d\n", midiChannel, + midiData1); + break; + case (int32_t)0xE0: { + int32_t pbVal = midiData1 + (midiData2 << 7); + fluid_synth_pitch_bend(fluidSynth, midiChannel, pbVal); + if (printMsgs) + log(csound, "Result: %d, Pitch bend: c:%d b:%d\n", result, + midiChannel, pbVal); + } break; + case (int32_t)0xF0: + if (printMsgs) + log(csound, "System exclusive (not handled): " + "c:%3d v1:%3d v2:%3d\n", + midiChannel, midiData1, midiData2); + break; + } + priorMidiStatus = midiStatus; + priorMidiChannel = midiChannel; + priorMidiData1 = midiData1; + priorMidiData2 = midiData2; + } + return OK; + } +}; + +class FluidSetInterpMethod : public csound::OpcodeBase { + // Inputs. + cs_float *iFluidSynth; + cs_float *iChannelNumber; + cs_float *iInterpMethod; + // State. + fluid_synth_t *fluidSynth; + int32_t channel; + int32_t interpolationMethod; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(iFluidSynth, fluidSynth); + channel = (int32_t)*iChannelNumber; + interpolationMethod = (int32_t)*iInterpMethod; + if (UNLIKELY(interpolationMethod != 0 && interpolationMethod != 1 && + interpolationMethod != 4 && interpolationMethod != 7)) { + return csound->InitError(csound, "%s", + Str("Illegal Interpolation Method: Must be " + "either 0, 1, 4, or 7.\n")); + } else { + fluid_synth_set_interp_method(fluidSynth, channel, interpolationMethod); + } + return OK; + } +}; + +static OENTRY localops[] = { + {(char *)"fluidEngine", sizeof(FluidEngine), 0, (char *)"i", (char *)"ppoo", + (SUBR)&FluidEngine::init_, (SUBR)0, (SUBR)0}, + {(char *)"fluidLoad", sizeof(FluidLoad), 0, (char *)"i", (char *)"Tio", + (SUBR)&FluidLoad::init_, (SUBR)0, (SUBR)0}, + {(char *)"fluidInfo", sizeof(FluidInfo), 0, (char *)"S[]", (char *)"i", + (SUBR)&FluidInfo::init_, (SUBR)0, (SUBR)0}, + {(char *)"fluidProgramSelect", sizeof(FluidProgramSelect), 0, (char *)"", + (char *)"iiiii", (SUBR)&FluidProgramSelect::init_, (SUBR)0, (SUBR)0}, + {(char *)"fluidCCi", sizeof(FluidCCI), 0, (char *)"", (char *)"iiii", + (SUBR)&FluidCCI::init_, (SUBR)0, (SUBR)0}, + {(char *)"fluidCCk", sizeof(FluidCCK), 0, (char *)"", (char *)"ikkk", + (SUBR)&FluidCCK::init_, (SUBR)&FluidCCK::kontrol_, (SUBR)0}, + {(char *)"fluidNote", sizeof(FluidNote), 0, (char *)"", (char *)"iiii", + (SUBR)&FluidNote::init_, (SUBR)0, (SUBR)&FluidNote::deinit_}, + {(char *)"fluidOut", sizeof(FluidOut), 0, (char *)"aa", (char *)"i", + (SUBR)&FluidOut::init_, (SUBR)&FluidOut::audio_, (SUBR)0}, + {(char *)"fluidAllOut", sizeof(FluidAllOut), 0, (char *)"aa", (char *)"", + (SUBR)&FluidAllOut::init_, (SUBR)&FluidAllOut::audio_, (SUBR)0}, + {(char *)"fluidControl", sizeof(FluidControl), 0, (char *)"", + (char *)"ikkkkp", (SUBR)FluidControl::init_, (SUBR)FluidControl::kontrol_, + (SUBR)0}, + {(char *)"fluidSetInterpMethod", sizeof(FluidSetInterpMethod), 0, + (char *)"", (char *)"iii", (SUBR)&FluidSetInterpMethod::init_, (SUBR)0, + (SUBR)0}, + {NULL, 0, 0, NULL, NULL, (SUBR)0, (SUBR)0, (SUBR)0, NULL, 0}}; + +PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { + std::vector *fluid_synths = + new std::vector(); + int32_t result = 0; + result = csound::CreateGlobalPointer(csound, "fluid_synths", fluid_synths); + void *fluid_synths_mutex = csound->Create_Mutex(0); + result = csound::CreateGlobalPointer(csound, "fluid_synths_mutex", + fluid_synths_mutex); + return result; +} + +PUBLIC int32_t csoundModuleInit(CSOUND *csound) { + // printf("csoundModuleInit: %p\n", csound); + OENTRY *ep; + int32_t err = 0; + + for (ep = (OENTRY *)&(localops[0]); ep->opname != NULL; ep++) { + err |= csound->AppendOpcode(csound, ep->opname, ep->dsblksiz, ep->flags, + ep->outypes, ep->intypes, + (int32_t (*)(CSOUND *, void *))ep->init, + (int32_t (*)(CSOUND *, void *))ep->perf, + (int32_t (*)(CSOUND *, void *))ep->deinit); + } + return err; +} + +/** + * Called by Csound to de-initialize the opcode + * just before destroying it. + */ +PUBLIC int32_t csoundModuleDestroy(CSOUND *csound) { + // printf("csoundModuleDestroy: %p\n", csound); + void *fluid_synths_mutex = 0; + csound::QueryGlobalPointer(csound, "fluid_synths_mutex", fluid_synths_mutex); + if (fluid_synths_mutex) { + std::vector *fluid_synths = 0; + csound::QueryGlobalPointer(csound, "fluid_synths", fluid_synths); + csound->LockMutex(fluid_synths_mutex); + if (fluid_synths) { + for (size_t i = 0, n = fluid_synths->size(); i < n; i++) { + fluid_synth_t *fluidSynth = (*fluid_synths)[i]; + // printf("deleting engine: %p\n", fluidSynth); + fluid_settings_t *fluidSettings = fluid_synth_get_settings(fluidSynth); + delete_fluid_synth(fluidSynth); + delete_fluid_settings(fluidSettings); + } + fluid_synths->clear(); + delete fluid_synths; + fluid_synths = 0; + } + csound->UnlockMutex(fluid_synths_mutex); + csound->DestroyMutex(fluid_synths_mutex); + fluid_synths_mutex = 0; + } + return 0; +} + +PUBLIC int32_t csoundModuleInfo(void) { + return CSOUND_MODULE_INFO; +} diff --git a/7.x/src/linear_algebra/CMakeLists.txt b/7.x/src/linear_algebra/CMakeLists.txt index b68c133..e564934 100644 --- a/7.x/src/linear_algebra/CMakeLists.txt +++ b/7.x/src/linear_algebra/CMakeLists.txt @@ -1,5 +1,9 @@ option(BUILD_LINEAR_ALGEBRA_OPCODES "Build the linear algebra opcodes" ON) +# gmm++ is header-only and vendored under this directory as gmm/gmm.h. +# GMM_INCLUDE_PATH can be overridden to use a system gmm++ installation. +set(GMM_INCLUDE_PATH "${CMAKE_CURRENT_SOURCE_DIR}" CACHE PATH "Path to the gmm++ headers") + find_package(GMM) check_deps(BUILD_LINEAR_ALGEBRA_OPCODES GMM_FOUND) diff --git a/7.x/src/linear_algebra/gmm/gmm.h b/7.x/src/linear_algebra/gmm/gmm.h new file mode 100644 index 0000000..b7d989a --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm.h @@ -0,0 +1,54 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm.h + @author Yves Renard + @date October 13, 2002. + @brief Include common gmm files. +*/ +#ifndef GMM_H__ +#define GMM_H__ + +#include "gmm_kernel.h" +#include "gmm_dense_lu.h" +#include "gmm_dense_qr.h" + +#include "gmm_iter_solvers.h" +#include "gmm_condition_number.h" +#include "gmm_inoutput.h" + +#include "gmm_lapack_interface.h" +#include "gmm_superlu_interface.h" +#include "gmm_range_basis.h" + +#include "gmm_domain_decomp.h" + +#endif // GMM_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_MUMPS_interface.h b/7.x/src/linear_algebra/gmm/gmm_MUMPS_interface.h new file mode 100644 index 0000000..3325690 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_MUMPS_interface.h @@ -0,0 +1,355 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard, Julien Pommier + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_MUMPS_interface.h + @author Yves Renard , + @author Julien Pommier + @date December 8, 2005. + @brief Interface with MUMPS (LU direct solver for sparse matrices). +*/ +#if defined(GMM_USES_MUMPS) || defined(HAVE_DMUMPS_C_H) + +#ifndef GMM_MUMPS_INTERFACE_H +#define GMM_MUMPS_INTERFACE_H + +#include "gmm_kernel.h" + + +extern "C" { + +#include +#undef F_INT +#undef F_DOUBLE +#undef F_DOUBLE2 +#include +#undef F_INT +#undef F_DOUBLE +#undef F_DOUBLE2 +#include +#undef F_INT +#undef F_DOUBLE +#undef F_DOUBLE2 +#include +#undef F_INT +#undef F_DOUBLE +#undef F_DOUBLE2 + +} + +namespace gmm { + +#define ICNTL(I) icntl[(I)-1] +#define INFO(I) info[(I)-1] +#define INFOG(I) infog[(I)-1] +#define RINFOG(I) rinfog[(I)-1] + + template struct ij_sparse_matrix { + std::vector irn; + std::vector jcn; + std::vector a; + bool sym; + + template void store(const L& l, size_type i) { + typename linalg_traits::const_iterator it = vect_const_begin(l), + ite = vect_const_end(l); + for (; it != ite; ++it) { + int ir = (int)i + 1, jc = (int)it.index() + 1; + if (*it != T(0) && (!sym || ir >= jc)) + { irn.push_back(ir); jcn.push_back(jc); a.push_back(*it); } + } + } + + template void build_from(const L& l, row_major) { + for (size_type i = 0; i < mat_nrows(l); ++i) + store(mat_const_row(l, i), i); + } + + template void build_from(const L& l, col_major) { + for (size_type i = 0; i < mat_ncols(l); ++i) + store(mat_const_col(l, i), i); + irn.swap(jcn); + } + + template ij_sparse_matrix(const L& A, bool sym_) { + size_type nz = nnz(A); + sym = sym_; + irn.reserve(nz); jcn.reserve(nz); a.reserve(nz); + build_from(A, typename principal_orientation_type::sub_orientation>::potype()); + } + }; + + /* ********************************************************************* */ + /* MUMPS solve interface */ + /* ********************************************************************* */ + + template struct mumps_interf {}; + + template <> struct mumps_interf { + typedef SMUMPS_STRUC_C MUMPS_STRUC_C; + typedef float value_type; + + static void mumps_c(MUMPS_STRUC_C &id) { smumps_c(&id); } + }; + + template <> struct mumps_interf { + typedef DMUMPS_STRUC_C MUMPS_STRUC_C; + typedef double value_type; + static void mumps_c(MUMPS_STRUC_C &id) { dmumps_c(&id); } + }; + + template <> struct mumps_interf > { + typedef CMUMPS_STRUC_C MUMPS_STRUC_C; + typedef mumps_complex value_type; + static void mumps_c(MUMPS_STRUC_C &id) { cmumps_c(&id); } + }; + + template <> struct mumps_interf > { + typedef ZMUMPS_STRUC_C MUMPS_STRUC_C; + typedef mumps_double_complex value_type; + static void mumps_c(MUMPS_STRUC_C &id) { zmumps_c(&id); } + }; + + + template + static inline bool mumps_error_check(MUMPS_STRUCT &id) { + if (id.INFO(1) < 0) { + switch (id.INFO(1)) { + case -2: + GMM_ASSERT1(false, "Solve with MUMPS failed: NZ = " << id.INFO(2) + << " is out of range"); + case -6 : case -10 : + GMM_WARNING1("Solve with MUMPS failed: matrix is singular"); + return false; + case -9: + GMM_ASSERT1(false, "Solve with MUMPS failed: error " + << id.INFO(1) << ", increase ICNTL(14)"); + case -13 : + GMM_ASSERT1(false, "Solve with MUMPS failed: not enough memory"); + default : + GMM_ASSERT1(false, "Solve with MUMPS failed with error " + << id.INFO(1)); + } + } + return true; + } + + + /** MUMPS solve interface + * Works only with sparse or skyline matrices + */ + template + bool MUMPS_solve(const MAT &A, const VECTX &X_, const VECTB &B, + bool sym = false, bool distributed = false) { + VECTX &X = const_cast(X_); + + typedef typename linalg_traits::value_type T; + typedef typename mumps_interf::value_type MUMPS_T; + GMM_ASSERT2(gmm::mat_nrows(A) == gmm::mat_ncols(A), "Non-square matrix"); + + std::vector rhs(gmm::vect_size(B)); gmm::copy(B, rhs); + + ij_sparse_matrix AA(A, sym); + + const int JOB_INIT = -1; + const int JOB_END = -2; + const int USE_COMM_WORLD = -987654; + + typename mumps_interf::MUMPS_STRUC_C id; + + int rank(0); +#ifdef GMM_USES_MPI + MPI_Comm_rank(MPI_COMM_WORLD, &rank); +#endif + + id.job = JOB_INIT; + id.par = 1; + id.sym = sym ? 2 : 0; + id.comm_fortran = USE_COMM_WORLD; + mumps_interf::mumps_c(id); + + if (rank == 0 || distributed) { + id.n = int(gmm::mat_nrows(A)); + if (distributed) { + id.nz_loc = int(AA.irn.size()); + id.irn_loc = &(AA.irn[0]); + id.jcn_loc = &(AA.jcn[0]); + id.a_loc = (MUMPS_T*)(&(AA.a[0])); + } else { + id.nz = int(AA.irn.size()); + id.irn = &(AA.irn[0]); + id.jcn = &(AA.jcn[0]); + id.a = (MUMPS_T*)(&(AA.a[0])); + } + if (rank == 0) + id.rhs = (MUMPS_T*)(&(rhs[0])); + } + + id.ICNTL(1) = -1; // output stream for error messages + id.ICNTL(2) = -1; // output stream for other messages + id.ICNTL(3) = -1; // output stream for global information + id.ICNTL(4) = 0; // verbosity level + + if (distributed) + id.ICNTL(5) = 0; // assembled input matrix (default) + + id.ICNTL(14) += 80; /* small boost to the workspace size as we have encountered some problem + who did not fit in the default settings of mumps.. + by default, ICNTL(14) = 15 or 20 + */ + //cout << "ICNTL(14): " << id.ICNTL(14) << "\n"; + + if (distributed) + id.ICNTL(18) = 3; // strategy for distributed input matrix + + // id.ICNTL(22) = 1; /* enables out-of-core support */ + + id.job = 6; + mumps_interf::mumps_c(id); + bool ok = mumps_error_check(id); + + id.job = JOB_END; + mumps_interf::mumps_c(id); + +#ifdef GMM_USES_MPI + MPI_Bcast(&(rhs[0]),id.n,gmm::mpi_type(T()),0,MPI_COMM_WORLD); +#endif + + gmm::copy(rhs, X); + + return ok; + + } + + + + /** MUMPS solve interface for distributed matrices + * Works only with sparse or skyline matrices + */ + template + bool MUMPS_distributed_matrix_solve(const MAT &A, const VECTX &X_, + const VECTB &B, bool sym = false) { + return MUMPS_solve(A, X_, B, sym, true); + } + + + + template + inline T real_or_complex(std::complex a) { return a.real(); } + template + inline T real_or_complex(T &a) { return a; } + + + /** Evaluate matrix determinant with MUMPS + * Works only with sparse or skyline matrices + */ + template ::value_type> + T MUMPS_determinant(const MAT &A, int &exponent, + bool sym = false, bool distributed = false) { + exponent = 0; + typedef typename mumps_interf::value_type MUMPS_T; + typedef typename number_traits::magnitude_type R; + GMM_ASSERT2(gmm::mat_nrows(A) == gmm::mat_ncols(A), "Non-square matrix"); + + ij_sparse_matrix AA(A, sym); + + const int JOB_INIT = -1; + const int JOB_END = -2; + const int USE_COMM_WORLD = -987654; + + typename mumps_interf::MUMPS_STRUC_C id; + + int rank(0); +#ifdef GMM_USES_MPI + MPI_Comm_rank(MPI_COMM_WORLD, &rank); +#endif + + id.job = JOB_INIT; + id.par = 1; + id.sym = sym ? 2 : 0; + id.comm_fortran = USE_COMM_WORLD; + mumps_interf::mumps_c(id); + + if (rank == 0 || distributed) { + id.n = int(gmm::mat_nrows(A)); + if (distributed) { + id.nz_loc = int(AA.irn.size()); + id.irn_loc = &(AA.irn[0]); + id.jcn_loc = &(AA.jcn[0]); + id.a_loc = (MUMPS_T*)(&(AA.a[0])); + } else { + id.nz = int(AA.irn.size()); + id.irn = &(AA.irn[0]); + id.jcn = &(AA.jcn[0]); + id.a = (MUMPS_T*)(&(AA.a[0])); + } + } + + id.ICNTL(1) = -1; // output stream for error messages + id.ICNTL(2) = -1; // output stream for other messages + id.ICNTL(3) = -1; // output stream for global information + id.ICNTL(4) = 0; // verbosity level + + if (distributed) + id.ICNTL(5) = 0; // assembled input matrix (default) + +// id.ICNTL(14) += 80; // small boost to the workspace size + + if (distributed) + id.ICNTL(18) = 3; // strategy for distributed input matrix + + id.ICNTL(31) = 1; // only factorization, no solution to follow + id.ICNTL(33) = 1; // request determinant calculation + + id.job = 4; // abalysis (job=1) + factorization (job=2) + mumps_interf::mumps_c(id); + mumps_error_check(id); + + T det = real_or_complex(std::complex(id.RINFOG(12),id.RINFOG(13))); + exponent = id.INFOG(34); + + id.job = JOB_END; + mumps_interf::mumps_c(id); + + return det; + } + +#undef ICNTL +#undef INFO +#undef INFOG +#undef RINFOG + +} + + +#endif // GMM_MUMPS_INTERFACE_H + +#endif // GMM_USES_MUMPS diff --git a/7.x/src/linear_algebra/gmm/gmm_algobase.h b/7.x/src/linear_algebra/gmm/gmm_algobase.h new file mode 100644 index 0000000..b07b6d9 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_algobase.h @@ -0,0 +1,223 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2000-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/** @file gmm_algobase.h + @author Yves Renard + @date September 28, 2000. + @brief Miscelleanous algorithms on containers. +*/ + +#ifndef GMM_ALGOBASE_H__ +#define GMM_ALGOBASE_H__ +#include "gmm_std.h" +#include "gmm_except.h" +#include + +namespace gmm { + + /* ********************************************************************* */ + /* Definitition de classes de comparaison. */ + /* retournant un int. */ + /* ********************************************************************* */ + + template + struct less { + inline int operator()(const T& x, const T& y) const + { return (x < y) ? -1 : ((y < x) ? 1 : 0); } + }; + + template<> struct less { + int operator()(int x, int y) const { return x-y; } }; + template<> struct less { + int operator()(char x, char y) const { return int(x-y); } }; + template<> struct less { + int operator()(short x, short y) const { return int(x-y); } }; + template<> struct less { + int operator()(unsigned char x, unsigned char y) const + { return int(x)-int(y); } + }; + + + template + struct greater { + inline int operator()(const T& x, const T& y) const + { return (y < x) ? -1 : ((x < y) ? 1 : 0); } + }; + + template<> struct greater { + int operator()(int x, int y) const { return y-x; } }; + template<> struct greater { + int operator()(char x, char y) const { return int(y-x); } }; + template<> struct greater { + int operator()(short x, short y) const { return int(y-x); } }; + template<> struct greater { + int operator()(unsigned char x, unsigned char y) const + { return int(y)-int(x); } + }; + + template inline T my_abs(T a) { return (a < T(0)) ? T(-a) : a; } + + template + struct approx_less { + double eps; + inline int operator()(const T &x, const T &y) const + { if (my_abs(x - y) <= eps) return 0; if (x < y) return -1; return 1; } + approx_less(double e = 1E-13) { eps = e; } + }; + + template + struct approx_greater { + double eps; + inline int operator()(const T &x, const T &y) const + { if (my_abs(x - y) <= eps) return 0; if (x > y) return -1; return 1; } + approx_greater(double e = 1E-13) { eps = e; } + }; + + template + int lexicographical_compare(ITER1 b1, const ITER1 &e1, + ITER2 b2, const ITER2 &e2, const COMP &c) { + int i; + for ( ; b1 != e1 && b2 != e2; ++b1, ++b2) + if ((i = c(*b1, *b2)) != 0) return i; + if (b1 != e1) return 1; + if (b2 != e2) return -1; + return 0; + } + + template > + struct lexicographical_less { + COMP c; + int operator()(const CONT &x, const CONT &y) const { + return gmm::lexicographical_compare(x.begin(), x.end(), + y.begin(), y.end(), c); + } + lexicographical_less(const COMP &d = COMP()) { c = d; } + }; + + template > + struct lexicographical_greater { + COMP c; + int operator()(const CONT &x, const CONT &y) const { + return -gmm::lexicographical_compare(x.begin(), x.end(), + y.begin(), y.end(), c); + } + lexicographical_greater(const COMP &d = COMP()) { c = d; } + }; + + + /* ********************************************************************* */ + /* "Virtual" iterators on sequences. */ + /* The class T represent a class of sequence. */ + /* ********************************************************************* */ + + template struct sequence_iterator { + + typedef T value_type; + typedef value_type* pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef std::forward_iterator_tag iterator_category; + + T Un; + + sequence_iterator(T U0 = T(0)) { Un = U0; } + + sequence_iterator &operator ++() + { ++Un; return *this; } + sequence_iterator operator ++(int) + { sequence_iterator tmp = *this; (*this)++; return tmp; } + + const_reference operator *() const { return Un; } + reference operator *() { return Un; } + + bool operator ==(const sequence_iterator &i) const { return (i.Un==Un);} + bool operator !=(const sequence_iterator &i) const { return (i.Un!=Un);} + }; + + /* ********************************************************************* */ + /* generic algorithms. */ + /* ********************************************************************* */ + + template + ITER2 copy_n(ITER1 first, SIZE count, ITER2 result) { + for ( ; count > 0; --count, ++first, ++result) *result = *first; + return result; + } + + template + typename std::iterator_traits::value_type + mean_value(ITER first, const ITER &last) { + GMM_ASSERT2(first != last, "mean value of empty container"); + size_t n = 1; + typename std::iterator_traits::value_type res = *first++; + while (first != last) { res += *first; ++first; ++n; } + res /= float(n); + return res; + } + + template + typename CONT::value_type + mean_value(const CONT &c) { return mean_value(c.begin(), c.end()); } + + template /* hum ... */ + void minmax_box(typename std::iterator_traits::value_type &pmin, + typename std::iterator_traits::value_type &pmax, + ITER first, const ITER &last) { + typedef typename std::iterator_traits::value_type PT; + if (first != last) { pmin = pmax = *first; ++first; } + while (first != last) { + typename PT::const_iterator b = (*first).begin(), e = (*first).end(); + typename PT::iterator b1 = pmin.begin(), b2 = pmax.begin(); + while (b != e) + { *b1 = std::min(*b1, *b); *b2 = std::max(*b2, *b); ++b; ++b1; ++b2; } + } + } + + template struct sorted_indexes_aux { + const VEC &v; + public: + sorted_indexes_aux(const VEC& v_) : v(v_) {} + template + bool operator()(const IDX &ia, const IDX &ib) const + { return v[ia] < v[ib]; } + }; + + template + void sorted_indexes(const VEC &v, IVEC &iv) { + iv.clear(); iv.resize(v.size()); + for (size_t i=0; i < v.size(); ++i) iv[i] = i; + std::sort(iv.begin(), iv.end(), sorted_indexes_aux(v)); + } + +} + + +#endif /* GMM_ALGOBASE_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_arch_config.h b/7.x/src/linear_algebra/gmm/gmm_arch_config.h new file mode 100644 index 0000000..8d3ce66 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_arch_config.h @@ -0,0 +1,7 @@ +# ifndef _SRC_GMM_GMM_ARCH_CONFIG_H +#define _SRC_GMM_GMM_ARCH_CONFIG_H 1 +// enable the following line for OpenMP support +// #define GMM_HAVE_OPENMP +// +/* once: _SRC_GMM_GMM_ARCH_CONFIG_H */ +#endif diff --git a/7.x/src/linear_algebra/gmm/gmm_blas.h b/7.x/src/linear_algebra/gmm/gmm_blas.h new file mode 100644 index 0000000..e41b5da --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_blas.h @@ -0,0 +1,2287 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_blas.h + @author Yves Renard + @date October 13, 2002. + @brief Basic linear algebra functions. +*/ + +#ifndef GMM_BLAS_H__ +#define GMM_BLAS_H__ + +#include "gmm_scaled.h" +#include "gmm_transposed.h" +#include "gmm_conjugated.h" + +namespace gmm { + + /* ******************************************************************** */ + /* */ + /* Generic algorithms */ + /* */ + /* ******************************************************************** */ + + + /* ******************************************************************** */ + /* Miscellaneous */ + /* ******************************************************************** */ + + /** clear (fill with zeros) a vector or matrix. */ + template inline void clear(L &l) + { linalg_traits::do_clear(l); } + /** @cond DOXY_SHOW_ALL_FUNCTIONS + skip all these redundant definitions in doxygen documentation.. + */ + template inline void clear(const L &l) + { linalg_traits::do_clear(linalg_const_cast(l)); } + + ///@endcond + /** count the number of non-zero entries of a vector or matrix. */ template inline size_type nnz(const L& l) + { return nnz(l, typename linalg_traits::linalg_type()); } + + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template inline size_type nnz(const L& l, abstract_vector) { + auto it = vect_const_begin(l), ite = vect_const_end(l); + size_type res(0); + for (; it != ite; ++it) ++res; + return res; + } + + template inline size_type nnz(const L& l, abstract_matrix) { + return nnz(l, typename principal_orientation_type::sub_orientation>::potype()); + } + + template inline size_type nnz(const L& l, row_major) { + size_type res(0); + for (size_type i = 0; i < mat_nrows(l); ++i) + res += nnz(mat_const_row(l, i)); + return res; + } + + template inline size_type nnz(const L& l, col_major) { + size_type res(0); + for (size_type i = 0; i < mat_ncols(l); ++i) + res += nnz(mat_const_col(l, i)); + return res; + } + + ///@endcond + + + /** fill a vector or matrix with x. */ + template inline + void fill(L& l, typename gmm::linalg_traits::value_type x) { + typedef typename gmm::linalg_traits::value_type T; + if (x == T(0)) gmm::clear(l); + fill(l, x, typename linalg_traits::linalg_type()); + } + + template inline + void fill(const L& l, typename gmm::linalg_traits::value_type x) { + fill(linalg_const_cast(l), x); + } + + template inline // to be optimized for dense vectors ... + void fill(L& l, typename gmm::linalg_traits::value_type x, + abstract_vector) { + for (size_type i = 0; i < vect_size(l); ++i) l[i] = x; + } + + template inline // to be optimized for dense matrices ... + void fill(L& l, typename gmm::linalg_traits::value_type x, + abstract_matrix) { + for (size_type i = 0; i < mat_nrows(l); ++i) + for (size_type j = 0; j < mat_ncols(l); ++j) + l(i,j) = x; + } + + /** fill a vector or matrix with random value (uniform [-1,1]). */ + template inline void fill_random(L& l) + { fill_random(l, typename linalg_traits::linalg_type()); } + + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template inline void fill_random(const L& l) { + fill_random(linalg_const_cast(l), + typename linalg_traits::linalg_type()); + } + + template inline void fill_random(L& l, abstract_vector) { + for (size_type i = 0; i < vect_size(l); ++i) + l[i] = gmm::random(typename linalg_traits::value_type()); + } + + template inline void fill_random(L& l, abstract_matrix) { + for (size_type i = 0; i < mat_nrows(l); ++i) + for (size_type j = 0; j < mat_ncols(l); ++j) + l(i,j) = gmm::random(typename linalg_traits::value_type()); + } + + ///@endcond + /** fill a vector or matrix with random value. + @param l a vector or matrix. + @param cfill probability of a non-zero value. + */ + template inline void fill_random(L& l, double cfill) + { fill_random(l, cfill, typename linalg_traits::linalg_type()); } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template inline void fill_random(const L& l, double cfill) { + fill_random(linalg_const_cast(l), cfill, + typename linalg_traits::linalg_type()); + } + + template inline + void fill_random(L& l, double cfill, abstract_vector) { + typedef typename linalg_traits::value_type T; + size_type ntot = std::min(vect_size(l), + size_type(double(vect_size(l))*cfill) + 1); + for (size_type nb = 0; nb < ntot;) { + size_type i = gmm::irandom(vect_size(l)); + if (l[i] == T(0)) { + l[i] = gmm::random(typename linalg_traits::value_type()); + ++nb; + } + } + } + + template inline + void fill_random(L& l, double cfill, abstract_matrix) { + fill_random(l, cfill, typename principal_orientation_type::sub_orientation>::potype()); + } + + template inline + void fill_random(L& l, double cfill, row_major) { + for (size_type i=0; i < mat_nrows(l); ++i) fill_random(mat_row(l,i),cfill); + } + + template inline + void fill_random(L& l, double cfill, col_major) { + for (size_type j=0; j < mat_ncols(l); ++j) fill_random(mat_col(l,j),cfill); + } + + /* resize a vector */ + template inline + void resize(V &v, size_type n, linalg_false) + { linalg_traits::resize(v, n); } + + template inline + void resize(V &, size_type , linalg_modifiable) + { GMM_ASSERT1(false, "You cannot resize a reference"); } + + template inline + void resize(V &, size_type , linalg_const) + { GMM_ASSERT1(false, "You cannot resize a reference"); } + + ///@endcond + /** resize a vector. */ + template inline + void resize(V &v, size_type n) { + resize(v, n, typename linalg_traits::is_reference()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + /** resize a matrix **/ + template inline + void resize(M &v, size_type m, size_type n, linalg_false) { + linalg_traits::resize(v, m, n); + } + + template inline + void resize(M &, size_type, size_type, linalg_modifiable) + { GMM_ASSERT1(false, "You cannot resize a reference"); } + + template inline + void resize(M &, size_type, size_type, linalg_const) + { GMM_ASSERT1(false, "You cannot resize a reference"); } + + ///@endcond + /** resize a matrix */ + template inline + void resize(M &v, size_type m, size_type n) + { resize(v, m, n, typename linalg_traits::is_reference()); } + ///@cond + + template inline + void reshape(M &v, size_type m, size_type n, linalg_false) + { linalg_traits::reshape(v, m, n); } + + template inline + void reshape(M &, size_type, size_type, linalg_modifiable) + { GMM_ASSERT1(false, "You cannot reshape a reference"); } + + template inline + void reshape(M &, size_type, size_type, linalg_const) + { GMM_ASSERT1(false, "You cannot reshape a reference"); } + + ///@endcond + /** reshape a matrix */ + template inline + void reshape(M &v, size_type m, size_type n) + { reshape(v, m, n, typename linalg_traits::is_reference()); } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + + /* ******************************************************************** */ + /* Scalar product */ + /* ******************************************************************** */ + + ///@endcond + /** scalar product between two vectors */ + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2) { + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch, " + << vect_size(v1) << " !=" << vect_size(v2)); + return vect_sp(v1, v2, + typename linalg_traits::storage_type(), + typename linalg_traits::storage_type()); + } + + /** scalar product between two vectors, using a matrix. + @param ps the matrix of the scalar product. + @param v1 the first vector + @param v2 the second vector + */ + template inline + typename strongest_value_type3::value_type + vect_sp(const MATSP &ps, const V1 &v1, const V2 &v2) { + return vect_sp_with_mat(ps, v1, v2, + typename linalg_traits::sub_orientation()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template inline + typename strongest_value_type3::value_type + vect_sp_with_mat(const MATSP &ps, const V1 &v1, const V2 &v2, row_major) { + return vect_sp_with_matr(ps, v1, v2, + typename linalg_traits::storage_type()); + } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_matr(const MATSP &ps, const V1 &v1, const V2 &v2, + abstract_sparse) { + GMM_ASSERT2(vect_size(v1) == mat_ncols(ps) && + vect_size(v2) == mat_nrows(ps), "dimensions mismatch"); + size_type nr = mat_nrows(ps); + typename linalg_traits::const_iterator + it = vect_const_begin(v2), ite = vect_const_end(v2); + typename strongest_value_type3::value_type res(0); + for (; it != ite; ++it) + res += vect_sp(mat_const_row(ps, it.index()), v1)* (*it); + return res; + } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_matr(const MATSP &ps, const V1 &v1, const V2 &v2, + abstract_skyline) + { return vect_sp_with_matr(ps, v1, v2, abstract_sparse()); } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_matr(const MATSP &ps, const V1 &v1, const V2 &v2, + abstract_dense) { + GMM_ASSERT2(vect_size(v1) == mat_ncols(ps) && + vect_size(v2) == mat_nrows(ps), "dimensions mismatch"); + typename linalg_traits::const_iterator + it = vect_const_begin(v2), ite = vect_const_end(v2); + typename strongest_value_type3::value_type res(0); + for (size_type i = 0; it != ite; ++i, ++it) + res += vect_sp(mat_const_row(ps, i), v1) * (*it); + return res; + } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_mat(const MATSP &ps, const V1 &v1,const V2 &v2,row_and_col) + { return vect_sp_with_mat(ps, v1, v2, row_major()); } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_mat(const MATSP &ps, const V1 &v1, const V2 &v2,col_major){ + return vect_sp_with_matc(ps, v1, v2, + typename linalg_traits::storage_type()); + } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_matc(const MATSP &ps, const V1 &v1, const V2 &v2, + abstract_sparse) { + GMM_ASSERT2(vect_size(v1) == mat_ncols(ps) && + vect_size(v2) == mat_nrows(ps), "dimensions mismatch"); + typename linalg_traits::const_iterator + it = vect_const_begin(v1), ite = vect_const_end(v1); + typename strongest_value_type3::value_type res(0); + for (; it != ite; ++it) + res += vect_sp(mat_const_col(ps, it.index()), v2) * (*it); + return res; + } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_matc(const MATSP &ps, const V1 &v1, const V2 &v2, + abstract_skyline) + { return vect_sp_with_matc(ps, v1, v2, abstract_sparse()); } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_matc(const MATSP &ps, const V1 &v1, const V2 &v2, + abstract_dense) { + GMM_ASSERT2(vect_size(v1) == mat_ncols(ps) && + vect_size(v2) == mat_nrows(ps), "dimensions mismatch"); + typename linalg_traits::const_iterator + it = vect_const_begin(v1), ite = vect_const_end(v1); + typename strongest_value_type3::value_type res(0); + for (size_type i = 0; it != ite; ++i, ++it) + res += vect_sp(mat_const_col(ps, i), v2) * (*it); + return res; + } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_mat(const MATSP &ps, const V1 &v1,const V2 &v2,col_and_row) + { return vect_sp_with_mat(ps, v1, v2, col_major()); } + + template inline + typename strongest_value_type3::value_type + vect_sp_with_mat(const MATSP &ps, const V1 &v1, const V2 &v2, + abstract_null_type) { + typename temporary_vector::vector_type w(mat_nrows(ps)); + GMM_WARNING2("Warning, a temporary is used in scalar product\n"); + mult(ps, v1, w); + return vect_sp(w, v2); + } + + template inline + typename strongest_numeric_type::value_type, + typename std::iterator_traits::value_type>::T + vect_sp_dense_(IT1 it, IT1 ite, IT2 it2) { + typename strongest_numeric_type::value_type, + typename std::iterator_traits::value_type>::T res(0); + for (; it != ite; ++it, ++it2) res += (*it) * (*it2); + return res; + } + + template inline + typename strongest_numeric_type::value_type, + typename linalg_traits::value_type>::T + vect_sp_sparse_(IT1 it, IT1 ite, const V &v) { + typename strongest_numeric_type::value_type, + typename linalg_traits::value_type>::T res(0); + for (; it != ite; ++it) res += (*it) * v[it.index()]; + return res; + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2, abstract_dense, abstract_dense) { + return vect_sp_dense_(vect_const_begin(v1), vect_const_end(v1), + vect_const_begin(v2)); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2, abstract_skyline, abstract_dense) { + typename linalg_traits::const_iterator it1 = vect_const_begin(v1), + ite = vect_const_end(v1); + typename linalg_traits::const_iterator it2 = vect_const_begin(v2); + return vect_sp_dense_(it1, ite, it2 + it1.index()); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2, abstract_dense, abstract_skyline) { + typename linalg_traits::const_iterator it1 = vect_const_begin(v2), + ite = vect_const_end(v2); + typename linalg_traits::const_iterator it2 = vect_const_begin(v1); + return vect_sp_dense_(it1, ite, it2 + it1.index()); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2, abstract_skyline, abstract_skyline) { + typedef typename strongest_value_type::value_type T; + auto it1 = vect_const_begin(v1), ite1 = vect_const_end(v1); + auto it2 = vect_const_begin(v2), ite2 = vect_const_end(v2); + size_type n = std::min(ite1.index(), ite2.index()); + size_type l = std::max(it1.index(), it2.index()); + + if (l < n) { + size_type m = l - it1.index(), p = l - it2.index(), q = m + n - l; + return vect_sp_dense_(it1+m, it1+q, it2 + p); + } + return T(0); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2,abstract_sparse,abstract_dense) { + return vect_sp_sparse_(vect_const_begin(v1), vect_const_end(v1), v2); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2, abstract_sparse, abstract_skyline) { + return vect_sp_sparse_(vect_const_begin(v1), vect_const_end(v1), v2); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2, abstract_skyline, abstract_sparse) { + return vect_sp_sparse_(vect_const_begin(v2), vect_const_end(v2), v1); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2, abstract_dense,abstract_sparse) { + return vect_sp_sparse_(vect_const_begin(v2), vect_const_end(v2), v1); + } + + + template inline + typename strongest_value_type::value_type + vect_sp_sparse_sparse(const V1 &v1, const V2 &v2, linalg_true) { + typename linalg_traits::const_iterator it1 = vect_const_begin(v1), + ite1 = vect_const_end(v1); + typename linalg_traits::const_iterator it2 = vect_const_begin(v2), + ite2 = vect_const_end(v2); + typename strongest_value_type::value_type res(0); + + while (it1 != ite1 && it2 != ite2) { + if (it1.index() == it2.index()) + { res += (*it1) * *it2; ++it1; ++it2; } + else if (it1.index() < it2.index()) ++it1; else ++it2; + } + return res; + } + + template inline + typename strongest_value_type::value_type + vect_sp_sparse_sparse(const V1 &v1, const V2 &v2, linalg_false) { + return vect_sp_sparse_(vect_const_begin(v1), vect_const_end(v1), v2); + } + + template inline + typename strongest_value_type::value_type + vect_sp(const V1 &v1, const V2 &v2,abstract_sparse,abstract_sparse) { + return vect_sp_sparse_sparse(v1, v2, + typename linalg_and::index_sorted, + typename linalg_traits::index_sorted>::bool_type()); + } + + /* ******************************************************************** */ + /* Hermitian product */ + /* ******************************************************************** */ + ///@endcond + /** Hermitian product. */ + template + inline typename strongest_value_type::value_type + vect_hp(const V1 &v1, const V2 &v2) + { return vect_sp(v1, conjugated(v2)); } + + /** Hermitian product with a matrix. */ + template inline + typename strongest_value_type3::value_type + vect_hp(const MATSP &ps, const V1 &v1, const V2 &v2) { + return vect_sp(ps, v1, gmm::conjugated(v2)); + } + + /* ******************************************************************** */ + /* Trace of a matrix */ + /* ******************************************************************** */ + + /** Trace of a matrix */ + template + typename linalg_traits::value_type + mat_trace(const M &m) { + typedef typename linalg_traits::value_type T; + T res(0); + for (size_type i = 0; i < std::min(mat_nrows(m), mat_ncols(m)); ++i) + res += m(i,i); + return res; + } + + /* ******************************************************************** */ + /* Euclidean norm */ + /* ******************************************************************** */ + + /** squared Euclidean norm of a vector. */ + template + typename number_traits::value_type> + ::magnitude_type + vect_norm2_sqr(const V &v) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + auto it = vect_const_begin(v), ite = vect_const_end(v); + R res(0); + for (; it != ite; ++it) res += gmm::abs_sqr(*it); + return res; + } + + /** Euclidean norm of a vector. */ + template inline + typename number_traits::value_type> + ::magnitude_type + vect_norm2(const V &v) + { return sqrt(vect_norm2_sqr(v)); } + + + /** squared Euclidean distance between two vectors */ + template inline + typename number_traits::value_type> + ::magnitude_type + vect_dist2_sqr(const V1 &v1, const V2 &v2) { // not fully optimized + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + auto it1 = vect_const_begin(v1), ite1 = vect_const_end(v1); + auto it2 = vect_const_begin(v2), ite2 = vect_const_end(v2); + size_type k1(0), k2(0); + R res(0); + while (it1 != ite1 && it2 != ite2) { + size_type i1 = index_of_it(it1, k1, + typename linalg_traits::storage_type()); + size_type i2 = index_of_it(it2, k2, + typename linalg_traits::storage_type()); + + if (i1 == i2) { + res += gmm::abs_sqr(*it2 - *it1); ++it1; ++k1; ++it2; ++k2; + } + else if (i1 < i2) { + res += gmm::abs_sqr(*it1); ++it1; ++k1; + } + else { + res += gmm::abs_sqr(*it2); ++it2; ++k2; + } + } + while (it1 != ite1) { res += gmm::abs_sqr(*it1); ++it1; } + while (it2 != ite2) { res += gmm::abs_sqr(*it2); ++it2; } + return res; + } + + /** Euclidean distance between two vectors */ + template inline + typename number_traits::value_type> + ::magnitude_type + vect_dist2(const V1 &v1, const V2 &v2) + { return sqrt(vect_dist2_sqr(v1, v2)); } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template + typename number_traits::value_type> + ::magnitude_type + mat_euclidean_norm_sqr(const M &m, row_major) { + typename number_traits::value_type> + ::magnitude_type res(0); + for (size_type i = 0; i < mat_nrows(m); ++i) + res += vect_norm2_sqr(mat_const_row(m, i)); + return res; + } + + template + typename number_traits::value_type> + ::magnitude_type + mat_euclidean_norm_sqr(const M &m, col_major) { + typename number_traits::value_type> + ::magnitude_type res(0); + for (size_type i = 0; i < mat_ncols(m); ++i) + res += vect_norm2_sqr(mat_const_col(m, i)); + return res; + } + ///@endcond + /** squared Euclidean norm of a matrix. */ + template inline + typename number_traits::value_type> + ::magnitude_type + mat_euclidean_norm_sqr(const M &m) { + return mat_euclidean_norm_sqr(m, + typename principal_orientation_type::sub_orientation>::potype()); + } + + /** Euclidean norm of a matrix. */ + template inline + typename number_traits::value_type> + ::magnitude_type + mat_euclidean_norm(const M &m) + { return gmm::sqrt(mat_euclidean_norm_sqr(m)); } + + /* ******************************************************************** */ + /* vector norm1 */ + /* ******************************************************************** */ + /** 1-norm of a vector */ + template + typename number_traits::value_type> + ::magnitude_type + vect_norm1(const V &v) { + auto it = vect_const_begin(v), ite = vect_const_end(v); + typename number_traits::value_type> + ::magnitude_type res(0); + for (; it != ite; ++it) res += gmm::abs(*it); + return res; + } + + /** 1-distance between two vectors */ + template inline + typename number_traits::value_type> + ::magnitude_type + vect_dist1(const V1 &v1, const V2 &v2) { // not fully optimized + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + auto it1 = vect_const_begin(v1), ite1 = vect_const_end(v1); + auto it2 = vect_const_begin(v2), ite2 = vect_const_end(v2); + size_type k1(0), k2(0); + R res(0); + while (it1 != ite1 && it2 != ite2) { + size_type i1 = index_of_it(it1, k1, + typename linalg_traits::storage_type()); + size_type i2 = index_of_it(it2, k2, + typename linalg_traits::storage_type()); + + if (i1 == i2) { + res += gmm::abs(*it2 - *it1); ++it1; ++k1; ++it2; ++k2; + } + else if (i1 < i2) { + res += gmm::abs(*it1); ++it1; ++k1; + } + else { + res += gmm::abs(*it2); ++it2; ++k2; + } + } + while (it1 != ite1) { res += gmm::abs(*it1); ++it1; } + while (it2 != ite2) { res += gmm::abs(*it2); ++it2; } + return res; + } + + /* ******************************************************************** */ + /* vector Infinity norm */ + /* ******************************************************************** */ + /** Infinity norm of a vector. */ + template + typename number_traits::value_type> + ::magnitude_type + vect_norminf(const V &v) { + auto it = vect_const_begin(v), ite = vect_const_end(v); + typename number_traits::value_type> + ::magnitude_type res(0); + for (; it != ite; ++it) res = std::max(res, gmm::abs(*it)); + return res; + } + + /** Infinity distance between two vectors */ + template inline + typename number_traits::value_type> + ::magnitude_type + vect_distinf(const V1 &v1, const V2 &v2) { // not fully optimized + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + auto it1 = vect_const_begin(v1), ite1 = vect_const_end(v1); + auto it2 = vect_const_begin(v2), ite2 = vect_const_end(v2); + size_type k1(0), k2(0); + R res(0); + while (it1 != ite1 && it2 != ite2) { + size_type i1 = index_of_it(it1, k1, + typename linalg_traits::storage_type()); + size_type i2 = index_of_it(it2, k2, + typename linalg_traits::storage_type()); + + if (i1 == i2) { + res = std::max(res, gmm::abs(*it2 - *it1)); ++it1; ++k1; ++it2; ++k2; + } + else if (i1 < i2) { + res = std::max(res, gmm::abs(*it1)); ++it1; ++k1; + } + else { + res = std::max(res, gmm::abs(*it2)); ++it2; ++k2; + } + } + while (it1 != ite1) { res = std::max(res, gmm::abs(*it1)); ++it1; } + while (it2 != ite2) { res = std::max(res, gmm::abs(*it2)); ++it2; } + return res; + } + + /* ******************************************************************** */ + /* matrix norm1 */ + /* ******************************************************************** */ + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template + typename number_traits::value_type> + ::magnitude_type + mat_norm1(const M &m, col_major) { + typename number_traits::value_type> + ::magnitude_type res(0); + for (size_type i = 0; i < mat_ncols(m); ++i) + res = std::max(res, vect_norm1(mat_const_col(m,i))); + return res; + } + + template + typename number_traits::value_type> + ::magnitude_type + mat_norm1(const M &m, row_major) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + typedef typename linalg_traits::storage_type store_type; + + std::vector aux(mat_ncols(m)); + for (size_type i = 0; i < mat_nrows(m); ++i) { + typename linalg_traits::const_sub_row_type row = mat_const_row(m, i); + auto it = vect_const_begin(row), ite = vect_const_end(row); + for (size_type k = 0; it != ite; ++it, ++k) + aux[index_of_it(it, k, store_type())] += gmm::abs(*it); + } + return vect_norminf(aux); + } + + template + typename number_traits::value_type> + ::magnitude_type + mat_norm1(const M &m, col_and_row) + { return mat_norm1(m, col_major()); } + + template + typename number_traits::value_type> + ::magnitude_type + mat_norm1(const M &m, row_and_col) + { return mat_norm1(m, col_major()); } + ///@endcond + /** 1-norm of a matrix */ + template + typename number_traits::value_type> + ::magnitude_type + mat_norm1(const M &m) { + return mat_norm1(m, typename linalg_traits::sub_orientation()); + } + + + /* ******************************************************************** */ + /* matrix Infinity norm */ + /* ******************************************************************** */ + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template + typename number_traits::value_type> + ::magnitude_type + mat_norminf(const M &m, row_major) { + typename number_traits::value_type> + ::magnitude_type res(0); + for (size_type i = 0; i < mat_nrows(m); ++i) + res = std::max(res, vect_norm1(mat_const_row(m,i))); + return res; + } + + template + typename number_traits::value_type> + ::magnitude_type + mat_norminf(const M &m, col_major) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + typedef typename linalg_traits::storage_type store_type; + + std::vector aux(mat_nrows(m)); + for (size_type i = 0; i < mat_ncols(m); ++i) { + typename linalg_traits::const_sub_col_type col = mat_const_col(m, i); + auto it = vect_const_begin(col), ite = vect_const_end(col); + for (size_type k = 0; it != ite; ++it, ++k) + aux[index_of_it(it, k, store_type())] += gmm::abs(*it); + } + return vect_norminf(aux); + } + + template + typename number_traits::value_type> + ::magnitude_type + mat_norminf(const M &m, col_and_row) + { return mat_norminf(m, row_major()); } + + template + typename number_traits::value_type> + ::magnitude_type + mat_norminf(const M &m, row_and_col) + { return mat_norminf(m, row_major()); } + ///@endcond + /** infinity-norm of a matrix.*/ + template + typename number_traits::value_type> + ::magnitude_type + mat_norminf(const M &m) { + return mat_norminf(m, typename linalg_traits::sub_orientation()); + } + + /* ******************************************************************** */ + /* Max norm for matrices */ + /* ******************************************************************** */ + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template + typename number_traits::value_type> + ::magnitude_type + mat_maxnorm(const M &m, row_major) { + typename number_traits::value_type> + ::magnitude_type res(0); + for (size_type i = 0; i < mat_nrows(m); ++i) + res = std::max(res, vect_norminf(mat_const_row(m,i))); + return res; + } + + template + typename number_traits::value_type> + ::magnitude_type + mat_maxnorm(const M &m, col_major) { + typename number_traits::value_type> + ::magnitude_type res(0); + for (size_type i = 0; i < mat_ncols(m); ++i) + res = std::max(res, vect_norminf(mat_const_col(m,i))); + return res; + } + ///@endcond + /** max-norm of a matrix. */ + template + typename number_traits::value_type> + ::magnitude_type + mat_maxnorm(const M &m) { + return mat_maxnorm(m, + typename principal_orientation_type::sub_orientation>::potype()); + } + + /* ******************************************************************** */ + /* Clean */ + /* ******************************************************************** */ + /** Clean a vector or matrix (replace near-zero entries with zeroes). */ + + template inline void clean(L &l, double threshold); + + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template + void clean(L &l, double threshold, abstract_dense, T) { + typedef typename number_traits::magnitude_type R; + auto it = vect_begin(l), ite = vect_end(l); + for (; it != ite; ++it) + if (gmm::abs(*it) < R(threshold)) *it = T(0); + } + + template + void clean(L &l, double threshold, abstract_skyline, T) + { gmm::clean(l, threshold, abstract_dense(), T()); } + + template + void clean(L &l, double threshold, abstract_sparse, T) { + typedef typename number_traits::magnitude_type R; + auto it = vect_begin(l), ite = vect_end(l); + std::vector ind; + for (; it != ite; ++it) + if (gmm::abs(*it) < R(threshold)) ind.push_back(it.index()); + for (size_type i = 0; i < ind.size(); ++i) l[ind[i]] = T(0); + } + + template + void clean(L &l, double threshold, abstract_dense, std::complex) { + auto it = vect_begin(l), ite = vect_end(l); + for (; it != ite; ++it){ + if (gmm::abs((*it).real()) < T(threshold)) + *it = std::complex(T(0), (*it).imag()); + if (gmm::abs((*it).imag()) < T(threshold)) + *it = std::complex((*it).real(), T(0)); + } + } + + template + void clean(L &l, double threshold, abstract_skyline, std::complex) + { gmm::clean(l, threshold, abstract_dense(), std::complex()); } + + template + void clean(L &l, double threshold, abstract_sparse, std::complex) { + auto it = vect_begin(l), ite = vect_end(l); + std::vector ind; + for (; it != ite; ++it) { + bool r = (gmm::abs((*it).real()) < T(threshold)); + bool i = (gmm::abs((*it).imag()) < T(threshold)); + if (r && i) ind.push_back(it.index()); + else if (r) *it = std::complex(T(0), (*it).imag()); + else if (i) *it = std::complex((*it).real(), T(0)); + } + for (size_type i = 0; i < ind.size(); ++i) + l[ind[i]] = std::complex(T(0),T(0)); + } + + template inline void clean(L &l, double threshold, + abstract_vector) { + gmm::clean(l, threshold, typename linalg_traits::storage_type(), + typename linalg_traits::value_type()); + } + + template inline void clean(const L &l, double threshold); + + template void clean(L &l, double threshold, row_major) { + for (size_type i = 0; i < mat_nrows(l); ++i) + gmm::clean(mat_row(l, i), threshold); + } + + template void clean(L &l, double threshold, col_major) { + for (size_type i = 0; i < mat_ncols(l); ++i) + gmm::clean(mat_col(l, i), threshold); + } + + template inline void clean(L &l, double threshold, + abstract_matrix) { + gmm::clean(l, threshold, + typename principal_orientation_type::sub_orientation>::potype()); + } + + template inline void clean(L &l, double threshold) + { clean(l, threshold, typename linalg_traits::linalg_type()); } + + template inline void clean(const L &l, double threshold) + { gmm::clean(linalg_const_cast(l), threshold); } + + /* ******************************************************************** */ + /* Copy */ + /* ******************************************************************** */ + ///@endcond + /** Copy vectors or matrices. + @param l1 source vector or matrix. + @param l2 destination. + */ + template inline + void copy(const L1& l1, L2& l2) { + if ((const void *)(&l1) != (const void *)(&l2)) { + if (same_origin(l1,l2)) + GMM_WARNING2("Warning : a conflict is possible in copy\n"); + + copy(l1, l2, typename linalg_traits::linalg_type(), + typename linalg_traits::linalg_type()); + } + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template inline + void copy(const L1& l1, const L2& l2) { copy(l1, linalg_const_cast(l2)); } + + template inline + void copy(const L1& l1, L2& l2, abstract_vector, abstract_vector) { + GMM_ASSERT2(vect_size(l1) == vect_size(l2), "dimensions mismatch, " + << vect_size(l1) << " !=" << vect_size(l2)); + copy_vect(l1, l2, typename linalg_traits::storage_type(), + typename linalg_traits::storage_type()); + } + + template inline + void copy(const L1& l1, L2& l2, abstract_matrix, abstract_matrix) { + size_type m = mat_nrows(l1), n = mat_ncols(l1); + if (!m || !n) return; + GMM_ASSERT2(n==mat_ncols(l2) && m==mat_nrows(l2), "dimensions mismatch"); + copy_mat(l1, l2, typename linalg_traits::sub_orientation(), + typename linalg_traits::sub_orientation()); + } + + template inline + void copy_vect(const V1 &v1, const V2 &v2, C1, C2) + { copy_vect(v1, const_cast(v2), C1(), C2()); } + + + template + void copy_mat_by_row(const L1& l1, L2& l2) { + size_type nbr = mat_nrows(l1); + for (size_type i = 0; i < nbr; ++i) + copy(mat_const_row(l1, i), mat_row(l2, i)); + } + + template + void copy_mat_by_col(const L1 &l1, L2 &l2) { + size_type nbc = mat_ncols(l1); + for (size_type i = 0; i < nbc; ++i) { + copy(mat_const_col(l1, i), mat_col(l2, i)); + } + } + + template inline + void copy_mat(const L1& l1, L2& l2, row_major, row_major) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, row_major, row_and_col) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, row_and_col, row_and_col) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, row_and_col, row_major) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, col_and_row, row_major) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, row_major, col_and_row) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, col_and_row, row_and_col) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, row_and_col, col_and_row) + { copy_mat_by_row(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, col_major, col_major) + { copy_mat_by_col(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, col_major, col_and_row) + { copy_mat_by_col(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, col_major, row_and_col) + { copy_mat_by_col(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, row_and_col, col_major) + { copy_mat_by_col(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, col_and_row, col_major) + { copy_mat_by_col(l1, l2); } + + template inline + void copy_mat(const L1& l1, L2& l2, col_and_row, col_and_row) + { copy_mat_by_col(l1, l2); } + + template inline + void copy_mat_mixed_rc(const L1& l1, L2& l2, size_type i) { + copy_mat_mixed_rc(l1, l2, i, typename linalg_traits::storage_type()); + } + + template + void copy_mat_mixed_rc(const L1& l1, L2& l2, size_type i, abstract_sparse) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) + l2(i, it.index()) = *it; + } + + template + void copy_mat_mixed_rc(const L1& l1, L2& l2, size_type i, abstract_skyline) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) + l2(i, it.index()) = *it; + } + + template + void copy_mat_mixed_rc(const L1& l1, L2& l2, size_type i, abstract_dense) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (size_type j = 0; it != ite; ++it, ++j) l2(i, j) = *it; + } + + template inline + void copy_mat_mixed_cr(const L1& l1, L2& l2, size_type i) { + copy_mat_mixed_cr(l1, l2, i, typename linalg_traits::storage_type()); + } + + template + void copy_mat_mixed_cr(const L1& l1, L2& l2, size_type i, abstract_sparse) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) l2(it.index(), i) = *it; + } + + template + void copy_mat_mixed_cr(const L1& l1, L2& l2, size_type i, abstract_skyline) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) l2(it.index(), i) = *it; + } + + template + void copy_mat_mixed_cr(const L1& l1, L2& l2, size_type i, abstract_dense) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (size_type j = 0; it != ite; ++it, ++j) l2(j, i) = *it; + } + + template + void copy_mat(const L1& l1, L2& l2, row_major, col_major) { + clear(l2); + size_type nbr = mat_nrows(l1); + for (size_type i = 0; i < nbr; ++i) + copy_mat_mixed_rc(mat_const_row(l1, i), l2, i); + } + + template + void copy_mat(const L1& l1, L2& l2, col_major, row_major) { + clear(l2); + size_type nbc = mat_ncols(l1); + for (size_type i = 0; i < nbc; ++i) + copy_mat_mixed_cr(mat_const_col(l1, i), l2, i); + } + + template inline + void copy_vect(const L1 &l1, L2 &l2, abstract_dense, abstract_dense) { + std::copy(vect_const_begin(l1), vect_const_end(l1), vect_begin(l2)); + } + + template inline // to be optimised ? + void copy_vect(const L1 &l1, L2 &l2, abstract_skyline, abstract_skyline) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + while (it1 != ite1 && *it1 == typename linalg_traits::value_type(0)) + ++it1; + + if (ite1 - it1 > 0) { + clear(l2); + auto it2 = vect_begin(l2), ite2 = vect_end(l2); + while (*(ite1-1) == typename linalg_traits::value_type(0)) ite1--; + + if (it2 == ite2) { + l2[it1.index()] = *it1; ++it1; + l2[ite1.index()-1] = *(ite1-1); --ite1; + if (it1 < ite1) + { it2 = vect_begin(l2); ++it2; std::copy(it1, ite1, it2); } + } + else { + ptrdiff_t m = it1.index() - it2.index(); + if (m >= 0 && ite1.index() <= ite2.index()) + std::copy(it1, ite1, it2 + m); + else { + if (m < 0) l2[it1.index()] = *it1; + if (ite1.index() > ite2.index()) l2[ite1.index()-1] = *(ite1-1); + it2 = vect_begin(l2); ite2 = vect_end(l2); + m = it1.index() - it2.index(); + std::copy(it1, ite1, it2 + m); + } + } + } + } + + template + void copy_vect(const L1& l1, L2& l2, abstract_sparse, abstract_dense) { + clear(l2); + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) { l2[it.index()] = *it; } + } + + template + void copy_vect(const L1& l1, L2& l2, abstract_sparse, abstract_skyline) { + clear(l2); + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) l2[it.index()] = *it; + } + + template + void copy_vect(const L1& l1, L2& l2, abstract_skyline, abstract_dense) { + typedef typename linalg_traits::value_type T; + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + if (it == ite) + gmm::clear(l2); + else { + auto it2 = vect_begin(l2), ite2 = vect_end(l2); + + size_type i = it.index(), j; + for (j = 0; j < i; ++j, ++it2) *it2 = T(0); + for (; it != ite; ++it, ++it2) *it2 = *it; + for (; it2 != ite2; ++it2) *it2 = T(0); + } + } + + template + void copy_vect(const L1& l1, L2& l2, abstract_sparse, abstract_sparse) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + clear(l2); + // cout << "copy " << l1 << " of size " << vect_size(l1) << " nnz = " << nnz(l1) << endl; + for (; it != ite; ++it) { + // cout << "*it = " << *it << endl; + // cout << "it.index() = " << it.index() << endl; + if (*it != (typename linalg_traits::value_type)(0)) + l2[it.index()] = *it; + } + } + + template + void copy_vect(const L1& l1, L2& l2, abstract_dense, abstract_sparse) { + clear(l2); + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (size_type i = 0; it != ite; ++it, ++i) + if (*it != (typename linalg_traits::value_type)(0)) + l2[i] = *it; + } + + template // to be optimised ... + void copy_vect(const L1& l1, L2& l2, abstract_dense, abstract_skyline) { + clear(l2); + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (size_type i = 0; it != ite; ++it, ++i) + if (*it != (typename linalg_traits::value_type)(0)) + l2[i] = *it; + } + + + template + void copy_vect(const L1& l1, L2& l2, abstract_skyline, abstract_sparse) { + clear(l2); + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) + if (*it != (typename linalg_traits::value_type)(0)) + l2[it.index()] = *it; + } + + /* ******************************************************************** */ + /* Matrix and vector addition */ + /* algorithms are built in order to avoid some conflicts with */ + /* repeated arguments or with overlapping part of a same object. */ + /* In the latter case, conflicts are still possible. */ + /* ******************************************************************** */ + ///@endcond + /** Add two vectors or matrices + @param l1 + @param l2 contains on output, l2+l1. + */ + template inline + void add(const L1& l1, L2& l2) { + add_spec(l1, l2, typename linalg_traits::linalg_type()); + } + ///@cond + + template inline + void add(const L1& l1, const L2& l2) { add(l1, linalg_const_cast(l2)); } + + template inline + void add_spec(const L1& l1, L2& l2, abstract_vector) { + GMM_ASSERT2(vect_size(l1) == vect_size(l2), "dimensions mismatch, " + << vect_size(l1) << " !=" << vect_size(l2)); + add(l1, l2, typename linalg_traits::storage_type(), + typename linalg_traits::storage_type()); + } + + template inline + void add_spec(const L1& l1, L2& l2, abstract_matrix) { + GMM_ASSERT2(mat_nrows(l1)==mat_nrows(l2) && mat_ncols(l1)==mat_ncols(l2), + "dimensions mismatch l1 is " << mat_nrows(l1) << "x" + << mat_ncols(l1) << " and l2 is " << mat_nrows(l2) + << "x" << mat_ncols(l2)); + add(l1, l2, typename linalg_traits::sub_orientation(), + typename linalg_traits::sub_orientation()); + } + + template + void add(const L1& l1, L2& l2, row_major, row_major) { + auto it1 = mat_row_begin(l1), ite = mat_row_end(l1); + auto it2 = mat_row_begin(l2); + for ( ; it1 != ite; ++it1, ++it2) + add(linalg_traits::row(it1), linalg_traits::row(it2)); + } + + template + void add(const L1& l1, L2& l2, col_major, col_major) { + auto it1 = mat_col_const_begin(l1), ite = mat_col_const_end(l1); + typename linalg_traits::col_iterator it2 = mat_col_begin(l2); + for ( ; it1 != ite; ++it1, ++it2) + add(linalg_traits::col(it1), linalg_traits::col(it2)); + } + + template inline + void add_mat_mixed_rc(const L1& l1, L2& l2, size_type i) { + add_mat_mixed_rc(l1, l2, i, typename linalg_traits::storage_type()); + } + + template + void add_mat_mixed_rc(const L1& l1, L2& l2, size_type i, abstract_sparse) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) l2(i, it.index()) += *it; + } + + template + void add_mat_mixed_rc(const L1& l1, L2& l2, size_type i, abstract_skyline) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) l2(i, it.index()) += *it; + } + + template + void add_mat_mixed_rc(const L1& l1, L2& l2, size_type i, abstract_dense) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (size_type j = 0; it != ite; ++it, ++j) l2(i, j) += *it; + } + + template inline + void add_mat_mixed_cr(const L1& l1, L2& l2, size_type i) { + add_mat_mixed_cr(l1, l2, i, typename linalg_traits::storage_type()); + } + + template + void add_mat_mixed_cr(const L1& l1, L2& l2, size_type i, abstract_sparse) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) l2(it.index(), i) += *it; + } + + template + void add_mat_mixed_cr(const L1& l1, L2& l2, size_type i, abstract_skyline) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (; it != ite; ++it) l2(it.index(), i) += *it; + } + + template + void add_mat_mixed_cr(const L1& l1, L2& l2, size_type i, abstract_dense) { + auto it = vect_const_begin(l1), ite = vect_const_end(l1); + for (size_type j = 0; it != ite; ++it, ++j) l2(j, i) += *it; + } + + template + void add(const L1& l1, L2& l2, row_major, col_major) { + size_type nbr = mat_nrows(l1); + for (size_type i = 0; i < nbr; ++i) + add_mat_mixed_rc(mat_const_row(l1, i), l2, i); + } + + template + void add(const L1& l1, L2& l2, col_major, row_major) { + size_type nbc = mat_ncols(l1); + for (size_type i = 0; i < nbc; ++i) + add_mat_mixed_cr(mat_const_col(l1, i), l2, i); + } + + template inline + void add(const L1& l1, L2& l2, row_and_col, row_major) + { add(l1, l2, row_major(), row_major()); } + + template inline + void add(const L1& l1, L2& l2, row_and_col, row_and_col) + { add(l1, l2, row_major(), row_major()); } + + template inline + void add(const L1& l1, L2& l2, row_and_col, col_and_row) + { add(l1, l2, row_major(), row_major()); } + + template inline + void add(const L1& l1, L2& l2, col_and_row, row_and_col) + { add(l1, l2, row_major(), row_major()); } + + template inline + void add(const L1& l1, L2& l2, row_major, row_and_col) + { add(l1, l2, row_major(), row_major()); } + + template inline + void add(const L1& l1, L2& l2, col_and_row, row_major) + { add(l1, l2, row_major(), row_major()); } + + template inline + void add(const L1& l1, L2& l2, row_major, col_and_row) + { add(l1, l2, row_major(), row_major()); } + + template inline + void add(const L1& l1, L2& l2, row_and_col, col_major) + { add(l1, l2, col_major(), col_major()); } + + template inline + void add(const L1& l1, L2& l2, col_major, row_and_col) + { add(l1, l2, col_major(), col_major()); } + + template inline + void add(const L1& l1, L2& l2, col_and_row, col_major) + { add(l1, l2, col_major(), col_major()); } + + template inline + void add(const L1& l1, L2& l2, col_and_row, col_and_row) + { add(l1, l2, col_major(), col_major()); } + + template inline + void add(const L1& l1, L2& l2, col_major, col_and_row) + { add(l1, l2, col_major(), col_major()); } + + ///@endcond + /** Addition of two vectors/matrices + @param l1 + @param l2 + @param l3 contains l1+l2 on output + */ + template inline + void add(const L1& l1, const L2& l2, L3& l3) { + add_spec(l1, l2, l3, typename linalg_traits::linalg_type()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template inline + void add(const L1& l1, const L2& l2, const L3& l3) + { add(l1, l2, linalg_const_cast(l3)); } + + template inline + void add_spec(const L1& l1, const L2& l2, L3& l3, abstract_matrix) + { copy(l2, l3); add(l1, l3); } + + template inline + void add_spec(const L1& l1, const L2& l2, L3& l3, abstract_vector) { + GMM_ASSERT2(vect_size(l1) == vect_size(l2), "dimensions mismatch, " + << vect_size(l1) << " !=" << vect_size(l2)); + GMM_ASSERT2(vect_size(l1) == vect_size(l3), "dimensions mismatch, " + << vect_size(l1) << " !=" << vect_size(l3)); + if ((const void *)(&l1) == (const void *)(&l3)) + add(l2, l3); + else if ((const void *)(&l2) == (const void *)(&l3)) + add(l1, l3); + else + add(l1, l2, l3, typename linalg_traits::storage_type(), + typename linalg_traits::storage_type(), + typename linalg_traits::storage_type()); + } + + template + void add_full_(IT1 it1, IT2 it2, IT3 it3, IT3 ite) { + for (; it3 != ite; ++it3, ++it2, ++it1) *it3 = *it1 + *it2; + } + + template + void add_almost_full_(IT1 it1, IT1 ite1, IT2 it2, IT3 it3, IT3 ite3) { + IT3 it = it3; + for (; it != ite3; ++it, ++it2) *it = *it2; + for (; it1 != ite1; ++it1) + *(it3 + it1.index()) += *it1; + } + + template + void add_to_full_(IT1 it1, IT1 ite1, IT2 it2, IT2 ite2, + IT3 it3, IT3 ite3) { + typedef typename std::iterator_traits::value_type T; + IT3 it = it3; + for (; it != ite3; ++it) *it = T(0); + for (; it1 != ite1; ++it1) *(it3 + it1.index()) = *it1; + for (; it2 != ite2; ++it2) *(it3 + it2.index()) += *it2; + } + + template inline + void add(const L1& l1, const L2& l2, L3& l3, + abstract_dense, abstract_dense, abstract_dense) { + add_full_(vect_const_begin(l1), vect_const_begin(l2), + vect_begin(l3), vect_end(l3)); + } + + // generic function for add(v1, v2, v3). + // Need to be specialized to optimize particular additions. + template + inline void add(const L1& l1, const L2& l2, L3& l3, ST1, ST2, ST3) + { copy(l2, l3); add(l1, l3, ST1(), ST3()); } + + template inline + void add(const L1& l1, const L2& l2, L3& l3, + abstract_sparse, abstract_dense, abstract_dense) { + add_almost_full_(vect_const_begin(l1), vect_const_end(l1), + vect_const_begin(l2), vect_begin(l3), vect_end(l3)); + } + + template inline + void add(const L1& l1, const L2& l2, L3& l3, + abstract_dense, abstract_sparse, abstract_dense) + { add(l2, l1, l3, abstract_sparse(), abstract_dense(), abstract_dense()); } + + template inline + void add(const L1& l1, const L2& l2, L3& l3, + abstract_sparse, abstract_sparse, abstract_dense) { + add_to_full_(vect_const_begin(l1), vect_const_end(l1), + vect_const_begin(l2), vect_const_end(l2), + vect_begin(l3), vect_end(l3)); + } + + + template + void add_spspsp(const L1& l1, const L2& l2, L3& l3, linalg_true) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + auto it2 = vect_const_begin(l2), ite2 = vect_const_end(l2); + clear(l3); + while (it1 != ite1 && it2 != ite2) { + ptrdiff_t d = it1.index() - it2.index(); + if (d < 0) + { l3[it1.index()] += *it1; ++it1; } + else if (d > 0) + { l3[it2.index()] += *it2; ++it2; } + else + { l3[it1.index()] = *it1 + *it2; ++it1; ++it2; } + } + for (; it1 != ite1; ++it1) l3[it1.index()] += *it1; + for (; it2 != ite2; ++it2) l3[it2.index()] += *it2; + } + + template + void add_spspsp(const L1& l1, const L2& l2, L3& l3, linalg_false) + { copy(l2, l3); add(l2, l3); } + + template + void add(const L1& l1, const L2& l2, L3& l3, + abstract_sparse, abstract_sparse, abstract_sparse) { + add_spspsp(l1, l2, l3, typename linalg_and::index_sorted, + typename linalg_traits::index_sorted>::bool_type()); + } + + template + void add(const L1& l1, L2& l2, abstract_dense, abstract_dense) { + auto it1 = vect_const_begin(l1); + auto it2 = vect_begin(l2), ite = vect_end(l2); + for (; it2 != ite; ++it2, ++it1) *it2 += *it1; + } + + template + void add(const L1& l1, L2& l2, abstract_dense, abstract_skyline) { + typedef typename linalg_traits::value_type T; + + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + size_type i1 = 0, ie1 = vect_size(l1); + while (it1 != ite1 && *it1 == T(0)) { ++it1; ++i1; } + if (it1 != ite1) { + auto it2 = vect_begin(l2), ite2 = vect_end(l2); + while (ie1 && *(ite1-1) == T(0)) { ite1--; --ie1; } + + if (it2 == ite2 || i1 < it2.index()) { + l2[i1] = *it1; ++i1; ++it1; + if (it1 == ite1) return; + it2 = vect_begin(l2); ite2 = vect_end(l2); + } + if (ie1 > ite2.index()) { + --ite1; l2[ie1 - 1] = *ite1; + it2 = vect_begin(l2); + } + it2 += i1 - it2.index(); + for (; it1 != ite1; ++it1, ++it2) { *it2 += *it1; } + } + } + + + template + void add(const L1& l1, L2& l2, abstract_skyline, abstract_dense) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + if (it1 != ite1) { + auto it2 = vect_begin(l2); + it2 += it1.index(); + for (; it1 != ite1; ++it2, ++it1) *it2 += *it1; + } + } + + + template + void add(const L1& l1, L2& l2, abstract_sparse, abstract_dense) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + for (; it1 != ite1; ++it1) l2[it1.index()] += *it1; + } + + template + void add(const L1& l1, L2& l2, abstract_sparse, abstract_sparse) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + for (; it1 != ite1; ++it1) l2[it1.index()] += *it1; + } + + template + void add(const L1& l1, L2& l2, abstract_sparse, abstract_skyline) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + for (; it1 != ite1; ++it1) l2[it1.index()] += *it1; + } + + + template + void add(const L1& l1, L2& l2, abstract_skyline, abstract_sparse) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + for (; it1 != ite1; ++it1) + if (*it1 != typename linalg_traits::value_type(0)) + l2[it1.index()] += *it1; + } + + template + void add(const L1& l1, L2& l2, abstract_skyline, abstract_skyline) { + typedef typename linalg_traits::value_type T1; + typedef typename linalg_traits::value_type T2; + + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + + while (it1 != ite1 && *it1 == T1(0)) ++it1; + if (ite1 != it1) { + auto it2 = vect_begin(l2), ite2 = vect_end(l2); + while (*(ite1-1) == T1(0)) ite1--; + if (it2 == ite2 || it1.index() < it2.index()) { + l2[it1.index()] = T2(0); + it2 = vect_begin(l2); ite2 = vect_end(l2); + } + if (ite1.index() > ite2.index()) { + l2[ite1.index() - 1] = T2(0); + it2 = vect_begin(l2); + } + it2 += it1.index() - it2.index(); + for (; it1 != ite1; ++it1, ++it2) *it2 += *it1; + } + } + + template + void add(const L1& l1, L2& l2, abstract_dense, abstract_sparse) { + auto it1 = vect_const_begin(l1), ite1 = vect_const_end(l1); + for (size_type i = 0; it1 != ite1; ++it1, ++i) + if (*it1 != typename linalg_traits::value_type(0)) l2[i] += *it1; + } + + /* ******************************************************************** */ + /* Matrix-vector mult */ + /* ******************************************************************** */ + ///@endcond + /** matrix-vector or matrix-matrix product. + @param l1 a matrix. + @param l2 a vector or matrix. + @param l3 the product l1*l2. + */ + template inline + void mult(const L1& l1, const L2& l2, L3& l3) { + mult_dispatch(l1, l2, l3, typename linalg_traits::linalg_type()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template inline + void mult(const L1& l1, const L2& l2, const L3& l3) + { mult(l1, l2, linalg_const_cast(l3)); } + + template inline + void mult_dispatch(const L1& l1, const L2& l2, L3& l3, abstract_vector) { + size_type m = mat_nrows(l1), n = mat_ncols(l1); + if (!m || !n) { gmm::clear(l3); return; } + GMM_ASSERT2(n==vect_size(l2) && m==vect_size(l3), "dimensions mismatch"); + if (!same_origin(l2, l3)) + mult_spec(l1, l2, l3, typename principal_orientation_type::sub_orientation>::potype()); + else { + GMM_WARNING2("Warning, A temporary is used for mult\n"); + typename temporary_vector::vector_type temp(vect_size(l3)); + mult_spec(l1, l2, temp, typename principal_orientation_type::sub_orientation>::potype()); + copy(temp, l3); + } + } + + template + void mult_by_row(const L1& l1, const L2& l2, L3& l3, abstract_sparse) { + typedef typename linalg_traits::value_type T; + clear(l3); + size_type nr = mat_nrows(l1); + for (size_type i = 0; i < nr; ++i) { + T aux = vect_sp(mat_const_row(l1, i), l2); + if (aux != T(0)) l3[i] = aux; + } + } + + template + void mult_by_row(const L1& l1, const L2& l2, L3& l3, abstract_skyline) { + typedef typename linalg_traits::value_type T; + clear(l3); + size_type nr = mat_nrows(l1); + for (size_type i = 0; i < nr; ++i) { + T aux = vect_sp(mat_const_row(l1, i), l2); + if (aux != T(0)) l3[i] = aux; + } + } + + template + void mult_by_row(const L1& l1, const L2& l2, L3& l3, abstract_dense) { + typename linalg_traits::iterator it=vect_begin(l3), ite=vect_end(l3); + auto itr = mat_row_const_begin(l1); + for (; it != ite; ++it, ++itr) + *it = vect_sp(linalg_traits::row(itr), l2, + typename linalg_traits::storage_type(), + typename linalg_traits::storage_type()); + } + + template + void mult_by_col(const L1& l1, const L2& l2, L3& l3, abstract_dense) { + clear(l3); + size_type nc = mat_ncols(l1); + for (size_type i = 0; i < nc; ++i) + add(scaled(mat_const_col(l1, i), l2[i]), l3); + } + + template + void mult_by_col(const L1& l1, const L2& l2, L3& l3, abstract_sparse) { + typedef typename linalg_traits::value_type T; + clear(l3); + auto it = vect_const_begin(l2), ite = vect_const_end(l2); + for (; it != ite; ++it) + if (*it != T(0)) add(scaled(mat_const_col(l1, it.index()), *it), l3); + } + + template + void mult_by_col(const L1& l1, const L2& l2, L3& l3, abstract_skyline) { + typedef typename linalg_traits::value_type T; + clear(l3); + auto it = vect_const_begin(l2), ite = vect_const_end(l2); + for (; it != ite; ++it) + if (*it != T(0)) add(scaled(mat_const_col(l1, it.index()), *it), l3); + } + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, row_major) + { mult_by_row(l1, l2, l3, typename linalg_traits::storage_type()); } + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, col_major) + { mult_by_col(l1, l2, l3, typename linalg_traits::storage_type()); } + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, abstract_null_type) + { mult_ind(l1, l2, l3, typename linalg_traits::storage_type()); } + + template + void mult_ind(const L1& l1, const L2& l2, L3& l3, abstract_indirect) { + GMM_ASSERT1(false, "gmm::mult(m, ., .) undefined for this kind of matrix"); + } + + template inline + void mult(const L1& l1, const L2& l2, const L3& l3, L4& l4) { + size_type m = mat_nrows(l1), n = mat_ncols(l1); + copy(l3, l4); + if (!m || !n) { gmm::copy(l3, l4); return; } + GMM_ASSERT2(n==vect_size(l2) && m==vect_size(l4), "dimensions mismatch"); + if (!same_origin(l2, l4)) { + mult_add_spec(l1, l2, l4, typename principal_orientation_type::sub_orientation>::potype()); + } + else { + GMM_WARNING2("Warning, A temporary is used for mult\n"); + typename temporary_vector::vector_type temp(vect_size(l2)); + copy(l2, temp); + mult_add_spec(l1,temp, l4, typename principal_orientation_type::sub_orientation>::potype()); + } + } + + template inline + void mult(const L1& l1, const L2& l2, const L3& l3, const L4& l4) + { mult(l1, l2, l3, linalg_const_cast(l4)); } + + ///@endcond + /** Multiply-accumulate. l3 += l1*l2; */ + template inline + void mult_add(const L1& l1, const L2& l2, L3& l3) { + size_type m = mat_nrows(l1), n = mat_ncols(l1); + if (!m || !n) return; + GMM_ASSERT2(n==vect_size(l2) && m==vect_size(l3), "dimensions mismatch"); + if (!same_origin(l2, l3)) { + mult_add_spec(l1, l2, l3, typename principal_orientation_type::sub_orientation>::potype()); + } + else { + GMM_WARNING2("Warning, A temporary is used for mult\n"); + typename temporary_vector::vector_type temp(vect_size(l2)); + copy(l2, temp); + mult_add_spec(l1,temp, l3, typename principal_orientation_type::sub_orientation>::potype()); + } + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template inline + void mult_add(const L1& l1, const L2& l2, const L3& l3) + { mult_add(l1, l2, linalg_const_cast(l3)); } + + template + void mult_add_by_row(const L1& l1, const L2& l2, L3& l3, abstract_sparse) { + typedef typename linalg_traits::value_type T; + size_type nr = mat_nrows(l1); + for (size_type i = 0; i < nr; ++i) { + T aux = vect_sp(mat_const_row(l1, i), l2); + if (aux != T(0)) l3[i] += aux; + } + } + + template + void mult_add_by_row(const L1& l1, const L2& l2, L3& l3, abstract_skyline) { + typedef typename linalg_traits::value_type T; + size_type nr = mat_nrows(l1); + for (size_type i = 0; i < nr; ++i) { + T aux = vect_sp(mat_const_row(l1, i), l2); + if (aux != T(0)) l3[i] += aux; + } + } + + template + void mult_add_by_row(const L1& l1, const L2& l2, L3& l3, abstract_dense) { + auto it=vect_begin(l3), ite=vect_end(l3); + auto itr = mat_row_const_begin(l1); + for (; it != ite; ++it, ++itr) + *it += vect_sp(linalg_traits::row(itr), l2); + } + + template + void mult_add_by_col(const L1& l1, const L2& l2, L3& l3, abstract_dense) { + size_type nc = mat_ncols(l1); + for (size_type i = 0; i < nc; ++i) + add(scaled(mat_const_col(l1, i), l2[i]), l3); + } + + template + void mult_add_by_col(const L1& l1, const L2& l2, L3& l3, abstract_sparse) { + auto it = vect_const_begin(l2), ite = vect_const_end(l2); + for (; it != ite; ++it) + if (*it != typename linalg_traits::value_type(0)) + add(scaled(mat_const_col(l1, it.index()), *it), l3); + } + + template + void mult_add_by_col(const L1& l1, const L2& l2, L3& l3, abstract_skyline) { + auto it = vect_const_begin(l2), ite = vect_const_end(l2); + for (; it != ite; ++it) + if (*it != typename linalg_traits::value_type(0)) + add(scaled(mat_const_col(l1, it.index()), *it), l3); + } + + template inline + void mult_add_spec(const L1& l1, const L2& l2, L3& l3, row_major) + { mult_add_by_row(l1, l2, l3, typename linalg_traits::storage_type()); } + + template inline + void mult_add_spec(const L1& l1, const L2& l2, L3& l3, col_major) + { mult_add_by_col(l1, l2, l3, typename linalg_traits::storage_type()); } + + template inline + void mult_add_spec(const L1& l1, const L2& l2, L3& l3, abstract_null_type) + { mult_ind(l1, l2, l3, typename linalg_traits::storage_type()); } + + template + void transposed_mult(const L1& l1, const L2& l2, const L3& l3) + { mult(gmm::transposed(l1), l2, l3); } + + + /* ******************************************************************** */ + /* Matrix-matrix mult */ + /* ******************************************************************** */ + + + struct g_mult {}; // generic mult, less optimized + struct c_mult {}; // col x col -> col mult + struct r_mult {}; // row x row -> row mult + struct rcmult {}; // row x col -> col mult + struct crmult {}; // col x row -> row mult + + + template struct mult_t; + #define DEFMU__ template<> struct mult_t + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef g_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef crmult t; }; + DEFMU__ { typedef g_mult t; }; + DEFMU__ { typedef crmult t; }; + DEFMU__ { typedef crmult t; }; + DEFMU__ { typedef g_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef crmult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef crmult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef rcmult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef c_mult t; }; + DEFMU__ { typedef r_mult t; }; + DEFMU__ { typedef r_mult t; }; + + template + void mult_dispatch(const L1& l1, const L2& l2, L3& l3, abstract_matrix) { + typedef typename temporary_matrix::matrix_type temp_mat_type; + size_type n = mat_ncols(l1); + if (n == 0) { gmm::clear(l3); return; } + GMM_ASSERT2(n == mat_nrows(l2) && mat_nrows(l1) == mat_nrows(l3) && + mat_ncols(l2) == mat_ncols(l3), "dimensions mismatch"); + + if (same_origin(l2, l3) || same_origin(l1, l3)) { + GMM_WARNING2("A temporary is used for mult"); + temp_mat_type temp(mat_nrows(l3), mat_ncols(l3)); + mult_spec(l1, l2, temp, typename mult_t< + typename linalg_traits::sub_orientation, + typename linalg_traits::sub_orientation, + typename linalg_traits::sub_orientation>::t()); + copy(temp, l3); + } + else + mult_spec(l1, l2, l3, typename mult_t< + typename linalg_traits::sub_orientation, + typename linalg_traits::sub_orientation, + typename linalg_traits::sub_orientation>::t()); + } + + // Completely generic but inefficient + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, g_mult) { + typedef typename linalg_traits::value_type T; + GMM_WARNING2("Inefficient generic matrix-matrix mult is used"); + for (size_type i = 0; i < mat_nrows(l3) ; ++i) + for (size_type j = 0; j < mat_ncols(l3) ; ++j) { + T a(0); + for (size_type k = 0; k < mat_nrows(l2) ; ++k) a += l1(i, k)*l2(k, j); + l3(i, j) = a; + } + } + + // row x col matrix-matrix mult + + template + void mult_row_col_with_temp(const L1& l1, const L2& l2, L3& l3, col_major) { + typedef typename temporary_col_matrix::matrix_type temp_col_mat; + temp_col_mat temp(mat_nrows(l1), mat_ncols(l1)); + copy(l1, temp); + mult(temp, l2, l3); + } + + template + void mult_row_col_with_temp(const L1& l1, const L2& l2, L3& l3, row_major) { + typedef typename temporary_row_matrix::matrix_type temp_row_mat; + temp_row_mat temp(mat_nrows(l2), mat_ncols(l2)); + copy(l2, temp); + mult(l1, temp, l3); + } + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, rcmult) { + if (is_sparse(l1) && is_sparse(l2)) { + GMM_WARNING3("Inefficient row matrix - col matrix mult for " + "sparse matrices, using temporary"); + mult_row_col_with_temp(l1, l2, l3, + typename principal_orientation_type::sub_orientation>::potype()); + } + else { + auto it2b = linalg_traits::col_begin(l2), it2 = it2b, + ite = linalg_traits::col_end(l2); + size_type i,j, k = mat_nrows(l1); + + for (i = 0; i < k; ++i) { + typename linalg_traits::const_sub_row_type r1=mat_const_row(l1, i); + for (it2 = it2b, j = 0; it2 != ite; ++it2, ++j) + l3(i,j) = vect_sp(r1, linalg_traits::col(it2)); + } + } + } + + // row - row matrix-matrix mult + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, r_mult) { + mult_spec(l1, l2, l3,r_mult(),typename linalg_traits::storage_type()); + } + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, r_mult, abstract_dense) { + // optimizable + clear(l3); + size_type nn = mat_nrows(l3), mm = mat_nrows(l2); + for (size_type i = 0; i < nn; ++i) { + for (size_type j = 0; j < mm; ++j) { + add(scaled(mat_const_row(l2, j), l1(i, j)), mat_row(l3, i)); + } + } + } + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, r_mult, abstract_sparse) { + // optimizable + clear(l3); + size_type nn = mat_nrows(l3); + for (size_type i = 0; i < nn; ++i) { + typename linalg_traits::const_sub_row_type rl1=mat_const_row(l1, i); + auto it = vect_const_begin(rl1), ite = vect_const_end(rl1); + for (; it != ite; ++it) + add(scaled(mat_const_row(l2, it.index()), *it), mat_row(l3, i)); + } + } + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, r_mult, abstract_skyline) + { mult_spec(l1, l2, l3, r_mult(), abstract_sparse()); } + + // col - col matrix-matrix mult + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, c_mult) { + mult_spec(l1, l2,l3,c_mult(),typename linalg_traits::storage_type(), + typename linalg_traits::sub_orientation()); + } + + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, c_mult, + abstract_dense, ORIEN) { + typedef typename linalg_traits::value_type T; + size_type nn = mat_ncols(l3), mm = mat_ncols(l1); + + for (size_type i = 0; i < nn; ++i) { + clear(mat_col(l3, i)); + for (size_type j = 0; j < mm; ++j) { + T b = l2(j, i); + if (b != T(0)) add(scaled(mat_const_col(l1, j), b), mat_col(l3, i)); + } + } + } + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, c_mult, + abstract_sparse, ORIEN) { + // optimizable + clear(l3); + size_type nn = mat_ncols(l3); + for (size_type i = 0; i < nn; ++i) { + typename linalg_traits::const_sub_col_type rc2 = mat_const_col(l2, i); + auto it = vect_const_begin(rc2), ite = vect_const_end(rc2); + for (; it != ite; ++it) + add(scaled(mat_const_col(l1, it.index()), *it), mat_col(l3, i)); + } + } + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, c_mult, + abstract_sparse, row_major) { + typedef typename linalg_traits::value_type T; + GMM_WARNING3("Inefficient matrix-matrix mult for sparse matrices"); + clear(l3); + size_type mm = mat_nrows(l2), nn = mat_ncols(l3); + for (size_type i = 0; i < nn; ++i) + for (size_type j = 0; j < mm; ++j) { + T a = l2(i,j); + if (a != T(0)) add(scaled(mat_const_col(l1, j), a), mat_col(l3, i)); + } + } + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, c_mult, + abstract_skyline, ORIEN) + { mult_spec(l1, l2, l3, c_mult(), abstract_sparse(), ORIEN()); } + + + // col - row matrix-matrix mult + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, crmult) + { mult_spec(l1,l2,l3,crmult(), typename linalg_traits::storage_type()); } + + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, crmult, abstract_dense) { + // optimizable + clear(l3); + size_type nn = mat_ncols(l1), mm = mat_nrows(l1); + for (size_type i = 0; i < nn; ++i) { + for (size_type j = 0; j < mm; ++j) + add(scaled(mat_const_row(l2, i), l1(j, i)), mat_row(l3, j)); + } + } + + template + void mult_spec(const L1& l1, const L2& l2, L3& l3, crmult, abstract_sparse) { + // optimizable + clear(l3); + size_type nn = mat_ncols(l1); + for (size_type i = 0; i < nn; ++i) { + typename linalg_traits::const_sub_col_type rc1 = mat_const_col(l1, i); + auto it = vect_const_begin(rc1), ite = vect_const_end(rc1); + for (; it != ite; ++it) + add(scaled(mat_const_row(l2, i), *it), mat_row(l3, it.index())); + } + } + + template inline + void mult_spec(const L1& l1, const L2& l2, L3& l3, crmult, abstract_skyline) + { mult_spec(l1, l2, l3, crmult(), abstract_sparse()); } + + + /* ******************************************************************** */ + /* Symmetry test. */ + /* ******************************************************************** */ + + ///@endcond + /** test if A is symmetric. + @param A a matrix. + @param tol a threshold. + */ + template inline + bool is_symmetric(const MAT &A, magnitude_of_linalg(MAT) tol + = magnitude_of_linalg(MAT)(-1)) { + typedef magnitude_of_linalg(MAT) R; + if (tol < R(0)) tol = default_tol(R()) * mat_maxnorm(A); + if (mat_nrows(A) != mat_ncols(A)) return false; + return is_symmetric(A, tol, typename linalg_traits::storage_type()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template + bool is_symmetric(const MAT &A, magnitude_of_linalg(MAT) tol, + abstract_dense) { + size_type m = mat_nrows(A); + for (size_type i = 1; i < m; ++i) + for (size_type j = 0; j < i; ++j) + if (gmm::abs(A(i, j)-A(j, i)) > tol) return false; + return true; + } + + template + bool is_symmetric(const MAT &A, magnitude_of_linalg(MAT) tol, + abstract_sparse) { + return is_symmetric(A, tol, typename principal_orientation_type::sub_orientation>::potype()); + } + + template + bool is_symmetric(const MAT &A, magnitude_of_linalg(MAT) tol, + row_major) { + for (size_type i = 0; i < mat_nrows(A); ++i) { + typename linalg_traits::const_sub_row_type row = mat_const_row(A, i); + auto it = vect_const_begin(row), ite = vect_const_end(row); + for (; it != ite; ++it) + if (gmm::abs(*it - A(it.index(), i)) > tol) return false; + } + return true; + } + + template + bool is_symmetric(const MAT &A, magnitude_of_linalg(MAT) tol, + col_major) { + for (size_type i = 0; i < mat_ncols(A); ++i) { + typename linalg_traits::const_sub_col_type col = mat_const_col(A, i); + auto it = vect_const_begin(col), ite = vect_const_end(col); + for (; it != ite; ++it) + if (gmm::abs(*it - A(i, it.index())) > tol) return false; + } + return true; + } + + template + bool is_symmetric(const MAT &A, magnitude_of_linalg(MAT) tol, + abstract_skyline) + { return is_symmetric(A, tol, abstract_sparse()); } + + ///@endcond + /** test if A is Hermitian. + @param A a matrix. + @param tol a threshold. + */ + template inline + bool is_hermitian(const MAT &A, magnitude_of_linalg(MAT) tol + = magnitude_of_linalg(MAT)(-1)) { + typedef magnitude_of_linalg(MAT) R; + if (tol < R(0)) tol = default_tol(R()) * mat_maxnorm(A); + if (mat_nrows(A) != mat_ncols(A)) return false; + return is_hermitian(A, tol, typename linalg_traits::storage_type()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template + bool is_hermitian(const MAT &A, magnitude_of_linalg(MAT) tol, + abstract_dense) { + size_type m = mat_nrows(A); + for (size_type i = 1; i < m; ++i) + for (size_type j = 0; j < i; ++j) + if (gmm::abs(A(i, j)-gmm::conj(A(j, i))) > tol) return false; + return true; + } + + template + bool is_hermitian(const MAT &A, magnitude_of_linalg(MAT) tol, + abstract_sparse) { + return is_hermitian(A, tol, typename principal_orientation_type::sub_orientation>::potype()); + } + + template + bool is_hermitian(const MAT &A, magnitude_of_linalg(MAT) tol, + row_major) { + for (size_type i = 0; i < mat_nrows(A); ++i) { + typename linalg_traits::const_sub_row_type row = mat_const_row(A, i); + auto it = vect_const_begin(row), ite = vect_const_end(row); + for (; it != ite; ++it) + if (gmm::abs(gmm::conj(*it) - A(it.index(), i)) > tol) return false; + } + return true; + } + + template + bool is_hermitian(const MAT &A, magnitude_of_linalg(MAT) tol, + col_major) { + for (size_type i = 0; i < mat_ncols(A); ++i) { + typename linalg_traits::const_sub_col_type col = mat_const_col(A, i); + auto it = vect_const_begin(col), ite = vect_const_end(col); + for (; it != ite; ++it) + if (gmm::abs(gmm::conj(*it) - A(i, it.index())) > tol) return false; + } + return true; + } + + template + bool is_hermitian(const MAT &A, magnitude_of_linalg(MAT) tol, + abstract_skyline) + { return is_hermitian(A, tol, abstract_sparse()); } + ///@endcond +} + + +#endif // GMM_BLAS_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_blas_interface.h b/7.x/src/linear_algebra/gmm/gmm_blas_interface.h new file mode 100644 index 0000000..c724a3b --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_blas_interface.h @@ -0,0 +1,1055 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_blas_interface.h + @author Yves Renard + @date October 7, 2003. + @brief gmm interface for fortran BLAS. +*/ + +#if defined(GETFEM_USES_BLAS) || defined(GMM_USES_BLAS) \ + || defined(GMM_USES_LAPACK) || defined(GMM_USES_ATLAS) + +#ifndef GMM_BLAS_INTERFACE_H +#define GMM_BLAS_INTERFACE_H + +#include "gmm_blas.h" +#include "gmm_interface.h" +#include "gmm_matrix.h" + +namespace gmm { + + // Use ./configure --enable-blas-interface to activate this interface. + +#define GMMLAPACK_TRACE(f) + // #define GMMLAPACK_TRACE(f) cout << "function " << f << " called" << endl; + +#if defined(WeirdNEC) || defined(GMM_USE_BLAS64_INTERFACE) + #define BLAS_INT long +#else // By default BLAS_INT will just be int in C + #define BLAS_INT int +#endif + + /* ********************************************************************* */ + /* Operations interfaced for T = float, double, std::complex */ + /* or std::complex : */ + /* */ + /* vect_norm2(std::vector) */ + /* */ + /* vect_sp(std::vector, std::vector) */ + /* vect_sp(scaled(std::vector), std::vector) */ + /* vect_sp(std::vector, scaled(std::vector)) */ + /* vect_sp(scaled(std::vector), scaled(std::vector)) */ + /* */ + /* vect_hp(std::vector, std::vector) */ + /* vect_hp(scaled(std::vector), std::vector) */ + /* vect_hp(std::vector, scaled(std::vector)) */ + /* vect_hp(scaled(std::vector), scaled(std::vector)) */ + /* */ + /* add(std::vector, std::vector) */ + /* add(scaled(std::vector, a), std::vector) */ + /* */ + /* mult(dense_matrix, dense_matrix, dense_matrix) */ + /* mult(transposed(dense_matrix), dense_matrix, dense_matrix) */ + /* mult(dense_matrix, transposed(dense_matrix), dense_matrix) */ + /* mult(transposed(dense_matrix), transposed(dense_matrix), */ + /* dense_matrix) */ + /* mult(conjugated(dense_matrix), dense_matrix, dense_matrix) */ + /* mult(dense_matrix, conjugated(dense_matrix), dense_matrix) */ + /* mult(conjugated(dense_matrix), conjugated(dense_matrix), */ + /* dense_matrix) */ + /* */ + /* mult(dense_matrix, std::vector, std::vector) */ + /* mult(transposed(dense_matrix), std::vector, std::vector) */ + /* mult(conjugated(dense_matrix), std::vector, std::vector) */ + /* mult(dense_matrix, scaled(std::vector), std::vector) */ + /* mult(transposed(dense_matrix), scaled(std::vector), */ + /* std::vector) */ + /* mult(conjugated(dense_matrix), scaled(std::vector), */ + /* std::vector) */ + /* */ + /* mult_add(dense_matrix, std::vector, std::vector) */ + /* mult_add(transposed(dense_matrix), std::vector, std::vector) */ + /* mult_add(conjugated(dense_matrix), std::vector, std::vector) */ + /* mult_add(dense_matrix, scaled(std::vector), std::vector) */ + /* mult_add(transposed(dense_matrix), scaled(std::vector), */ + /* std::vector) */ + /* mult_add(conjugated(dense_matrix), scaled(std::vector), */ + /* std::vector) */ + /* */ + /* mult(dense_matrix, std::vector, std::vector, std::vector) */ + /* mult(transposed(dense_matrix), std::vector, std::vector, */ + /* std::vector) */ + /* mult(conjugated(dense_matrix), std::vector, std::vector, */ + /* std::vector) */ + /* mult(dense_matrix, scaled(std::vector), std::vector, */ + /* std::vector) */ + /* mult(transposed(dense_matrix), scaled(std::vector), */ + /* std::vector, std::vector) */ + /* mult(conjugated(dense_matrix), scaled(std::vector), */ + /* std::vector, std::vector) */ + /* mult(dense_matrix, std::vector, scaled(std::vector), */ + /* std::vector) */ + /* mult(transposed(dense_matrix), std::vector, */ + /* scaled(std::vector), std::vector) */ + /* mult(conjugated(dense_matrix), std::vector, */ + /* scaled(std::vector), std::vector) */ + /* mult(dense_matrix, scaled(std::vector), scaled(std::vector), */ + /* std::vector) */ + /* mult(transposed(dense_matrix), scaled(std::vector), */ + /* scaled(std::vector), std::vector) */ + /* mult(conjugated(dense_matrix), scaled(std::vector), */ + /* scaled(std::vector), std::vector) */ + /* */ + /* lower_tri_solve(dense_matrix, std::vector, k, b) */ + /* upper_tri_solve(dense_matrix, std::vector, k, b) */ + /* lower_tri_solve(transposed(dense_matrix), std::vector, k, b) */ + /* upper_tri_solve(transposed(dense_matrix), std::vector, k, b) */ + /* lower_tri_solve(conjugated(dense_matrix), std::vector, k, b) */ + /* upper_tri_solve(conjugated(dense_matrix), std::vector, k, b) */ + /* */ + /* rank_one_update(dense_matrix, std::vector, std::vector) */ + /* rank_one_update(dense_matrix, scaled(std::vector), */ + /* std::vector) */ + /* rank_one_update(dense_matrix, std::vector, */ + /* scaled(std::vector)) */ + /* */ + /* ********************************************************************* */ + + /* ********************************************************************* */ + /* Basic defines. */ + /* ********************************************************************* */ + +# define BLAS_S float +# define BLAS_D double +# define BLAS_C std::complex +# define BLAS_Z std::complex + + /* ********************************************************************* */ + /* BLAS functions used. */ + /* ********************************************************************* */ + extern "C" { + void daxpy_(const BLAS_INT *n, const double *alpha, const double *x, + const BLAS_INT *incx, double *y, const BLAS_INT *incy); + void dgemm_(const char *tA, const char *tB, const BLAS_INT *m, + const BLAS_INT *n, const BLAS_INT *k, const double *alpha, + const double *A, const BLAS_INT *ldA, const double *B, + const BLAS_INT *ldB, const double *beta, double *C, + const BLAS_INT *ldC); + void sgemm_(...); void cgemm_(...); void zgemm_(...); + void sgemv_(...); void dgemv_(...); void cgemv_(...); void zgemv_(...); + void strsv_(...); void dtrsv_(...); void ctrsv_(...); void ztrsv_(...); + void saxpy_(...); /*void daxpy_(...); */void caxpy_(...); void zaxpy_(...); + BLAS_S sdot_ (...); BLAS_D ddot_ (...); + BLAS_C cdotu_(...); BLAS_Z zdotu_(...); + BLAS_C cdotc_(...); BLAS_Z zdotc_(...); + BLAS_S snrm2_(...); BLAS_D dnrm2_(...); + BLAS_S scnrm2_(...); BLAS_D dznrm2_(...); + void sger_(...); void dger_(...); void cgerc_(...); void zgerc_(...); + } + +#if 1 + + /* ********************************************************************* */ + /* vect_norm2(x). */ + /* ********************************************************************* */ + +# define nrm2_interface(param1, trans1, blas_name, base_type) \ + inline number_traits::magnitude_type \ + vect_norm2(param1(base_type)) { \ + GMMLAPACK_TRACE("nrm2_interface"); \ + BLAS_INT inc(1), n(BLAS_INT(vect_size(x))); trans1(base_type); \ + return blas_name(&n, &x[0], &inc); \ + } + +# define nrm2_p1(base_type) const std::vector &x +# define nrm2_trans1(base_type) + + nrm2_interface(nrm2_p1, nrm2_trans1, snrm2_ , BLAS_S) + nrm2_interface(nrm2_p1, nrm2_trans1, dnrm2_ , BLAS_D) + nrm2_interface(nrm2_p1, nrm2_trans1, scnrm2_, BLAS_C) + nrm2_interface(nrm2_p1, nrm2_trans1, dznrm2_, BLAS_Z) + + /* ********************************************************************* */ + /* vect_sp(x, y). */ + /* ********************************************************************* */ + +# define dot_interface(param1, trans1, mult1, param2, trans2, mult2, \ + blas_name, base_type) \ + inline base_type vect_sp(param1(base_type), param2(base_type)) { \ + GMMLAPACK_TRACE("dot_interface"); \ + trans1(base_type); trans2(base_type); \ + BLAS_INT inc(1), n(BLAS_INT(vect_size(y))); \ + return mult1 mult2 blas_name(&n, &x[0], &inc, &y[0], &inc); \ + } + +# define dot_p1(base_type) const std::vector &x +# define dot_trans1(base_type) +# define dot_p1_s(base_type) \ + const scaled_vector_const_ref, base_type > &x_ +# define dot_trans1_s(base_type) \ + std::vector &x = \ + const_cast &>(*(linalg_origin(x_))); \ + base_type a(x_.r) + +# define dot_p2(base_type) const std::vector &y +# define dot_trans2(base_type) +# define dot_p2_s(base_type) \ + const scaled_vector_const_ref, base_type > &y_ +# define dot_trans2_s(base_type) \ + std::vector &y = \ + const_cast &>(*(linalg_origin(y_))); \ + base_type b(y_.r) + + dot_interface(dot_p1, dot_trans1, (BLAS_S), dot_p2, dot_trans2, (BLAS_S), + sdot_ , BLAS_S) + dot_interface(dot_p1, dot_trans1, (BLAS_D), dot_p2, dot_trans2, (BLAS_D), + ddot_ , BLAS_D) + dot_interface(dot_p1, dot_trans1, (BLAS_C), dot_p2, dot_trans2, (BLAS_C), + cdotu_, BLAS_C) + dot_interface(dot_p1, dot_trans1, (BLAS_Z), dot_p2, dot_trans2, (BLAS_Z), + zdotu_, BLAS_Z) + + dot_interface(dot_p1_s, dot_trans1_s, a*, dot_p2, dot_trans2, (BLAS_S), + sdot_ ,BLAS_S) + dot_interface(dot_p1_s, dot_trans1_s, a*, dot_p2, dot_trans2, (BLAS_D), + ddot_ ,BLAS_D) + dot_interface(dot_p1_s, dot_trans1_s, a*, dot_p2, dot_trans2, (BLAS_C), + cdotu_,BLAS_C) + dot_interface(dot_p1_s, dot_trans1_s, a*, dot_p2, dot_trans2, (BLAS_Z), + zdotu_,BLAS_Z) + + dot_interface(dot_p1, dot_trans1, (BLAS_S), dot_p2_s, dot_trans2_s, b*, + sdot_ ,BLAS_S) + dot_interface(dot_p1, dot_trans1, (BLAS_D), dot_p2_s, dot_trans2_s, b*, + ddot_ ,BLAS_D) + dot_interface(dot_p1, dot_trans1, (BLAS_C), dot_p2_s, dot_trans2_s, b*, + cdotu_,BLAS_C) + dot_interface(dot_p1, dot_trans1, (BLAS_Z), dot_p2_s, dot_trans2_s, b*, + zdotu_,BLAS_Z) + + dot_interface(dot_p1_s,dot_trans1_s,a*,dot_p2_s,dot_trans2_s,b*,sdot_ , + BLAS_S) + dot_interface(dot_p1_s,dot_trans1_s,a*,dot_p2_s,dot_trans2_s,b*,ddot_ , + BLAS_D) + dot_interface(dot_p1_s,dot_trans1_s,a*,dot_p2_s,dot_trans2_s,b*,cdotu_, + BLAS_C) + dot_interface(dot_p1_s,dot_trans1_s,a*,dot_p2_s,dot_trans2_s,b*,zdotu_, + BLAS_Z) + + + /* ********************************************************************* */ + /* vect_hp(x, y). */ + /* ********************************************************************* */ + +# define dotc_interface(param1, trans1, mult1, param2, trans2, mult2, \ + blas_name, base_type) \ + inline base_type vect_hp(param1(base_type), param2(base_type)) { \ + GMMLAPACK_TRACE("dotc_interface"); \ + trans1(base_type); trans2(base_type); \ + BLAS_INT inc(1), n(BLAS_INT(vect_size(y))); \ + return mult1 mult2 blas_name(&n, &x[0], &inc, &y[0], &inc); \ + } + +# define dotc_p1(base_type) const std::vector &x +# define dotc_trans1(base_type) +# define dotc_p1_s(base_type) \ + const scaled_vector_const_ref, base_type > &x_ +# define dotc_trans1_s(base_type) \ + std::vector &x = \ + const_cast &>(*(linalg_origin(x_))); \ + base_type a(x_.r) + +# define dotc_p2(base_type) const std::vector &y +# define dotc_trans2(base_type) +# define dotc_p2_s(base_type) \ + const scaled_vector_const_ref, base_type > &y_ +# define dotc_trans2_s(base_type) \ + std::vector &y = \ + const_cast &>(*(linalg_origin(y_))); \ + base_type b(gmm::conj(y_.r)) + + dotc_interface(dotc_p1, dotc_trans1, (BLAS_S), dotc_p2, dotc_trans2, + (BLAS_S),sdot_ ,BLAS_S) + dotc_interface(dotc_p1, dotc_trans1, (BLAS_D), dotc_p2, dotc_trans2, + (BLAS_D),ddot_ ,BLAS_D) + dotc_interface(dotc_p1, dotc_trans1, (BLAS_C), dotc_p2, dotc_trans2, + (BLAS_C),cdotc_,BLAS_C) + dotc_interface(dotc_p1, dotc_trans1, (BLAS_Z), dotc_p2, dotc_trans2, + (BLAS_Z),zdotc_,BLAS_Z) + + dotc_interface(dotc_p1_s, dotc_trans1_s, a*, dotc_p2, dotc_trans2, + (BLAS_S),sdot_, BLAS_S) + dotc_interface(dotc_p1_s, dotc_trans1_s, a*, dotc_p2, dotc_trans2, + (BLAS_D),ddot_ , BLAS_D) + dotc_interface(dotc_p1_s, dotc_trans1_s, a*, dotc_p2, dotc_trans2, + (BLAS_C),cdotc_, BLAS_C) + dotc_interface(dotc_p1_s, dotc_trans1_s, a*, dotc_p2, dotc_trans2, + (BLAS_Z),zdotc_, BLAS_Z) + + dotc_interface(dotc_p1, dotc_trans1, (BLAS_S), dotc_p2_s, dotc_trans2_s, + b*,sdot_ , BLAS_S) + dotc_interface(dotc_p1, dotc_trans1, (BLAS_D), dotc_p2_s, dotc_trans2_s, + b*,ddot_ , BLAS_D) + dotc_interface(dotc_p1, dotc_trans1, (BLAS_C), dotc_p2_s, dotc_trans2_s, + b*,cdotc_, BLAS_C) + dotc_interface(dotc_p1, dotc_trans1, (BLAS_Z), dotc_p2_s, dotc_trans2_s, + b*,zdotc_, BLAS_Z) + + dotc_interface(dotc_p1_s,dotc_trans1_s,a*,dotc_p2_s,dotc_trans2_s,b*,sdot_ , + BLAS_S) + dotc_interface(dotc_p1_s,dotc_trans1_s,a*,dotc_p2_s,dotc_trans2_s,b*,ddot_ , + BLAS_D) + dotc_interface(dotc_p1_s,dotc_trans1_s,a*,dotc_p2_s,dotc_trans2_s,b*,cdotc_, + BLAS_C) + dotc_interface(dotc_p1_s,dotc_trans1_s,a*,dotc_p2_s,dotc_trans2_s,b*,zdotc_, + BLAS_Z) + + /* ********************************************************************* */ + /* add(x, y). */ + /* ********************************************************************* */ + template + inline void add_fixed(const V1 &x, V2 &y) + { + for(size_type i = 0; i != N; ++i) y[i] += x[i]; + } + + template + inline void add_for_short_vectors(const V1 &x, V2 &y, size_type n) + { + switch(n) + { + case 1: add_fixed<1>(x, y); break; + case 2: add_fixed<2>(x, y); break; + case 3: add_fixed<3>(x, y); break; + case 4: add_fixed<4>(x, y); break; + case 5: add_fixed<5>(x, y); break; + case 6: add_fixed<6>(x, y); break; + case 7: add_fixed<7>(x, y); break; + case 8: add_fixed<8>(x, y); break; + case 9: add_fixed<9>(x, y); break; + case 10: add_fixed<10>(x, y); break; + case 11: add_fixed<11>(x, y); break; + case 12: add_fixed<12>(x, y); break; + case 13: add_fixed<13>(x, y); break; + case 14: add_fixed<14>(x, y); break; + case 15: add_fixed<15>(x, y); break; + case 16: add_fixed<16>(x, y); break; + case 17: add_fixed<17>(x, y); break; + case 18: add_fixed<18>(x, y); break; + case 19: add_fixed<19>(x, y); break; + case 20: add_fixed<20>(x, y); break; + case 21: add_fixed<21>(x, y); break; + case 22: add_fixed<22>(x, y); break; + case 23: add_fixed<23>(x, y); break; + case 24: add_fixed<24>(x, y); break; + default: GMM_ASSERT2(false, "add_for_short_vectors used with unsupported size"); break; + } + } + + template + inline void add_fixed(const V1 &x, V2 &y, const T &a) + { + for(size_type i = 0; i != N; ++i) y[i] += a*x[i]; + } + + template + inline void add_for_short_vectors(const V1 &x, V2 &y, const T &a, size_type n) + { + switch(n) + { + case 1: add_fixed<1>(x, y, a); break; + case 2: add_fixed<2>(x, y, a); break; + case 3: add_fixed<3>(x, y, a); break; + case 4: add_fixed<4>(x, y, a); break; + case 5: add_fixed<5>(x, y, a); break; + case 6: add_fixed<6>(x, y, a); break; + case 7: add_fixed<7>(x, y, a); break; + case 8: add_fixed<8>(x, y, a); break; + case 9: add_fixed<9>(x, y, a); break; + case 10: add_fixed<10>(x, y, a); break; + case 11: add_fixed<11>(x, y, a); break; + case 12: add_fixed<12>(x, y, a); break; + case 13: add_fixed<13>(x, y, a); break; + case 14: add_fixed<14>(x, y, a); break; + case 15: add_fixed<15>(x, y, a); break; + case 16: add_fixed<16>(x, y, a); break; + case 17: add_fixed<17>(x, y, a); break; + case 18: add_fixed<18>(x, y, a); break; + case 19: add_fixed<19>(x, y, a); break; + case 20: add_fixed<20>(x, y, a); break; + case 21: add_fixed<21>(x, y, a); break; + case 22: add_fixed<22>(x, y, a); break; + case 23: add_fixed<23>(x, y, a); break; + case 24: add_fixed<24>(x, y, a); break; + default: GMM_ASSERT2(false, "add_for_short_vectors used with unsupported size"); break; + } + } + + +# define axpy_interface(param1, trans1, blas_name, base_type) \ + inline void add(param1(base_type), std::vector &y) { \ + GMMLAPACK_TRACE("axpy_interface"); \ + BLAS_INT inc(1), n(BLAS_INT(vect_size(y))); trans1(base_type); \ + if(n == 0) return; \ + else if(n < 25) add_for_short_vectors(x, y, n); \ + else blas_name(&n, &a, &x[0], &inc, &y[0], &inc); \ + } + +# define axpy2_interface(param1, trans1, blas_name, base_type) \ + inline void add(param1(base_type), std::vector &y) { \ + GMMLAPACK_TRACE("axpy_interface"); \ + BLAS_INT inc(1), n(BLAS_INT(vect_size(y))); trans1(base_type); \ + if(n == 0) return; \ + else if(n < 25) add_for_short_vectors(x, y, a, n); \ + else blas_name(&n, &a, &x[0], &inc, &y[0], &inc); \ + } + +# define axpy_p1(base_type) const std::vector &x +# define axpy_trans1(base_type) base_type a(1) +# define axpy_p1_s(base_type) \ + const scaled_vector_const_ref, base_type > &x_ +# define axpy_trans1_s(base_type) \ + std::vector &x = \ + const_cast &>(*(linalg_origin(x_))); \ + base_type a(x_.r) + + axpy_interface(axpy_p1, axpy_trans1, saxpy_, BLAS_S) + axpy_interface(axpy_p1, axpy_trans1, daxpy_, BLAS_D) + axpy_interface(axpy_p1, axpy_trans1, caxpy_, BLAS_C) + axpy_interface(axpy_p1, axpy_trans1, zaxpy_, BLAS_Z) + + axpy2_interface(axpy_p1_s, axpy_trans1_s, saxpy_, BLAS_S) + axpy2_interface(axpy_p1_s, axpy_trans1_s, daxpy_, BLAS_D) + axpy2_interface(axpy_p1_s, axpy_trans1_s, caxpy_, BLAS_C) + axpy2_interface(axpy_p1_s, axpy_trans1_s, zaxpy_, BLAS_Z) + + + /* ********************************************************************* */ + /* mult_add(A, x, z). */ + /* ********************************************************************* */ + +# define gemv_interface(param1, trans1, param2, trans2, blas_name, \ + base_type, orien) \ + inline void mult_add_spec(param1(base_type), param2(base_type), \ + std::vector &z, orien) { \ + GMMLAPACK_TRACE("gemv_interface"); \ + trans1(base_type); trans2(base_type); base_type beta(1); \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda(m); \ + BLAS_INT n(BLAS_INT(mat_ncols(A))), inc(1); \ + if (m && n) blas_name(&t, &m, &n, &alpha, &A(0,0), &lda, &x[0], &inc, \ + &beta, &z[0], &inc); \ + else gmm::clear(z); \ + } + + // First parameter +# define gem_p1_n(base_type) const dense_matrix &A +# define gem_trans1_n(base_type) const char t = 'N' +# define gem_p1_t(base_type) \ + const transposed_col_ref *> &A_ +# define gem_trans1_t(base_type) dense_matrix &A = \ + const_cast &>(*(linalg_origin(A_))); \ + const char t = 'T' +# define gem_p1_tc(base_type) \ + const transposed_col_ref *> &A_ +# define gem_p1_c(base_type) \ + const conjugated_col_matrix_const_ref > &A_ +# define gem_trans1_c(base_type) dense_matrix &A = \ + const_cast &>(*(linalg_origin(A_))); \ + const char t = 'C' + + // second parameter +# define gemv_p2_n(base_type) const std::vector &x +# define gemv_trans2_n(base_type) base_type alpha(1) +# define gemv_p2_s(base_type) \ + const scaled_vector_const_ref, base_type > &x_ +# define gemv_trans2_s(base_type) std::vector &x = \ + const_cast &>(*(linalg_origin(x_))); \ + base_type alpha(x_.r) + + // Z <- AX + Z. + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, col_major) + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, col_major) + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, col_major) + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, col_major) + + // Z <- transposed(A)X + Z. + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, row_major) + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, row_major) + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, row_major) + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, row_major) + + // Z <- transposed(const A)X + Z. + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, row_major) + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, row_major) + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, row_major) + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, row_major) + + // Z <- conjugated(A)X + Z. + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, row_major) + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, row_major) + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, row_major) + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, row_major) + + // Z <- A scaled(X) + Z. + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, col_major) + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, col_major) + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, col_major) + gemv_interface(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, col_major) + + // Z <- transposed(A) scaled(X) + Z. + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, row_major) + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, row_major) + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, row_major) + gemv_interface(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, row_major) + + // Z <- transposed(const A) scaled(X) + Z. + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, row_major) + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, row_major) + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, row_major) + gemv_interface(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, row_major) + + // Z <- conjugated(A) scaled(X) + Z. + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, row_major) + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, row_major) + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, row_major) + gemv_interface(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, row_major) + + + /* ********************************************************************* */ + /* mult(A, x, y). */ + /* ********************************************************************* */ + +# define gemv_interface2(param1, trans1, param2, trans2, blas_name, \ + base_type, orien) \ + inline void mult_spec(param1(base_type), param2(base_type), \ + std::vector &z, orien) { \ + GMMLAPACK_TRACE("gemv_interface2"); \ + trans1(base_type); trans2(base_type); base_type beta(0); \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda(m); \ + BLAS_INT n(BLAS_INT(mat_ncols(A))), inc(1); \ + if (m && n) \ + blas_name(&t, &m, &n, &alpha, &A(0,0), &lda, &x[0], &inc, &beta, \ + &z[0], &inc); \ + else gmm::clear(z); \ + } + + // Y <- AX. + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, col_major) + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, col_major) + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, col_major) + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, col_major) + + // Y <- transposed(A)X. + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, row_major) + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, row_major) + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, row_major) + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, row_major) + + // Y <- transposed(const A)X. + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, row_major) + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, row_major) + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, row_major) + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, row_major) + + // Y <- conjugated(A)X. + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, sgemv_, + BLAS_S, row_major) + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, dgemv_, + BLAS_D, row_major) + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, cgemv_, + BLAS_C, row_major) + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_n, gemv_trans2_n, zgemv_, + BLAS_Z, row_major) + + // Y <- A scaled(X). + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, col_major) + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, col_major) + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, col_major) + gemv_interface2(gem_p1_n, gem_trans1_n, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, col_major) + + // Y <- transposed(A) scaled(X). + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, row_major) + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, row_major) + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, row_major) + gemv_interface2(gem_p1_t, gem_trans1_t, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, row_major) + + // Y <- transposed(const A) scaled(X). + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, row_major) + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, row_major) + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, row_major) + gemv_interface2(gem_p1_tc, gem_trans1_t, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, row_major) + + // Y <- conjugated(A) scaled(X). + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, sgemv_, + BLAS_S, row_major) + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, dgemv_, + BLAS_D, row_major) + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, cgemv_, + BLAS_C, row_major) + gemv_interface2(gem_p1_c, gem_trans1_c, gemv_p2_s, gemv_trans2_s, zgemv_, + BLAS_Z, row_major) + + + /* ********************************************************************* */ + /* Rank one update. */ + /* ********************************************************************* */ + +# define ger_interface(blas_name, base_type) \ + inline void rank_one_update(const dense_matrix &A, \ + const std::vector &V, \ + const std::vector &W) { \ + GMMLAPACK_TRACE("ger_interface"); \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda = m; \ + BLAS_INT n(BLAS_INT(mat_ncols(A))); \ + BLAS_INT incx = 1, incy = 1; \ + base_type alpha(1); \ + if (m && n) \ + blas_name(&m, &n, &alpha, &V[0], &incx, &W[0], &incy, &A(0,0), &lda);\ + } + + ger_interface(sger_, BLAS_S) + ger_interface(dger_, BLAS_D) + ger_interface(cgerc_, BLAS_C) + ger_interface(zgerc_, BLAS_Z) + +# define ger_interface_sn(blas_name, base_type) \ + inline void rank_one_update(const dense_matrix &A, \ + gemv_p2_s(base_type), \ + const std::vector &W) { \ + GMMLAPACK_TRACE("ger_interface"); \ + gemv_trans2_s(base_type); \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda = m; \ + BLAS_INT n(BLAS_INT(mat_ncols(A))); \ + BLAS_INT incx = 1, incy = 1; \ + if (m && n) \ + blas_name(&m, &n, &alpha, &x[0], &incx, &W[0], &incy, &A(0,0), &lda);\ + } + + ger_interface_sn(sger_, BLAS_S) + ger_interface_sn(dger_, BLAS_D) + ger_interface_sn(cgerc_, BLAS_C) + ger_interface_sn(zgerc_, BLAS_Z) + +# define ger_interface_ns(blas_name, base_type) \ + inline void rank_one_update(const dense_matrix &A, \ + const std::vector &V, \ + gemv_p2_s(base_type)) { \ + GMMLAPACK_TRACE("ger_interface"); \ + gemv_trans2_s(base_type); \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda = m; \ + BLAS_INT n(BLAS_INT(mat_ncols(A))); \ + BLAS_INT incx = 1, incy = 1; \ + base_type al2 = gmm::conj(alpha); \ + if (m && n) \ + blas_name(&m, &n, &al2, &V[0], &incx, &x[0], &incy, &A(0,0), &lda); \ + } + + ger_interface_ns(sger_, BLAS_S) + ger_interface_ns(dger_, BLAS_D) + ger_interface_ns(cgerc_, BLAS_C) + ger_interface_ns(zgerc_, BLAS_Z) + + /* ********************************************************************* */ + /* dense matrix x dense matrix multiplication. */ + /* ********************************************************************* */ + +# define gemm_interface_nn(blas_name, base_type) \ + inline void mult_spec(const dense_matrix &A, \ + const dense_matrix &B, \ + dense_matrix &C, c_mult) { \ + GMMLAPACK_TRACE("gemm_interface_nn"); \ + const char t = 'N'; \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda = m; \ + BLAS_INT k(BLAS_INT(mat_ncols(A))); \ + BLAS_INT n(BLAS_INT(mat_ncols(B))); \ + BLAS_INT ldb = k, ldc = m; \ + base_type alpha(1), beta(0); \ + if (m && k && n) \ + blas_name(&t, &t, &m, &n, &k, &alpha, \ + &A(0,0), &lda, &B(0,0), &ldb, &beta, &C(0,0), &ldc); \ + else gmm::clear(C); \ + } + + gemm_interface_nn(sgemm_, BLAS_S) + gemm_interface_nn(dgemm_, BLAS_D) + gemm_interface_nn(cgemm_, BLAS_C) + gemm_interface_nn(zgemm_, BLAS_Z) + + /* ********************************************************************* */ + /* transposed(dense matrix) x dense matrix multiplication. */ + /* ********************************************************************* */ + +# define gemm_interface_tn(blas_name, base_type, is_const) \ + inline void mult_spec( \ + const transposed_col_ref *> &A_,\ + const dense_matrix &B, \ + dense_matrix &C, rcmult) { \ + GMMLAPACK_TRACE("gemm_interface_tn"); \ + dense_matrix &A \ + = const_cast &>(*(linalg_origin(A_))); \ + const char t = 'T', u = 'N'; \ + BLAS_INT m(BLAS_INT(mat_ncols(A))), k(BLAS_INT(mat_nrows(A))); \ + BLAS_INT n(BLAS_INT(mat_ncols(B))); \ + BLAS_INT lda = k, ldb = k, ldc = m; \ + base_type alpha(1), beta(0); \ + if (m && k && n) \ + blas_name(&t, &u, &m, &n, &k, &alpha, \ + &A(0,0), &lda, &B(0,0), &ldb, &beta, &C(0,0), &ldc); \ + else gmm::clear(C); \ + } + + gemm_interface_tn(sgemm_, BLAS_S, dense_matrix) + gemm_interface_tn(dgemm_, BLAS_D, dense_matrix) + gemm_interface_tn(cgemm_, BLAS_C, dense_matrix) + gemm_interface_tn(zgemm_, BLAS_Z, dense_matrix) + gemm_interface_tn(sgemm_, BLAS_S, const dense_matrix) + gemm_interface_tn(dgemm_, BLAS_D, const dense_matrix) + gemm_interface_tn(cgemm_, BLAS_C, const dense_matrix) + gemm_interface_tn(zgemm_, BLAS_Z, const dense_matrix) + + /* ********************************************************************* */ + /* dense matrix x transposed(dense matrix) multiplication. */ + /* ********************************************************************* */ + +# define gemm_interface_nt(blas_name, base_type, is_const) \ + inline void mult_spec(const dense_matrix &A, \ + const transposed_col_ref *> &B_, \ + dense_matrix &C, r_mult) { \ + GMMLAPACK_TRACE("gemm_interface_nt"); \ + dense_matrix &B \ + = const_cast &>(*(linalg_origin(B_))); \ + const char t = 'N', u = 'T'; \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda = m; \ + BLAS_INT k(BLAS_INT(mat_ncols(A))); \ + BLAS_INT n(BLAS_INT(mat_nrows(B))); \ + BLAS_INT ldb = n, ldc = m; \ + base_type alpha(1), beta(0); \ + if (m && k && n) \ + blas_name(&t, &u, &m, &n, &k, &alpha, \ + &A(0,0), &lda, &B(0,0), &ldb, &beta, &C(0,0), &ldc); \ + else gmm::clear(C); \ + } + + gemm_interface_nt(sgemm_, BLAS_S, dense_matrix) + gemm_interface_nt(dgemm_, BLAS_D, dense_matrix) + gemm_interface_nt(cgemm_, BLAS_C, dense_matrix) + gemm_interface_nt(zgemm_, BLAS_Z, dense_matrix) + gemm_interface_nt(sgemm_, BLAS_S, const dense_matrix) + gemm_interface_nt(dgemm_, BLAS_D, const dense_matrix) + gemm_interface_nt(cgemm_, BLAS_C, const dense_matrix) + gemm_interface_nt(zgemm_, BLAS_Z, const dense_matrix) + + /* ********************************************************************* */ + /* transposed(dense matrix) x transposed(dense matrix) multiplication. */ + /* ********************************************************************* */ + +# define gemm_interface_tt(blas_name, base_type, isA_const, isB_const) \ + inline void mult_spec( \ + const transposed_col_ref *> &A_, \ + const transposed_col_ref *> &B_, \ + dense_matrix &C, r_mult) { \ + GMMLAPACK_TRACE("gemm_interface_tt"); \ + dense_matrix &A \ + = const_cast &>(*(linalg_origin(A_))); \ + dense_matrix &B \ + = const_cast &>(*(linalg_origin(B_))); \ + const char t = 'T', u = 'T'; \ + BLAS_INT m(BLAS_INT(mat_ncols(A))), k(BLAS_INT(mat_nrows(A))); \ + BLAS_INT n(BLAS_INT(mat_nrows(B))); \ + BLAS_INT lda = k, ldb = n, ldc = m; \ + base_type alpha(1), beta(0); \ + if (m && k && n) \ + blas_name(&t, &u, &m, &n, &k, &alpha, \ + &A(0,0), &lda, &B(0,0), &ldb, &beta, &C(0,0), &ldc); \ + else gmm::clear(C); \ + } + + gemm_interface_tt(sgemm_, BLAS_S, dense_matrix, dense_matrix) + gemm_interface_tt(dgemm_, BLAS_D, dense_matrix, dense_matrix) + gemm_interface_tt(cgemm_, BLAS_C, dense_matrix, dense_matrix) + gemm_interface_tt(zgemm_, BLAS_Z, dense_matrix, dense_matrix) + gemm_interface_tt(sgemm_, BLAS_S, const dense_matrix, dense_matrix) + gemm_interface_tt(dgemm_, BLAS_D, const dense_matrix, dense_matrix) + gemm_interface_tt(cgemm_, BLAS_C, const dense_matrix, dense_matrix) + gemm_interface_tt(zgemm_, BLAS_Z, const dense_matrix, dense_matrix) + gemm_interface_tt(sgemm_, BLAS_S, dense_matrix, const dense_matrix) + gemm_interface_tt(dgemm_, BLAS_D, dense_matrix, const dense_matrix) + gemm_interface_tt(cgemm_, BLAS_C, dense_matrix, const dense_matrix) + gemm_interface_tt(zgemm_, BLAS_Z, dense_matrix, const dense_matrix) + gemm_interface_tt(sgemm_, BLAS_S, const dense_matrix, const dense_matrix) + gemm_interface_tt(dgemm_, BLAS_D, const dense_matrix, const dense_matrix) + gemm_interface_tt(cgemm_, BLAS_C, const dense_matrix, const dense_matrix) + gemm_interface_tt(zgemm_, BLAS_Z, const dense_matrix, const dense_matrix) + + + /* ********************************************************************* */ + /* conjugated(dense matrix) x dense matrix multiplication. */ + /* ********************************************************************* */ + +# define gemm_interface_cn(blas_name, base_type) \ + inline void mult_spec( \ + const conjugated_col_matrix_const_ref > &A_,\ + const dense_matrix &B, \ + dense_matrix &C, rcmult) { \ + GMMLAPACK_TRACE("gemm_interface_cn"); \ + dense_matrix &A \ + = const_cast &>(*(linalg_origin(A_))); \ + const char t = 'C', u = 'N'; \ + BLAS_INT m(BLAS_INT(mat_ncols(A))), k(BLAS_INT(mat_nrows(A))); \ + BLAS_INT n(BLAS_INT(mat_ncols(B))); \ + BLAS_INT lda = k, ldb = k, ldc = m; \ + base_type alpha(1), beta(0); \ + if (m && k && n) \ + blas_name(&t, &u, &m, &n, &k, &alpha, \ + &A(0,0), &lda, &B(0,0), &ldb, &beta, &C(0,0), &ldc); \ + else gmm::clear(C); \ + } + + gemm_interface_cn(sgemm_, BLAS_S) + gemm_interface_cn(dgemm_, BLAS_D) + gemm_interface_cn(cgemm_, BLAS_C) + gemm_interface_cn(zgemm_, BLAS_Z) + + /* ********************************************************************* */ + /* dense matrix x conjugated(dense matrix) multiplication. */ + /* ********************************************************************* */ + +# define gemm_interface_nc(blas_name, base_type) \ + inline void mult_spec(const dense_matrix &A, \ + const conjugated_col_matrix_const_ref > &B_,\ + dense_matrix &C, c_mult, row_major) { \ + GMMLAPACK_TRACE("gemm_interface_nc"); \ + dense_matrix &B \ + = const_cast &>(*(linalg_origin(B_))); \ + const char t = 'N', u = 'C'; \ + BLAS_INT m(BLAS_INT(mat_nrows(A))), lda = m; \ + BLAS_INT k(BLAS_INT(mat_ncols(A))); \ + BLAS_INT n(BLAS_INT(mat_nrows(B))), ldb = n, ldc = m; \ + base_type alpha(1), beta(0); \ + if (m && k && n) \ + blas_name(&t, &u, &m, &n, &k, &alpha, \ + &A(0,0), &lda, &B(0,0), &ldb, &beta, &C(0,0), &ldc); \ + else gmm::clear(C); \ + } + + gemm_interface_nc(sgemm_, BLAS_S) + gemm_interface_nc(dgemm_, BLAS_D) + gemm_interface_nc(cgemm_, BLAS_C) + gemm_interface_nc(zgemm_, BLAS_Z) + + /* ********************************************************************* */ + /* conjugated(dense matrix) x conjugated(dense matrix) multiplication. */ + /* ********************************************************************* */ + +# define gemm_interface_cc(blas_name, base_type) \ + inline void mult_spec( \ + const conjugated_col_matrix_const_ref > &A_,\ + const conjugated_col_matrix_const_ref > &B_,\ + dense_matrix &C, r_mult) { \ + GMMLAPACK_TRACE("gemm_interface_cc"); \ + dense_matrix &A \ + = const_cast &>(*(linalg_origin(A_))); \ + dense_matrix &B \ + = const_cast &>(*(linalg_origin(B_))); \ + const char t = 'C', u = 'C'; \ + BLAS_INT m(BLAS_INT(mat_ncols(A))), k(BLAS_INT(mat_nrows(A))); \ + BLAS_INT lda = k, n(BLAS_INT(mat_nrows(B))), ldb = n, ldc = m; \ + base_type alpha(1), beta(0); \ + if (m && k && n) \ + blas_name(&t, &u, &m, &n, &k, &alpha, \ + &A(0,0), &lda, &B(0,0), &ldb, &beta, &C(0,0), &ldc); \ + else gmm::clear(C); \ + } + + gemm_interface_cc(sgemm_, BLAS_S) + gemm_interface_cc(dgemm_, BLAS_D) + gemm_interface_cc(cgemm_, BLAS_C) + gemm_interface_cc(zgemm_, BLAS_Z) + + /* ********************************************************************* */ + /* Tri solve. */ + /* ********************************************************************* */ + +# define trsv_interface(f_name, loru, param1, trans1, blas_name, base_type)\ + inline void f_name(param1(base_type), std::vector &x, \ + size_type k, bool is_unit) { \ + GMMLAPACK_TRACE("trsv_interface"); \ + loru; trans1(base_type); char d = is_unit ? 'U' : 'N'; \ + BLAS_INT lda(BLAS_INT(mat_nrows(A))), inc(1), n = BLAS_INT(k); \ + if (lda) blas_name(&l, &t, &d, &n, &A(0,0), &lda, &x[0], &inc); \ + } + +# define trsv_upper const char l = 'U' +# define trsv_lower const char l = 'L' + + // X <- LOWER(A)^{-1}X. + trsv_interface(lower_tri_solve, trsv_lower, gem_p1_n, gem_trans1_n, + strsv_, BLAS_S) + trsv_interface(lower_tri_solve, trsv_lower, gem_p1_n, gem_trans1_n, + dtrsv_, BLAS_D) + trsv_interface(lower_tri_solve, trsv_lower, gem_p1_n, gem_trans1_n, + ctrsv_, BLAS_C) + trsv_interface(lower_tri_solve, trsv_lower, gem_p1_n, gem_trans1_n, + ztrsv_, BLAS_Z) + + // X <- UPPER(A)^{-1}X. + trsv_interface(upper_tri_solve, trsv_upper, gem_p1_n, gem_trans1_n, + strsv_, BLAS_S) + trsv_interface(upper_tri_solve, trsv_upper, gem_p1_n, gem_trans1_n, + dtrsv_, BLAS_D) + trsv_interface(upper_tri_solve, trsv_upper, gem_p1_n, gem_trans1_n, + ctrsv_, BLAS_C) + trsv_interface(upper_tri_solve, trsv_upper, gem_p1_n, gem_trans1_n, + ztrsv_, BLAS_Z) + + // X <- LOWER(transposed(A))^{-1}X. + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_t, gem_trans1_t, + strsv_, BLAS_S) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_t, gem_trans1_t, + dtrsv_, BLAS_D) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_t, gem_trans1_t, + ctrsv_, BLAS_C) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_t, gem_trans1_t, + ztrsv_, BLAS_Z) + + // X <- UPPER(transposed(A))^{-1}X. + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_t, gem_trans1_t, + strsv_, BLAS_S) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_t, gem_trans1_t, + dtrsv_, BLAS_D) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_t, gem_trans1_t, + ctrsv_, BLAS_C) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_t, gem_trans1_t, + ztrsv_, BLAS_Z) + + // X <- LOWER(transposed(const A))^{-1}X. + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_tc, gem_trans1_t, + strsv_, BLAS_S) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_tc, gem_trans1_t, + dtrsv_, BLAS_D) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_tc, gem_trans1_t, + ctrsv_, BLAS_C) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_tc, gem_trans1_t, + ztrsv_, BLAS_Z) + + // X <- UPPER(transposed(const A))^{-1}X. + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_tc, gem_trans1_t, + strsv_, BLAS_S) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_tc, gem_trans1_t, + dtrsv_, BLAS_D) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_tc, gem_trans1_t, + ctrsv_, BLAS_C) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_tc, gem_trans1_t, + ztrsv_, BLAS_Z) + + // X <- LOWER(conjugated(A))^{-1}X. + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_c, gem_trans1_c, + strsv_, BLAS_S) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_c, gem_trans1_c, + dtrsv_, BLAS_D) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_c, gem_trans1_c, + ctrsv_, BLAS_C) + trsv_interface(lower_tri_solve, trsv_upper, gem_p1_c, gem_trans1_c, + ztrsv_, BLAS_Z) + + // X <- UPPER(conjugated(A))^{-1}X. + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_c, gem_trans1_c, + strsv_, BLAS_S) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_c, gem_trans1_c, + dtrsv_, BLAS_D) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_c, gem_trans1_c, + ctrsv_, BLAS_C) + trsv_interface(upper_tri_solve, trsv_lower, gem_p1_c, gem_trans1_c, + ztrsv_, BLAS_Z) + +#endif +} + +#endif // GMM_BLAS_INTERFACE_H + +#endif // GMM_USES_BLAS diff --git a/7.x/src/linear_algebra/gmm/gmm_condition_number.h b/7.x/src/linear_algebra/gmm/gmm_condition_number.h new file mode 100644 index 0000000..d5b9738 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_condition_number.h @@ -0,0 +1,147 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard, Julien Pommier + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_condition_number.h + @author Yves Renard , Julien Pommier + @date August 27, 2003. + @brief computation of the condition number of dense matrices. +*/ +#ifndef GMM_CONDITION_NUMBER_H__ +#define GMM_CONDITION_NUMBER_H__ + +#include "gmm_dense_qr.h" + +namespace gmm { + + /** computation of the condition number of dense matrices using SVD. + + Uses symmetric_qr_algorithm => dense matrices only. + + @param M a matrix. + @param emin smallest (in magnitude) eigenvalue + @param emax largest eigenvalue. + */ + template + typename number_traits::value_type>::magnitude_type + condition_number(const MAT& M, + typename number_traits::value_type>::magnitude_type& emin, + typename number_traits::value_type>::magnitude_type& emax) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + // Added because of errors in complex with zero det + if (sizeof(T) != sizeof(R) && gmm::abs(gmm::lu_det(M)) == R(0)) + return gmm::default_max(R()); + + size_type m = mat_nrows(M), n = mat_ncols(M); + emax = emin = R(0); + std::vector eig(m+n); + + if (m+n == 0) return R(0); + if (is_hermitian(M)) { + eig.resize(m); + gmm::symmetric_qr_algorithm(M, eig); + } + else { + dense_matrix B(m+n, m+n); // not very efficient ?? + gmm::copy(conjugated(M), sub_matrix(B, sub_interval(m, n), sub_interval(0, m))); + gmm::copy(M, sub_matrix(B, sub_interval(0, m), + sub_interval(m, n))); + gmm::symmetric_qr_algorithm(B, eig); + } + emin = emax = gmm::abs(eig[0]); + for (size_type i = 1; i < eig.size(); ++i) { + R e = gmm::abs(eig[i]); + emin = std::min(emin, e); + emax = std::max(emax, e); + } + // cout << "emin = " << emin << " emax = " << emax << endl; + if (emin == R(0)) return gmm::default_max(R()); + return emax / emin; + } + + template + typename number_traits::value_type>::magnitude_type + condition_number(const MAT& M) { + typename number_traits::value_type>::magnitude_type emax, emin; + return condition_number(M, emin, emax); + } + + template + typename number_traits::value_type>::magnitude_type + Frobenius_condition_number_sqr(const MAT& M) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + size_type m = mat_nrows(M), n = mat_ncols(M); + dense_matrix B(std::min(m,n), std::min(m,n)); + if (m < n) mult(M,gmm::conjugated(M),B); + else mult(gmm::conjugated(M),M,B); + R trB = abs(mat_trace(B)); + lu_inverse(B); + return trB*abs(mat_trace(B)); + } + + template + typename number_traits::value_type>::magnitude_type + Frobenius_condition_number(const MAT& M) + { return sqrt(Frobenius_condition_number_sqr(M)); } + + /** estimation of the condition number (TO BE DONE...) + */ + template + typename number_traits::value_type>::magnitude_type + condest(const MAT& M, + typename number_traits::value_type>::magnitude_type& emin, + typename number_traits::value_type>::magnitude_type& emax) { + return condition_number(M, emin, emax); + } + + template + typename number_traits::value_type>::magnitude_type + condest(const MAT& M) { + typename number_traits::value_type>::magnitude_type emax, emin; + return condest(M, emin, emax); + } +} + +#endif diff --git a/7.x/src/linear_algebra/gmm/gmm_conjugated.h b/7.x/src/linear_algebra/gmm/gmm_conjugated.h new file mode 100644 index 0000000..2ff8ad1 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_conjugated.h @@ -0,0 +1,398 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_conjugated.h + @author Yves Renard + @date September 18, 2003. + @brief handle conjugation of complex matrices/vectors. +*/ +#ifndef GMM_CONJUGATED_H__ +#define GMM_CONJUGATED_H__ + +#include "gmm_def.h" + +namespace gmm { + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + /* ********************************************************************* */ + /* Conjugated references on vectors */ + /* ********************************************************************* */ + + template struct conjugated_const_iterator { + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::difference_type difference_type; + typedef typename std::iterator_traits::iterator_category + iterator_category; + + IT it; + + conjugated_const_iterator(void) {} + conjugated_const_iterator(const IT &i) : it(i) {} + + inline size_type index(void) const { return it.index(); } + conjugated_const_iterator operator ++(int) + { conjugated_const_iterator tmp = *this; ++it; return tmp; } + conjugated_const_iterator operator --(int) + { conjugated_const_iterator tmp = *this; --it; return tmp; } + conjugated_const_iterator &operator ++() { ++it; return *this; } + conjugated_const_iterator &operator --() { --it; return *this; } + conjugated_const_iterator &operator +=(difference_type i) + { it += i; return *this; } + conjugated_const_iterator &operator -=(difference_type i) + { it -= i; return *this; } + conjugated_const_iterator operator +(difference_type i) const + { conjugated_const_iterator itb = *this; return (itb += i); } + conjugated_const_iterator operator -(difference_type i) const + { conjugated_const_iterator itb = *this; return (itb -= i); } + difference_type operator -(const conjugated_const_iterator &i) const + { return difference_type(it - i.it); } + + value_type operator *() const { return gmm::conj(*it); } + value_type operator [](size_type ii) const { return gmm::conj(it[ii]); } + + bool operator ==(const conjugated_const_iterator &i) const + { return (i.it == it); } + bool operator !=(const conjugated_const_iterator &i) const + { return (i.it != it); } + bool operator < (const conjugated_const_iterator &i) const + { return (it < i.it); } + }; + + template struct conjugated_vector_const_ref { + typedef conjugated_vector_const_ref this_type; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::const_iterator iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::origin_type origin_type; + + iterator begin_, end_; + const origin_type *origin; + size_type size_; + + conjugated_vector_const_ref(const V &v) + : begin_(vect_const_begin(v)), end_(vect_const_end(v)), + origin(linalg_origin(v)), + size_(vect_size(v)) {} + + reference operator[](size_type i) const + { return gmm::conj(linalg_traits::access(origin, begin_, end_, i)); } + }; + + template struct linalg_traits > { + typedef conjugated_vector_const_ref this_type; + typedef typename linalg_traits::origin_type origin_type; + typedef linalg_const is_reference; + typedef abstract_vector linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef value_type reference; + typedef abstract_null_type iterator; + typedef conjugated_const_iterator::const_iterator> const_iterator; + typedef typename linalg_traits::storage_type storage_type; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type size(const this_type &v) { return v.size_; } + static iterator begin(this_type &v) { return iterator(v.begin_); } + static const_iterator begin(const this_type &v) + { return const_iterator(v.begin_); } + static iterator end(this_type &v) + { return iterator(v.end_); } + static const_iterator end(const this_type &v) + { return const_iterator(v.end_); } + static value_type access(const origin_type *o, const const_iterator &it, + const const_iterator &ite, size_type i) + { return gmm::conj(linalg_traits::access(o, it.it, ite.it, i)); } + static const origin_type* origin(const this_type &v) { return v.origin; } + }; + + template std::ostream &operator << + (std::ostream &o, const conjugated_vector_const_ref& m) + { gmm::write(o,m); return o; } + + /* ********************************************************************* */ + /* Conjugated references on matrices */ + /* ********************************************************************* */ + + template struct conjugated_row_const_iterator { + typedef conjugated_row_const_iterator iterator; + typedef typename linalg_traits::const_row_iterator ITER; + typedef typename linalg_traits::value_type value_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + + ITER it; + + iterator operator ++(int) { iterator tmp = *this; it++; return tmp; } + iterator operator --(int) { iterator tmp = *this; it--; return tmp; } + iterator &operator ++() { it++; return *this; } + iterator &operator --() { it--; return *this; } + iterator &operator +=(difference_type i) { it += i; return *this; } + iterator &operator -=(difference_type i) { it -= i; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const + { return it - i.it; } + + ITER operator *() const { return it; } + ITER operator [](int i) { return it + i; } + + bool operator ==(const iterator &i) const { return (it == i.it); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (it < i.it); } + + conjugated_row_const_iterator(void) {} + conjugated_row_const_iterator(const ITER &i) : it(i) { } + + }; + + template struct conjugated_row_matrix_const_ref { + + typedef conjugated_row_matrix_const_ref this_type; + typedef typename linalg_traits::const_row_iterator iterator; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::origin_type origin_type; + + iterator begin_, end_; + const origin_type *origin; + size_type nr, nc; + + conjugated_row_matrix_const_ref(const M &m) + : begin_(mat_row_begin(m)), end_(mat_row_end(m)), + origin(linalg_origin(m)), nr(mat_ncols(m)), nc(mat_nrows(m)) {} + + value_type operator()(size_type i, size_type j) const + { return gmm::conj(linalg_traits::access(begin_+j, i)); } + }; + + template std::ostream &operator << + (std::ostream &o, const conjugated_row_matrix_const_ref& m) + { gmm::write(o,m); return o; } + + + template struct conjugated_col_const_iterator { + typedef conjugated_col_const_iterator iterator; + typedef typename linalg_traits::const_col_iterator ITER; + typedef typename linalg_traits::value_type value_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + + ITER it; + + iterator operator ++(int) { iterator tmp = *this; it++; return tmp; } + iterator operator --(int) { iterator tmp = *this; it--; return tmp; } + iterator &operator ++() { it++; return *this; } + iterator &operator --() { it--; return *this; } + iterator &operator +=(difference_type i) { it += i; return *this; } + iterator &operator -=(difference_type i) { it -= i; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const + { return it - i.it; } + + ITER operator *() const { return it; } + ITER operator [](int i) { return it + i; } + + bool operator ==(const iterator &i) const { return (it == i.it); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (it < i.it); } + + conjugated_col_const_iterator(void) {} + conjugated_col_const_iterator(const ITER &i) : it(i) { } + + }; + + template struct conjugated_col_matrix_const_ref { + + typedef conjugated_col_matrix_const_ref this_type; + typedef typename linalg_traits::const_col_iterator iterator; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::origin_type origin_type; + + iterator begin_, end_; + const origin_type *origin; + size_type nr, nc; + + conjugated_col_matrix_const_ref(const M &m) + : begin_(mat_col_begin(m)), end_(mat_col_end(m)), + origin(linalg_origin(m)), nr(mat_ncols(m)), nc(mat_nrows(m)) {} + + value_type operator()(size_type i, size_type j) const + { return gmm::conj(linalg_traits::access(begin_+i, j)); } + }; + + + + template std::ostream &operator << + (std::ostream &o, const conjugated_col_matrix_const_ref& m) + { gmm::write(o,m); return o; } + + + template struct conjugated_return__ { + typedef conjugated_row_matrix_const_ref return_type; + }; + template struct conjugated_return__ { + typedef conjugated_col_matrix_const_ref return_type; + }; + template struct conjugated_return_ { + typedef const L & return_type; + }; + template + struct conjugated_return_, abstract_vector> { + typedef conjugated_vector_const_ref return_type; + }; + template + struct conjugated_return_ { + typedef typename conjugated_return__::sub_orientation>::potype + >::return_type return_type; + }; + template struct conjugated_return { + typedef typename + conjugated_return_::value_type, + typename linalg_traits::linalg_type + >::return_type return_type; + }; + + ///@endcond + /** return a conjugated view of the input matrix or vector. */ + template inline + typename conjugated_return::return_type + conjugated(const L &v) { + return conjugated(v, typename linalg_traits::value_type(), + typename linalg_traits::linalg_type()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + template inline + const L & conjugated(const L &v, T, LT) { return v; } + + template inline + conjugated_vector_const_ref conjugated(const L &v, std::complex, + abstract_vector) + { return conjugated_vector_const_ref(v); } + + template inline + typename conjugated_return__::sub_orientation>::potype>::return_type + conjugated(const L &v, T, abstract_matrix) { + return conjugated(v, typename principal_orientation_type::sub_orientation>::potype()); + } + + template inline + conjugated_row_matrix_const_ref conjugated(const L &v, row_major) + { return conjugated_row_matrix_const_ref(v); } + + template inline + conjugated_col_matrix_const_ref conjugated(const L &v, col_major) + { return conjugated_col_matrix_const_ref(v); } + + template + struct linalg_traits > { + typedef conjugated_row_matrix_const_ref this_type; + typedef typename linalg_traits::origin_type origin_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef value_type reference; + typedef typename linalg_traits::storage_type storage_type; + typedef typename org_type::const_sub_row_type>::t vector_type; + typedef conjugated_vector_const_ref sub_col_type; + typedef conjugated_vector_const_ref const_sub_col_type; + typedef conjugated_row_const_iterator col_iterator; + typedef conjugated_row_const_iterator const_col_iterator; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_row_iterator; + typedef abstract_null_type row_iterator; + typedef col_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static inline size_type ncols(const this_type &m) { return m.nc; } + static inline size_type nrows(const this_type &m) { return m.nr; } + static inline const_sub_col_type col(const const_col_iterator &it) + { return conjugated(linalg_traits::row(it.it)); } + static inline const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(m.begin_); } + static inline const_col_iterator col_end(const this_type &m) + { return const_col_iterator(m.end_); } + static inline const origin_type* origin(const this_type &m) + { return m.origin; } + static value_type access(const const_col_iterator &it, size_type i) + { return gmm::conj(linalg_traits::access(it.it, i)); } + }; + + template + struct linalg_traits > { + typedef conjugated_col_matrix_const_ref this_type; + typedef typename linalg_traits::origin_type origin_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef value_type reference; + typedef typename linalg_traits::storage_type storage_type; + typedef typename org_type::const_sub_col_type>::t vector_type; + typedef conjugated_vector_const_ref sub_row_type; + typedef conjugated_vector_const_ref const_sub_row_type; + typedef conjugated_col_const_iterator row_iterator; + typedef conjugated_col_const_iterator const_row_iterator; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_col_iterator; + typedef abstract_null_type col_iterator; + typedef row_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static inline size_type nrows(const this_type &m) { return m.nr; } + static inline size_type ncols(const this_type &m) { return m.nc; } + static inline const_sub_row_type row(const const_row_iterator &it) + { return conjugated(linalg_traits::col(it.it)); } + static inline const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(m.begin_); } + static inline const_row_iterator row_end(const this_type &m) + { return const_row_iterator(m.end_); } + static inline const origin_type* origin(const this_type &m) + { return m.origin; } + static value_type access(const const_row_iterator &it, size_type i) + { return gmm::conj(linalg_traits::access(it.it, i)); } + }; + + ///@endcond + + +} + +#endif // GMM_CONJUGATED_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_def.h b/7.x/src/linear_algebra/gmm/gmm_def.h new file mode 100644 index 0000000..25468c7 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_def.h @@ -0,0 +1,1122 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_def.h + @author Yves Renard + @date October 13, 2002. + @brief Basic definitions and tools of GMM. +*/ +#ifndef GMM_DEF_H__ +#define GMM_DEF_H__ + +#include "gmm_ref.h" +#include + +#ifndef M_PI +# define M_E 2.7182818284590452354 /* e */ +# define M_LOG2E 1.4426950408889634074 /* 1/ln(2) */ +# define M_LOG10E 0.43429448190325182765 /* 1/ln(10) */ +# define M_LN2 0.69314718055994530942 /* ln(2) */ +# define M_LN10 2.30258509299404568402 /* ln(10) */ +# define M_PI 3.14159265358979323846 /* pi */ +# define M_PI_2 1.57079632679489661923 /* pi/2 */ +# define M_PI_4 0.78539816339744830962 /* pi/4 */ +# define M_1_PI 0.31830988618379067154 /* 1/pi */ +# define M_2_PI 0.63661977236758134308 /* 2/pi */ +# define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */ +# define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ +# define M_SQRT1_2 0.70710678118654752440 /* sqrt(2)/2 */ +#endif + +#ifndef M_PIl +# define M_PIl 3.1415926535897932384626433832795029L /* pi */ +# define M_PI_2l 1.5707963267948966192313216916397514L /* pi/2 */ +# define M_PI_4l 0.7853981633974483096156608458198757L /* pi/4 */ +# define M_1_PIl 0.3183098861837906715377675267450287L /* 1/pi */ +# define M_2_PIl 0.6366197723675813430755350534900574L /* 2/pi */ +# define M_2_SQRTPIl 1.1283791670955125738961589031215452L /* 2/sqrt(pi) */ +#endif + +namespace gmm { + + typedef size_t size_type; + + /* ******************************************************************** */ + /* Specifier types */ + /* ******************************************************************** */ + /* not perfectly null, required by aCC 3.33 */ + struct abstract_null_type { + abstract_null_type(int=0) {} + template void operator()(A,B,C) {} + }; // specify an information lake. + + struct linalg_true {}; + struct linalg_false {}; + + template struct linalg_and + { typedef linalg_false bool_type; }; + template <> struct linalg_and + { typedef linalg_true bool_type; }; + template struct linalg_or + { typedef linalg_true bool_type; }; + template <> struct linalg_and + { typedef linalg_false bool_type; }; + + struct linalg_const {}; // A reference is either linalg_const, + struct linalg_modifiable {}; // linalg_modifiable or linalg_false. + + struct abstract_vector {}; // The object is a vector + struct abstract_matrix {}; // The object is a matrix + + struct abstract_sparse {}; // sparse matrix or vector + struct abstract_skyline {}; // 'sky-line' matrix or vector + struct abstract_dense {}; // dense matrix or vector + struct abstract_indirect {}; // matrix given by the product with a vector + + struct row_major {}; // matrix with a row access. + struct col_major {}; // matrix with a column access + struct row_and_col {}; // both accesses but row preference + struct col_and_row {}; // both accesses but column preference + + template struct transposed_type; + template<> struct transposed_type {typedef col_major t_type;}; + template<> struct transposed_type {typedef row_major t_type;}; + template<> struct transposed_type {typedef col_and_row t_type;}; + template<> struct transposed_type {typedef row_and_col t_type;}; + + template struct principal_orientation_type + { typedef abstract_null_type potype; }; + template<> struct principal_orientation_type + { typedef row_major potype; }; + template<> struct principal_orientation_type + { typedef col_major potype; }; + template<> struct principal_orientation_type + { typedef row_major potype; }; + template<> struct principal_orientation_type + { typedef col_major potype; }; + + // template struct linalg_traits; + template struct linalg_traits { + typedef abstract_null_type this_type; + typedef abstract_null_type linalg_type; + typedef abstract_null_type value_type; + typedef abstract_null_type is_reference; + typedef abstract_null_type& reference; + typedef abstract_null_type* iterator; + typedef const abstract_null_type* const_iterator; + typedef abstract_null_type index_sorted; + typedef abstract_null_type storage_type; + typedef abstract_null_type origin_type; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_row_iterator; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_col_iterator; + typedef abstract_null_type col_iterator; + typedef abstract_null_type sub_orientation; + }; + + template struct vect_ref_type; + template struct vect_ref_type

{ + typedef typename linalg_traits::reference access_type; + typedef typename linalg_traits::iterator iterator; + }; + template struct vect_ref_type { + typedef typename linalg_traits::value_type access_type; + typedef typename linalg_traits::const_iterator iterator; + }; + + template struct const_pointer; + template struct const_pointer

+ { typedef const P* pointer; }; + template struct const_pointer + { typedef const P* pointer; }; + + template struct modifiable_pointer; + template struct modifiable_pointer

+ { typedef P* pointer; }; + template struct modifiable_pointer + { typedef P* pointer; }; + + template struct const_reference; + template struct const_reference + { typedef const R &reference; }; + template struct const_reference + { typedef const R &reference; }; + + + inline bool is_sparse(abstract_sparse) { return true; } + inline bool is_sparse(abstract_dense) { return false; } + inline bool is_sparse(abstract_skyline) { return true; } + inline bool is_sparse(abstract_indirect) { return false; } + + template inline bool is_sparse(const L &) + { return is_sparse(typename linalg_traits::storage_type()); } + + inline bool is_row_matrix_(row_major) { return true; } + inline bool is_row_matrix_(col_major) { return false; } + inline bool is_row_matrix_(row_and_col) { return true; } + inline bool is_row_matrix_(col_and_row) { return true; } + + template inline bool is_row_matrix(const L &) + { return is_row_matrix_(typename linalg_traits::sub_orientation()); } + + inline bool is_col_matrix_(row_major) { return false; } + inline bool is_col_matrix_(col_major) { return true; } + inline bool is_col_matrix_(row_and_col) { return true; } + inline bool is_col_matrix_(col_and_row) { return true; } + + template inline bool is_col_matrix(const L &) + { return is_col_matrix_(typename linalg_traits::sub_orientation()); } + + inline bool is_col_matrix(row_major) { return false; } + inline bool is_col_matrix(col_major) { return true; } + inline bool is_row_matrix(row_major) { return true; } + inline bool is_row_matrix(col_major) { return false; } + + template inline bool is_const_reference(L) { return false; } + inline bool is_const_reference(linalg_const) { return true; } + + + template struct is_gmm_interfaced_ { + typedef linalg_true result; + }; + + template<> struct is_gmm_interfaced_ { + typedef linalg_false result; + }; + + template struct is_gmm_interfaced { + typedef typename is_gmm_interfaced_::this_type >::result result; + }; + + /* ******************************************************************** */ + /* Original type from a pointer or a reference. */ + /* ******************************************************************** */ + + template struct org_type { typedef V t; }; + template struct org_type { typedef V t; }; + template struct org_type { typedef V t; }; + template struct org_type { typedef V t; }; + template struct org_type { typedef V t; }; + + /* ******************************************************************** */ + /* Types to deal with const object representing a modifiable reference */ + /* ******************************************************************** */ + + template struct mref_type_ + { typedef abstract_null_type return_type; }; + template struct mref_type_ + { typedef typename org_type::t & return_type; }; + template struct mref_type_ + { typedef const typename org_type::t & return_type; }; + template struct mref_type_ + { typedef const typename org_type::t & return_type; }; + template struct mref_type_ + { typedef const typename org_type::t & return_type; }; + template struct mref_type_ + { typedef typename org_type::t & return_type; }; + template struct mref_type_ + { typedef typename org_type::t & return_type; }; + + template struct mref_type { + typedef typename std::iterator_traits::value_type L; + typedef typename mref_type_::is_reference>::return_type return_type; + }; + + template typename mref_type::return_type + linalg_cast(const L &l) + { return const_cast::return_type>(l); } + + template typename mref_type::return_type linalg_cast(L &l) + { return const_cast::return_type>(l); } + + template struct cref_type_ + { typedef abstract_null_type return_type; }; + template struct cref_type_ + { typedef typename org_type::t & return_type; }; + template struct cref_type { + typedef typename cref_type_::is_reference>::return_type return_type; + }; + + template typename cref_type::return_type + linalg_const_cast(const L &l) + { return const_cast::return_type>(l); } + + + // To be used to select between a reference or a const refercence for + // the return type of a function + // select_return return C1 if L is a const reference, + // C2 otherwise. + // select_return return C2 if L is a modifiable reference + // C1 otherwise. + template struct select_return_ { + typedef abstract_null_type return_type; + }; + template + struct select_return_ { typedef C1 return_type; }; + template + struct select_return_ { typedef C2 return_type; }; + template struct select_return { + typedef typename std::iterator_traits::value_type L; + typedef typename select_return_::return_type>::return_type return_type; + }; + + + // To be used to select between a reference or a const refercence inside + // a structure or a linagl_traits + // select_ref return C1 if L is a const reference, + // C2 otherwise. + // select_ref return C2 in any case. + template struct select_ref_ + { typedef abstract_null_type ref_type; }; + template + struct select_ref_ { typedef C1 ref_type; }; + template + struct select_ref_ { typedef C2 ref_type; }; + template struct select_ref { + typedef typename std::iterator_traits::value_type L; + typedef typename select_ref_::return_type>::ref_type ref_type; + }; + template + struct select_ref + { typedef C1 ref_type; }; + + + template struct is_a_reference_ + { typedef linalg_true reference; }; + template<> struct is_a_reference_ + { typedef linalg_false reference; }; + + template struct is_a_reference { + typedef typename is_a_reference_::is_reference> + ::reference reference; + }; + + + template inline bool is_original_linalg(const L &) + { return is_original_linalg(typename is_a_reference::reference()); } + inline bool is_original_linalg(linalg_false) { return true; } + inline bool is_original_linalg(linalg_true) { return false; } + + + template struct which_reference + { typedef abstract_null_type is_reference; }; + template struct which_reference + { typedef linalg_modifiable is_reference; }; + template struct which_reference + { typedef linalg_const is_reference; }; + + + template struct select_orientation_ + { typedef abstract_null_type return_type; }; + template + struct select_orientation_ + { typedef C1 return_type; }; + template + struct select_orientation_ + { typedef C2 return_type; }; + template struct select_orientation { + typedef typename select_orientation_::sub_orientation>::potype>::return_type return_type; + }; + + /* ******************************************************************** */ + /* Operations on scalars */ + /* ******************************************************************** */ + + template inline T sqr(T a) { return T(a * a); } + template inline T abs(T a) { return (a < T(0)) ? T(-a) : a; } + template inline T abs(std::complex a) + { T x = a.real(), y = a.imag(); return T(::sqrt(x*x+y*y)); } + template inline T abs_sqr(T a) { return T(a*a); } + template inline T abs_sqr(std::complex a) + { return gmm::sqr(a.real()) + gmm::sqr(a.imag()); } + template inline T pos(T a) { return (a < T(0)) ? T(0) : a; } + template inline T neg(T a) { return (a < T(0)) ? T(-a) : T(0); } + template inline T sgn(T a) { return (a < T(0)) ? T(-1) : T(1); } + template inline T Heaviside(T a) { return (a < T(0)) ? T(0) : T(1); } + inline double random() { return double(rand())/(RAND_MAX+0.5); } + template inline T random(T) + { return T(rand()*2.0)/(T(RAND_MAX)+T(1)/T(2)) - T(1); } + template inline std::complex random(std::complex) + { return std::complex(gmm::random(T()), gmm::random(T())); } + template inline T irandom(T max) + { return T(gmm::random() * double(max)); } + template inline T conj(T a) { return a; } + template inline std::complex conj(std::complex a) + { return std::conj(a); } + template inline T real(T a) { return a; } + template inline T real(std::complex a) { return a.real(); } + template inline T imag(T ) { return T(0); } + template inline T imag(std::complex a) { return a.imag(); } + template inline T sqrt(T a) { return T(::sqrt(a)); } + template inline std::complex sqrt(std::complex a) { + T x = a.real(), y = a.imag(); + if (x == T(0)) { + T t = T(::sqrt(gmm::abs(y) / T(2))); + return std::complex(t, y < T(0) ? -t : t); + } + T t = T(::sqrt(T(2) * (gmm::abs(a) + gmm::abs(x)))), u = t / T(2); + return x > T(0) ? std::complex(u, y / t) + : std::complex(gmm::abs(y) / t, y < T(0) ? -u : u); + } + using std::swap; + + + template struct number_traits { + typedef T magnitude_type; + }; + + template struct number_traits > { + typedef T magnitude_type; + }; + + template inline T conj_product(T a, T b) { return a * b; } + template inline + std::complex conj_product(std::complex a, std::complex b) + { return std::conj(a) * b; } // to be optimized ? + + template inline bool is_complex(T) { return false; } + template inline bool is_complex(std::complex ) + { return true; } + +# define magnitude_of_linalg(M) typename number_traits::value_type>::magnitude_type + + /* ******************************************************************** */ + /* types promotion */ + /* ******************************************************************** */ + + /* should be completed for more specific cases etc */ + template + struct strongest_numeric_type_aux { + typedef T1 T; + }; + template + struct strongest_numeric_type_aux { + typedef T2 T; + }; + + template + struct strongest_numeric_type { + typedef typename + strongest_numeric_type_auxsizeof(T2))>::T T; + }; + template + struct strongest_numeric_type > { + typedef typename number_traits::magnitude_type R1; + typedef std::complex::T > T; + }; + template + struct strongest_numeric_type,T2 > { + typedef typename number_traits::magnitude_type R2; + typedef std::complex::T > T; + }; + template + struct strongest_numeric_type,std::complex > { + typedef std::complex::T > T; + }; + + template<> struct strongest_numeric_type { typedef float T; }; + template<> struct strongest_numeric_type { typedef float T; }; + template<> struct strongest_numeric_type { typedef float T; }; + template<> struct strongest_numeric_type { typedef float T; }; + template<> struct strongest_numeric_type { typedef double T; }; + template<> struct strongest_numeric_type { typedef double T; }; + + template + struct strongest_value_type { + typedef typename + strongest_numeric_type::value_type, + typename linalg_traits::value_type>::T + value_type; + }; + template + struct strongest_value_type3 { + typedef typename + strongest_value_type::value_type>::value_type + value_type; + }; + + + + /* ******************************************************************** */ + /* Basic vectors used */ + /* ******************************************************************** */ + + template struct dense_vector_type + { typedef std::vector vector_type; }; + + template class wsvector; + template class rsvector; + template class dsvector; + template struct sparse_vector_type + { typedef wsvector vector_type; }; + + template class slvector; + template class dense_matrix; + template class row_matrix; + template class col_matrix; + + + /* ******************************************************************** */ + /* Selects a temporary vector type */ + /* V if V is a valid vector type, */ + /* wsvector if V is a reference on a sparse vector, */ + /* std::vector if V is a reference on a dense vector. */ + /* ******************************************************************** */ + + + template + struct temporary_vector_ { + typedef abstract_null_type vector_type; + }; + template + struct temporary_vector_ + { typedef wsvector::value_type> vector_type; }; + template + struct temporary_vector_ + { typedef slvector::value_type> vector_type; }; + template + struct temporary_vector_ + { typedef std::vector::value_type> vector_type; }; + template + struct temporary_vector_ + { typedef V vector_type; }; + template + struct temporary_vector_ + { typedef std::vector::value_type> vector_type; }; + template + struct temporary_vector_ + { typedef wsvector::value_type> vector_type; }; + + template struct temporary_vector { + typedef typename temporary_vector_::reference, + typename linalg_traits::storage_type, + typename linalg_traits::linalg_type, + V>::vector_type vector_type; + }; + + /* ******************************************************************** */ + /* Selects a temporary matrix type */ + /* M if M is a valid matrix type, */ + /* row_matrix if M is a reference on a sparse matrix, */ + /* dense_matrix if M is a reference on a dense matrix. */ + /* ******************************************************************** */ + + + template + struct temporary_matrix_ { typedef abstract_null_type matrix_type; }; + template + struct temporary_matrix_ { + typedef typename linalg_traits::value_type T; + typedef row_matrix > matrix_type; + }; + template + struct temporary_matrix_ { + typedef typename linalg_traits::value_type T; + typedef row_matrix > matrix_type; + }; + template + struct temporary_matrix_ + { typedef dense_matrix::value_type> matrix_type; }; + template + struct temporary_matrix_ + { typedef V matrix_type; }; + + template struct temporary_matrix { + typedef typename temporary_matrix_::reference, + typename linalg_traits::storage_type, + typename linalg_traits::linalg_type, + V>::matrix_type matrix_type; + }; + + + template + struct temporary_col_matrix_ { typedef abstract_null_type matrix_type; }; + template + struct temporary_col_matrix_ { + typedef typename linalg_traits::value_type T; + typedef col_matrix > matrix_type; + }; + template + struct temporary_col_matrix_ { + typedef typename linalg_traits::value_type T; + typedef col_matrix > matrix_type; + }; + template + struct temporary_col_matrix_ + { typedef dense_matrix::value_type> matrix_type; }; + + template struct temporary_col_matrix { + typedef typename temporary_col_matrix_< + typename linalg_traits::storage_type, + typename linalg_traits::linalg_type, + V>::matrix_type matrix_type; + }; + + + + + template + struct temporary_row_matrix_ { typedef abstract_null_type matrix_type; }; + template + struct temporary_row_matrix_ { + typedef typename linalg_traits::value_type T; + typedef row_matrix > matrix_type; + }; + template + struct temporary_row_matrix_ { + typedef typename linalg_traits::value_type T; + typedef row_matrix > matrix_type; + }; + template + struct temporary_row_matrix_ + { typedef dense_matrix::value_type> matrix_type; }; + + template struct temporary_row_matrix { + typedef typename temporary_row_matrix_< + typename linalg_traits::storage_type, + typename linalg_traits::linalg_type, + V>::matrix_type matrix_type; + }; + + + + /* ******************************************************************** */ + /* Selects a temporary dense vector type */ + /* V if V is a valid dense vector type, */ + /* std::vector if V is a reference or another type of vector */ + /* ******************************************************************** */ + + template + struct temporary_dense_vector_ { typedef abstract_null_type vector_type; }; + template + struct temporary_dense_vector_ + { typedef std::vector::value_type> vector_type; }; + template + struct temporary_dense_vector_ + { typedef std::vector::value_type> vector_type; }; + template + struct temporary_dense_vector_ + { typedef std::vector::value_type> vector_type; }; + template + struct temporary_dense_vector_ + { typedef V vector_type; }; + + template struct temporary_dense_vector { + typedef typename temporary_dense_vector_::reference, + typename linalg_traits::storage_type, V>::vector_type vector_type; + }; + + /* ******************************************************************** */ + /* Selects a temporary sparse vector type */ + /* V if V is a valid sparse vector type, */ + /* wsvector if V is a reference or another type of vector */ + /* ******************************************************************** */ + + template + struct temporary_sparse_vector_ { typedef abstract_null_type vector_type; }; + template + struct temporary_sparse_vector_ + { typedef wsvector::value_type> vector_type; }; + template + struct temporary_sparse_vector_ + { typedef V vector_type; }; + template + struct temporary_sparse_vector_ + { typedef wsvector::value_type> vector_type; }; + template + struct temporary_sparse_vector_ + { typedef wsvector::value_type> vector_type; }; + + template struct temporary_sparse_vector { + typedef typename temporary_sparse_vector_::reference, + typename linalg_traits::storage_type, V>::vector_type vector_type; + }; + + /* ******************************************************************** */ + /* Selects a temporary sky-line vector type */ + /* V if V is a valid sky-line vector type, */ + /* slvector if V is a reference or another type of vector */ + /* ******************************************************************** */ + + template + struct temporary_skyline_vector_ + { typedef abstract_null_type vector_type; }; + template + struct temporary_skyline_vector_ + { typedef slvector::value_type> vector_type; }; + template + struct temporary_skyline_vector_ + { typedef V vector_type; }; + template + struct temporary_skyline_vector_ + { typedef slvector::value_type> vector_type; }; + template + struct temporary_skyline_vector_ + { typedef slvector::value_type> vector_type; }; + + template struct temporary_skylines_vector { + typedef typename temporary_skyline_vector_::reference, + typename linalg_traits::storage_type, V>::vector_type vector_type; + }; + + /* ********************************************************************* */ + /* Definition & Comparison of origins. */ + /* ********************************************************************* */ + + template + typename select_return::origin_type *, + typename linalg_traits::origin_type *, + L *>::return_type + linalg_origin(L &l) + { return linalg_traits::origin(linalg_cast(l)); } + + template + typename select_return::origin_type *, + typename linalg_traits::origin_type *, + const L *>::return_type + linalg_origin(const L &l) + { return linalg_traits::origin(linalg_cast(l)); } + + template + bool same_porigin(PT1, PT2) { return false; } + + template + bool same_porigin(PT pt1, PT pt2) { return (pt1 == pt2); } + + template + bool same_origin(const L1 &l1, const L2 &l2) + { return same_porigin(linalg_origin(l1), linalg_origin(l2)); } + + + /* ******************************************************************** */ + /* Miscellaneous */ + /* ******************************************************************** */ + + template inline size_type vect_size(const V &v) + { return linalg_traits::size(v); } + + template inline size_type mat_nrows(const MAT &m) + { return linalg_traits::nrows(m); } + + template inline size_type mat_ncols(const MAT &m) + { return linalg_traits::ncols(m); } + + + template inline + typename select_return::const_iterator, + typename linalg_traits::iterator, V *>::return_type + vect_begin(V &v) + { return linalg_traits::begin(linalg_cast(v)); } + + template inline + typename select_return::const_iterator, + typename linalg_traits::iterator, const V *>::return_type + vect_begin(const V &v) + { return linalg_traits::begin(linalg_cast(v)); } + + template inline + typename linalg_traits::const_iterator + vect_const_begin(const V &v) + { return linalg_traits::begin(v); } + + template inline + typename select_return::const_iterator, + typename linalg_traits::iterator, V *>::return_type + vect_end(V &v) + { return linalg_traits::end(linalg_cast(v)); } + + template inline + typename select_return::const_iterator, + typename linalg_traits::iterator, const V *>::return_type + vect_end(const V &v) + { return linalg_traits::end(linalg_cast(v)); } + + template inline + typename linalg_traits::const_iterator + vect_const_end(const V &v) + { return linalg_traits::end(v); } + + template inline + typename select_return::const_row_iterator, + typename linalg_traits::row_iterator, M *>::return_type + mat_row_begin(M &m) { return linalg_traits::row_begin(linalg_cast(m)); } + + template inline + typename select_return::const_row_iterator, + typename linalg_traits::row_iterator, const M *>::return_type + mat_row_begin(const M &m) + { return linalg_traits::row_begin(linalg_cast(m)); } + + template inline typename linalg_traits::const_row_iterator + mat_row_const_begin(const M &m) + { return linalg_traits::row_begin(m); } + + template inline + typename select_return::const_row_iterator, + typename linalg_traits::row_iterator, M *>::return_type + mat_row_end(M &v) { + return linalg_traits::row_end(linalg_cast(v)); + } + + template inline + typename select_return::const_row_iterator, + typename linalg_traits::row_iterator, const M *>::return_type + mat_row_end(const M &v) { + return linalg_traits::row_end(linalg_cast(v)); + } + + template inline + typename linalg_traits::const_row_iterator + mat_row_const_end(const M &v) + { return linalg_traits::row_end(v); } + + template inline + typename select_return::const_col_iterator, + typename linalg_traits::col_iterator, M *>::return_type + mat_col_begin(M &v) { + return linalg_traits::col_begin(linalg_cast(v)); + } + + template inline + typename select_return::const_col_iterator, + typename linalg_traits::col_iterator, const M *>::return_type + mat_col_begin(const M &v) { + return linalg_traits::col_begin(linalg_cast(v)); + } + + template inline + typename linalg_traits::const_col_iterator + mat_col_const_begin(const M &v) + { return linalg_traits::col_begin(v); } + + template inline + typename linalg_traits::const_col_iterator + mat_col_const_end(const M &v) + { return linalg_traits::col_end(v); } + + template inline + typename select_return::const_col_iterator, + typename linalg_traits::col_iterator, + M *>::return_type + mat_col_end(M &m) + { return linalg_traits::col_end(linalg_cast(m)); } + + template inline + typename select_return::const_col_iterator, + typename linalg_traits::col_iterator, + const M *>::return_type + mat_col_end(const M &m) + { return linalg_traits::col_end(linalg_cast(m)); } + + template inline + typename select_return::const_sub_row_type, + typename linalg_traits::sub_row_type, + const MAT *>::return_type + mat_row(const MAT &m, size_type i) + { return linalg_traits::row(mat_row_begin(m) + i); } + + template inline + typename select_return::const_sub_row_type, + typename linalg_traits::sub_row_type, + MAT *>::return_type + mat_row(MAT &m, size_type i) + { return linalg_traits::row(mat_row_begin(m) + i); } + + template inline + typename linalg_traits::const_sub_row_type + mat_const_row(const MAT &m, size_type i) + { return linalg_traits::row(mat_row_const_begin(m) + i); } + + template inline + typename select_return::const_sub_col_type, + typename linalg_traits::sub_col_type, + const MAT *>::return_type + mat_col(const MAT &m, size_type i) + { return linalg_traits::col(mat_col_begin(m) + i); } + + + template inline + typename select_return::const_sub_col_type, + typename linalg_traits::sub_col_type, + MAT *>::return_type + mat_col(MAT &m, size_type i) + { return linalg_traits::col(mat_col_begin(m) + i); } + + template inline + typename linalg_traits::const_sub_col_type + mat_const_col(const MAT &m, size_type i) + { return linalg_traits::col(mat_col_const_begin(m) + i); } + + /* ********************************************************************* */ + /* Set to begin end set to end for iterators on non-const sparse vectors.*/ + /* ********************************************************************* */ + + template inline + void set_to_begin(IT &it, ORG o, VECT *, linalg_false) + { it = vect_begin(*o); } + + template inline + void set_to_begin(IT &it, ORG o, const VECT *, linalg_false) + { it = vect_const_begin(*o); } + + template inline + void set_to_end(IT &it, ORG o, VECT *, linalg_false) + { it = vect_end(*o); } + + template inline + void set_to_end(IT &it, ORG o, const VECT *, linalg_false) + { it = vect_const_end(*o); } + + + template inline + void set_to_begin(IT &, ORG, VECT *, linalg_const) { } + + template inline + void set_to_begin(IT &, ORG, const VECT *, linalg_const) { } + + template inline + void set_to_end(IT &, ORG, VECT *, linalg_const) { } + + template inline + void set_to_end(IT &, ORG, const VECT *, linalg_const) { } + + template inline + void set_to_begin(IT &, ORG, VECT *v, linalg_modifiable) + { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; } + + template inline + void set_to_begin(IT &, ORG, const VECT *v, linalg_modifiable) + { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; } + + template inline + void set_to_end(IT &, ORG, VECT *v, linalg_modifiable) + { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; } + + template inline + void set_to_end(IT &, ORG, const VECT *v, linalg_modifiable) + { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; } + + /* ******************************************************************** */ + /* General index for certain algorithms. */ + /* ******************************************************************** */ + + template + size_type index_of_it(const IT &it, size_type, abstract_sparse) + { return it.index(); } + template + size_type index_of_it(const IT &it, size_type, abstract_skyline) + { return it.index(); } + template + size_type index_of_it(const IT &, size_type k, abstract_dense) + { return k; } + + /* ********************************************************************* */ + /* Numeric limits. */ + /* ********************************************************************* */ + + template inline T default_tol(T) { + using namespace std; + static T tol(10); + if (tol == T(10)) { + if (numeric_limits::is_specialized) + tol = numeric_limits::epsilon(); + else { + int i=int(sizeof(T)/4); while(i-- > 0) tol*=T(1E-8); + GMM_WARNING1("The numeric type " << typeid(T).name() + << " has no numeric_limits defined !!\n" + << "Taking " << tol << " as default tolerance"); + } + } + return tol; + } + template inline T default_tol(std::complex) + { return default_tol(T()); } + + template inline T default_min(T) { + using namespace std; + static T mi(10); + if (mi == T(10)) { + if (numeric_limits::is_specialized) + mi = std::numeric_limits::min(); + else { + mi = T(0); + GMM_WARNING1("The numeric type " << typeid(T).name() + << " has no numeric_limits defined !!\n" + << "Taking 0 as default minimum"); + } + } + return mi; + } + template inline T default_min(std::complex) + { return default_min(T()); } + + template inline T default_max(T) { + using namespace std; + static T mi(10); + if (mi == T(10)) { + if (numeric_limits::is_specialized) + mi = std::numeric_limits::max(); + else { + mi = T(1); + GMM_WARNING1("The numeric type " << typeid(T).name() + << " has no numeric_limits defined !!\n" + << "Taking 1 as default maximum !"); + } + } + return mi; + } + template inline T default_max(std::complex) + { return default_max(T()); } + + + /* + use safe_divide to avoid NaNs when dividing very small complex + numbers, for example + std::complex(1e-23,1e-30)/std::complex(1e-23,1e-30) + */ + template inline T safe_divide(T a, T b) { return a/b; } + template inline std::complex + safe_divide(std::complex a, std::complex b) { + T m = std::max(gmm::abs(b.real()), gmm::abs(b.imag())); + a = std::complex(a.real()/m, a.imag()/m); + b = std::complex(b.real()/m, b.imag()/m); + return a / b; + } + + + /* ******************************************************************** */ + /* Write */ + /* ******************************************************************** */ + + template struct cast_char_type { typedef T return_type; }; + template <> struct cast_char_type { typedef int return_type; }; + template <> struct cast_char_type + { typedef unsigned int return_type; }; + template inline typename cast_char_type::return_type + cast_char(const T &c) { return typename cast_char_type::return_type(c); } + + + template inline void write(std::ostream &o, const L &l) + { write(o, l, typename linalg_traits::linalg_type()); } + + template void write(std::ostream &o, const L &l, + abstract_vector) { + o << "vector(" << vect_size(l) << ") ["; + write(o, l, typename linalg_traits::storage_type()); + o << " ]"; + } + + template void write(std::ostream &o, const L &l, + abstract_sparse) { + typename linalg_traits::const_iterator it = vect_const_begin(l), + ite = vect_const_end(l); + for (; it != ite; ++it) + o << " (r" << it.index() << ", " << cast_char(*it) << ")"; + } + + template void write(std::ostream &o, const L &l, + abstract_dense) { + typename linalg_traits::const_iterator it = vect_const_begin(l), + ite = vect_const_end(l); + if (it != ite) o << " " << cast_char(*it++); + for (; it != ite; ++it) o << ", " << cast_char(*it); + } + + template void write(std::ostream &o, const L &l, + abstract_skyline) { + typedef typename linalg_traits::const_iterator const_iterator; + const_iterator it = vect_const_begin(l), ite = vect_const_end(l); + if (it != ite) { + o << ""; + if (it != ite) o << " " << cast_char(*it++); + for (; it != ite; ++it) { o << ", " << cast_char(*it); } + } + } + + template inline void write(std::ostream &o, const L &l, + abstract_matrix) { + write(o, l, typename linalg_traits::sub_orientation()); + } + + + template void write(std::ostream &o, const L &l, + row_major) { + o << "matrix(" << mat_nrows(l) << ", " << mat_ncols(l) << ")" << endl; + for (size_type i = 0; i < mat_nrows(l); ++i) { + o << "("; + write(o, mat_const_row(l, i), typename linalg_traits::storage_type()); + o << " )\n"; + } + } + + template inline + void write(std::ostream &o, const L &l, row_and_col) + { write(o, l, row_major()); } + + template inline + void write(std::ostream &o, const L &l, col_and_row) + { write(o, l, row_major()); } + + template void write(std::ostream &o, const L &l, col_major) { + o << "matrix(" << mat_nrows(l) << ", " << mat_ncols(l) << ")" << endl; + for (size_type i = 0; i < mat_nrows(l); ++i) { + o << "("; + if (is_sparse(l)) { // not optimized ... + for (size_type j = 0; j < mat_ncols(l); ++j) + if (l(i,j) != typename linalg_traits::value_type(0)) + o << " (r" << j << ", " << l(i,j) << ")"; + } + else { + if (mat_ncols(l) != 0) o << ' ' << l(i, 0); + for (size_type j = 1; j < mat_ncols(l); ++j) o << ", " << l(i, j); + } + o << " )\n"; + } + } + +} + +#endif // GMM_DEF_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_dense_Householder.h b/7.x/src/linear_algebra/gmm/gmm_dense_Householder.h new file mode 100644 index 0000000..ea010ed --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_dense_Householder.h @@ -0,0 +1,317 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard, Caroline Lecalvez + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_dense_Householder.h + @author Caroline Lecalvez + @author Yves Renard + @date June 5, 2003. + @brief Householder for dense matrices. +*/ + +#ifndef GMM_DENSE_HOUSEHOLDER_H +#define GMM_DENSE_HOUSEHOLDER_H + +#include "gmm_kernel.h" + +namespace gmm { + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + /* ********************************************************************* */ + /* Rank one update (complex and real version) */ + /* ********************************************************************* */ + + template + inline void rank_one_update(Matrix &A, const VecX& x, + const VecY& y, row_major) { + typedef typename linalg_traits::value_type T; + size_type N = mat_nrows(A); + GMM_ASSERT2(N <= vect_size(x) && mat_ncols(A) <= vect_size(y), + "dimensions mismatch"); + typename linalg_traits::const_iterator itx = vect_const_begin(x); + for (size_type i = 0; i < N; ++i, ++itx) { + typedef typename linalg_traits::sub_row_type row_type; + row_type row = mat_row(A, i); + typename linalg_traits::t>::iterator + it = vect_begin(row), ite = vect_end(row); + typename linalg_traits::const_iterator ity = vect_const_begin(y); + T tx = *itx; + for (; it != ite; ++it, ++ity) *it += conj_product(*ity, tx); + } + } + + template + inline void rank_one_update(Matrix &A, const VecX& x, + const VecY& y, col_major) { + typedef typename linalg_traits::value_type T; + size_type M = mat_ncols(A); + GMM_ASSERT2(mat_nrows(A) <= vect_size(x) && M <= vect_size(y), + "dimensions mismatch"); + typename linalg_traits::const_iterator ity = vect_const_begin(y); + for (size_type i = 0; i < M; ++i, ++ity) { + typedef typename linalg_traits::sub_col_type col_type; + col_type col = mat_col(A, i); + typename linalg_traits::t>::iterator + it = vect_begin(col), ite = vect_end(col); + typename linalg_traits::const_iterator itx = vect_const_begin(x); + T ty = *ity; + for (; it != ite; ++it, ++itx) *it += conj_product(ty, *itx); + } + } + + ///@endcond + template + inline void rank_one_update(const Matrix &AA, const VecX& x, + const VecY& y) { + Matrix& A = const_cast(AA); + rank_one_update(A, x, y, typename principal_orientation_type::sub_orientation>::potype()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + /* ********************************************************************* */ + /* Rank two update (complex and real version) */ + /* ********************************************************************* */ + + template + inline void rank_two_update(Matrix &A, const VecX& x, + const VecY& y, row_major) { + typedef typename linalg_traits::value_type value_type; + size_type N = mat_nrows(A); + GMM_ASSERT2(N <= vect_size(x) && mat_ncols(A) <= vect_size(y), + "dimensions mismatch"); + typename linalg_traits::const_iterator itx1 = vect_const_begin(x); + typename linalg_traits::const_iterator ity2 = vect_const_begin(y); + for (size_type i = 0; i < N; ++i, ++itx1, ++ity2) { + typedef typename linalg_traits::sub_row_type row_type; + row_type row = mat_row(A, i); + typename linalg_traits::t>::iterator + it = vect_begin(row), ite = vect_end(row); + typename linalg_traits::const_iterator itx2 = vect_const_begin(x); + typename linalg_traits::const_iterator ity1 = vect_const_begin(y); + value_type tx = *itx1, ty = *ity2; + for (; it != ite; ++it, ++ity1, ++itx2) + *it += conj_product(*ity1, tx) + conj_product(*itx2, ty); + } + } + + template + inline void rank_two_update(Matrix &A, const VecX& x, + const VecY& y, col_major) { + typedef typename linalg_traits::value_type value_type; + size_type M = mat_ncols(A); + GMM_ASSERT2(mat_nrows(A) <= vect_size(x) && M <= vect_size(y), + "dimensions mismatch"); + typename linalg_traits::const_iterator itx2 = vect_const_begin(x); + typename linalg_traits::const_iterator ity1 = vect_const_begin(y); + for (size_type i = 0; i < M; ++i, ++ity1, ++itx2) { + typedef typename linalg_traits::sub_col_type col_type; + col_type col = mat_col(A, i); + typename linalg_traits::t>::iterator + it = vect_begin(col), ite = vect_end(col); + typename linalg_traits::const_iterator itx1 = vect_const_begin(x); + typename linalg_traits::const_iterator ity2 = vect_const_begin(y); + value_type ty = *ity1, tx = *itx2; + for (; it != ite; ++it, ++itx1, ++ity2) + *it += conj_product(ty, *itx1) + conj_product(tx, *ity2); + } + } + + ///@endcond + template + inline void rank_two_update(const Matrix &AA, const VecX& x, + const VecY& y) { + Matrix& A = const_cast(AA); + rank_two_update(A, x, y, typename principal_orientation_type::sub_orientation>::potype()); + } + ///@cond DOXY_SHOW_ALL_FUNCTIONS + + /* ********************************************************************* */ + /* Householder vector computation (complex and real version) */ + /* ********************************************************************* */ + + template void house_vector(const VECT &VV) { + VECT &V = const_cast(VV); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + R mu = vect_norm2(V), abs_v0 = gmm::abs(V[0]); + if (mu != R(0)) + gmm::scale(V, (abs_v0 == R(0)) ? T(R(1) / mu) + : (safe_divide(T(abs_v0), V[0]) / (abs_v0 + mu))); + if (gmm::real(V[vect_size(V)-1]) * R(0) != R(0)) gmm::clear(V); + V[0] = T(1); + } + + template void house_vector_last(const VECT &VV) { + VECT &V = const_cast(VV); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type m = vect_size(V); + R mu = vect_norm2(V), abs_v0 = gmm::abs(V[m-1]); + if (mu != R(0)) + gmm::scale(V, (abs_v0 == R(0)) ? T(R(1) / mu) + : ((abs_v0 / V[m-1]) / (abs_v0 + mu))); + if (gmm::real(V[0]) * R(0) != R(0)) gmm::clear(V); + V[m-1] = T(1); + } + + /* ********************************************************************* */ + /* Householder updates (complex and real version) */ + /* ********************************************************************* */ + + // multiply A to the left by the reflector stored in V. W is a temporary. + template inline + void row_house_update(const MAT &AA, const VECT1 &V, const VECT2 &WW) { + VECT2 &W = const_cast(WW); MAT &A = const_cast(AA); + typedef typename linalg_traits::value_type value_type; + typedef typename number_traits::magnitude_type magnitude_type; + + gmm::mult(conjugated(A), + scaled(V, value_type(magnitude_type(-2)/vect_norm2_sqr(V))), W); + rank_one_update(A, V, W); + } + + // multiply A to the right by the reflector stored in V. W is a temporary. + template inline + void col_house_update(const MAT &AA, const VECT1 &V, const VECT2 &WW) { + VECT2 &W = const_cast(WW); MAT &A = const_cast(AA); + typedef typename linalg_traits::value_type value_type; + typedef typename number_traits::magnitude_type magnitude_type; + + gmm::mult(A, + scaled(V, value_type(magnitude_type(-2)/vect_norm2_sqr(V))), W); + rank_one_update(A, W, V); + } + + ///@endcond + + /* ********************************************************************* */ + /* Hessenberg reduction with Householder. */ + /* ********************************************************************* */ + + template + void Hessenberg_reduction(const MAT1& AA, const MAT2 &QQ, bool compute_Q){ + MAT1& A = const_cast(AA); MAT2& Q = const_cast(QQ); + typedef typename linalg_traits::value_type value_type; + if (compute_Q) gmm::copy(identity_matrix(), Q); + size_type n = mat_nrows(A); if (n < 2) return; + std::vector v(n), w(n); + sub_interval SUBK(0,n); + for (size_type k = 1; k+1 < n; ++k) { + sub_interval SUBI(k, n-k), SUBJ(k-1,n-k+1); + v.resize(n-k); + for (size_type j = k; j < n; ++j) v[j-k] = A(j, k-1); + house_vector(v); + row_house_update(sub_matrix(A, SUBI, SUBJ), v, sub_vector(w, SUBJ)); + col_house_update(sub_matrix(A, SUBK, SUBI), v, w); + // is it possible to "unify" the two on the common part of the matrix? + if (compute_Q) col_house_update(sub_matrix(Q, SUBK, SUBI), v, w); + } + } + + /* ********************************************************************* */ + /* Householder tridiagonalization for symmetric matrices */ + /* ********************************************************************* */ + + template + void Householder_tridiagonalization(const MAT1 &AA, const MAT2 &QQ, + bool compute_q) { + MAT1 &A = const_cast(AA); MAT2 &Q = const_cast(QQ); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = mat_nrows(A); if (n < 2) return; + std::vector v(n), p(n), w(n), ww(n); + sub_interval SUBK(0,n); + + for (size_type k = 1; k+1 < n; ++k) { // not optimized ... + sub_interval SUBI(k, n-k); + v.resize(n-k); p.resize(n-k); w.resize(n-k); + for (size_type l = k; l < n; ++l) + { v[l-k] = w[l-k] = A(l, k-1); A(l, k-1) = A(k-1, l) = T(0); } + house_vector(v); + R norm = vect_norm2_sqr(v); + A(k-1, k) = gmm::conj(A(k, k-1) = w[0] - T(2)*v[0]*vect_hp(w, v)/norm); + + gmm::mult(sub_matrix(A, SUBI), gmm::scaled(v, T(-2) / norm), p); + gmm::add(p, gmm::scaled(v, -vect_hp(v, p) / norm), w); + rank_two_update(sub_matrix(A, SUBI), v, w); + // it should be possible to compute only the upper or lower part + + if (compute_q) col_house_update(sub_matrix(Q, SUBK, SUBI), v, ww); + } + } + + /* ********************************************************************* */ + /* Real and complex Givens rotations */ + /* ********************************************************************* */ + + template void Givens_rotation(T a, T b, T &c, T &s) { + typedef typename number_traits::magnitude_type R; + R aa = gmm::abs(a), bb = gmm::abs(b); + if (bb == R(0)) { c = T(1); s = T(0); return; } + if (aa == R(0)) { c = T(0); s = b / bb; return; } + if (bb > aa) + { T t = -safe_divide(a,b); s = T(R(1) / (sqrt(R(1)+gmm::abs_sqr(t)))); c = s * t; } + else + { T t = -safe_divide(b,a); c = T(R(1) / (sqrt(R(1)+gmm::abs_sqr(t)))); s = c * t; } + } + + // Apply Q* v + template inline + void Apply_Givens_rotation_left(T &x, T &y, T c, T s) + { T t1=x, t2=y; x = gmm::conj(c)*t1 - gmm::conj(s)*t2; y = c*t2 + s*t1; } + + // Apply v^T Q + template inline + void Apply_Givens_rotation_right(T &x, T &y, T c, T s) + { T t1=x, t2=y; x = c*t1 - s*t2; y = gmm::conj(c)*t2 + gmm::conj(s)*t1; } + + template + void row_rot(const MAT &AA, T c, T s, size_type i, size_type k) { + MAT &A = const_cast(AA); // can be specialized for row matrices + for (size_type j = 0; j < mat_ncols(A); ++j) + Apply_Givens_rotation_left(A(i,j), A(k,j), c, s); + } + + template + void col_rot(const MAT &AA, T c, T s, size_type i, size_type k) { + MAT &A = const_cast(AA); // can be specialized for column matrices + for (size_type j = 0; j < mat_nrows(A); ++j) + Apply_Givens_rotation_right(A(j,i), A(j,k), c, s); + } + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_dense_lu.h b/7.x/src/linear_algebra/gmm/gmm_dense_lu.h new file mode 100644 index 0000000..33fbbcb --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_dense_lu.h @@ -0,0 +1,288 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of lu.h from MTL. +// See http://osl.iu.edu/research/mtl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_dense_lu.h + @author Andrew Lumsdaine, Jeremy G. Siek, Lie-Quan Lee, Y. Renard + @date June 5, 2003. + @brief LU factorizations and determinant computation for dense matrices. +*/ +#ifndef GMM_DENSE_LU_H +#define GMM_DENSE_LU_H + +#include "gmm_dense_Householder.h" + +namespace gmm { + + /* ********************************************************************** */ + /* IPVT structure. */ + /* ********************************************************************** */ + // For compatibility with lapack version with 64 or 32 bit integer. + // Should be replaced by std::vector if 32 bit integer version + // of lapack is not used anymore (and lapack_ipvt_int set to size_type) + + // Do not use iterators of this interface container + class lapack_ipvt : public std::vector { + bool is_int64; + size_type &operator[](size_type i) + { return std::vector::operator[](i); } + size_type operator[] (size_type i) const + { return std::vector::operator[](i); } + void begin(void) const {} + void begin(void) {} + void end(void) const {} + void end(void) {} + + public: + void set_to_int32() { is_int64 = false; } + const size_type *pfirst() const + { return &(*(std::vector::begin())); } + size_type *pfirst() { return &(*(std::vector::begin())); } + + lapack_ipvt(size_type n) : std::vector(n), is_int64(true) {} + + size_type get(size_type i) const { + const size_type *p = pfirst(); + return is_int64 ? p[i] : size_type(((const int *)(p))[i]); + } + void set(size_type i, size_type val) { + size_type *p = pfirst(); + if (is_int64) p[i] = val; else ((int *)(p))[i] = int(val); + } + }; +} + +#include "gmm_opt.h" + +namespace gmm { + + /** LU Factorization of a general (dense) matrix (real or complex). + + This is the outer product (a level-2 operation) form of the LU + Factorization with pivoting algorithm . This is equivalent to + LAPACK's dgetf2. Also see "Matrix Computations" 3rd Ed. by Golub + and Van Loan section 3.2.5 and especially page 115. + + The pivot indices in ipvt are indexed starting from 1 + so that this is compatible with LAPACK (Fortran). + */ + template + size_type lu_factor(DenseMatrix& A, lapack_ipvt& ipvt) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + size_type info(0), i, j, jp, M(mat_nrows(A)), N(mat_ncols(A)); + size_type NN = std::min(M, N); + std::vector c(M), r(N); + + GMM_ASSERT2(ipvt.size()+1 >= NN, "IPVT too small"); + for (i = 0; i+1 < NN; ++i) ipvt.set(i, i); + + if (M || N) { + for (j = 0; j+1 < NN; ++j) { + R max = gmm::abs(A(j,j)); jp = j; + for (i = j+1; i < M; ++i) /* find pivot. */ + if (gmm::abs(A(i,j)) > max) { jp = i; max = gmm::abs(A(i,j)); } + ipvt.set(j, jp + 1); + + if (max == R(0)) { info = j + 1; break; } + if (jp != j) for (i = 0; i < N; ++i) std::swap(A(jp, i), A(j, i)); + + for (i = j+1; i < M; ++i) { A(i, j) /= A(j,j); c[i-j-1] = -A(i, j); } + for (i = j+1; i < N; ++i) r[i-j-1] = A(j, i); // avoid the copy ? + rank_one_update(sub_matrix(A, sub_interval(j+1, M-j-1), + sub_interval(j+1, N-j-1)), c, conjugated(r)); + } + ipvt.set(NN-1, NN); + } + return info; + } + + /** LU Solve : Solve equation Ax=b, given an LU factored matrix.*/ + // Thanks to Valient Gough for this routine! + template + void lu_solve(const DenseMatrix &LU, const Pvector& pvector, + VectorX &x, const VectorB &b) { + typedef typename linalg_traits::value_type T; + copy(b, x); + for(size_type i = 0; i < pvector.size(); ++i) { + size_type perm = pvector.get(i)-1; // permutations stored in 1's offset + if(i != perm) { T aux = x[i]; x[i] = x[perm]; x[perm] = aux; } + } + /* solve Ax = b -> LUx = b -> Ux = L^-1 b. */ + lower_tri_solve(LU, x, true); + upper_tri_solve(LU, x, false); + } + + template + void lu_solve(const DenseMatrix &A, VectorX &x, const VectorB &b) { + typedef typename linalg_traits::value_type T; + dense_matrix B(mat_nrows(A), mat_ncols(A)); + lapack_ipvt ipvt(mat_nrows(A)); + gmm::copy(A, B); + size_type info = lu_factor(B, ipvt); + GMM_ASSERT1(!info, "Singular system, pivot = " << info); + lu_solve(B, ipvt, x, b); + } + + template + void lu_solve_transposed(const DenseMatrix &LU, const Pvector& pvector, + VectorX &x, const VectorB &b) { + typedef typename linalg_traits::value_type T; + copy(b, x); + lower_tri_solve(transposed(LU), x, false); + upper_tri_solve(transposed(LU), x, true); + for(size_type i = pvector.size(); i > 0; --i) { + size_type perm = pvector.get(i-1)-1; // permutations stored in 1's offset + if(i-1 != perm) { T aux = x[i-1]; x[i-1] = x[perm]; x[perm] = aux; } + } + } + + + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template + void lu_inverse(const DenseMatrixLU& LU, const Pvector& pvector, + DenseMatrix& AInv, col_major) { + typedef typename linalg_traits::value_type T; + std::vector tmp(pvector.size(), T(0)); + std::vector result(pvector.size()); + for(size_type i = 0; i < pvector.size(); ++i) { + tmp[i] = T(1); + lu_solve(LU, pvector, result, tmp); + copy(result, mat_col(AInv, i)); + tmp[i] = T(0); + } + } + + template + void lu_inverse(const DenseMatrixLU& LU, const Pvector& pvector, + DenseMatrix& AInv, row_major) { + typedef typename linalg_traits::value_type T; + std::vector tmp(pvector.size(), T(0)); + std::vector result(pvector.size()); + for(size_type i = 0; i < pvector.size(); ++i) { + tmp[i] = T(1); // to be optimized !! + // on peut sur le premier tri solve reduire le systeme + // et peut etre faire un solve sur une serie de vecteurs au lieu + // de vecteur a vecteur (accumulation directe de l'inverse dans la + // matrice au fur et a mesure du calcul ... -> evite la copie finale + lu_solve_transposed(LU, pvector, result, tmp); + copy(result, mat_row(AInv, i)); + tmp[i] = T(0); + } + } + ///@endcond + + /** Given an LU factored matrix, build the inverse of the matrix. */ + template + void lu_inverse(const DenseMatrixLU& LU, const Pvector& pvector, + const DenseMatrix& AInv_) { + DenseMatrix& AInv = const_cast(AInv_); + lu_inverse(LU, pvector, AInv, typename principal_orientation_type::sub_orientation>::potype()); + } + + /** Given a dense matrix, build the inverse of the matrix, and + return the determinant */ + template + typename linalg_traits::value_type + lu_inverse(const DenseMatrix& A_, bool doassert = true) { + typedef typename linalg_traits::value_type T; + DenseMatrix& A = const_cast(A_); + dense_matrix B(mat_nrows(A), mat_ncols(A)); + lapack_ipvt ipvt(mat_nrows(A)); + gmm::copy(A, B); + size_type info = lu_factor(B, ipvt); + if (doassert) GMM_ASSERT1(!info, "Non invertible matrix, pivot = "< + typename linalg_traits::value_type + lu_det(const DenseMatrixLU& LU, const Pvector &pvector) { + typedef typename linalg_traits::value_type T; + T det(1); + for (size_type j = 0; j < std::min(mat_nrows(LU), mat_ncols(LU)); ++j) + det *= LU(j,j); + for(size_type i = 0; i < pvector.size(); ++i) + if (i != size_type(pvector.get(i)-1)) { det = -det; } + return det; + } + + template + typename linalg_traits::value_type + lu_det(const DenseMatrix& A) { + typedef typename linalg_traits::value_type T; + dense_matrix B(mat_nrows(A), mat_ncols(A)); + lapack_ipvt ipvt(mat_nrows(A)); + gmm::copy(A, B); + lu_factor(B, ipvt); + return lu_det(B, ipvt); + } + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_dense_matrix_functions.h b/7.x/src/linear_algebra/gmm/gmm_dense_matrix_functions.h new file mode 100644 index 0000000..3cd18b6 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_dense_matrix_functions.h @@ -0,0 +1,302 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2014-2020 Konstantinos Poulios + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_dense_matrix_functions.h + @author Konstantinos Poulios + @date December 10, 2014. + @brief Common matrix functions for dense matrices. +*/ +#ifndef GMM_DENSE_MATRIX_FUNCTIONS_H +#define GMM_DENSE_MATRIX_FUNCTIONS_H + + +namespace gmm { + + + /** + Matrix square root for upper triangular matrices (from GNU Octave). + */ + template + void sqrtm_utri_inplace(dense_matrix& A) + { + typedef typename number_traits::magnitude_type R; + bool singular = false; + + // The following code is equivalent to this triple loop: + // + // n = rows (A); + // for j = 1:n + // A(j,j) = sqrt (A(j,j)); + // for i = j-1:-1:1 + // A(i,j) /= (A(i,i) + A(j,j)); + // k = 1:i-1; + // t storing a A(k,j) -= A(k,i) * A(i,j); + // endfor + // endfor + + R tol = R(0); // default_tol(R()) * gmm::mat_maxnorm(A); + + const size_type n = mat_nrows(A); + for (int j=0; j < int(n); j++) { + typename dense_matrix::iterator colj = A.begin() + j*n; + if (gmm::abs(colj[j]) > tol) + colj[j] = gmm::sqrt(colj[j]); + else + singular = true; + + for (int i=j-1; i >= 0; i--) { + typename dense_matrix::const_iterator coli = A.begin() + i*n; + T colji = colj[i] = safe_divide(colj[i], (coli[i] + colj[j])); + for (int k = 0; k < i; k++) + colj[k] -= coli[k] * colji; + } + } + + if (singular) + GMM_WARNING1("Matrix is singular, may not have a square root"); + } + + + template + void sqrtm(const dense_matrix >& A, + dense_matrix >& SQRTMA) + { + GMM_ASSERT1(gmm::mat_nrows(A) == gmm::mat_ncols(A), + "Matrix square root requires a square matrix"); + gmm::resize(SQRTMA, gmm::mat_nrows(A), gmm::mat_ncols(A)); + dense_matrix > S(A), Q(A), TMP(A); + #if defined(GMM_USES_LAPACK) + schur(TMP, S, Q); + #else + GMM_ASSERT1(false, "Please recompile with lapack and blas librairies " + "to use sqrtm matrix function."); + #endif + sqrtm_utri_inplace(S); + gmm::mult(Q, S, TMP); + gmm::mult(TMP, gmm::transposed(Q), SQRTMA); + } + + template + void sqrtm(const dense_matrix& A, + dense_matrix >& SQRTMA) + { + dense_matrix > cA(mat_nrows(A), mat_ncols(A)); + gmm::copy(A, gmm::real_part(cA)); + sqrtm(cA, SQRTMA); + } + + template + void sqrtm(const dense_matrix& A, dense_matrix& SQRTMA) + { + dense_matrix > cA(mat_nrows(A), mat_ncols(A)); + gmm::copy(A, gmm::real_part(cA)); + dense_matrix > cSQRTMA(cA); + sqrtm(cA, cSQRTMA); + gmm::resize(SQRTMA, gmm::mat_nrows(A), gmm::mat_ncols(A)); + gmm::copy(gmm::real_part(cSQRTMA), SQRTMA); +// dense_matrix >::const_reference +// it = cSQRTMA.begin(), ite = cSQRTMA.end(); +// dense_matrix >::reference +// rit = SQRTMA.begin(); +// for (; it != ite; ++it, ++rit) *rit = it->real(); + } + + + /** + Matrix logarithm for upper triangular matrices (from GNU/Octave) + */ + template + void logm_utri_inplace(dense_matrix& S) + { + typedef typename number_traits::magnitude_type R; + + size_type n = gmm::mat_nrows(S); + GMM_ASSERT1(n == gmm::mat_ncols(S), + "Matrix logarithm is not defined for non-square matrices"); + for (size_type i=0; i < n-1; ++i) + if (gmm::abs(S(i+1,i)) > default_tol(T())) { + GMM_ASSERT1(false, "An upper triangular matrix is expected"); + break; + } + for (size_type i=0; i < n-1; ++i) + if (gmm::real(S(i,i)) <= -default_tol(R()) && + gmm::abs(gmm::imag(S(i,i))) <= default_tol(R())) { + GMM_ASSERT1(false, "Principal matrix logarithm is not defined " + "for matrices with negative eigenvalues"); + break; + } + + // Algorithm 11.9 in "Function of matrices", by N. Higham + R theta[] = { R(0),R(0),R(1.61e-2),R(5.38e-2),R(1.13e-1),R(1.86e-1),R(2.6429608311114350e-1) }; + + R scaling(1); + size_type p(0), m(6), opt_iters(100); + for (size_type k=0; k < opt_iters; ++k, scaling *= R(2)) { + dense_matrix auxS(S); + for (size_type i = 0; i < n; ++i) auxS(i,i) -= R(1); + R tau = gmm::mat_norm1(auxS); + if (tau <= theta[6]) { + ++p; + size_type j1(6), j2(6); + for (size_type j=0; j < 6; ++j) + if (tau <= theta[j]) { j1 = j; break; } + for (size_type j=0; j < j1; ++j) + if (tau <= 2*theta[j]) { j2 = j; break; } + if (j1 - j2 <= 1 || p == 2) { m = j1; break; } + } + sqrtm_utri_inplace(S); + if (k == opt_iters-1) + GMM_WARNING1 ("Maximum number of square roots exceeded; " + "the calculated matrix logarithm may still be accurate"); + } + + for (size_type i = 0; i < n; ++i) S(i,i) -= R(1); + + if (m > 0) { + + std::vector nodes, wts; + switch(m) { + case 0: { + R nodes_[] = { R(0.5) }; + R wts_[] = { R(1) }; + nodes.assign(nodes_, nodes_+m+1); + wts.assign(wts_, wts_+m+1); + } break; + case 1: { + R nodes_[] = { R(0.211324865405187),R(0.788675134594813) }; + R wts_[] = { R(0.5),R(0.5) }; + nodes.assign(nodes_, nodes_+m+1); + wts.assign(wts_, wts_+m+1); + } break; + case 2: { + R nodes_[] = { R(0.112701665379258),R(0.500000000000000),R(0.887298334620742) }; + R wts_[] = { R(0.277777777777778),R(0.444444444444444),R(0.277777777777778) }; + nodes.assign(nodes_, nodes_+m+1); + wts.assign(wts_, wts_+m+1); + } break; + case 3: { + R nodes_[] = { R(0.0694318442029737),R(0.3300094782075718),R(0.6699905217924281),R(0.9305681557970263) }; + R wts_[] = { R(0.173927422568727),R(0.326072577431273),R(0.326072577431273),R(0.173927422568727) }; + nodes.assign(nodes_, nodes_+m+1); + wts.assign(wts_, wts_+m+1); + } break; + case 4: { + R nodes_[] = { R(0.0469100770306681),R(0.2307653449471584),R(0.5000000000000000),R(0.7692346550528415),R(0.9530899229693319) }; + R wts_[] = { R(0.118463442528095),R(0.239314335249683),R(0.284444444444444),R(0.239314335249683),R(0.118463442528094) }; + nodes.assign(nodes_, nodes_+m+1); + wts.assign(wts_, wts_+m+1); + } break; + case 5: { + R nodes_[] = { R(0.0337652428984240),R(0.1693953067668678),R(0.3806904069584015),R(0.6193095930415985),R(0.8306046932331322),R(0.9662347571015761) }; + R wts_[] = { R(0.0856622461895853),R(0.1803807865240693),R(0.2339569672863452),R(0.2339569672863459),R(0.1803807865240693),R(0.0856622461895852) }; + nodes.assign(nodes_, nodes_+m+1); + wts.assign(wts_, wts_+m+1); + } break; + case 6: { + R nodes_[] = { R(0.0254460438286208),R(0.1292344072003028),R(0.2970774243113015),R(0.4999999999999999),R(0.7029225756886985),R(0.8707655927996973),R(0.9745539561713792) }; + R wts_[] = { R(0.0647424830844348),R(0.1398526957446384),R(0.1909150252525594),R(0.2089795918367343),R(0.1909150252525595),R(0.1398526957446383),R(0.0647424830844349) }; + nodes.assign(nodes_, nodes_+m+1); + wts.assign(wts_, wts_+m+1); + } break; + } + + dense_matrix auxS1(S), auxS2(S); + std::vector auxvec(n); + gmm::clear(S); + for (size_type j=0; j <= m; ++j) { + gmm::copy(gmm::scaled(auxS1, nodes[j]), auxS2); + gmm::add(gmm::identity_matrix(), auxS2); + // S += wts[i] * auxS1 * inv(auxS2) + for (size_type i=0; i < n; ++i) { + gmm::copy(gmm::mat_row(auxS1, i), auxvec); + gmm::lower_tri_solve(gmm::transposed(auxS2), auxvec, false); + gmm::add(gmm::scaled(auxvec, wts[j]), gmm::mat_row(S, i)); + } + } + } + gmm::scale(S, scaling); + } + + /** + Matrix logarithm (from GNU/Octave) + */ + template + void logm(const dense_matrix& A, dense_matrix& LOGMA) + { + typedef typename number_traits::magnitude_type R; + size_type n = gmm::mat_nrows(A); + GMM_ASSERT1(n == gmm::mat_ncols(A), + "Matrix logarithm is not defined for non-square matrices"); + dense_matrix S(A), Q(A); + #if defined(GMM_USES_LAPACK) + schur(A, S, Q); // A = Q * S * Q^T + #else + GMM_ASSERT1(false, "Please recompile with lapack and blas librairies " + "to use logm matrix function."); + #endif + + bool convert_to_complex(false); + if (!is_complex(T())) + for (size_type i=0; i < n-1; ++i) + if (gmm::abs(S(i+1,i)) > default_tol(T())) { + convert_to_complex = true; + break; + } + + gmm::resize(LOGMA, n, n); + if (convert_to_complex) { + dense_matrix > cS(n,n), cQ(n,n), auxmat(n,n); + gmm::copy(gmm::real_part(S), gmm::real_part(cS)); + gmm::copy(gmm::real_part(Q), gmm::real_part(cQ)); + block2x2_reduction(cS, cQ, default_tol(R())*R(3)); + for (size_type j=0; j < n-1; ++j) + for (size_type i=j+1; i < n; ++i) + cS(i,j) = T(0); + logm_utri_inplace(cS); + gmm::mult(cQ, cS, auxmat); + gmm::mult(auxmat, gmm::transposed(cQ), cS); + // Remove small complex values which may have entered calculation + gmm::copy(gmm::real_part(cS), LOGMA); +// GMM_ASSERT1(gmm::mat_norm1(gmm::imag_part(cS)) < n*default_tol(T()), +// "Internal error, imag part should be zero"); + } else { + dense_matrix auxmat(n,n); + logm_utri_inplace(S); + gmm::mult(Q, S, auxmat); + gmm::mult(auxmat, gmm::transposed(Q), LOGMA); + } + + } + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_dense_qr.h b/7.x/src/linear_algebra/gmm/gmm_dense_qr.h new file mode 100644 index 0000000..1fcf03f --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_dense_qr.h @@ -0,0 +1,789 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_dense_qr.h + @author Caroline Lecalvez, Caroline.Lecalvez@gmm.insa-tlse.fr, Yves Renard + @date September 12, 2003. + @brief Dense QR factorization. +*/ +#ifndef GMM_DENSE_QR_H +#define GMM_DENSE_QR_H + +#include "gmm_dense_Householder.h" + +namespace gmm { + + + /** + QR factorization using Householder method (complex and real version). + */ + template + void qr_factor(const MAT1 &A_) { + MAT1 &A = const_cast(A_); + typedef typename linalg_traits::value_type value_type; + + size_type m = mat_nrows(A), n = mat_ncols(A); + GMM_ASSERT2(m >= n, "dimensions mismatch"); + + std::vector W(m), V(m); + + for (size_type j = 0; j < n; ++j) { + sub_interval SUBI(j, m-j), SUBJ(j, n-j); + V.resize(m-j); W.resize(n-j); + + for (size_type i = j; i < m; ++i) V[i-j] = A(i, j); + house_vector(V); + + row_house_update(sub_matrix(A, SUBI, SUBJ), V, W); + for (size_type i = j+1; i < m; ++i) A(i, j) = V[i-j]; + } + } + + + // QR comes from QR_factor(QR) where the upper triangular part stands for R + // and the lower part contains the Householder reflectors. + // A <- AQ + template + void apply_house_right(const MAT1 &QR, const MAT2 &A_) { + MAT2 &A = const_cast(A_); + typedef typename linalg_traits::value_type T; + size_type m = mat_nrows(QR), n = mat_ncols(QR); + GMM_ASSERT2(m == mat_ncols(A), "dimensions mismatch"); + if (m == 0) return; + std::vector V(m), W(mat_nrows(A)); + V[0] = T(1); + for (size_type j = 0; j < n; ++j) { + V.resize(m-j); + for (size_type i = j+1; i < m; ++i) V[i-j] = QR(i, j); + col_house_update(sub_matrix(A, sub_interval(0, mat_nrows(A)), + sub_interval(j, m-j)), V, W); + } + } + + // QR comes from QR_factor(QR) where the upper triangular part stands for R + // and the lower part contains the Householder reflectors. + // A <- Q*A + template + void apply_house_left(const MAT1 &QR, const MAT2 &A_) { + MAT2 &A = const_cast(A_); + typedef typename linalg_traits::value_type T; + size_type m = mat_nrows(QR), n = mat_ncols(QR); + GMM_ASSERT2(m == mat_nrows(A), "dimensions mismatch"); + if (m == 0) return; + std::vector V(m), W(mat_ncols(A)); + V[0] = T(1); + for (size_type j = 0; j < n; ++j) { + V.resize(m-j); + for (size_type i = j+1; i < m; ++i) V[i-j] = QR(i, j); + row_house_update(sub_matrix(A, sub_interval(j, m-j), + sub_interval(0, mat_ncols(A))), V, W); + } + } + + /** Compute the QR factorization, where Q is assembled. */ + template + void qr_factor(const MAT1 &A, const MAT2 &QQ, const MAT3 &RR) { + MAT2 &Q = const_cast(QQ); MAT3 &R = const_cast(RR); + typedef typename linalg_traits::value_type value_type; + + size_type m = mat_nrows(A), n = mat_ncols(A); + GMM_ASSERT2(m >= n, "dimensions mismatch"); + gmm::copy(A, Q); + + std::vector W(m); + dense_matrix VV(m, n); + + for (size_type j = 0; j < n; ++j) { + sub_interval SUBI(j, m-j), SUBJ(j, n-j); + + for (size_type i = j; i < m; ++i) VV(i,j) = Q(i, j); + house_vector(sub_vector(mat_col(VV,j), SUBI)); + + row_house_update(sub_matrix(Q, SUBI, SUBJ), + sub_vector(mat_col(VV,j), SUBI), sub_vector(W, SUBJ)); + } + + gmm::copy(sub_matrix(Q, sub_interval(0, n), sub_interval(0, n)), R); + gmm::copy(identity_matrix(), Q); + + for (size_type j = n-1; j != size_type(-1); --j) { + sub_interval SUBI(j, m-j), SUBJ(j, n-j); + row_house_update(sub_matrix(Q, SUBI, SUBJ), + sub_vector(mat_col(VV,j), SUBI), sub_vector(W, SUBJ)); + } + } + + ///@cond DOXY_SHOW_ALL_FUNCTIONS + template + void extract_eig(const MAT &A, VECT &V, Ttol tol, TA, TV) { + size_type n = mat_nrows(A); + if (n == 0) return; + tol *= Ttol(2); + Ttol tol_i = tol * gmm::abs(A(0,0)), tol_cplx = tol_i; + for (size_type i = 0; i < n; ++i) { + if (i < n-1) { + tol_i = (gmm::abs(A(i,i))+gmm::abs(A(i+1,i+1)))*tol; + tol_cplx = std::max(tol_cplx, tol_i); + } + if ((i < n-1) && gmm::abs(A(i+1,i)) >= tol_i) { + TA tr = A(i,i) + A(i+1, i+1); + TA det = A(i,i)*A(i+1, i+1) - A(i,i+1)*A(i+1, i); + TA delta = tr*tr - TA(4) * det; + if (delta < -tol_cplx) { + GMM_WARNING1("A complex eigenvalue has been detected : " + << std::complex(tr/TA(2), gmm::sqrt(-delta)/TA(2))); + V[i] = V[i+1] = tr / TA(2); + } + else { + delta = std::max(TA(0), delta); + V[i ] = TA(tr + gmm::sqrt(delta))/ TA(2); + V[i+1] = TA(tr - gmm::sqrt(delta))/ TA(2); + } + ++i; + } + else + V[i] = TV(A(i,i)); + } + } + + template + void extract_eig(const MAT &A, VECT &V, Ttol tol, TA, std::complex) { + size_type n = mat_nrows(A); + tol *= Ttol(2); + for (size_type i = 0; i < n; ++i) + if ((i == n-1) || + gmm::abs(A(i+1,i)) < (gmm::abs(A(i,i))+gmm::abs(A(i+1,i+1)))*tol) + V[i] = std::complex(A(i,i)); + else { + TA tr = A(i,i) + A(i+1, i+1); + TA det = A(i,i)*A(i+1, i+1) - A(i,i+1)*A(i+1, i); + TA delta = tr*tr - TA(4) * det; + if (delta < TA(0)) { + V[i] = std::complex(tr / TA(2), gmm::sqrt(-delta) / TA(2)); + V[i+1] = std::complex(tr / TA(2), -gmm::sqrt(-delta)/ TA(2)); + } + else { + V[i ] = TA(tr + gmm::sqrt(delta)) / TA(2); + V[i+1] = TA(tr - gmm::sqrt(delta)) / TA(2); + } + ++i; + } + } + + template + void extract_eig(const MAT &A, VECT &V, Ttol tol, std::complex, TV) { + typedef std::complex T; + size_type n = mat_nrows(A); + if (n == 0) return; + tol *= Ttol(2); + Ttol tol_i = tol * gmm::abs(A(0,0)), tol_cplx = tol_i; + for (size_type i = 0; i < n; ++i) { + if (i < n-1) { + tol_i = (gmm::abs(A(i,i))+gmm::abs(A(i+1,i+1)))*tol; + tol_cplx = std::max(tol_cplx, tol_i); + } + if ((i == n-1) || gmm::abs(A(i+1,i)) < tol_i) { + if (gmm::abs(std::imag(A(i,i))) > tol_cplx) + GMM_WARNING1("A complex eigenvalue has been detected : " + << T(A(i,i)) << " : " << gmm::abs(std::imag(A(i,i))) + / gmm::abs(std::real(A(i,i))) << " : " << tol_cplx); + V[i] = std::real(A(i,i)); + } + else { + T tr = A(i,i) + A(i+1, i+1); + T det = A(i,i)*A(i+1, i+1) - A(i,i+1)*A(i+1, i); + T delta = tr*tr - TA(4) * det; + T a1 = (tr + gmm::sqrt(delta)) / TA(2); + T a2 = (tr - gmm::sqrt(delta)) / TA(2); + if (gmm::abs(std::imag(a1)) > tol_cplx) + GMM_WARNING1("A complex eigenvalue has been detected : " << a1); + if (gmm::abs(std::imag(a2)) > tol_cplx) + GMM_WARNING1("A complex eigenvalue has been detected : " << a2); + + V[i] = std::real(a1); V[i+1] = std::real(a2); + ++i; + } + } + } + + template + void extract_eig(const MAT &A, VECT &V, Ttol tol, + std::complex, std::complex) { + size_type n = mat_nrows(A); + tol *= Ttol(2); + for (size_type i = 0; i < n; ++i) + if ((i == n-1) || + gmm::abs(A(i+1,i)) < (gmm::abs(A(i,i))+gmm::abs(A(i+1,i+1)))*tol) + V[i] = std::complex(A(i,i)); + else { + std::complex tr = A(i,i) + A(i+1, i+1); + std::complex det = A(i,i)*A(i+1, i+1) - A(i,i+1)*A(i+1, i); + std::complex delta = tr*tr - TA(4) * det; + V[i] = (tr + gmm::sqrt(delta)) / TA(2); + V[i+1] = (tr - gmm::sqrt(delta)) / TA(2); + ++i; + } + } + + ///@endcond + /** + Compute eigenvalue vector. + */ + template inline + void extract_eig(const MAT &A, const VECT &V, Ttol tol) { + extract_eig(A, const_cast(V), tol, + typename linalg_traits::value_type(), + typename linalg_traits::value_type()); + } + + /* ********************************************************************* */ + /* Stop criterion for QR algorithms */ + /* ********************************************************************* */ + + template + void qr_stop_criterion(MAT &A, size_type &p, size_type &q, Ttol tol) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + R rmin = default_min(R()) * R(2); + size_type n = mat_nrows(A); + if (n <= 2) { q = n; p = 0; } + else { + for (size_type i = 1; i < n-q; ++i) + if (gmm::abs(A(i,i-1)) < (gmm::abs(A(i,i))+ gmm::abs(A(i-1,i-1)))*tol + || gmm::abs(A(i,i-1)) < rmin) + A(i,i-1) = T(0); + + while ((q < n-1 && A(n-1-q, n-2-q) == T(0)) || + (q < n-2 && A(n-2-q, n-3-q) == T(0))) ++q; + if (q >= n-2) q = n; + p = n-q; if (p) --p; if (p) --p; + while (p > 0 && A(p,p-1) != T(0)) --p; + } + } + + template inline + void symmetric_qr_stop_criterion(const MAT &AA, size_type &p, size_type &q, + Ttol tol) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + R rmin = default_min(R()) * R(2); + MAT& A = const_cast(AA); + size_type n = mat_nrows(A); + if (n <= 1) { q = n; p = 0; } + else { + for (size_type i = 1; i < n-q; ++i) + if (gmm::abs(A(i,i-1)) < (gmm::abs(A(i,i))+ gmm::abs(A(i-1,i-1)))*tol + || gmm::abs(A(i,i-1)) < rmin) + A(i,i-1) = T(0); + + while (q < n-1 && A(n-1-q, n-2-q) == T(0)) ++q; + if (q >= n-1) q = n; + p = n-q; if (p) --p; if (p) --p; + while (p > 0 && A(p,p-1) != T(0)) --p; + } + } + + template inline + void symmetric_qr_stop_criterion(const VECT1 &diag, const VECT2 &sdiag_, + size_type &p, size_type &q, Ttol tol) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + R rmin = default_min(R()) * R(2); + VECT2 &sdiag = const_cast(sdiag_); + size_type n = vect_size(diag); + if (n <= 1) { q = n; p = 0; return; } + for (size_type i = 1; i < n-q; ++i) + if (gmm::abs(sdiag[i-1]) < (gmm::abs(diag[i])+ gmm::abs(diag[i-1]))*tol + || gmm::abs(sdiag[i-1]) < rmin) + sdiag[i-1] = T(0); + while (q < n-1 && sdiag[n-2-q] == T(0)) ++q; + if (q >= n-1) q = n; + p = n-q; if (p) --p; if (p) --p; + while (p > 0 && sdiag[p-1] != T(0)) --p; + } + + /* ********************************************************************* */ + /* 2x2 blocks reduction for Schur vectors */ + /* ********************************************************************* */ + + template + void block2x2_reduction(MATH &H, MATQ &Q, Ttol tol) { + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = mat_nrows(H), nq = mat_nrows(Q); + if (n < 2) return; + sub_interval SUBQ(0, nq), SUBL(0, 2); + std::vector v(2), w(std::max(n, nq)); v[0] = T(1); + tol *= Ttol(2); + Ttol tol_i = tol * gmm::abs(H(0,0)), tol_cplx = tol_i; + for (size_type i = 0; i < n-1; ++i) { + tol_i = (gmm::abs(H(i,i))+gmm::abs(H(i+1,i+1)))*tol; + tol_cplx = std::max(tol_cplx, tol_i); + + if (gmm::abs(H(i+1,i)) > tol_i) { // 2x2 block detected + T tr = (H(i+1, i+1) - H(i,i)) / T(2); + T delta = tr*tr + H(i,i+1)*H(i+1, i); + + if (is_complex(T()) || gmm::real(delta) >= R(0)) { + sub_interval SUBI(i, 2); + T theta = (tr - gmm::sqrt(delta)) / H(i+1,i); + R a = gmm::abs(theta); + v[1] = (a == R(0)) ? T(-1) + : gmm::conj(theta) * (R(1) - gmm::sqrt(a*a + R(1)) / a); + row_house_update(sub_matrix(H, SUBI), v, sub_vector(w, SUBL)); + col_house_update(sub_matrix(H, SUBI), v, sub_vector(w, SUBL)); + col_house_update(sub_matrix(Q, SUBQ, SUBI), v, sub_vector(w, SUBQ)); + } + ++i; + } + } + } + + /* ********************************************************************* */ + /* Basic qr algorithm. */ + /* ********************************************************************* */ + + #define tol_type_for_qr typename number_traits::value_type>::magnitude_type + #define default_tol_for_qr \ + (gmm::default_tol(tol_type_for_qr()) * tol_type_for_qr(3)) + + // QR method for real or complex square matrices based on QR factorisation. + // eigval has to be a complex vector if A has complex eigeinvalues. + // Very slow method. Use implicit_qr_method instead. + template + void rudimentary_qr_algorithm(const MAT1 &A, const VECT &eigval_, + const MAT2 &eigvect_, + tol_type_for_qr tol = default_tol_for_qr, + bool compvect = true) { + VECT &eigval = const_cast(eigval_); + MAT2 &eigvect = const_cast(eigvect_); + + typedef typename linalg_traits::value_type value_type; + + size_type n = mat_nrows(A), p, q = 0, ite = 0; + dense_matrix Q(n, n), R(n,n), A1(n,n); + gmm::copy(A, A1); + + Hessenberg_reduction(A1, eigvect, compvect); + qr_stop_criterion(A1, p, q, tol); + + while (q < n) { + qr_factor(A1, Q, R); + gmm::mult(R, Q, A1); + if (compvect) { gmm::mult(eigvect, Q, R); gmm::copy(R, eigvect); } + + qr_stop_criterion(A1, p, q, tol); + ++ite; + GMM_ASSERT1(ite < n*1000, "QR algorithm failed"); + } + if (compvect) block2x2_reduction(A1, Q, tol); + extract_eig(A1, eigval, tol); + } + + template + void rudimentary_qr_algorithm(const MAT1 &a, VECT &eigval, + tol_type_for_qr tol = default_tol_for_qr) { + dense_matrix::value_type> m(0,0); + rudimentary_qr_algorithm(a, eigval, m, tol, false); + } + + /* ********************************************************************* */ + /* Francis QR step. */ + /* ********************************************************************* */ + + template + void Francis_qr_step(const MAT1& HH, const MAT2 &QQ, bool compute_Q) { + MAT1& H = const_cast(HH); MAT2& Q = const_cast(QQ); + typedef typename linalg_traits::value_type value_type; + size_type n = mat_nrows(H), nq = mat_nrows(Q); + + std::vector v(3), w(std::max(n, nq)); + + value_type s = H(n-2, n-2) + H(n-1, n-1); + value_type t = H(n-2, n-2) * H(n-1, n-1) - H(n-2, n-1) * H(n-1, n-2); + value_type x = H(0, 0) * H(0, 0) + H(0,1) * H(1, 0) - s * H(0,0) + t; + value_type y = H(1, 0) * (H(0,0) + H(1,1) - s); + value_type z = H(1, 0) * H(2, 1); + + sub_interval SUBQ(0, nq); + + for (size_type k = 0; k < n - 2; ++k) { + v[0] = x; v[1] = y; v[2] = z; + house_vector(v); + size_type r = std::min(k+4, n), q = (k==0) ? 0 : k-1; + sub_interval SUBI(k, 3), SUBJ(0, r), SUBK(q, n-q); + + row_house_update(sub_matrix(H, SUBI, SUBK), v, sub_vector(w, SUBK)); + col_house_update(sub_matrix(H, SUBJ, SUBI), v, sub_vector(w, SUBJ)); + + if (compute_Q) + col_house_update(sub_matrix(Q, SUBQ, SUBI), v, sub_vector(w, SUBQ)); + + x = H(k+1, k); y = H(k+2, k); + if (k < n-3) z = H(k+3, k); + } + sub_interval SUBI(n-2,2), SUBJ(0, n), SUBK(n-3,3), SUBL(0, 3); + v.resize(2); + v[0] = x; v[1] = y; + house_vector(v); + row_house_update(sub_matrix(H, SUBI, SUBK), v, sub_vector(w, SUBL)); + col_house_update(sub_matrix(H, SUBJ, SUBI), v, sub_vector(w, SUBJ)); + if (compute_Q) + col_house_update(sub_matrix(Q, SUBQ, SUBI), v, sub_vector(w, SUBQ)); + } + + /* ********************************************************************* */ + /* Wilkinson Double shift QR step (from Lapack). */ + /* ********************************************************************* */ + + template + void Wilkinson_double_shift_qr_step(const MAT1& HH, const MAT2 &QQ, + Ttol tol, bool exc, bool compute_Q) { + MAT1& H = const_cast(HH); MAT2& Q = const_cast(QQ); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = mat_nrows(H), nq = mat_nrows(Q), m; + std::vector v(3), w(std::max(n, nq)); + const R dat1(0.75), dat2(-0.4375); + T h33, h44, h43h34, v1(0), v2(0), v3(0); + + if (exc) { /* Exceptional shift. */ + R s = gmm::abs(H(n-1, n-2)) + gmm::abs(H(n-2, n-3)); + h33 = h44 = dat1 * s; + h43h34 = dat2*s*s; + } + else { /* Wilkinson double shift. */ + h44 = H(n-1,n-1); h33 = H(n-2, n-2); + h43h34 = H(n-1, n-2) * H(n-2, n-1); + } + + /* Look for two consecutive small subdiagonal elements. */ + /* Determine the effect of starting the double-shift QR iteration at */ + /* row m, and see if this would make H(m-1, m-2) negligible. */ + for (m = n-2; m != 0; --m) { + T h11 = H(m-1, m-1), h22 = H(m, m); + T h21 = H(m, m-1), h12 = H(m-1, m); + T h44s = h44 - h11, h33s = h33 - h11; + v1 = (h33s*h44s-h43h34) / h21 + h12; + v2 = h22 - h11 - h33s - h44s; + v3 = H(m+1, m); + R s = gmm::abs(v1) + gmm::abs(v2) + gmm::abs(v3); + v1 /= s; v2 /= s; v3 /= s; + if (m == 1) break; + T h00 = H(m-2, m-2); + T h10 = H(m-1, m-2); + R tst1 = gmm::abs(v1)*(gmm::abs(h00)+gmm::abs(h11)+gmm::abs(h22)); + if (gmm::abs(h10)*(gmm::abs(v2)+gmm::abs(v3)) <= tol * tst1) break; + } + + /* Double shift QR step. */ + sub_interval SUBQ(0, nq); + for (size_type k = (m == 0) ? 0 : m-1; k < n-2; ++k) { + v[0] = v1; v[1] = v2; v[2] = v3; + house_vector(v); + size_type r = std::min(k+4, n), q = (k==0) ? 0 : k-1; + sub_interval SUBI(k, 3), SUBJ(0, r), SUBK(q, n-q); + + row_house_update(sub_matrix(H, SUBI, SUBK), v, sub_vector(w, SUBK)); + col_house_update(sub_matrix(H, SUBJ, SUBI), v, sub_vector(w, SUBJ)); + if (k > m-1) { H(k+1, k-1) = T(0); if (k < n-3) H(k+2, k-1) = T(0); } + + if (compute_Q) + col_house_update(sub_matrix(Q, SUBQ, SUBI), v, sub_vector(w, SUBQ)); + + v1 = H(k+1, k); v2 = H(k+2, k); + if (k < n-3) v3 = H(k+3, k); + } + sub_interval SUBI(n-2,2), SUBJ(0, n), SUBK(n-3,3), SUBL(0, 3); + v.resize(2); v[0] = v1; v[1] = v2; + house_vector(v); + row_house_update(sub_matrix(H, SUBI, SUBK), v, sub_vector(w, SUBL)); + col_house_update(sub_matrix(H, SUBJ, SUBI), v, sub_vector(w, SUBJ)); + if (compute_Q) + col_house_update(sub_matrix(Q, SUBQ, SUBI), v, sub_vector(w, SUBQ)); + } + + /* ********************************************************************* */ + /* Implicit QR algorithm. */ + /* ********************************************************************* */ + + // QR method for real or complex square matrices based on an + // implicit QR factorisation. eigval has to be a complex vector + // if A has complex eigenvalues. Complexity about 10n^3, 25n^3 if + // eigenvectors are computed + template + void implicit_qr_algorithm(const MAT1 &A, const VECT &eigval_, + const MAT2 &Q_, + tol_type_for_qr tol = default_tol_for_qr, + bool compvect = true) { + VECT &eigval = const_cast(eigval_); + MAT2 &Q = const_cast(Q_); + typedef typename linalg_traits::value_type value_type; + + size_type n(mat_nrows(A)), q(0), q_old, p(0), ite(0), its(0); + dense_matrix H(n,n); + sub_interval SUBK(0,0); + + gmm::copy(A, H); + Hessenberg_reduction(H, Q, compvect); + qr_stop_criterion(H, p, q, tol); + + while (q < n) { + sub_interval SUBI(p, n-p-q), SUBJ(0, mat_ncols(Q)); + if (compvect) SUBK = SUBI; +// Francis_qr_step(sub_matrix(H, SUBI), +// sub_matrix(Q, SUBJ, SUBK), compvect); + Wilkinson_double_shift_qr_step(sub_matrix(H, SUBI), + sub_matrix(Q, SUBJ, SUBK), + tol, (its == 10 || its == 20), compvect); + q_old = q; + qr_stop_criterion(H, p, q, tol*2); + if (q != q_old) its = 0; + ++its; ++ite; + GMM_ASSERT1(ite < n*100, "QR algorithm failed"); + } + if (compvect) block2x2_reduction(H, Q, tol); + extract_eig(H, eigval, tol); + } + + + template + void implicit_qr_algorithm(const MAT1 &a, VECT &eigval, + tol_type_for_qr tol = default_tol_for_qr) { + dense_matrix::value_type> m(1,1); + implicit_qr_algorithm(a, eigval, m, tol, false); + } + + /* ********************************************************************* */ + /* Implicit symmetric QR step with Wilkinson Shift. */ + /* ********************************************************************* */ + + template + void symmetric_Wilkinson_qr_step(const MAT1& MM, const MAT2 &ZZ, + bool compute_z) { + MAT1& M = const_cast(MM); MAT2& Z = const_cast(ZZ); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + size_type n = mat_nrows(M); + + for (size_type i = 0; i < n; ++i) { + M(i, i) = T(gmm::real(M(i, i))); + if (i > 0) { + T a = (M(i, i-1) + gmm::conj(M(i-1, i)))/R(2); + M(i, i-1) = a; M(i-1, i) = gmm::conj(a); + } + } + + R d = gmm::real(M(n-2, n-2) - M(n-1, n-1)) / R(2); + R e = gmm::abs_sqr(M(n-1, n-2)); + R nu = d + gmm::sgn(d)*gmm::sqrt(d*d+e); + if (nu == R(0)) { M(n-1, n-2) = T(0); return; } + R mu = gmm::real(M(n-1, n-1)) - e / nu; + T x = M(0,0) - T(mu), z = M(1, 0), c, s; + + for (size_type k = 1; k < n; ++k) { + Givens_rotation(x, z, c, s); + + if (k > 1) Apply_Givens_rotation_left(M(k-1,k-2), M(k,k-2), c, s); + Apply_Givens_rotation_left(M(k-1,k-1), M(k,k-1), c, s); + Apply_Givens_rotation_left(M(k-1,k ), M(k,k ), c, s); + if (k < n-1) Apply_Givens_rotation_left(M(k-1,k+1), M(k,k+1), c, s); + if (k > 1) Apply_Givens_rotation_right(M(k-2,k-1), M(k-2,k), c, s); + Apply_Givens_rotation_right(M(k-1,k-1), M(k-1,k), c, s); + Apply_Givens_rotation_right(M(k ,k-1), M(k,k) , c, s); + if (k < n-1) Apply_Givens_rotation_right(M(k+1,k-1), M(k+1,k), c, s); + + if (compute_z) col_rot(Z, c, s, k-1, k); + if (k < n-1) { x = M(k, k-1); z = M(k+1, k-1); } + } + + } + + template + void symmetric_Wilkinson_qr_step(const VECT1& diag_, const VECT2& sdiag_, + const MAT &ZZ, bool compute_z) { + VECT1& diag = const_cast(diag_); + VECT2& sdiag = const_cast(sdiag_); + MAT& Z = const_cast(ZZ); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = vect_size(diag); + R d = (diag[n-2] - diag[n-1]) / R(2); + R e = gmm::abs_sqr(sdiag[n-2]); + R nu = d + gmm::sgn(d)*gmm::sqrt(d*d+e); + if (nu == R(0)) { sdiag[n-2] = T(0); return; } + R mu = diag[n-1] - e / nu; + T x = diag[0] - T(mu), z = sdiag[0], c, s; + + T a01(0), a02(0); + T a10(0), a11(diag[0]), a12(gmm::conj(sdiag[0])), a13(0); + T a20(0), a21(sdiag[0]), a22(diag[1]), a23(gmm::conj(sdiag[1])); + T a31(0), a32(sdiag[1]); + + for (size_type k = 1; k < n; ++k) { + Givens_rotation(x, z, c, s); + + if (k > 1) Apply_Givens_rotation_left(a10, a20, c, s); + Apply_Givens_rotation_left(a11, a21, c, s); + Apply_Givens_rotation_left(a12, a22, c, s); + if (k < n-1) Apply_Givens_rotation_left(a13, a23, c, s); + + if (k > 1) Apply_Givens_rotation_right(a01, a02, c, s); + Apply_Givens_rotation_right(a11, a12, c, s); + Apply_Givens_rotation_right(a21, a22, c, s); + if (k < n-1) Apply_Givens_rotation_right(a31, a32, c, s); + + if (compute_z) col_rot(Z, c, s, k-1, k); + + diag[k-1] = gmm::real(a11); + diag[k] = gmm::real(a22); + if (k > 1) sdiag[k-2] = (gmm::conj(a01) + a10) / R(2); + sdiag[k-1] = (gmm::conj(a12) + a21) / R(2); + + x = sdiag[k-1]; z = (gmm::conj(a13) + a31) / R(2); + + a01 = a12; a02 = a13; + a10 = a21; a11 = a22; a12 = a23; a13 = T(0); + a20 = a31; a21 = a32; a31 = T(0); + + if (k < n-1) { + sdiag[k] = (gmm::conj(a23) + a32) / R(2); + a22 = T(diag[k+1]); a32 = sdiag[k+1]; a23 = gmm::conj(a32); + } + } + } + + /* ********************************************************************* */ + /* Implicit QR algorithm for symmetric or hermitian matrices. */ + /* ********************************************************************* */ + + // implicit QR method for real square symmetric matrices or complex + // hermitian matrices. + // eigval has to be a complex vector if A has complex eigeinvalues. + // complexity about 4n^3/3, 9n^3 if eigenvectors are computed + template + void symmetric_qr_algorithm_old(const MAT1 &A, const VECT &eigval_, + const MAT2 &eigvect_, + tol_type_for_qr tol = default_tol_for_qr, + bool compvect = true) { + VECT &eigval = const_cast(eigval_); + MAT2 &eigvect = const_cast(eigvect_); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + if (compvect) gmm::copy(identity_matrix(), eigvect); + size_type n = mat_nrows(A), q = 0, p, ite = 0; + dense_matrix Tri(n, n); + gmm::copy(A, Tri); + + Householder_tridiagonalization(Tri, eigvect, compvect); + + symmetric_qr_stop_criterion(Tri, p, q, tol); + + while (q < n) { + + sub_interval SUBI(p, n-p-q), SUBJ(0, mat_ncols(eigvect)), SUBK(p, n-p-q); + if (!compvect) SUBK = sub_interval(0,0); + symmetric_Wilkinson_qr_step(sub_matrix(Tri, SUBI), + sub_matrix(eigvect, SUBJ, SUBK), compvect); + + symmetric_qr_stop_criterion(Tri, p, q, tol*R(2)); + ++ite; + GMM_ASSERT1(ite < n*100, "QR algorithm failed. Probably, your matrix" + " is not real symmetric or complex hermitian"); + } + + extract_eig(Tri, eigval, tol); + } + + template + void symmetric_qr_algorithm(const MAT1 &A, const VECT &eigval_, + const MAT2 &eigvect_, + tol_type_for_qr tol = default_tol_for_qr, + bool compvect = true) { + VECT &eigval = const_cast(eigval_); + MAT2 &eigvect = const_cast(eigvect_); + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = mat_nrows(A), q = 0, p, ite = 0; + if (compvect) gmm::copy(identity_matrix(), eigvect); + if (n == 0) return; + if (n == 1) { eigval[0]=gmm::real(A(0,0)); return; } + dense_matrix Tri(n, n); + gmm::copy(A, Tri); + + Householder_tridiagonalization(Tri, eigvect, compvect); + + std::vector diag(n); + std::vector sdiag(n); + for (size_type i = 0; i < n; ++i) + { diag[i] = gmm::real(Tri(i, i)); if (i+1 < n) sdiag[i] = Tri(i+1, i); } + + symmetric_qr_stop_criterion(diag, sdiag, p, q, tol); + + while (q < n) { + sub_interval SUBI(p, n-p-q), SUBJ(0, mat_ncols(eigvect)), SUBK(p, n-p-q); + if (!compvect) SUBK = sub_interval(0,0); + + symmetric_Wilkinson_qr_step(sub_vector(diag, SUBI), + sub_vector(sdiag, SUBI), + sub_matrix(eigvect, SUBJ, SUBK), compvect); + + symmetric_qr_stop_criterion(diag, sdiag, p, q, tol*R(3)); + ++ite; + GMM_ASSERT1(ite < n*100, "QR algorithm failed."); + } + + gmm::copy(diag, eigval); + } + + + template + void symmetric_qr_algorithm(const MAT1 &a, VECT &eigval, + tol_type_for_qr tol = default_tol_for_qr) { + dense_matrix::value_type> m(0,0); + symmetric_qr_algorithm(a, eigval, m, tol, false); + } + + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_dense_sylvester.h b/7.x/src/linear_algebra/gmm/gmm_dense_sylvester.h new file mode 100644 index 0000000..88c9724 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_dense_sylvester.h @@ -0,0 +1,174 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/** @file gmm_dense_sylvester.h + @author Yves Renard + @date June 5, 2003. + @brief Sylvester equation solver. +*/ +#ifndef GMM_DENSE_SYLVESTER_H +#define GMM_DENSE_SYLVESTER_H + +#include "gmm_kernel.h" + +namespace gmm { + + /* ********************************************************************* */ + /* Kronecker system matrix. */ + /* ********************************************************************* */ + template + void kron(const MAT1 &m1, const MAT2 &m2, const MAT3 &m3_, + bool init = true) { + MAT3 &m3 = const_cast(m3_); + size_type m = mat_nrows(m1), n = mat_ncols(m1); + size_type l = mat_nrows(m2), k = mat_ncols(m2); + + GMM_ASSERT2(mat_nrows(m3) == m*l && mat_ncols(m3) == n*k, + "dimensions mismatch"); + + for (size_type i = 0; i < m; ++i) + for (size_type j = 0; j < m; ++j) + if (init) + gmm::copy(gmm::scaled(m2, m1(i,j)), + gmm::sub_matrix(m3, sub_interval(l*i, l), + sub_interval(k*j, k))); + else + gmm::add(gmm::scaled(m2, m1(i,j)), + gmm::sub_matrix(m3, sub_interval(l*i, l), + sub_interval(k*j, k))); + } + + + /* ********************************************************************* */ + /* Copy a matrix into a vector. */ + /* ********************************************************************* */ + + template + colmatrix_to_vector(const MAT &A, VECT &v, col_major) { + size_type m = mat_nrows(A), n = mat_ncols(A); + GMM_ASSERT2(m*n == vect_size(v), "dimensions mismatch"); + for (size_type i = 0; i < n; ++i) + gmm::copy(mat_col(A, i), sub_vector(v, sub_interval(i*m, m))); + } + + template + colmatrix_to_vector(const MAT &A, VECT &v, row_and_col) + { colmatrix_to_vector(A, v, col_major()); } + + template + colmatrix_to_vector(const MAT &A, VECT &v, col_and_row) + { colmatrix_to_vector(A, v, col_major()); } + + template + colmatrix_to_vector(const MAT &A, VECT &v, row_major) { + size_type m = mat_nrows(mat), n = mat_ncols(A); + GMM_ASSERT2(m*n == vect_size(v), "dimensions mismatch"); + for (size_type i = 0; i < m; ++i) + gmm::copy(mat_row(A, i), sub_vector(v, sub_slice(i, n, m))); + } + + template inline + colmatrix_to_vector(const MAT &A, const VECT &v_) { + VECT &v = const_cast(v_); + colmatrix_to_vector(A, v, typename linalg_traits::sub_orientation()); + } + + + /* ********************************************************************* */ + /* Copy a vector into a matrix. */ + /* ********************************************************************* */ + + template + vector_to_colmatrix(const VECT &v, MAT &A, col_major) { + size_type m = mat_nrows(A), n = mat_ncols(A); + GMM_ASSERT2(m*n == vect_size(v), "dimensions mismatch"); + for (size_type i = 0; i < n; ++i) + gmm::copy(sub_vector(v, sub_interval(i*m, m)), mat_col(A, i)); + } + + template + vector_to_colmatrix(const VECT &v, MAT &A, row_and_col) + { vector_to_colmatrix(v, A, col_major()); } + + template + vector_to_colmatrix(const VECT &v, MAT &A, col_and_row) + { vector_to_colmatrix(v, A, col_major()); } + + template + vector_to_colmatrix(const VECT &v, MAT &A, row_major) { + size_type m = mat_nrows(mat), n = mat_ncols(A); + GMM_ASSERT2(m*n == vect_size(v), "dimensions mismatch"); + for (size_type i = 0; i < m; ++i) + gmm::copy(sub_vector(v, sub_slice(i, n, m)), mat_row(A, i)); + } + + template inline + vector_to_colmatrix(const VECT &v, const MAT &A_) { + MAT &A = const_cast(A_); + vector_to_colmatrix(v, A, typename linalg_traits::sub_orientation()); + } + + /* ********************************************************************* */ + /* Solve sylvester equation. */ + /* ********************************************************************* */ + + // very prohibitive solver, to be replaced ... + template + void sylvester(const MAT1 &m1, const MAT2 &m2, const MAT3 &m3, + const MAT4 &m4_) { + typedef typename linalg_traits::value_type T; + + MAT3 &m4 = const_cast(m4_); + size_type m = mat_nrows(m1), n = mat_ncols(m1); + size_type l = mat_nrows(m2), k = mat_ncols(m2); + + GMM_ASSERT2(m == n && l == k && m == mat_nrows(m3) && + l == mat_ncols(m3) && m == mat_nrows(m4) && l == mat_ncols(m4), + "dimensions mismatch"); + + gmm::dense_matrix akronb(m*l, m*l); + gmm::dense_matrix idm(m, m), idl(l,l); + gmm::copy(identity_matrix(), idm); + gmm::copy(identity_matrix(), idl); + std::vector x(m*l), c(m*l); + + kron(idl, m1, akronb); + kron(gmm::transposed(m2), idm, akronb, false); + + colmatrix_to_vector(m3, c); + lu_solve(akronb, c, x); + vector_to_colmatrix(x, m4); + + } +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_domain_decomp.h b/7.x/src/linear_algebra/gmm/gmm_domain_decomp.h new file mode 100644 index 0000000..9bf663a --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_domain_decomp.h @@ -0,0 +1,165 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2004-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/** @file gmm_domain_decomp.h + @author Yves Renard + @date May 21, 2004. + @brief Domain decomposition. +*/ +#ifndef GMM_DOMAIN_DECOMP_H__ +#define GMM_DOMAIN_DECOMP_H__ + +#include "gmm_kernel.h" +#include + + +namespace gmm { + + /** This function separates into small boxes of size msize with a ratio + * of overlap (in [0,1[) a set of points. The result is given into a + * vector of sparse matrices vB. + */ + template + void rudimentary_regular_decomposition(std::vector pts, + double msize, + double overlap, + std::vector &vB) { + typedef typename linalg_traits::value_type value_type; + typedef abstract_null_type void_type; + typedef std::map map_type; + + size_type nbpts = pts.size(); + if (!nbpts || pts[0].size() == 0) { vB.resize(0); return; } + int dim = int(pts[0].size()); + + // computation of the global box and the number of sub-domains + Point pmin = pts[0], pmax = pts[0]; + for (size_type i = 1; i < nbpts; ++i) + for (int k = 0; k < dim; ++k) { + pmin[k] = std::min(pmin[k], pts[i][k]); + pmax[k] = std::max(pmax[k], pts[i][k]); + } + + std::vector nbsub(dim), mult(dim); + std::vector pts1(dim), pts2(dim); + size_type nbtotsub = 1; + for (int k = 0; k < dim; ++k) { + nbsub[k] = size_type((pmax[k] - pmin[k]) / msize)+1; + mult[k] = nbtotsub; nbtotsub *= nbsub[k]; + } + + std::vector subs(nbtotsub); + // points ventilation + std::vector ns(dim), na(dim), nu(dim); + for (size_type i = 0; i < nbpts; ++i) { + for (int k = 0; k < dim; ++k) { + double a = (pts[i][k] - pmin[k]) / msize; + ns[k] = size_type(a) - 1; na[k] = 0; + pts1[k] = int(a + overlap); pts2[k] = int(ceil(a-1.0-overlap)); + } + size_type sum = 0; + do { + bool ok = 1; + for (int k = 0; k < dim; ++k) + if ((ns[k] >= nbsub[k]) || (pts1[k] < int(ns[k])) + || (pts2[k] > int(ns[k]))) { ok = false; break; } + if (ok) { + size_type ind = ns[0]; + for (int k=1; k < dim; ++k) ind += ns[k]*mult[k]; + subs[ind][i] = void_type(); + } + for (int k = 0; k < dim; ++k) { + if (na[k] < 2) { na[k]++; ns[k]++; ++sum; break; } + na[k] = 0; ns[k] -= 2; sum -= 2; + } + } while (sum); + } + // delete too small domains. + size_type nbmaxinsub = 0; + for (size_type i = 0; i < nbtotsub; ++i) + nbmaxinsub = std::max(nbmaxinsub, subs[i].size()); + + std::fill(ns.begin(), ns.end(), size_type(0)); + for (size_type i = 0; i < nbtotsub; ++i) { + if (subs[i].size() > 0 && subs[i].size() < nbmaxinsub / 10) { + + for (int k = 0; k < dim; ++k) nu[k] = ns[k]; + size_type nbmax = 0, imax = 0; + + for (int l = 0; l < dim; ++l) { + nu[l]--; + for (int m = 0; m < 2; ++m, nu[l]+=2) { + bool ok = true; + for (int k = 0; k < dim && ok; ++k) + if (nu[k] >= nbsub[k]) ok = false; + if (ok) { + size_type ind = ns[0]; + for (int k=1; k < dim; ++k) ind += ns[k]*mult[k]; + if (subs[ind].size() > nbmax) + { nbmax = subs[ind].size(); imax = ind; } + } + } + nu[l]--; + } + + if (nbmax > subs[i].size()) { + for (map_type::iterator it=subs[i].begin(); it!=subs[i].end(); ++it) + subs[imax][it->first] = void_type(); + subs[i].clear(); + } + } + for (int k = 0; k < dim; ++k) + { ns[k]++; if (ns[k] < nbsub[k]) break; ns[k] = 0; } + } + + // delete empty domains. + size_type effnb = 0; + for (size_type i = 0; i < nbtotsub; ++i) { + if (subs[i].size() > 0) + { if (i != effnb) std::swap(subs[i], subs[effnb]); ++effnb; } + } + + // build matrices + subs.resize(effnb); + vB.resize(effnb); + for (size_type i = 0; i < effnb; ++i) { + clear(vB[i]); resize(vB[i], nbpts, subs[i].size()); + size_type j = 0; + for (map_type::iterator it=subs[i].begin(); it!=subs[i].end(); ++it, ++j) + vB[i](it->first, j) = value_type(1); + } + } + + +} + + +#endif diff --git a/7.x/src/linear_algebra/gmm/gmm_except.h b/7.x/src/linear_algebra/gmm/gmm_except.h new file mode 100644 index 0000000..3b38aa1 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_except.h @@ -0,0 +1,406 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/** @file gmm_except.h + @author Yves Renard + @author Julien Pommier + @date September 01, 2002. + @brief Definition of basic exceptions. +*/ + +#ifndef GMM_EXCEPT_H__ +#define GMM_EXCEPT_H__ + +#include +#include "gmm_std.h" +#include "gmm_feedback_management.h" + + +//provides external implementation of gmm_exception and logging. + +namespace gmm { + +/* *********************************************************************** */ +/* GetFEM generic errors. */ +/* *********************************************************************** */ + + // std logic_error with error level information + class gmm_error: public std::logic_error { + public: + gmm_error(const std::string& what_arg, int errorLevel = 1): + std::logic_error (what_arg), errorLevel_(errorLevel) {} + int errLevel() const { return errorLevel_; } + + private: + int errorLevel_; + }; + +#ifdef GETFEM_HAVE_PRETTY_FUNCTION +# define GMM_PRETTY_FUNCTION __PRETTY_FUNCTION__ +#elif _MSC_VER +# define GMM_PRETTY_FUNCTION __FUNCTION__ +#else +# define GMM_PRETTY_FUNCTION "" +#endif + + + // Errors : GMM_THROW should not be used on its own. + // GMM_ASSERT1 : Non-maskable errors. Typically for in/ouput and + // when the test do not significantly reduces the performance. + // GMM_ASSERT2 : All tests which are potentially performance + // consuming. Not hidden by default. Hidden when NDEBUG is + // defined. + // GMM_ASSERT3 : For internal checks. Hidden by default. Active + // only when DEBUG_MODE is defined. + // __EXCEPTIONS is defined by gcc, _CPPUNWIND is defined by visual c++ +#if defined(__EXCEPTIONS) || defined(_CPPUNWIND) + inline void short_error_throw(const char *file, int line, const char *func, + const char *errormsg) { + std::stringstream msg__; + msg__ << "Error in " << file << ", line " << line << " " << func + << ": \n" << errormsg << std::ends; + throw gmm::gmm_error(msg__.str()); + } +# define GMM_THROW_(type, errormsg) { \ + std::stringstream msg__; \ + msg__ << "Error in " << __FILE__ << ", line " \ + << __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \ + << errormsg << std::ends; \ + throw (type)(msg__.str()); \ + } + +# define GMM_THROW_AT_LEVEL(errormsg, level) \ + { \ + std::stringstream msg; \ + msg << "Error in " << __FILE__ << ", line " \ + << __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \ + << errormsg << std::ends; \ + throw gmm::gmm_error(msg.str(), level); \ + } + +#else +#ifndef _MSC_VER +# define abort_no_return() ::abort() +#else +// apparently ::abort() on windows is not declared with __declspec(noreturn) so the compiler spits a lot of warnings when abort is used. +# define abort_no_return() { assert("GMM ABORT"==0); throw "GMM ABORT"; } +#endif + + inline void short_error_throw(const char *file, int line, const char *func, + const char *errormsg) { + std::stringstream msg__; + msg__ << "Error in " << file << ", line " << line << " " << func + << ": \n" << errormsg << std::ends; + std::cerr << msg__.str() << std::endl; + abort_no_return(); + } + +# define GMM_THROW_(type, errormsg) { \ + std::stringstream msg__; \ + msg__ << "Error in " << __FILE__ << ", line " \ + << __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \ + << errormsg; \ + std::cerr << msg__.str() << std::endl; \ + abort_no_return(); \ + } + +# define GMM_THROW_AT_LEVEL(errormsg, level) \ + { \ + std::stringstream msg__; \ + msg__ << "Error in " << __FILE__ << ", line " \ + << __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \ + << errormsg << " at level " << level; \ + std::cerr << msg__.str() << std::endl; \ + abort_no_return(); \ + } +#endif + + +inline void GMM_THROW() {} +#define GMM_THROW(a, b) { GMM_THROW_(a,b); gmm::GMM_THROW(); } + +# define GMM_THROW_DEFAULT(errormsg) GMM_THROW_AT_LEVEL(errormsg, 1) + +// This allows not to compile some assertions +#ifndef GMM_ASSERT_LEVEL +#if defined(NDEBUG) +# define GMM_ASSERT_LEVEL 1 +#elif defined(DEBUG_MODE) +# define GMM_ASSERT_LEVEL 3 +#else +# define GMM_ASSERT_LEVEL 2 +#endif +#endif + + +# define GMM_ASSERT1(test, errormsg) { if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 1); } + +#if GMM_ASSERT_LEVEL < 2 +# define GMM_ASSERT2(test, errormsg) {} +# define GMM_ASSERT3(test, errormsg) {} +#elif GMM_ASSERT_LEVEL < 3 +# define GMM_ASSERT2(test, errormsg){ if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 2); } +# define GMM_ASSERT3(test, errormsg){} +#else +# define GMM_ASSERT2(test, errormsg){ if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 2); } +# define GMM_ASSERT3(test, errormsg){ if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 3); } +#endif + +/* *********************************************************************** */ +/* GetFEM warnings. */ +/* *********************************************************************** */ + + // This allows not to compile some Warnings +#ifndef GMM_WARNING_LEVEL +# define GMM_WARNING_LEVEL 4 +#endif + + // Warning levels : 0 always printed + // 1 very important : specify a possible error in the code. + // 2 important : specify a default of optimization for inst. + // 3 remark + // 4 ignored by default. + +#define GMM_WARNING_MSG(level_, thestr) { \ + std::stringstream msg__; \ + msg__ << "Level " << level_ << " Warning in " << __FILE__ << ", line " \ + << __LINE__ << ": " << thestr; \ + gmm::feedback_manager::manage()->send(msg__.str(), gmm::FeedbackType::WARNING, level_); \ +} + +#define GMM_WARNING0(thestr) GMM_WARNING_MSG(0, thestr) + + +#if GMM_WARNING_LEVEL > 0 +# define GMM_WARNING1(thestr) \ + { if (1 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(1, thestr) } +#else +# define GMM_WARNING1(thestr) {} +#endif + +#if GMM_WARNING_LEVEL > 1 +# define GMM_WARNING2(thestr) \ + { if (2 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(2, thestr) } +#else +# define GMM_WARNING2(thestr) {} +#endif + +#if GMM_WARNING_LEVEL > 2 +# define GMM_WARNING3(thestr) \ + { if (3 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(3, thestr) } +#else +# define GMM_WARNING3(thestr) {} +#endif + +#if GMM_WARNING_LEVEL > 3 +# define GMM_WARNING4(thestr) \ + { if (4 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(4, thestr) } +#else +# define GMM_WARNING4(thestr) {} +#endif + +/* *********************************************************************** */ +/* GetFEM traces. */ +/* *********************************************************************** */ + + // This allow not too compile some Warnings +#ifndef GMM_TRACES_LEVEL +# define GMM_TRACES_LEVEL 4 +#endif + + // Traces levels : 0 always printed + // 1 Susceptible to occur once in a program. + // 2 Susceptible to occur occasionnaly in a program (10). + // 3 Susceptible to occur often (100). + // 4 Susceptible to occur very often (>1000). + +#define GMM_TRACE_MSG_MPI // for Parallelized version +#define GMM_TRACE_MSG(level_, thestr) { \ + GMM_TRACE_MSG_MPI { \ + std::stringstream msg__; \ + msg__ << "Trace " << level_ << " in " << __FILE__ << ", line " \ + << __LINE__ << ": " << thestr; \ + gmm::feedback_manager::send(msg__.str(), gmm::FeedbackType::TRACE, level_); \ + } \ +} + +#define GMM_TRACE_SIMPLE_MSG(level_, thestr) { \ + GMM_TRACE_MSG_MPI { \ + std::stringstream msg__; \ + msg__ << "Trace " << level_ << ": " << thestr; \ + gmm::feedback_manager::send(msg__.str(), gmm::FeedbackType::TRACE, level_); \ + } \ +} + +#define GMM_TRACE0(thestr) GMM_TRACE_MSG(0, thestr) +#define GMM_SIMPLE_TRACE0(thestr) GMM_TRACE_MSG_SIMPLE(0, thestr) + +#if GMM_TRACES_LEVEL > 0 +# define GMM_TRACE1(thestr) \ + { if (1 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(1, thestr) } +# define GMM_SIMPLE_TRACE1(thestr) \ + { if (1 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(1, thestr) } +#else +# define GMM_TRACE1(thestr) {} +# define GMM_SIMPLE_TRACE1(thestr) {} +#endif + +#if GMM_TRACES_LEVEL > 1 +# define GMM_TRACE2(thestr) \ + { if (2 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(2, thestr) } +# define GMM_SIMPLE_TRACE2(thestr) \ + { if (2 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(2, thestr) } +#else +# define GMM_TRACE2(thestr) {} +# define GMM_SIMPLE_TRACE2(thestr) {} +#endif + +#if GMM_TRACES_LEVEL > 2 +# define GMM_TRACE3(thestr) \ + { if (3 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(3, thestr) } +# define GMM_SIMPLE_TRACE3(thestr) \ + { if (3 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(3, thestr) } +#else +# define GMM_TRACE3(thestr) {} +# define GMM_SIMPLE_TRACE3(thestr) {} +#endif + +#if GMM_TRACES_LEVEL > 3 +# define GMM_TRACE4(thestr) \ + { if (4 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(4, thestr) } +# define GMM_SIMPLE_TRACE4(thestr) \ + { if (4 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(4, thestr) } +#else +# define GMM_TRACE4(thestr) {} +# define GMM_SIMPLE_TRACE4(thestr) {} +#endif + +#define GMM_STANDARD_CATCH_ERROR \ + catch(const gmm::gmm_error &e) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| A GMM error has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + strStream << e.what() << std::endl << std::endl; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, e.errLevel()); \ + gmm::feedback_manager::terminating_action(); \ + } \ + catch(const std::logic_error &e) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| An error has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + strStream << e.what() << std::endl << std::endl; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, 0); \ + gmm::feedback_manager::terminating_action(); \ + } \ + catch(const std::runtime_error &e) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| A runtime error has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + strStream << e.what() << std::endl << std::endl; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, 0); \ + gmm::feedback_manager::terminating_action(); \ + } \ + catch(const std::bad_alloc &) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| A bad allocation has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, 0); \ + gmm::feedback_manager::terminating_action(); \ + } \ + catch(const std::bad_typeid &) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| A bad typeid has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, 0); \ + gmm::feedback_manager::terminating_action(); \ + } \ + catch(const std::bad_exception &) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| A bad exception has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, 0); \ + gmm::feedback_manager::terminating_action(); \ + } \ + catch(const std::bad_cast &) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| A bad_cast has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, 0); \ + gmm::feedback_manager::terminating_action(); \ + } \ + catch(...) \ + { \ + std::stringstream strStream; \ + strStream << "============================================\n"; \ + strStream << "| An unknown error has been detected !!! |\n"; \ + strStream << "============================================\n"; \ + gmm::feedback_manager::send(strStream.str(), \ + gmm::FeedbackType::ASSERT, 0); \ + gmm::feedback_manager::terminating_action(); \ + } + // catch(ios_base::failure) { + // std::cerr << "============================================\n"; + // std::cerr << "| A ios_base::failure has been detected !!!|\n"; + // std::cerr << "============================================\n"; + // exit(1); + // } + +#if defined(__GNUC__) && (__GNUC__ > 3) +# define GMM_SET_EXCEPTION_DEBUG \ + std::set_terminate(__gnu_cxx::__verbose_terminate_handler); +#else +# define GMM_SET_EXCEPTION_DEBUG +#endif + +} // namespace gmm + +#endif /* GMM_EXCEPT_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_feedback_management.h b/7.x/src/linear_algebra/gmm/gmm_feedback_management.h new file mode 100644 index 0000000..f445b16 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_feedback_management.h @@ -0,0 +1,174 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/** @file gmm_feedback_management.h + @date July 03, 2017. + @brief Support for run time management of trace, warning and assert + feedback. +*/ + +#ifndef GMM_FEEDBACK_MANAGEMENT_H__ +#define GMM_FEEDBACK_MANAGEMENT_H__ +#include +#include +#include + +namespace gmm { + +/* *********************************************************************** */ +/* GetFEM warnings. */ +/* *********************************************************************** */ + +// This allows to dynamically hide warnings +struct warning_level { + static int level(int l = -2) + { static int level_ = 3; return (l != -2) ? (level_ = l) : level_; } +}; + +inline void set_warning_level(int l) { warning_level::level(l>0 ? l : 0); } +inline int get_warning_level(void) { return warning_level::level(-2); } + +/* *********************************************************************** */ +/* GetFEM traces. */ +/* *********************************************************************** */ + +// This allows to dynamically hide traces +struct traces_level { + static int level(int l = -2) + { static int level_ = 3; return (l != -2) ? (level_ = l) : level_; } +}; + +inline void set_traces_level(int l) { traces_level::level(l>0 ? l : 0); } +inline int get_traces_level(void) { return traces_level::level(); } + + +/* *********************************************************************** */ +/* GetFEM feedback management */ +/* *********************************************************************** */ + +enum class FeedbackType { + TRACE = 0, + WARNING, + ASSERT +}; + +// Abstract class providing feedback management interface. +// The interface consist of three functions: +// * for sending feedback message +// * for getting traces level +// * for getting warning level +// * for action to be done after feedback is handled +struct base_feedback_handler { + virtual ~base_feedback_handler() = default; + virtual void send(const std::string &message, FeedbackType messageType, size_t level) = 0; + virtual size_t traces_level() { return get_traces_level(); } + virtual size_t warning_level() { return get_warning_level(); } + virtual void terminating_action() = 0; +}; + + +// Provides the default implementation of feedback handling. +struct default_feedback_handler final : public base_feedback_handler { + void send(const std::string &message, FeedbackType, size_t) override { + std::cerr << message << std::endl; + } + void terminating_action() override { + std::exit(1); + } +}; + +// This class acts as a run-time dispatcher for sending feedback +// messages and getting trace and warning levels. +class feedback_manager { +public: + // Management actions + enum Action { + SET, // Sets the feedback handler, releasing the one previously set. + GET, // Returns currently managed handler (it is still managed). + REPLACE, // Replace manager with a new one, stop managing the old one + // and returns it unmanaged to the caller. The caller is + // then responsible for managing the memory of the handler. + }; + + // Steals the pointer to a messenger object that provides + // feedback handling implementation. + // + // Example: + // feedback_manager::manage(new default_feedback_handler); + // + static base_feedback_handler* manage(enum Action action=GET, base_feedback_handler *pHandler=nullptr); + static void send(const std::string &message, FeedbackType type, size_t level); + static size_t traces_level(); + static size_t warning_level(); + // Action to be taken when feedback handling is done + static void terminating_action(); +}; + +// Depending on action either gets, sets or replaces feedback handler. Setting handler to null resets +// it to gmm::default_feedback_handler. +inline base_feedback_handler* feedback_manager::manage(enum Action action, base_feedback_handler *pHandler) { + static std::unique_ptr pHandler_ = + std::move(std::unique_ptr(new default_feedback_handler)); + base_feedback_handler *rethandler = nullptr; + switch(action) { + case SET: + pHandler_.reset(pHandler != nullptr ? pHandler : new default_feedback_handler); + rethandler = pHandler_.get(); + break; + case GET: + rethandler = pHandler_.get(); + break; + case REPLACE: + rethandler = pHandler_.release(); + pHandler_.reset(pHandler != nullptr ? pHandler : new default_feedback_handler); + break; + } + return rethandler; +} + +inline void feedback_manager::send(const std::string &message, FeedbackType type, size_t level) { + feedback_manager::manage()->send(message, type, level); +} + +inline void feedback_manager::terminating_action() { + feedback_manager::manage()->terminating_action(); +} + +inline size_t feedback_manager::traces_level() { + return feedback_manager::manage()->traces_level(); +} + +inline size_t feedback_manager::warning_level() { + return feedback_manager::manage()->warning_level(); +} + +} // namespace gmm +#endif /* GMM_FEEDBACK_MANAGEMENT_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_inoutput.h b/7.x/src/linear_algebra/gmm/gmm_inoutput.h new file mode 100644 index 0000000..9bb5171 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_inoutput.h @@ -0,0 +1,1184 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard, Julien Pommier + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_inoutput.h + @author Yves Renard + @author Julien Pommier + @date July 8, 2003. + @brief Input/output on sparse matrices + + Support Harwell-Boeing and Matrix-Market formats. +*/ +#ifndef GMM_INOUTPUT_H +#define GMM_INOUTPUT_H + +#include +#include "gmm_kernel.h" +namespace gmm { + + /*************************************************************************/ + /* */ + /* Functions to read and write Harwell Boeing format. */ + /* */ + /*************************************************************************/ + + // Fri Aug 15 16:29:47 EDT 1997 + // + // Harwell-Boeing File I/O in C + // V. 1.0 + // + // National Institute of Standards and Technology, MD. + // K.A. Remington + // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + // NOTICE + // + // Permission to use, copy, modify, and distribute this software and + // its documentation for any purpose and without fee is hereby granted + // provided that the above copyright notice appear in all copies and + // that both the copyright notice and this permission notice appear in + // supporting documentation. + // + // Neither the Author nor the Institution (National Institute of Standards + // and Technology) make any representations about the suitability of this + // software for any purpose. This software is provided "as is" without + // expressed or implied warranty. + // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + inline void IOHBTerminate(const char *a) { GMM_ASSERT1(false, a);} + + inline bool is_complex_double__(std::complex) { return true; } + inline bool is_complex_double__(double) { return false; } + + inline int ParseIfmt(const char *fmt, int* perline, int* width) { + if (SECURE_NONCHAR_SSCANF(fmt, " (%dI%d)", perline, width) != 2) { + *perline = 1; + int s = SECURE_NONCHAR_SSCANF(fmt, " (I%d)", width); + GMM_ASSERT1(s == 1, "invalid HB I-format: " << fmt); + } + return *width; + } + + inline int ParseRfmt(const char *fmt, int* perline, int* width, + int* prec, int* flag) { + char p; + *perline = *width = *flag = *prec = 0; +#ifdef GMM_SECURE_CRT + if (sscanf_s(fmt, " (%d%c%d.%d)", perline, &p, sizeof(char), width, prec) + < 3 || !strchr("PEDF", p)) +#else + if (sscanf(fmt, " (%d%c%d.%d)", perline, &p, width, prec) < 3 + || !strchr("PEDF", p)) +#endif + { + *perline = 1; +#ifdef GMM_SECURE_CRT + int s = sscanf_s(fmt, " (%c%d.%d)", &p, sizeof(char), width, prec); +#else + int s = sscanf(fmt, " (%c%d.%d)", &p, width, prec); +#endif + GMM_ASSERT1(s>=2 && strchr("PEDF",p), "invalid HB REAL format: " << fmt); + } + *flag = p; + return *width; + } + + /** matrix input/output for Harwell-Boeing format */ + struct HarwellBoeing_IO { + int nrows() const { return Nrow; } + int ncols() const { return Ncol; } + int nnz() const { return Nnzero; } + int is_complex() const { return Type[0] == 'C'; } + int is_symmetric() const { return Type[1] == 'S'; } + int is_hermitian() const { return Type[1] == 'H'; } + HarwellBoeing_IO() { clear(); } + HarwellBoeing_IO(const char *filename) { clear(); open(filename); } + ~HarwellBoeing_IO() { close(); } + /** open filename and reads header */ + void open(const char *filename); + /** read the opened file */ + template void read(csc_matrix& A); + template void read(MAT &M) IS_DEPRECATED; + template + static void write(const char *filename, const csc_matrix& A); + template + static void write(const char *filename, const csc_matrix& A, + const std::vector &rhs); + template + static void write(const char *filename, + const csc_matrix_ref& A); + template + static void write(const char *filename, + const csc_matrix_ref& A, + const std::vector &rhs); + + /** static method for saving the matrix */ + template static void write(const char *filename, + const MAT& A) IS_DEPRECATED; + private: + FILE *f; + char Title[73], Key[9], Rhstype[4], Type[4]; + int Nrow, Ncol, Nnzero, Nrhs; + char Ptrfmt[17], Indfmt[17], Valfmt[21], Rhsfmt[21]; + int Ptrcrd, Indcrd, Valcrd, Rhscrd; + int lcount; + + + void close() { if (f) fclose(f); clear(); } + void clear() { + Nrow = Ncol = Nnzero = Nrhs = 0; f = 0; lcount = 0; + memset(Type, 0, sizeof Type); + memset(Key, 0, sizeof Key); + memset(Title, 0, sizeof Title); + } + char *getline(char *buf) { + char *p = fgets(buf, BUFSIZ, f); ++lcount; + int s = SECURE_NONCHAR_SSCANF(buf,"%*s"); + GMM_ASSERT1(s >= 0 && p != 0, + "blank line in HB file at line " << lcount); + return buf; + } + + int substrtoi(const char *p, size_type len) { + char s[100]; len = std::min(len, sizeof s - 1); + SECURE_STRNCPY(s, 100, p, len); s[len] = 0; return atoi(s); + } + double substrtod(const char *p, size_type len, int Valflag) { + char s[100]; len = std::min(len, sizeof s - 1); + SECURE_STRNCPY(s, 100, p, len); s[len] = 0; + if ( Valflag != 'F' && !strchr(s,'E')) { + /* insert a char prefix for exp */ + int last = int(strlen(s)); + for (int j=last+1;j>=0;j--) { + s[j] = s[j-1]; + if ( s[j] == '+' || s[j] == '-' ) { + s[j-1] = char(Valflag); + break; + } + } + } + return atof(s); + } + template + int readHB_data(IND_TYPE colptr[], IND_TYPE rowind[], + double val[]) { + /***********************************************************************/ + /* This function opens and reads the specified file, interpreting its */ + /* contents as a sparse matrix stored in the Harwell/Boeing standard */ + /* format and creating compressed column storage scheme vectors to */ + /* hold the index and nonzero value information. */ + /* */ + /* ---------- */ + /* **CAVEAT** */ + /* ---------- */ + /* Parsing real formats from Fortran is tricky, and this file reader */ + /* does not claim to be foolproof. It has been tested for cases */ + /* when the real values are printed consistently and evenly spaced on */ + /* each line, with Fixed (F), and Exponential (E or D) formats. */ + /* */ + /* ** If the input file does not adhere to the H/B format, the ** */ + /* ** results will be unpredictable. ** */ + /* */ + /***********************************************************************/ + int i,ind,col,offset,count; + int Ptrperline, Ptrwidth, Indperline, Indwidth; + int Valperline, Valwidth, Valprec, Nentries; + int Valflag = 'D'; /* Indicates 'E','D', or 'F' float format */ + char line[BUFSIZ]; + gmm::standard_locale sl; + + + /* Parse the array input formats from Line 3 of HB file */ + ParseIfmt(Ptrfmt,&Ptrperline,&Ptrwidth); + ParseIfmt(Indfmt,&Indperline,&Indwidth); + if ( Type[0] != 'P' ) { /* Skip if pattern only */ + ParseRfmt(Valfmt,&Valperline,&Valwidth,&Valprec,&Valflag); + } + + /* Read column pointer array: */ + offset = 0; /* if base 0 storage is declared (via macro def), */ + /* then storage entries are offset by 1 */ + + for (count = 0, i=0;i Ncol) break; + colptr[count] = substrtoi(line+col,Ptrwidth)-offset; + count++; col += Ptrwidth; + } + } + + /* Read row index array: */ + for (count = 0, i=0;i(strchr(line,'D')) )) *p = 'E'; + } + for (col = 0, ind = 0;ind csc matrices */ + template void + HarwellBoeing_IO::read(csc_matrix& A) { + + // typedef typename csc_matrix::IND_TYPE IND_TYPE; + + GMM_ASSERT1(f, "no file opened!"); + GMM_ASSERT1(Type[0] != 'P', + "Bad HB matrix format (pattern matrices not supported)"); + GMM_ASSERT1(!is_complex_double__(T()) || Type[0] != 'R', + "Bad HB matrix format (file contains a REAL matrix)"); + GMM_ASSERT1(is_complex_double__(T()) || Type[0] != 'C', + "Bad HB matrix format (file contains a COMPLEX matrix)"); + A.nc = ncols(); A.nr = nrows(); + A.jc.resize(ncols()+1); + A.ir.resize(nnz()); + A.pr.resize(nnz()); + readHB_data(&A.jc[0], &A.ir[0], (double*)&A.pr[0]); + for (int i = 0; i <= ncols(); ++i) { A.jc[i] += shift; A.jc[i] -= 1; } + for (int i = 0; i < nnz(); ++i) { A.ir[i] += shift; A.ir[i] -= 1; } + } + + template void + HarwellBoeing_IO::read(MAT &M) { + csc_matrix::value_type> csc; + read(csc); + resize(M, mat_nrows(csc), mat_ncols(csc)); + copy(csc, M); + } + + template + inline int writeHB_mat_double(const char* filename, int M, int N, int nz, + const IND_TYPE colptr[], + const IND_TYPE rowind[], + const double val[], int Nrhs, + const double rhs[], const double guess[], + const double exact[], const char* Title, + const char* Key, const char* Type, + const char* Ptrfmt, const char* Indfmt, + const char* Valfmt, const char* Rhsfmt, + const char* Rhstype, int shift) { + /************************************************************************/ + /* The writeHB function opens the named file and writes the specified */ + /* matrix and optional right-hand-side(s) to that file in */ + /* Harwell-Boeing format. */ + /* */ + /* For a description of the Harwell Boeing standard, see: */ + /* Duff, et al., ACM TOMS Vol.15, No.1, March 1989 */ + /* */ + /************************************************************************/ + FILE *out_file; + int i, entry, offset, j, acount, linemod; + int totcrd, ptrcrd, indcrd, valcrd, rhscrd; + int nvalentries, nrhsentries; + int Ptrperline, Ptrwidth, Indperline, Indwidth; + int Rhsperline, Rhswidth, Rhsprec, Rhsflag; + int Valperline, Valwidth, Valprec; + int Valflag; /* Indicates 'E','D', or 'F' float format */ + char pformat[16],iformat[16],vformat[19],rformat[19]; + // char *pValflag, *pRhsflag; + gmm::standard_locale sl; + + if ( Type[0] == 'C' ) + { nvalentries = 2*nz; nrhsentries = 2*M; } + else + { nvalentries = nz; nrhsentries = M; } + + if ( filename != NULL ) { + SECURE_FOPEN(&out_file, filename, "w"); + GMM_ASSERT1(out_file != NULL, "Error: Cannot open file: " << filename); + } else out_file = stdout; + + if ( Ptrfmt == NULL ) Ptrfmt = "(8I10)"; + ParseIfmt(Ptrfmt, &Ptrperline, &Ptrwidth); + SECURE_SPRINTF1(pformat,sizeof(pformat),"%%%dd",Ptrwidth); + ptrcrd = (N+1)/Ptrperline; + if ( (N+1)%Ptrperline != 0) ptrcrd++; + + if ( Indfmt == NULL ) Indfmt = Ptrfmt; + ParseIfmt(Indfmt, &Indperline, &Indwidth); + SECURE_SPRINTF1(iformat,sizeof(iformat), "%%%dd",Indwidth); + indcrd = nz/Indperline; + if ( nz%Indperline != 0) indcrd++; + + if ( Type[0] != 'P' ) { /* Skip if pattern only */ + if ( Valfmt == NULL ) Valfmt = "(4E21.13)"; + ParseRfmt(Valfmt, &Valperline, &Valwidth, &Valprec, &Valflag); +// if (Valflag == 'D') { +// pValflag = (char *) strchr(Valfmt,'D'); +// *pValflag = 'E'; +// } + if (Valflag == 'F') + SECURE_SPRINTF2(vformat, sizeof(vformat), "%% %d.%df", Valwidth, + Valprec); + else + SECURE_SPRINTF2(vformat, sizeof(vformat), "%% %d.%dE", Valwidth, + Valprec); + valcrd = nvalentries/Valperline; + if ( nvalentries%Valperline != 0) valcrd++; + } else valcrd = 0; + + if ( Nrhs > 0 ) { + if ( Rhsfmt == NULL ) Rhsfmt = Valfmt; + ParseRfmt(Rhsfmt,&Rhsperline,&Rhswidth,&Rhsprec, &Rhsflag); + if (Rhsflag == 'F') + SECURE_SPRINTF2(rformat,sizeof(rformat), "%% %d.%df",Rhswidth,Rhsprec); + else + SECURE_SPRINTF2(rformat,sizeof(rformat), "%% %d.%dE",Rhswidth,Rhsprec); +// if (Valflag == 'D') { +// pRhsflag = (char *) strchr(Rhsfmt,'D'); +// *pRhsflag = 'E'; +// } + rhscrd = nrhsentries/Rhsperline; + if ( nrhsentries%Rhsperline != 0) rhscrd++; + if ( Rhstype[1] == 'G' ) rhscrd+=rhscrd; + if ( Rhstype[2] == 'X' ) rhscrd+=rhscrd; + rhscrd*=Nrhs; + } else rhscrd = 0; + + totcrd = 4+ptrcrd+indcrd+valcrd+rhscrd; + + + /* Print header information: */ + + fprintf(out_file,"%-72s%-8s\n%14d%14d%14d%14d%14d\n",Title, Key, totcrd, + ptrcrd, indcrd, valcrd, rhscrd); + fprintf(out_file,"%3s%11s%14d%14d%14d%14d\n",Type," ", M, N, nz, 0); + fprintf(out_file,"%-16s%-16s%-20s", Ptrfmt, Indfmt, Valfmt); + if ( Nrhs != 0 ) { + /* Print Rhsfmt on fourth line and */ + /* optional fifth header line for auxillary vector information:*/ + fprintf(out_file,"%-20s\n%-14s%d\n",Rhsfmt,Rhstype,Nrhs); + } + else + fprintf(out_file,"\n"); + + offset = 1 - shift; /* if base 0 storage is declared (via macro def), */ + /* then storage entries are offset by 1 */ + + /* Print column pointers: */ + for (i = 0; i < N+1; i++) { + entry = colptr[i]+offset; + fprintf(out_file,pformat,entry); + if ( (i+1)%Ptrperline == 0 ) fprintf(out_file,"\n"); + } + + if ( (N+1) % Ptrperline != 0 ) fprintf(out_file,"\n"); + + /* Print row indices: */ + for (i=0;i 0 ) { + for (j=0;j void + HarwellBoeing_IO::write(const char *filename, + const csc_matrix& A) { + write(filename, csc_matrix_ref + (&A.pr[0], &A.ir[0], &A.jc[0], A.nr, A.nc)); + } + + template void + HarwellBoeing_IO::write(const char *filename, + const csc_matrix& A, + const std::vector &rhs) { + write(filename, csc_matrix_ref + (&A.pr[0], &A.ir[0], &A.jc[0], A.nr, A.nc), rhs); + } + + template void + HarwellBoeing_IO::write(const char *filename, + const csc_matrix_ref& A) { + const char *t = 0; + if (is_complex_double__(T())) + if (mat_nrows(A) == mat_ncols(A)) t = "CUA"; else t = "CRA"; + else + if (mat_nrows(A) == mat_ncols(A)) t = "RUA"; else t = "RRA"; + writeHB_mat_double(filename, int(mat_nrows(A)), int(mat_ncols(A)), + A.jc[mat_ncols(A)], A.jc, A.ir, + (const double *)A.pr, + 0, 0, 0, 0, "GETFEM++ CSC MATRIX", "CSCMAT", + t, 0, 0, 0, 0, "F", shift); + } + + template void + HarwellBoeing_IO::write(const char *filename, + const csc_matrix_ref& A, + const std::vector &rhs) { + const char *t = 0; + if (is_complex_double__(T())) + if (mat_nrows(A) == mat_ncols(A)) t = "CUA"; else t = "CRA"; + else + if (mat_nrows(A) == mat_ncols(A)) t = "RUA"; else t = "RRA"; + int Nrhs = gmm::vect_size(rhs) / mat_nrows(A); + writeHB_mat_double(filename, int(mat_nrows(A)), int(mat_ncols(A)), + A.jc[mat_ncols(A)], A.jc, A.ir, + (const double *)A.pr, + Nrhs, (const double *)(&rhs[0]), 0, 0, + "GETFEM++ CSC MATRIX", "CSCMAT", + t, 0, 0, 0, 0, "F ", shift); + } + + + template void + HarwellBoeing_IO::write(const char *filename, const MAT& A) { + gmm::csc_matrix::value_type> + tmp(gmm::mat_nrows(A), gmm::mat_ncols(A)); + gmm::copy(A,tmp); + HarwellBoeing_IO::write(filename, tmp); + } + + /** save a "double" or "std::complex" csc matrix into a + HarwellBoeing file + */ + template inline void + Harwell_Boeing_save(const std::string &filename, + const csc_matrix& A) + { HarwellBoeing_IO::write(filename.c_str(), A); } + + /** save a reference on "double" or "std::complex" csc matrix + into a HarwellBoeing file + */ + template inline void + Harwell_Boeing_save(const std::string &filename, + const csc_matrix_ref& A) + { HarwellBoeing_IO::write(filename.c_str(), A); } + + /** save a "double" or "std::complex" generic matrix + into a HarwellBoeing file making a copy in a csc matrix + */ + template inline void + Harwell_Boeing_save(const std::string &filename, const MAT& A) { + gmm::csc_matrix::value_type> + tmp(gmm::mat_nrows(A), gmm::mat_ncols(A)); + gmm::copy(A, tmp); + HarwellBoeing_IO::write(filename.c_str(), tmp); + } + + template inline void + Harwell_Boeing_save(const std::string &filename, const MAT& A, + const VECT &RHS) { + typedef typename gmm::linalg_traits::value_type T; + gmm::csc_matrix tmp(gmm::mat_nrows(A), gmm::mat_ncols(A)); + gmm::copy(A, tmp); + std::vector tmprhs(gmm::vect_size(RHS)); + gmm::copy(RHS, tmprhs); + HarwellBoeing_IO::write(filename.c_str(), tmp, tmprhs); + } + + /** load a "double" or "std::complex" csc matrix from a + HarwellBoeing file + */ + template void + Harwell_Boeing_load(const std::string &filename, csc_matrix& A) { + HarwellBoeing_IO h(filename.c_str()); h.read(A); + } + + /** load a "double" or "std::complex" generic matrix from a + HarwellBoeing file + */ + template void + Harwell_Boeing_load(const std::string &filename, MAT& A) { + csc_matrix::value_type> csc; + Harwell_Boeing_load(filename, csc); + resize(A, mat_nrows(csc), mat_ncols(csc)); + copy(csc, A); + } + + /*************************************************************************/ + /* */ + /* Functions to read and write MatrixMarket format. */ + /* */ + /*************************************************************************/ + + /* + * Matrix Market I/O library for ANSI C + * + * See http://math.nist.gov/MatrixMarket for details. + * + * + */ + +#define MM_MAX_LINE_LENGTH 1025 +#define MatrixMarketBanner "%%MatrixMarket" +#define MM_MAX_TOKEN_LENGTH 64 + + typedef char MM_typecode[4]; + + /******************* MM_typecode query functions *************************/ + +#define mm_is_matrix(typecode) ((typecode)[0]=='M') + +#define mm_is_sparse(typecode) ((typecode)[1]=='C') +#define mm_is_coordinate(typecode) ((typecode)[1]=='C') +#define mm_is_dense(typecode) ((typecode)[1]=='A') +#define mm_is_array(typecode) ((typecode)[1]=='A') + +#define mm_is_complex(typecode) ((typecode)[2]=='C') +#define mm_is_real(typecode) ((typecode)[2]=='R') +#define mm_is_pattern(typecode) ((typecode)[2]=='P') +#define mm_is_integer(typecode) ((typecode)[2]=='I') + +#define mm_is_symmetric(typecode) ((typecode)[3]=='S') +#define mm_is_general(typecode) ((typecode)[3]=='G') +#define mm_is_skew(typecode) ((typecode)[3]=='K') +#define mm_is_hermitian(typecode) ((typecode)[3]=='H') + + /******************* MM_typecode modify fucntions ************************/ + +#define mm_set_matrix(typecode) ((*typecode)[0]='M') +#define mm_set_coordinate(typecode) ((*typecode)[1]='C') +#define mm_set_array(typecode) ((*typecode)[1]='A') +#define mm_set_dense(typecode) mm_set_array(typecode) +#define mm_set_sparse(typecode) mm_set_coordinate(typecode) + +#define mm_set_complex(typecode) ((*typecode)[2]='C') +#define mm_set_real(typecode) ((*typecode)[2]='R') +#define mm_set_pattern(typecode) ((*typecode)[2]='P') +#define mm_set_integer(typecode) ((*typecode)[2]='I') + + +#define mm_set_symmetric(typecode) ((*typecode)[3]='S') +#define mm_set_general(typecode) ((*typecode)[3]='G') +#define mm_set_skew(typecode) ((*typecode)[3]='K') +#define mm_set_hermitian(typecode) ((*typecode)[3]='H') + +#define mm_clear_typecode(typecode) ((*typecode)[0]=(*typecode)[1]= \ + (*typecode)[2]=' ',(*typecode)[3]='G') + +#define mm_initialize_typecode(typecode) mm_clear_typecode(typecode) + + + /******************* Matrix Market error codes ***************************/ + + +#define MM_COULD_NOT_READ_FILE 11 +#define MM_PREMATURE_EOF 12 +#define MM_NOT_MTX 13 +#define MM_NO_HEADER 14 +#define MM_UNSUPPORTED_TYPE 15 +#define MM_LINE_TOO_LONG 16 +#define MM_COULD_NOT_WRITE_FILE 17 + + + /******************** Matrix Market internal definitions ***************** + + MM_matrix_typecode: 4-character sequence + + object sparse/ data storage + dense type scheme + + string position: [0] [1] [2] [3] + + Matrix typecode: M(atrix) C(oord) R(eal) G(eneral) + A(array) C(omplex) H(ermitian) + P(attern) S(ymmetric) + I(nteger) K(kew) + + ***********************************************************************/ + +#define MM_MTX_STR "matrix" +#define MM_ARRAY_STR "array" +#define MM_DENSE_STR "array" +#define MM_COORDINATE_STR "coordinate" +#define MM_SPARSE_STR "coordinate" +#define MM_COMPLEX_STR "complex" +#define MM_REAL_STR "real" +#define MM_INT_STR "integer" +#define MM_GENERAL_STR "general" +#define MM_SYMM_STR "symmetric" +#define MM_HERM_STR "hermitian" +#define MM_SKEW_STR "skew-symmetric" +#define MM_PATTERN_STR "pattern" + + inline char *mm_typecode_to_str(MM_typecode matcode) { + char buffer[MM_MAX_LINE_LENGTH]; + const char *types[4] = {0,0,0,0}; + /* int error =0; */ + /* int i; */ + + /* check for MTX type */ + if (mm_is_matrix(matcode)) + types[0] = MM_MTX_STR; + /* + else + error=1; + */ + /* check for CRD or ARR matrix */ + if (mm_is_sparse(matcode)) + types[1] = MM_SPARSE_STR; + else + if (mm_is_dense(matcode)) + types[1] = MM_DENSE_STR; + else + return NULL; + + /* check for element data type */ + if (mm_is_real(matcode)) + types[2] = MM_REAL_STR; + else + if (mm_is_complex(matcode)) + types[2] = MM_COMPLEX_STR; + else + if (mm_is_pattern(matcode)) + types[2] = MM_PATTERN_STR; + else + if (mm_is_integer(matcode)) + types[2] = MM_INT_STR; + else + return NULL; + + + /* check for symmetry type */ + if (mm_is_general(matcode)) + types[3] = MM_GENERAL_STR; + else if (mm_is_symmetric(matcode)) + types[3] = MM_SYMM_STR; + else if (mm_is_hermitian(matcode)) + types[3] = MM_HERM_STR; + else if (mm_is_skew(matcode)) + types[3] = MM_SKEW_STR; + else + return NULL; + + SECURE_SPRINTF4(buffer, sizeof(buffer), "%s %s %s %s", types[0], types[1], + types[2], types[3]); + return SECURE_STRDUP(buffer); + + } + + inline int mm_read_banner(FILE *f, MM_typecode *matcode) { + char line[MM_MAX_LINE_LENGTH]; + char banner[MM_MAX_TOKEN_LENGTH]; + char mtx[MM_MAX_TOKEN_LENGTH]; + char crd[MM_MAX_TOKEN_LENGTH]; + char data_type[MM_MAX_TOKEN_LENGTH]; + char storage_scheme[MM_MAX_TOKEN_LENGTH]; + char *p; + gmm::standard_locale sl; + /* int ret_code; */ + + mm_clear_typecode(matcode); + + if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL) + return MM_PREMATURE_EOF; + +#ifdef GMM_SECURE_CRT + if (sscanf_s(line, "%s %s %s %s %s", banner, sizeof(banner), + mtx, sizeof(mtx), crd, sizeof(crd), data_type, + sizeof(data_type), storage_scheme, + sizeof(storage_scheme)) != 5) +#else + if (sscanf(line, "%s %s %s %s %s", banner, mtx, crd, + data_type, storage_scheme) != 5) +#endif + return MM_PREMATURE_EOF; + + for (p=mtx; *p!='\0'; *p=char(tolower(*p)),p++) {}; /* convert to lower case */ + for (p=crd; *p!='\0'; *p=char(tolower(*p)),p++) {}; + for (p=data_type; *p!='\0'; *p=char(tolower(*p)),p++) {}; + for (p=storage_scheme; *p!='\0'; *p=char(tolower(*p)),p++) {}; + + /* check for banner */ + if (strncmp(banner, MatrixMarketBanner, strlen(MatrixMarketBanner)) != 0) + return MM_NO_HEADER; + + /* first field should be "mtx" */ + if (strcmp(mtx, MM_MTX_STR) != 0) + return MM_UNSUPPORTED_TYPE; + mm_set_matrix(matcode); + + + /* second field describes whether this is a sparse matrix (in coordinate + storgae) or a dense array */ + + + if (strcmp(crd, MM_SPARSE_STR) == 0) + mm_set_sparse(matcode); + else + if (strcmp(crd, MM_DENSE_STR) == 0) + mm_set_dense(matcode); + else + return MM_UNSUPPORTED_TYPE; + + + /* third field */ + + if (strcmp(data_type, MM_REAL_STR) == 0) + mm_set_real(matcode); + else + if (strcmp(data_type, MM_COMPLEX_STR) == 0) + mm_set_complex(matcode); + else + if (strcmp(data_type, MM_PATTERN_STR) == 0) + mm_set_pattern(matcode); + else + if (strcmp(data_type, MM_INT_STR) == 0) + mm_set_integer(matcode); + else + return MM_UNSUPPORTED_TYPE; + + + /* fourth field */ + + if (strcmp(storage_scheme, MM_GENERAL_STR) == 0) + mm_set_general(matcode); + else + if (strcmp(storage_scheme, MM_SYMM_STR) == 0) + mm_set_symmetric(matcode); + else + if (strcmp(storage_scheme, MM_HERM_STR) == 0) + mm_set_hermitian(matcode); + else + if (strcmp(storage_scheme, MM_SKEW_STR) == 0) + mm_set_skew(matcode); + else + return MM_UNSUPPORTED_TYPE; + + return 0; + } + + inline int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz ) { + char line[MM_MAX_LINE_LENGTH]; + /* int ret_code;*/ + int num_items_read; + + /* set return null parameter values, in case we exit with errors */ + *M = *N = *nz = 0; + + /* now continue scanning until you reach the end-of-comments */ + do { + if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) + return MM_PREMATURE_EOF; + } while (line[0] == '%'); + + /* line[] is either blank or has M,N, nz */ + if (SECURE_NONCHAR_SSCANF(line, "%d %d %d", M, N, nz) == 3) return 0; + else + do { + num_items_read = SECURE_NONCHAR_FSCANF(f, "%d %d %d", M, N, nz); + if (num_items_read == EOF) return MM_PREMATURE_EOF; + } + while (num_items_read != 3); + + return 0; + } + + + inline int mm_read_mtx_crd_data(FILE *f, int, int, int nz, int II[], + int J[], double val[], MM_typecode matcode) { + int i; + if (mm_is_complex(matcode)) { + for (i=0; i void read(Matrix &A); + /* write a matrix */ + template static void + write(const char *filename, const csc_matrix& A); + template static void + write(const char *filename, + const csc_matrix_ref& A); + template static void + write(const char *filename, const MAT& A); + }; + + /** load a matrix-market file */ + template inline void + MatrixMarket_load(const char *filename, Matrix& A) { + MatrixMarket_IO mm; mm.open(filename); + mm.read(A); + } + /** write a matrix-market file */ + template void + MatrixMarket_save(const char *filename, const csc_matrix& A) { + MatrixMarket_IO mm; mm.write(filename, A); + } + + template inline void + MatrixMarket_save(const char *filename, + const csc_matrix_ref& A) { + MatrixMarket_IO mm; mm.write(filename, A); + } + + + inline void MatrixMarket_IO::open(const char *filename) { + gmm::standard_locale sl; + if (f) { fclose(f); } + SECURE_FOPEN(&f, filename, "r"); + GMM_ASSERT1(f, "Sorry, cannot open file " << filename); + int s1 = mm_read_banner(f, &matcode); + GMM_ASSERT1(s1 == 0, "Sorry, cannnot find the matrix market banner in " + << filename); + int s2 = mm_is_coordinate(matcode), s3 = mm_is_matrix(matcode); + GMM_ASSERT1(s2 > 0 && s3 > 0, + "file is not coordinate storage or is not a matrix"); + int s4 = mm_is_pattern(matcode); + GMM_ASSERT1(s4 == 0, + "the file does only contain the pattern of a sparse matrix"); + int s5 = mm_is_skew(matcode); + GMM_ASSERT1(s5 == 0, "not currently supporting skew symmetric"); + isSymmetric = mm_is_symmetric(matcode) || mm_is_hermitian(matcode); + isHermitian = mm_is_hermitian(matcode); + isComplex = mm_is_complex(matcode); + mm_read_mtx_crd_size(f, &row, &col, &nz); + } + + template void MatrixMarket_IO::read(Matrix &A) { + gmm::standard_locale sl; + typedef typename linalg_traits::value_type T; + GMM_ASSERT1(f, "no file opened!"); + GMM_ASSERT1(!is_complex_double__(T()) || isComplex, + "Bad MM matrix format (complex matrix expected)"); + GMM_ASSERT1(is_complex_double__(T()) || !isComplex, + "Bad MM matrix format (real matrix expected)"); + A = Matrix(row, col); + gmm::clear(A); + + std::vector II(nz), J(nz); + std::vector PR(nz); + mm_read_mtx_crd_data(f, row, col, nz, &II[0], &J[0], + (double*)&PR[0], matcode); + + for (size_type i = 0; i < size_type(nz); ++i) { + A(II[i]-1, J[i]-1) = PR[i]; + + // FIXED MM Format + if (mm_is_hermitian(matcode) && (II[i] != J[i]) ) { + A(J[i]-1, II[i]-1) = gmm::conj(PR[i]); + } + + if (mm_is_symmetric(matcode) && (II[i] != J[i]) ) { + A(J[i]-1, II[i]-1) = PR[i]; + } + + if (mm_is_skew(matcode) && (II[i] != J[i]) ) { + A(J[i]-1, II[i]-1) = -PR[i]; + } + } + } + + template void + MatrixMarket_IO::write(const char *filename, const csc_matrix& A) { + write(filename, csc_matrix_ref + (&A.pr[0], &A.ir[0], &A.jc[0], A.nr, A.nc)); + } + + template void + MatrixMarket_IO::write(const char *filename, + const csc_matrix_ref& A) { + gmm::standard_locale sl; + static MM_typecode t1 = {'M', 'C', 'R', 'G'}; + static MM_typecode t2 = {'M', 'C', 'C', 'G'}; + MM_typecode t; + + if (is_complex_double__(T())) std::copy(&(t2[0]), &(t2[0])+4, &(t[0])); + else std::copy(&(t1[0]), &(t1[0])+4, &(t[0])); + size_type nz = A.jc[mat_ncols(A)]; + std::vector II(nz), J(nz); + for (size_type j=0; j < mat_ncols(A); ++j) { + for (size_type i = A.jc[j]; i < A.jc[j+1]; ++i) { + II[i] = A.ir[i] + 1 - shift; + J[i] = int(j + 1); + } + } + mm_write_mtx_crd(filename, int(mat_nrows(A)), int(mat_ncols(A)), + int(nz), &II[0], &J[0], (const double *)A.pr, t); + } + + + template void + MatrixMarket_IO::write(const char *filename, const MAT& A) { + gmm::csc_matrix::value_type> + tmp(gmm::mat_nrows(A), gmm::mat_ncols(A)); + gmm::copy(A,tmp); + MatrixMarket_IO::write(filename, tmp); + } + + template static void vecsave(std::string fname, const VEC& V, + bool binary=false, std::string Vformat="") { + if (binary) { + std::ofstream f(fname.c_str(), std::ofstream::binary); + for (size_type i=0; i < gmm::vect_size(V); ++i) + f.write(reinterpret_cast(&V[i]), sizeof(V[i])); + } + else { + if (Vformat.empty()){ + std::ofstream f(fname.c_str()); f.imbue(std::locale("C")); + f.precision(16); + for (size_type i=0; i < gmm::vect_size(V); ++i) f << V[i] << "\n"; + } + else { + FILE* f = fopen(fname.c_str(), "w"); + for (size_type i=0; i < gmm::vect_size(V); ++i) fprintf(f, Vformat.c_str(), V[i]); + fclose(f); + } + } + } + + template static void vecload(std::string fname, const VEC& V_, + bool binary=false) { + VEC &V(const_cast(V_)); + if (binary) { + std::ifstream f(fname.c_str(), std::ifstream::binary); + for (size_type i=0; i < gmm::vect_size(V); ++i) + f.read(reinterpret_cast(&V[i]), sizeof(V[i])); + } + else { + std::ifstream f(fname.c_str()); f.imbue(std::locale("C")); + for (size_type i=0; i < gmm::vect_size(V); ++i) f >> V[i]; + } + } +} + + +#endif // GMM_INOUTPUT_H diff --git a/7.x/src/linear_algebra/gmm/gmm_interface.h b/7.x/src/linear_algebra/gmm/gmm_interface.h new file mode 100644 index 0000000..6635a25 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_interface.h @@ -0,0 +1,1068 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + + +/**@file gmm_interface.h + @author Yves Renard + @date October 13, 2002. + @brief gmm interface for STL vectors. +*/ + +#ifndef GMM_INTERFACE_H__ +#define GMM_INTERFACE_H__ + +#include "gmm_blas.h" +#include "gmm_sub_index.h" + +namespace gmm { + + /* ********************************************************************* */ + /* */ + /* What is needed for a Vector type : */ + /* Vector v(n) defines a vector with n components. */ + /* v[i] allows to access to the ith component of v. */ + /* linalg_traits should be filled with appropriate definitions */ + /* */ + /* for a dense vector : the minimum is two random iterators (begin and */ + /* end) and a pointer to a valid origin. */ + /* for a sparse vector : the minimum is two forward iterators, with */ + /* a method it.index() which gives the index of */ + /* a non zero element, an interface object */ + /* should describe the method to add new non */ + /* zero element, and a pointer to a valid */ + /* origin. */ + /* */ + /* What is needed for a Matrix type : */ + /* Matrix m(n, m) defines a matrix with n rows and m columns. */ + /* m(i, j) allows to access to the element at row i and column j. */ + /* linalg_traits should be filled with appropriate definitions */ + /* */ + /* What is needed for an iterator on dense vector */ + /* to be standard random access iterator */ + /* */ + /* What is needed for an iterator on a sparse vector */ + /* to be a standard bidirectional iterator */ + /* elt should be sorted with increasing indices. */ + /* it.index() gives the index of the non-zero element. */ + /* */ + /* Remark : If original iterators are not convenient, they could be */ + /* redefined and interfaced in linalg_traits without changing */ + /* the original Vector type. */ + /* */ + /* ********************************************************************* */ + + /* ********************************************************************* */ + /* Simple references on vectors */ + /* ********************************************************************* */ + + template struct simple_vector_ref { + typedef simple_vector_ref this_type; + typedef typename std::iterator_traits::value_type V; + typedef V * CPT; + typedef typename std::iterator_traits::reference ref_V; + typedef typename linalg_traits::iterator iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + size_type size_; + + simple_vector_ref(ref_V v) : begin_(vect_begin(const_cast(v))), + end_(vect_end(const_cast(v))), + origin(linalg_origin(const_cast(v))), + size_(vect_size(v)) {} + + simple_vector_ref(const simple_vector_ref &cr) + : begin_(cr.begin_),end_(cr.end_),origin(cr.origin),size_(cr.size_) {} + + simple_vector_ref(void) {} + + reference operator[](size_type i) const + { return linalg_traits::access(origin, begin_, end_, i); } + }; + + template inline + void set_to_begin(IT &it, ORG o, simple_vector_ref *,linalg_modifiable) { + typedef typename linalg_traits >::V_reference ref_t; + set_to_begin(it, o, PT(), ref_t()); + } + + template inline + void set_to_begin(IT &it, ORG o, const simple_vector_ref *, + linalg_modifiable) { + typedef typename linalg_traits >::V_reference ref_t; + set_to_begin(it, o, PT(), ref_t()); + } + + template inline + void set_to_end(IT &it, ORG o, simple_vector_ref *, linalg_modifiable) { + typedef typename linalg_traits >::V_reference ref_t; + set_to_end(it, o, PT(), ref_t()); + } + + template inline + void set_to_end(IT &it, ORG o, const simple_vector_ref *, + linalg_modifiable) { + typedef typename linalg_traits >::V_reference ref_t; + set_to_end(it, o, PT(), ref_t()); + } + + + template struct linalg_traits > { + typedef simple_vector_ref this_type; + typedef this_type *pthis_type; + typedef typename std::iterator_traits::value_type V; + typedef typename linalg_traits::origin_type origin_type; + typedef V *pV; + typedef typename linalg_traits::is_reference V_reference; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef typename select_ref::ref_type porigin_type; + typedef typename select_ref::const_iterator, + typename linalg_traits::iterator, PT>::ref_type iterator; + typedef typename linalg_traits::const_iterator const_iterator; + typedef typename linalg_traits::storage_type storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size_; } + static inline iterator begin(this_type &v) { + iterator it = v.begin_; + set_to_begin(it, v.origin, pthis_type(), is_reference()); + return it; + } + static inline const_iterator begin(const this_type &v) { + const_iterator it = v.begin_; + set_to_begin(it, v.origin, pthis_type(), is_reference()); + return it; + } + static inline iterator end(this_type &v) { + iterator it = v.end_; + set_to_end(it, v.origin, pthis_type(), is_reference()); + return it; + } + static inline const_iterator end(const this_type &v) { + const_iterator it = v.end_; + set_to_end(it, v.origin, pthis_type(), is_reference()); + return it; + } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void clear(origin_type* o, const iterator &it, const iterator &ite) + { linalg_traits::clear(o, it, ite); } + static void do_clear(this_type &v) { clear(v.origin, v.begin_, v.end_); } + static value_type access(const origin_type *o, const const_iterator &it, + const const_iterator &ite, size_type i) + { return linalg_traits::access(o, it, ite, i); } + static reference access(origin_type *o, const iterator &it, + const iterator &ite, size_type i) + { return linalg_traits::access(o, it, ite, i); } + }; + + template + std::ostream &operator << (std::ostream &o, const simple_vector_ref& v) + { gmm::write(o,v); return o; } + + template + simple_vector_ref *> + vref(const std::vector &vv) + { return simple_vector_ref *>(vv); } + + + /* ********************************************************************* */ + /* */ + /* Traits for S.T.L. object */ + /* */ + /* ********************************************************************* */ + + template + struct linalg_traits > { + typedef std::vector this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_vector linalg_type; + typedef T value_type; + typedef T& reference; + typedef typename this_type::iterator iterator; + typedef typename this_type::const_iterator const_iterator; + typedef abstract_dense storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static origin_type* origin(this_type &v) { return &v; } + static const origin_type* origin(const this_type &v) { return &v; } + static void clear(origin_type*, const iterator &it, const iterator &ite) + { std::fill(it, ite, value_type(0)); } + static void do_clear(this_type &v) { std::fill(v.begin(), v.end(), T(0)); } + static value_type access(const origin_type *, const const_iterator &it, + const const_iterator &, size_type i) + { return it[i]; } + static reference access(origin_type *, const iterator &it, + const iterator &, size_type i) + { return it[i]; } + static void resize(this_type &v, size_type n) { v.resize(n); } + }; + + + + template + inline size_type nnz(const std::vector& l) { return l.size(); } + + /* ********************************************************************* */ + /* */ + /* Traits for ref objects */ + /* */ + /* ********************************************************************* */ + + template + struct tab_ref_with_origin : public gmm::tab_ref { + typedef tab_ref_with_origin this_type; + // next line replaced by the 4 following lines in order to please aCC + //typedef typename linalg_traits::porigin_type porigin_type; + typedef typename linalg_traits::origin_type origin_type; + typedef typename std::iterator_traits::pointer PT; + typedef typename select_ref::ref_type porigin_type; + + + porigin_type origin; + + tab_ref_with_origin(void) {} + template tab_ref_with_origin(const IT &b, const IT &e, PT p) + : gmm::tab_ref(b,e), origin(porigin_type(p)) {} + tab_ref_with_origin(const IT &b, const IT &e, porigin_type p) + : gmm::tab_ref(b,e), origin(p) {} + + tab_ref_with_origin(const V &v, const sub_interval &si) + : gmm::tab_ref(vect_begin(const_cast(v))+si.min, + vect_begin(const_cast(v))+si.max), + origin(linalg_origin(const_cast(v))) {} + tab_ref_with_origin(V &v, const sub_interval &si) + : gmm::tab_ref(vect_begin(const_cast(v))+si.min, + vect_begin(const_cast(v))+si.max), + origin(linalg_origin(const_cast(v))) {} + }; + + template + struct linalg_traits > { + typedef typename std::iterator_traits::pointer PT; + typedef typename linalg_traits::origin_type origin_type; + typedef tab_ref_with_origin this_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::reference reference; + typedef typename this_type::iterator iterator; + typedef typename this_type::iterator const_iterator; + typedef abstract_dense storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void clear(origin_type*, const iterator &it, const iterator &ite) + { std::fill(it, ite, value_type(0)); } + static inline void do_clear(this_type &v) + { std::fill(v.begin(), v.end(), value_type(0)); } + static value_type access(const origin_type *, const const_iterator &it, + const const_iterator &, size_type i) + { return it[i]; } + static reference access(origin_type *, const iterator &it, + const iterator &, size_type i) + { return it[i]; } + }; + + template std::ostream &operator << + (std::ostream &o, const tab_ref_with_origin& m) + { gmm::write(o,m); return o; } + + + template + struct tab_ref_reg_spaced_with_origin : public gmm::tab_ref_reg_spaced { + typedef tab_ref_reg_spaced_with_origin this_type; + typedef typename linalg_traits::porigin_type porigin_type; + + porigin_type origin; + + tab_ref_reg_spaced_with_origin(void) {} + tab_ref_reg_spaced_with_origin(const IT &b, size_type n, size_type s, + const porigin_type p) + : gmm::tab_ref_reg_spaced(b,n,s), origin(p) {} + tab_ref_reg_spaced_with_origin(const V &v, const sub_slice &si) + : gmm::tab_ref_reg_spaced(vect_begin(const_cast(v)) + si.min, + si.N, (si.max - si.min)/si.N), + origin(linalg_origin(const_cast(v))) {} + tab_ref_reg_spaced_with_origin(V &v, const sub_slice &si) + : gmm::tab_ref_reg_spaced(vect_begin(const_cast(v)) + si.min, + si.N, (si.max - si.min)/si.N), + origin(linalg_origin(const_cast(v))) {} + }; + + template + struct linalg_traits > { + typedef typename std::iterator_traits::pointer PT; + typedef tab_ref_reg_spaced_with_origin this_type; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::reference reference; + typedef typename this_type::iterator iterator; + typedef typename this_type::iterator const_iterator; + typedef abstract_dense storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void clear(origin_type*, const iterator &it, const iterator &ite) + { std::fill(it, ite, value_type(0)); } + static void do_clear(this_type &v) + { std::fill(v.begin(), v.end(), value_type(0)); } + static value_type access(const origin_type *, const const_iterator &it, + const const_iterator &, size_type i) + { return it[i]; } + static reference access(origin_type *, const iterator &it, + const iterator &, size_type i) + { return it[i]; } + }; + + template std::ostream &operator << + (std::ostream &o, const tab_ref_reg_spaced_with_origin& m) + { gmm::write(o,m); return o; } + + + template + struct tab_ref_index_ref_with_origin + : public gmm::tab_ref_index_ref { + typedef tab_ref_index_ref_with_origin this_type; + typedef typename linalg_traits::porigin_type porigin_type; + + porigin_type origin; + + tab_ref_index_ref_with_origin(void) {} + tab_ref_index_ref_with_origin(const IT &b, const ITINDEX &bi, + const ITINDEX &ei, porigin_type p) + : gmm::tab_ref_index_ref(b, bi, ei), origin(p) {} + + tab_ref_index_ref_with_origin(const V &v, const sub_index &si) + : gmm::tab_ref_index_ref(vect_begin(const_cast(v)), + si.begin(), si.end()), + origin(linalg_origin(const_cast(v))) {} + tab_ref_index_ref_with_origin(V &v, const sub_index &si) + : gmm::tab_ref_index_ref(vect_begin(const_cast(v)), + si.begin(), si.end()), + origin(linalg_origin(const_cast(v))) {} + }; + + template + struct linalg_traits > { + typedef typename std::iterator_traits::pointer PT; + typedef tab_ref_index_ref_with_origin this_type; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::reference reference; + typedef typename this_type::iterator iterator; + typedef typename this_type::iterator const_iterator; + typedef abstract_dense storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void clear(origin_type*, const iterator &it, const iterator &ite) + { std::fill(it, ite, value_type(0)); } + static void do_clear(this_type &v) + { std::fill(v.begin(), v.end(), value_type(0)); } + static value_type access(const origin_type *, const const_iterator &it, + const const_iterator &, size_type i) + { return it[i]; } + static reference access(origin_type *, const iterator &it, + const iterator &, size_type i) + { return it[i]; } + }; + + template + std::ostream &operator << + (std::ostream &o, const tab_ref_index_ref_with_origin& m) + { gmm::write(o,m); return o; } + + + template + struct dense_compressed_iterator { + typedef ITER value_type; + typedef ITER *pointer; + typedef ITER &reference; + typedef ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; + typedef size_t size_type; + typedef dense_compressed_iterator iterator; + typedef typename std::iterator_traits::value_type *MPT; + + ITER it; + size_type N, nrows, ncols, i; + PT origin; + + iterator operator ++(int) { iterator tmp = *this; i++; return tmp; } + iterator operator --(int) { iterator tmp = *this; i--; return tmp; } + iterator &operator ++() { ++i; return *this; } + iterator &operator --() { --i; return *this; } + iterator &operator +=(difference_type ii) { i += ii; return *this; } + iterator &operator -=(difference_type ii) { i -= ii; return *this; } + iterator operator +(difference_type ii) const + { iterator itt = *this; return (itt += ii); } + iterator operator -(difference_type ii) const + { iterator itt = *this; return (itt -= ii); } + difference_type operator -(const iterator &ii) const + { return (N ? (it - ii.it) / N : 0) + i - ii.i; } + + ITER operator *() const { return it+i*N; } + ITER operator [](int ii) const { return it + (i+ii) * N; } + + bool operator ==(const iterator &ii) const + { return (*this - ii) == difference_type(0); } + bool operator !=(const iterator &ii) const { return !(ii == *this); } + bool operator < (const iterator &ii) const + { return (*this - ii) < difference_type(0); } + + dense_compressed_iterator(void) {} + dense_compressed_iterator(const dense_compressed_iterator &ii) + : it(ii.it), N(ii.N), nrows(ii.nrows), ncols(ii.ncols), i(ii.i), + origin(ii.origin) {} + dense_compressed_iterator(const ITER &iter, size_type n, size_type r, + size_type c, size_type ii, PT o) + : it(iter), N(n), nrows(r), ncols(c), i(ii), origin(o) { } + + }; + + /* ******************************************************************** */ + /* Read only reference on a compressed sparse vector */ + /* ******************************************************************** */ + + template + struct cs_vector_ref_iterator { + PT1 pr; + PT2 ir; + + typedef typename std::iterator_traits::value_type value_type; + typedef PT1 pointer; + typedef typename std::iterator_traits::reference reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef cs_vector_ref_iterator iterator; + + cs_vector_ref_iterator(void) {} + cs_vector_ref_iterator(PT1 p1, PT2 p2) : pr(p1), ir(p2) {} + + inline size_type index(void) const { return (*ir) - shift; } + iterator &operator ++() { ++pr; ++ir; return *this; } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator &operator --() { --pr; --ir; return *this; } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + + reference operator *() const { return *pr; } + pointer operator ->() const { return pr; } + + bool operator ==(const iterator &i) const { return (i.pr==pr);} + bool operator !=(const iterator &i) const { return (i.pr!=pr);} + }; + + template struct cs_vector_ref { + PT1 pr; + PT2 ir; + size_type n, size_; + + typedef cs_vector_ref this_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename linalg_traits::const_iterator const_iterator; + + cs_vector_ref(PT1 pt1, PT2 pt2, size_type nnz, size_type ns) + : pr(pt1), ir(pt2), n(nnz), size_(ns) {} + cs_vector_ref(void) {} + + size_type size(void) const { return size_; } + + const_iterator begin(void) const { return const_iterator(pr, ir); } + const_iterator end(void) const { return const_iterator(pr+n, ir+n); } + + value_type operator[](size_type i) const + { return linalg_traits::access(pr, begin(), end(),i); } + }; + + template + struct linalg_traits > { + typedef cs_vector_ref this_type; + typedef linalg_const is_reference; + typedef abstract_vector linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef value_type origin_type; + typedef typename std::iterator_traits::value_type reference; + typedef cs_vector_ref_iterator::pointer, + typename const_pointer::pointer, shift> const_iterator; + typedef abstract_null_type iterator; + typedef abstract_sparse storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static const origin_type* origin(const this_type &v) { return v.pr; } + static value_type access(const origin_type *, const const_iterator &b, + const const_iterator &e, size_type i) { + if (b.ir == e.ir) return value_type(0); + PT2 p = std::lower_bound(b.ir, e.ir, i+shift); + return (*p == i+shift && p != e.ir) ? b.pr[p-b.ir] : value_type(0); + } + }; + + template + std::ostream &operator << + (std::ostream &o, const cs_vector_ref& m) + { gmm::write(o,m); return o; } + + template + inline size_type nnz(const cs_vector_ref& l) { return l.n; } + + /* ******************************************************************** */ + /* Read only reference on a compressed sparse column matrix */ + /* ******************************************************************** */ + + template + struct sparse_compressed_iterator { + typedef typename std::iterator_traits::value_type value_type; + typedef const value_type *pointer; + typedef const value_type &reference; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef std::random_access_iterator_tag iterator_category; + typedef sparse_compressed_iterator iterator; + + PT1 pr; + PT2 ir; + PT3 jc; + size_type n; + const value_type *origin; + + iterator operator ++(int) { iterator tmp = *this; jc++; return tmp; } + iterator operator --(int) { iterator tmp = *this; jc--; return tmp; } + iterator &operator ++() { jc++; return *this; } + iterator &operator --() { jc--; return *this; } + iterator &operator +=(difference_type i) { jc += i; return *this; } + iterator &operator -=(difference_type i) { jc -= i; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const { return jc - i.jc; } + + reference operator *() const { return pr + *jc - shift; } + reference operator [](int ii) { return pr + *(jc+ii) - shift; } + + bool operator ==(const iterator &i) const { return (jc == i.jc); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (jc < i.jc); } + + sparse_compressed_iterator(void) {} + sparse_compressed_iterator(PT1 p1, PT2 p2, PT3 p3, size_type nn, + const value_type *o) + : pr(p1), ir(p2), jc(p3), n(nn), origin(o) { } + + }; + + template + struct csc_matrix_ref { + PT1 pr; // values. + PT2 ir; // row indexes. + PT3 jc; // column repartition on pr and ir. + size_type nc, nr; + + typedef typename std::iterator_traits::value_type value_type; + csc_matrix_ref(PT1 pt1, PT2 pt2, PT3 pt3, size_type nrr, size_type ncc) + : pr(pt1), ir(pt2), jc(pt3), nc(ncc), nr(nrr) {} + csc_matrix_ref(void) {} + + size_type nrows(void) const { return nr; } + size_type ncols(void) const { return nc; } + + value_type operator()(size_type i, size_type j) const + { return mat_col(*this, j)[i]; } + }; + + template + struct linalg_traits > { + typedef csc_matrix_ref this_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::value_type reference; + typedef value_type origin_type; + typedef abstract_sparse storage_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_row_iterator; + typedef abstract_null_type sub_col_type; + typedef cs_vector_ref::pointer, + typename const_pointer::pointer, shift> const_sub_col_type; + typedef sparse_compressed_iterator::pointer, + typename const_pointer::pointer, + typename const_pointer::pointer, + shift> const_col_iterator; + typedef abstract_null_type col_iterator; + typedef col_major sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(m.pr, m.ir, m.jc, m.nr, m.pr); } + static const_col_iterator col_end(const this_type &m) + { return const_col_iterator(m.pr, m.ir, m.jc + m.nc, m.nr, m.pr); } + static const_sub_col_type col(const const_col_iterator &it) { + return const_sub_col_type(it.pr + *(it.jc) - shift, + it.ir + *(it.jc) - shift, *(it.jc + 1) - *(it.jc), it.n); + } + static const origin_type* origin(const this_type &m) { return m.pr; } + static value_type access(const const_col_iterator &itcol, size_type j) + { return col(itcol)[j]; } + }; + + + template + std::ostream &operator << + (std::ostream &o, const csc_matrix_ref& m) + { gmm::write(o,m); return o; } + + /* ******************************************************************** */ + /* Read only reference on a compressed sparse row matrix */ + /* ******************************************************************** */ + + template + struct csr_matrix_ref { + PT1 pr; // values. + PT2 ir; // column indexes. + PT3 jc; // row repartition on pr and ir. + size_type nc, nr; + + typedef typename std::iterator_traits::value_type value_type; + csr_matrix_ref(PT1 pt1, PT2 pt2, PT3 pt3, size_type nrr, size_type ncc) + : pr(pt1), ir(pt2), jc(pt3), nc(ncc), nr(nrr) {} + csr_matrix_ref(void) {} + + size_type nrows(void) const { return nr; } + size_type ncols(void) const { return nc; } + + value_type operator()(size_type i, size_type j) const + { return mat_row(*this, i)[j]; } + }; + + template + struct linalg_traits > { + typedef csr_matrix_ref this_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::value_type reference; + typedef value_type origin_type; + typedef abstract_sparse storage_type; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_col_iterator; + typedef abstract_null_type sub_row_type; + typedef cs_vector_ref::pointer, + typename const_pointer::pointer, shift> + const_sub_row_type; + typedef sparse_compressed_iterator::pointer, + typename const_pointer::pointer, + typename const_pointer::pointer, + shift> const_row_iterator; + typedef abstract_null_type row_iterator; + typedef row_major sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(m.pr, m.ir, m.jc, m.nc, m.pr); } + static const_row_iterator row_end(const this_type &m) + { return const_row_iterator(m.pr, m.ir, m.jc + m.nr, m.nc, m.pr); } + static const_sub_row_type row(const const_row_iterator &it) { + return const_sub_row_type(it.pr + *(it.jc) - shift, + it.ir + *(it.jc) - shift, *(it.jc + 1) - *(it.jc), it.n); + } + static const origin_type* origin(const this_type &m) { return m.pr; } + static value_type access(const const_row_iterator &itrow, size_type j) + { return row(itrow)[j]; } + }; + + template + std::ostream &operator << + (std::ostream &o, const csr_matrix_ref& m) + { gmm::write(o,m); return o; } + + /* ********************************************************************* */ + /* */ + /* Simple interface for C arrays */ + /* */ + /* ********************************************************************* */ + + template struct array1D_reference { + + typedef typename std::iterator_traits::value_type value_type; + + PT begin, end; + + const value_type &operator[](size_type i) const { return *(begin+i); } + value_type &operator[](size_type i) { return *(begin+i); } + + array1D_reference(PT begin_, size_type s) : begin(begin_), end(begin_+s) {} + }; + + template + struct linalg_traits > { + typedef array1D_reference this_type; + typedef this_type origin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::reference reference; + typedef PT iterator; + typedef PT const_iterator; + typedef abstract_dense storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.end - v.begin; } + static iterator begin(this_type &v) { return v.begin; } + static const_iterator begin(const this_type &v) { return v.begin; } + static iterator end(this_type &v) { return v.end; } + static const_iterator end(const this_type &v) { return v.end; } + static origin_type* origin(this_type &v) { return &v; } + static const origin_type* origin(const this_type &v) { return &v; } + static void clear(origin_type*, const iterator &it, const iterator &ite) + { std::fill(it, ite, value_type(0)); } + static void do_clear(this_type &v) + { std::fill(v.begin, v.end, value_type(0)); } + static value_type access(const origin_type *, const const_iterator &it, + const const_iterator &, size_type i) + { return it[i]; } + static reference access(origin_type *, const iterator &it, + const iterator &, size_type i) + { return it[i]; } + static void resize(this_type &, size_type ) + { GMM_ASSERT1(false, "Not resizable vector"); } + }; + + template std::ostream &operator << + (std::ostream &o, const array1D_reference& v) + { gmm::write(o,v); return o; } + + template struct array2D_col_reference { + + typedef typename std::iterator_traits::value_type T; + typedef typename std::iterator_traits::reference reference; + typedef typename const_reference::reference const_reference; + typedef PT iterator; + typedef typename const_pointer::pointer const_iterator; + + PT begin_; + size_type nbl, nbc; + + inline const_reference operator ()(size_type l, size_type c) const { + GMM_ASSERT2(l < nbl && c < nbc, "out of range"); + return *(begin_ + c*nbl+l); + } + inline reference operator ()(size_type l, size_type c) { + GMM_ASSERT2(l < nbl && c < nbc, "out of range"); + return *(begin_ + c*nbl+l); + } + + void resize(size_type, size_type); + void reshape(size_type m, size_type n) { + GMM_ASSERT2(n*m == nbl*nbc, "dimensions mismatch"); + nbl = m; nbc = n; + } + + void fill(T a, T b = T(0)) { + std::fill(begin_, begin_+nbc*nbl, b); + iterator p = begin_, e = begin_+nbc*nbl; + while (p < e) { *p = a; p += nbl+1; } + } + inline size_type nrows(void) const { return nbl; } + inline size_type ncols(void) const { return nbc; } + + iterator begin(void) { return begin_; } + const_iterator begin(void) const { return begin_; } + iterator end(void) { return begin_+nbl*nbc; } + const_iterator end(void) const { return begin_+nbl*nbc; } + + array2D_col_reference(PT begin__, size_type nrows_, size_type ncols_) + : begin_(begin__), nbl(nrows_), nbc(ncols_) {} + }; + + template struct linalg_traits > { + typedef array2D_col_reference this_type; + typedef this_type origin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::reference reference; + typedef abstract_dense storage_type; + typedef tab_ref_reg_spaced_with_origin sub_row_type; + typedef tab_ref_reg_spaced_with_origin const_sub_row_type; + typedef dense_compressed_iterator row_iterator; + typedef dense_compressed_iterator const_row_iterator; + typedef tab_ref_with_origin sub_col_type; + typedef tab_ref_with_origin const_sub_col_type; + typedef dense_compressed_iterator col_iterator; + typedef dense_compressed_iterator const_col_iterator; + typedef col_and_row sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_sub_row_type row(const const_row_iterator &it) + { return const_sub_row_type(*it, it.nrows, it.ncols, it.origin); } + static const_sub_col_type col(const const_col_iterator &it) + { return const_sub_col_type(*it, *it + it.nrows, it.origin); } + static sub_row_type row(const row_iterator &it) + { return sub_row_type(*it, it.nrows, it.ncols, it.origin); } + static sub_col_type col(const col_iterator &it) + { return sub_col_type(*it, *it + it.nrows, it.origin); } + static row_iterator row_begin(this_type &m) + { return row_iterator(m.begin(), 1, m.nrows(), m.ncols(), 0, &m); } + static row_iterator row_end(this_type &m) + { return row_iterator(m.begin(), 1, m.nrows(), m.ncols(), m.nrows(), &m); } + static const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(m.begin(), 1, m.nrows(), m.ncols(), 0, &m); } + static const_row_iterator row_end(const this_type &m) { + return const_row_iterator(m.begin(), 1, m.nrows(), + m.ncols(), m.nrows(), &m); + } + static col_iterator col_begin(this_type &m) + { return col_iterator(m.begin(), m.nrows(), m.nrows(), m.ncols(), 0, &m); } + static col_iterator col_end(this_type &m) { + return col_iterator(m.begin(), m.nrows(), m.nrows(), m.ncols(), + m.ncols(), &m); + } + static const_col_iterator col_begin(const this_type &m) { + return const_col_iterator(m.begin(), m.nrows(), m.nrows(), + m.ncols(), 0, &m); + } + static const_col_iterator col_end(const this_type &m) { + return const_col_iterator(m.begin(), m.nrows(),m.nrows(),m.ncols(), + m.ncols(), &m); + } + static origin_type* origin(this_type &m) { return &m; } + static const origin_type* origin(const this_type &m) { return &m; } + static void do_clear(this_type &m) { m.fill(value_type(0)); } + static value_type access(const const_col_iterator &itcol, size_type j) + { return (*itcol)[j]; } + static reference access(const col_iterator &itcol, size_type j) + { return (*itcol)[j]; } + static void resize(this_type &v, size_type m, size_type n) + { v.resize(m,n); } + static void reshape(this_type &v, size_type m, size_type n) + { v.reshape(m, n); } + }; + + template std::ostream &operator << + (std::ostream &o, const array2D_col_reference& m) + { gmm::write(o,m); return o; } + + + + template struct array2D_row_reference { + + typedef typename std::iterator_traits::value_type T; + typedef typename std::iterator_traits::reference reference; + typedef typename const_reference::reference const_reference; + typedef PT iterator; + typedef typename const_pointer::pointer const_iterator; + + PT begin_; + size_type nbl, nbc; + + inline const_reference operator ()(size_type l, size_type c) const { + GMM_ASSERT2(l < nbl && c < nbc, "out of range"); + return *(begin_ + l*nbc+c); + } + inline reference operator ()(size_type l, size_type c) { + GMM_ASSERT2(l < nbl && c < nbc, "out of range"); + return *(begin_ + l*nbc+c); + } + + void resize(size_type, size_type); + void reshape(size_type m, size_type n) { + GMM_ASSERT2(n*m == nbl*nbc, "dimensions mismatch"); + nbl = m; nbc = n; + } + + void fill(T a, T b = T(0)) { + std::fill(begin_, begin_+nbc*nbl, b); + iterator p = begin_, e = begin_+nbc*nbl; + while (p < e) { *p = a; p += nbc+1; } + } + inline size_type nrows(void) const { return nbl; } + inline size_type ncols(void) const { return nbc; } + + iterator begin(void) { return begin_; } + const_iterator begin(void) const { return begin_; } + iterator end(void) { return begin_+nbl*nbc; } + const_iterator end(void) const { return begin_+nbl*nbc; } + + array2D_row_reference(PT begin__, size_type nrows_, size_type ncols_) + : begin_(begin__), nbl(nrows_), nbc(ncols_) {} + }; + + template struct linalg_traits > { + typedef array2D_row_reference this_type; + typedef this_type origin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::reference reference; + typedef abstract_dense storage_type; + typedef tab_ref_reg_spaced_with_origin sub_col_type; + typedef tab_ref_reg_spaced_with_origin const_sub_col_type; + typedef dense_compressed_iterator col_iterator; + typedef dense_compressed_iterator const_col_iterator; + typedef tab_ref_with_origin sub_row_type; + typedef tab_ref_with_origin const_sub_row_type; + typedef dense_compressed_iterator row_iterator; + typedef dense_compressed_iterator const_row_iterator; + typedef col_and_row sub_orientation; + typedef linalg_true index_sorted; + static size_type ncols(const this_type &m) { return m.ncols(); } + static size_type nrows(const this_type &m) { return m.nrows(); } + static const_sub_col_type col(const const_col_iterator &it) + { return const_sub_col_type(*it, it.ncols, it.nrows, it.origin); } + static const_sub_row_type row(const const_row_iterator &it) + { return const_sub_row_type(*it, *it + it.ncols, it.origin); } + static sub_col_type col(const col_iterator &it) + { return sub_col_type(*it, *it, it.ncols, it.nrows, it.origin); } + static sub_row_type row(const row_iterator &it) + { return sub_row_type(*it, *it + it.ncols, it.origin); } + static col_iterator col_begin(this_type &m) + { return col_iterator(m.begin(), 1, m.ncols(), m.nrows(), 0, &m); } + static col_iterator col_end(this_type &m) + { return col_iterator(m.begin(), 1, m.ncols(), m.nrows(), m.ncols(), &m); } + static const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(m.begin(), 1, m.ncols(), m.nrows(), 0, &m); } + static const_col_iterator col_end(const this_type &m) { + return const_col_iterator(m.begin(), 1, m.ncols(), + m.nrows(), m.ncols(), &m); + } + static row_iterator row_begin(this_type &m) + { return row_iterator(m.begin(), m.ncols(), m.ncols(), m.nrows(), 0, &m); } + static row_iterator row_end(this_type &m) { + return row_iterator(m.begin(), m.ncols(), m.ncols(), m.nrows(), + m.nrows(), &m); + } + static const_row_iterator row_begin(const this_type &m) { + return const_row_iterator(m.begin(), m.ncols(), m.ncols(), m.nrows(), + 0, &m); + } + static const_row_iterator row_end(const this_type &m) { + return const_row_iterator(m.begin(), m.ncols(), m.ncols(), m.nrows(), + m.nrows(), &m); + } + static origin_type* origin(this_type &m) { return &m; } + static const origin_type* origin(const this_type &m) { return &m; } + static void do_clear(this_type &m) { m.fill(value_type(0)); } + static value_type access(const const_row_iterator &itrow, size_type j) + { return (*itrow)[j]; } + static reference access(const row_iterator &itrow, size_type j) + { return (*itrow)[j]; } + static void resize(this_type &v, size_type m, size_type n) + { v.resize(m,n); } + static void reshape(this_type &v, size_type m, size_type n) + { v.reshape(m, n); } + }; + + template std::ostream &operator << + (std::ostream &o, const array2D_row_reference& m) + { gmm::write(o,m); return o; } + + + + + + +} + + +#endif // GMM_INTERFACE_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_interface_bgeot.h b/7.x/src/linear_algebra/gmm/gmm_interface_bgeot.h new file mode 100644 index 0000000..69a34bd --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_interface_bgeot.h @@ -0,0 +1,83 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_interface_bgeot.h + @author Yves Renard + @date October 13, 2002. + @brief interface for bgeot::small_vector +*/ +#ifndef GMM_INTERFACE_BGEOT_H__ +#define GMM_INTERFACE_BGEOT_H__ + + +namespace gmm { + + /* ********************************************************************* */ + /* */ + /* Traits for bgeot objects */ + /* */ + /* ********************************************************************* */ + + template struct linalg_traits > { + typedef bgeot::small_vector this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_vector linalg_type; + typedef T value_type; + typedef T& reference; + typedef typename this_type::iterator iterator; + typedef typename this_type::const_iterator const_iterator; + typedef abstract_dense storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static origin_type* origin(this_type &v) { return &v; } + static const origin_type* origin(const this_type &v) { return &v; } + static void clear(origin_type* o, const iterator &it, const iterator &ite) + { std::fill(it, ite, value_type(0)); } + static void do_clear(this_type &v) + { std::fill(v.begin(), v.end(), value_type(0)); } + static value_type access(const origin_type *, const const_iterator &it, + const const_iterator &, size_type i) + { return it[i]; } + static reference access(origin_type *, const iterator &it, + const iterator &, size_type i) + { return it[i]; } + static void resize(this_type &v, size_type n) { v.resize(n); } + }; + +} + + +#endif // GMM_INTERFACE_BGEOT_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_iter.h b/7.x/src/linear_algebra/gmm/gmm_iter.h new file mode 100644 index 0000000..b8db9dd --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_iter.h @@ -0,0 +1,162 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_iter.h + @author Yves Renard + @date February 10, 2003. + @brief Iteration object. +*/ + +#ifndef GMM_ITER_H__ +#define GMM_ITER_H__ + +#include "gmm_kernel.h" +#include + +namespace gmm { + + /** The Iteration object calculates whether the solution has reached the + desired accuracy, or whether the maximum number of iterations has + been reached. + + The method finished() checks the convergence. The first() + method is used to determine the first iteration of the loop. + */ + class iteration { + protected : + double rhsn; /* Right hand side norm. */ + size_type maxiter; /* Max. number of iterations. */ + int noise; /* if noise > 0 iterations are printed. */ + double resmax; /* maximum residu. */ + double resminreach, resadd; + double diverged_res; /* Threshold beyond which the iterative */ + /* is considered to diverge. */ + size_type nit; /* iteration number. */ + double res; /* last computed residu. */ + std::string name; /* eventually, name of the method. */ + bool written; + void (*callback)(const gmm::iteration&); + public : + + void init(void) { + nit = 0; res = 0.0; written = false; + resminreach = 1E200; resadd = 0.0; + callback = 0; + } + + iteration(double r = 1.0E-8, int noi = 0, size_type mit = size_type(-1), + double div_res = 1E200) + : rhsn(1.0), maxiter(mit), noise(noi), resmax(r), diverged_res(div_res) + { init(); } + + void operator ++(int) { nit++; written = false; resadd += res; } + void operator ++() { (*this)++; } + + bool first(void) { return nit == 0; } + + /* get/set the "noisyness" (verbosity) of the solvers */ + int get_noisy(void) const { return noise; } + void set_noisy(int n) { noise = n; } + void reduce_noisy(void) { if (noise > 0) noise--; } + + double get_resmax(void) const { return resmax; } + void set_resmax(double r) { resmax = r; } + + double get_res() const { return res; } + void enforce_converged(bool c = true) + { if (c) res = double(0); else res = rhsn * resmax + double(1); } + + /* change the user-definable callback, called after each iteration */ + void set_callback(void (*t)(const gmm::iteration&)) { + callback = t; + } + + double get_diverged_residual(void) const { return diverged_res; } + void set_diverged_residual(double r) { diverged_res = r; } + + size_type get_iteration(void) const { return nit; } + void set_iteration(size_type i) { nit = i; } + + size_type get_maxiter(void) const { return maxiter; } + void set_maxiter(size_type i) { maxiter = i; } + + double get_rhsnorm(void) const { return rhsn; } + void set_rhsnorm(double r) { rhsn = r; } + + bool converged(void) { + return !isnan(res) && res <= rhsn * resmax; + } + bool converged(double nr) { + res = gmm::abs(nr); + resminreach = std::min(resminreach, res); + return converged(); + } + template bool converged(const VECT &v) + { return converged(gmm::vect_norm2(v)); } + bool diverged(void) { + return isnan(res) || (nit>=maxiter) + || (res>=rhsn*diverged_res && nit > 4); + } + bool diverged(double nr) { + res = gmm::abs(nr); + resminreach = std::min(resminreach, res); + return diverged(); + } + + bool finished(double nr) { + if (callback) callback(*this); + if (noise > 0 && !written) { + double a = (rhsn == 0) ? 1.0 : rhsn; + converged(nr); + cout << name << " iter " << std::setw(3) << nit << " residual " + << std::setw(12) << gmm::abs(nr) / a; +// if (nit % 100 == 0 && nit > 0) { +// cout << " (residual min " << resminreach / a << " mean val " +// << resadd / (100.0 * a) << " )"; +// resadd = 0.0; +// } + cout << endl; + written = true; + } + return (converged(nr) || diverged(nr)); + } + template bool finished_vect(const VECT &v) + { return finished(double(gmm::vect_norm2(v))); } + + + void set_name(const std::string &n) { name = n; } + const std::string &get_name(void) const { return name; } + + }; + +} + +#endif /* GMM_ITER_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_iter_solvers.h b/7.x/src/linear_algebra/gmm/gmm_iter_solvers.h new file mode 100644 index 0000000..a2406f3 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_iter_solvers.h @@ -0,0 +1,111 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_iter_solvers.h + @author Yves Renard + @date October 13, 2002. + @brief Include standard gmm iterative solvers (cg, gmres, ...) +*/ +#ifndef GMM_ITER_SOLVERS_H__ +#define GMM_ITER_SOLVERS_H__ + +#include "gmm_iter.h" + + +namespace gmm { + + /** mixed method to find a zero of a real function G, a priori + * between a and b. If the zero is not between a and b, iterations + * of secant are applied. When a convenient interval is found, + * iterations of dichotomie and regula falsi are applied. + */ + template + T find_root(const FUNC &G, T a = T(0), T b = T(1), + T tol = gmm::default_tol(T())) { + T c, Ga = G(a), Gb = G(b), Gc, d; + d = gmm::abs(b - a); +#if 0 + for (int i = 0; i < 4; i++) { /* secant iterations. */ + if (d < tol) return (b + a) / 2.0; + c = b - Gb * (b - a) / (Gb - Ga); Gc = G(c); + a = b; b = c; Ga = Gb; Gb = Gc; + d = gmm::abs(b - a); + } +#endif + while (Ga * Gb > 0.0) { /* secant iterations. */ + if (d < tol) return (b + a) / 2.0; + c = b - Gb * (b - a) / (Gb - Ga); Gc = G(c); + a = b; b = c; Ga = Gb; Gb = Gc; + d = gmm::abs(b - a); + } + + c = std::max(a, b); a = std::min(a, b); b = c; + while (d > tol) { + c = b - (b - a) * (Gb / (Gb - Ga)); /* regula falsi. */ + if (c > b) c = b; + if (c < a) c = a; + Gc = G(c); + if (Gc*Gb > 0) { b = c; Gb = Gc; } else { a = c; Ga = Gc; } + c = (b + a) / 2.0 ; Gc = G(c); /* Dichotomie. */ + if (Gc*Gb > 0) { b = c; Gb = Gc; } else { a = c; Ga = Gc; } + d = gmm::abs(b - a); c = (b + a) / 2.0; if ((c == a) || (c == b)) d = 0.0; + } + return (b + a) / 2.0; + } + +} + +#include "gmm_precond_diagonal.h" +#include "gmm_precond_ildlt.h" +#include "gmm_precond_ildltt.h" +#include "gmm_precond_mr_approx_inverse.h" +#include "gmm_precond_ilu.h" +#include "gmm_precond_ilut.h" +#include "gmm_precond_ilutp.h" + + + +#include "gmm_solver_cg.h" +#include "gmm_solver_bicgstab.h" +#include "gmm_solver_qmr.h" +#include "gmm_solver_constrained_cg.h" +#include "gmm_solver_Schwarz_additive.h" +#include "gmm_modified_gram_schmidt.h" +#include "gmm_tri_solve.h" +#include "gmm_solver_gmres.h" +#include "gmm_solver_bfgs.h" +#include "gmm_least_squares_cg.h" + +// #include "gmm_solver_idgmres.h" + + + +#endif // GMM_ITER_SOLVERS_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_kernel.h b/7.x/src/linear_algebra/gmm/gmm_kernel.h new file mode 100644 index 0000000..7fdae24 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_kernel.h @@ -0,0 +1,55 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_kernel.h + @author Yves Renard + @date November 15, 2003. + @brief Include the base gmm files. + */ + +#ifndef GMM_KERNEL_H__ +#define GMM_KERNEL_H__ + +#include "gmm_def.h" +#include "gmm_blas.h" +#include "gmm_real_part.h" +#include "gmm_interface.h" +#include "gmm_sub_vector.h" +#include "gmm_sub_matrix.h" +#include "gmm_vector_to_matrix.h" +#include "gmm_vector.h" +#include "gmm_matrix.h" +#include "gmm_tri_solve.h" +#include "gmm_blas_interface.h" +#include "gmm_lapack_interface.h" + + +#endif // GMM_KERNEL_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_lapack_interface.h b/7.x/src/linear_algebra/gmm/gmm_lapack_interface.h new file mode 100644 index 0000000..37bc48f --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_lapack_interface.h @@ -0,0 +1,484 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_lapack_interface.h + @author Yves Renard + @date October 7, 2003. + @brief gmm interface for LAPACK +*/ + +#ifndef GMM_LAPACK_INTERFACE_H +#define GMM_LAPACK_INTERFACE_H + +#include "gmm_blas_interface.h" +#include "gmm_dense_lu.h" +#include "gmm_dense_qr.h" + + +#if defined(GMM_USES_LAPACK) + +namespace gmm { + + /* ********************************************************************** */ + /* Operations interfaced for T = float, double, std::complex */ + /* or std::complex : */ + /* */ + /* lu_factor(dense_matrix, std::vector) */ + /* lu_solve(dense_matrix, std::vector, std::vector) */ + /* lu_solve(dense_matrix, std::vector, std::vector, */ + /* std::vector) */ + /* lu_solve_transposed(dense_matrix, std::vector, std::vector,*/ + /* std::vector) */ + /* lu_inverse(dense_matrix) */ + /* lu_inverse(dense_matrix, std::vector, dense_matrix) */ + /* */ + /* qr_factor(dense_matrix, dense_matrix, dense_matrix) */ + /* */ + /* implicit_qr_algorithm(dense_matrix, std::vector) */ + /* implicit_qr_algorithm(dense_matrix, std::vector, */ + /* dense_matrix) */ + /* implicit_qr_algorithm(dense_matrix, std::vector >) */ + /* implicit_qr_algorithm(dense_matrix, std::vector >, */ + /* dense_matrix) */ + /* */ + /* geev_interface_right */ + /* geev_interface_left */ + /* */ + /* schur(dense_matrix, dense_matrix, dense_matrix) */ + /* */ + /* svd(dense_matrix, dense_matrix, dense_matrix, std::vector) */ + /* svd(dense_matrix, dense_matrix, dense_matrix, */ + /* std::vector >) */ + /* */ + /* ********************************************************************** */ + + /* ********************************************************************** */ + /* LAPACK functions used. */ + /* ********************************************************************** */ + + extern "C" { + void sgetrf_(...); void dgetrf_(...); void cgetrf_(...); void zgetrf_(...); + void sgetrs_(...); void dgetrs_(...); void cgetrs_(...); void zgetrs_(...); + void sgetri_(...); void dgetri_(...); void cgetri_(...); void zgetri_(...); + void sgeqrf_(...); void dgeqrf_(...); void cgeqrf_(...); void zgeqrf_(...); + void sorgqr_(...); void dorgqr_(...); void cungqr_(...); void zungqr_(...); + void sormqr_(...); void dormqr_(...); void cunmqr_(...); void zunmqr_(...); + void sgees_ (...); void dgees_ (...); void cgees_ (...); void zgees_ (...); + void sgeev_ (...); void dgeev_ (...); void cgeev_ (...); void zgeev_ (...); + void sgeesx_(...); void dgeesx_(...); void cgeesx_(...); void zgeesx_(...); + void sgesvd_(...); void dgesvd_(...); void cgesvd_(...); void zgesvd_(...); + } + + /* ********************************************************************** */ + /* LU decomposition. */ + /* ********************************************************************** */ + +# define getrf_interface(lapack_name, base_type) inline \ + size_type lu_factor(dense_matrix &A, lapack_ipvt &ipvt){ \ + GMMLAPACK_TRACE("getrf_interface"); \ + BLAS_INT m = BLAS_INT(mat_nrows(A)), n = BLAS_INT(mat_ncols(A)), lda(m); \ + long info(-1L); \ + if (m && n) lapack_name(&m, &n, &A(0,0), &lda, ipvt.pfirst(), &info); \ + if ((sizeof(BLAS_INT) == 4) || \ + ((info & 0xFFFFFFFF00000000L) && !(info & 0x00000000FFFFFFFFL))) \ + /* For compatibility with lapack version with 32 bit integer. */ \ + ipvt.set_to_int32(); \ + return size_type(int(info & 0x00000000FFFFFFFFL)); \ + } + + getrf_interface(sgetrf_, BLAS_S) + getrf_interface(dgetrf_, BLAS_D) + getrf_interface(cgetrf_, BLAS_C) + getrf_interface(zgetrf_, BLAS_Z) + + /* ********************************************************************* */ + /* LU solve. */ + /* ********************************************************************* */ + +# define getrs_interface(f_name, trans1, lapack_name, base_type) inline \ + void f_name(const dense_matrix &A, \ + const lapack_ipvt &ipvt, std::vector &x, \ + const std::vector &b) { \ + GMMLAPACK_TRACE("getrs_interface"); \ + BLAS_INT n = BLAS_INT(mat_nrows(A)), info(0), nrhs(1); \ + gmm::copy(b, x); trans1; \ + if (n) \ + lapack_name(&t,&n,&nrhs,&(A(0,0)),&n,ipvt.pfirst(),&x[0],&n,&info); \ + } + +# define getrs_trans_n const char t = 'N' +# define getrs_trans_t const char t = 'T' + + getrs_interface(lu_solve, getrs_trans_n, sgetrs_, BLAS_S) + getrs_interface(lu_solve, getrs_trans_n, dgetrs_, BLAS_D) + getrs_interface(lu_solve, getrs_trans_n, cgetrs_, BLAS_C) + getrs_interface(lu_solve, getrs_trans_n, zgetrs_, BLAS_Z) + getrs_interface(lu_solve_transposed, getrs_trans_t, sgetrs_, BLAS_S) + getrs_interface(lu_solve_transposed, getrs_trans_t, dgetrs_, BLAS_D) + getrs_interface(lu_solve_transposed, getrs_trans_t, cgetrs_, BLAS_C) + getrs_interface(lu_solve_transposed, getrs_trans_t, zgetrs_, BLAS_Z) + + /* ********************************************************************* */ + /* LU inverse. */ + /* ********************************************************************* */ + +# define getri_interface(lapack_name, base_type) inline \ + void lu_inverse(const dense_matrix &LU, \ + const lapack_ipvt &ipvt, const dense_matrix &A_) { \ + GMMLAPACK_TRACE("getri_interface"); \ + dense_matrix& \ + A = const_cast &>(A_); \ + BLAS_INT n = BLAS_INT(mat_nrows(A)), info(0), lwork(-1); \ + base_type work1; \ + if (n) { \ + gmm::copy(LU, A); \ + lapack_name(&n, &A(0,0), &n, ipvt.pfirst(), &work1, &lwork, &info); \ + lwork = int(gmm::real(work1)); \ + std::vector work(lwork); \ + lapack_name(&n, &A(0,0), &n, ipvt.pfirst(), &work[0], &lwork,&info); \ + } \ + } + + getri_interface(sgetri_, BLAS_S) + getri_interface(dgetri_, BLAS_D) + getri_interface(cgetri_, BLAS_C) + getri_interface(zgetri_, BLAS_Z) + + /* ********************************************************************** */ + /* QR factorization. */ + /* ********************************************************************** */ + +# define geqrf_interface(lapack_name1, base_type) inline \ + void qr_factor(dense_matrix &A){ \ + GMMLAPACK_TRACE("geqrf_interface"); \ + BLAS_INT m = BLAS_INT(mat_nrows(A)), n=BLAS_INT(mat_ncols(A)); \ + BLAS_INT info(0), lwork(-1); \ + base_type work1; \ + if (m && n) { \ + std::vector tau(n); \ + lapack_name1(&m, &n, &A(0,0), &m, &tau[0], &work1 , &lwork, &info); \ + lwork = BLAS_INT(gmm::real(work1)); \ + std::vector work(lwork); \ + lapack_name1(&m, &n, &A(0,0), &m, &tau[0], &work[0], &lwork, &info); \ + GMM_ASSERT1(!info, "QR factorization failed"); \ + } \ + } + + geqrf_interface(sgeqrf_, BLAS_S) + geqrf_interface(dgeqrf_, BLAS_D) + // For complex values, housholder vectors are not the same as in + // gmm::lu_factor. Impossible to interface for the moment. + // geqrf_interface(cgeqrf_, BLAS_C) + // geqrf_interface(zgeqrf_, BLAS_Z) + +# define geqrf_interface2(lapack_name1, lapack_name2, base_type) inline \ + void qr_factor(const dense_matrix &A, \ + dense_matrix &Q, dense_matrix &R) { \ + GMMLAPACK_TRACE("geqrf_interface2"); \ + BLAS_INT m = BLAS_INT(mat_nrows(A)), n=BLAS_INT(mat_ncols(A)); \ + BLAS_INT info(0), lwork(-1); \ + base_type work1; \ + if (m && n) { \ + std::copy(A.begin(), A.end(), Q.begin()); \ + std::vector tau(n); \ + lapack_name1(&m, &n, &Q(0,0), &m, &tau[0], &work1 , &lwork, &info); \ + lwork = BLAS_INT(gmm::real(work1)); \ + std::vector work(lwork); \ + lapack_name1(&m, &n, &Q(0,0), &m, &tau[0], &work[0], &lwork, &info); \ + GMM_ASSERT1(!info, "QR factorization failed"); \ + base_type *p = &R(0,0), *q = &Q(0,0); \ + for (BLAS_INT j = 0; j < n; ++j, q += m-n) \ + for (BLAS_INT i = 0; i < n; ++i, ++p, ++q) \ + *p = (j < i) ? base_type(0) : *q; \ + lapack_name2(&m, &n, &n, &Q(0,0), &m,&tau[0],&work[0],&lwork,&info); \ + } \ + else gmm::clear(Q); \ + } + + geqrf_interface2(sgeqrf_, sorgqr_, BLAS_S) + geqrf_interface2(dgeqrf_, dorgqr_, BLAS_D) + geqrf_interface2(cgeqrf_, cungqr_, BLAS_C) + geqrf_interface2(zgeqrf_, zungqr_, BLAS_Z) + + /* ********************************************************************** */ + /* QR algorithm for eigenvalues search. */ + /* ********************************************************************** */ + +# define gees_interface(lapack_name, base_type) \ + template inline void implicit_qr_algorithm( \ + const dense_matrix &A, const VECT &eigval_, \ + dense_matrix &Q, \ + double tol=gmm::default_tol(base_type()), bool compvect = true) { \ + GMMLAPACK_TRACE("gees_interface"); \ + typedef bool (*L_fp)(...); L_fp p = 0; \ + BLAS_INT n=BLAS_INT(mat_nrows(A)), info(0), lwork(-1), sdim; \ + base_type work1; \ + if (!n) return; \ + dense_matrix H(n,n); gmm::copy(A, H); \ + char jobvs = (compvect ? 'V' : 'N'), sort = 'N'; \ + std::vector rwork(n), eigv1(n), eigv2(n); \ + lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigv1[0], \ + &eigv2[0], &Q(0,0), &n, &work1, &lwork, &rwork[0], &info); \ + lwork = BLAS_INT(gmm::real(work1)); \ + std::vector work(lwork); \ + lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigv1[0], \ + &eigv2[0], &Q(0,0), &n, &work[0], &lwork, &rwork[0],&info);\ + GMM_ASSERT1(!info, "QR algorithm failed"); \ + extract_eig(H, const_cast(eigval_), tol); \ + } + +# define gees_interface2(lapack_name, base_type) \ + template inline void implicit_qr_algorithm( \ + const dense_matrix &A, const VECT &eigval_, \ + dense_matrix &Q, \ + double tol=gmm::default_tol(base_type()), bool compvect = true) { \ + GMMLAPACK_TRACE("gees_interface2"); \ + typedef bool (*L_fp)(...); L_fp p = 0; \ + BLAS_INT n=BLAS_INT(mat_nrows(A)), info(0), lwork(-1), sdim; \ + base_type work1; \ + if (!n) return; \ + dense_matrix H(n,n); gmm::copy(A, H); \ + char jobvs = (compvect ? 'V' : 'N'), sort = 'N'; \ + std::vector rwork(n), eigvv(n*2); \ + lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigvv[0], \ + &Q(0,0), &n, &work1, &lwork, &rwork[0], &rwork[0], &info); \ + lwork = BLAS_INT(gmm::real(work1)); \ + std::vector work(lwork); \ + lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigvv[0], \ + &Q(0,0), &n, &work[0], &lwork, &rwork[0], &rwork[0],&info);\ + GMM_ASSERT1(!info, "QR algorithm failed"); \ + extract_eig(H, const_cast(eigval_), tol); \ + } + + gees_interface(sgees_, BLAS_S) + gees_interface(dgees_, BLAS_D) + gees_interface2(cgees_, BLAS_C) + gees_interface2(zgees_, BLAS_Z) + + +# define jobv_right char jobvl = 'N', jobvr = 'V'; +# define jobv_left char jobvl = 'V', jobvr = 'N'; + +# define geev_interface(lapack_name, base_type, side) \ + template inline void geev_interface_ ## side( \ + const dense_matrix &A, const VECT &eigval_, \ + dense_matrix &Q) { \ + GMMLAPACK_TRACE("geev_interface"); \ + BLAS_INT n = BLAS_INT(mat_nrows(A)), info(0), lwork(-1); \ + base_type work1; \ + if (!n) return; \ + dense_matrix H(n,n); gmm::copy(A, H); \ + jobv_ ## side \ + std::vector eigvr(n), eigvi(n); \ + lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigvr[0], &eigvi[0], \ + &Q(0,0), &n, &Q(0,0), &n, &work1, &lwork, &info); \ + lwork = BLAS_INT(gmm::real(work1)); \ + std::vector work(lwork); \ + lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigvr[0], &eigvi[0], \ + &Q(0,0), &n, &Q(0,0), &n, &work[0], &lwork, &info); \ + GMM_ASSERT1(!info, "QR algorithm failed"); \ + gmm::copy(eigvr, gmm::real_part(const_cast(eigval_))); \ + gmm::copy(eigvi, gmm::imag_part(const_cast(eigval_))); \ + } + +# define geev_interface2(lapack_name, base_type, side) \ + template inline void geev_interface_ ## side( \ + const dense_matrix &A, const VECT &eigval_, \ + dense_matrix &Q) { \ + GMMLAPACK_TRACE("geev_interface"); \ + BLAS_INT n = BLAS_INT(mat_nrows(A)), info(0), lwork(-1); \ + base_type work1; \ + if (!n) return; \ + dense_matrix H(n,n); gmm::copy(A, H); \ + jobv_ ## side \ + std::vector rwork(2*n); \ + std::vector eigv(n); \ + lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigv[0], &Q(0,0), &n, \ + &Q(0,0), &n, &work1, &lwork, &rwork[0], &info); \ + lwork = BLAS_INT(gmm::real(work1)); \ + std::vector work(lwork); \ + lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigv[0], &Q(0,0), &n, \ + &Q(0,0), &n, &work[0], &lwork, &rwork[0], &info); \ + GMM_ASSERT1(!info, "QR algorithm failed"); \ + gmm::copy(eigv, const_cast(eigval_)); \ + } + + geev_interface(sgeev_, BLAS_S, right) + geev_interface(dgeev_, BLAS_D, right) + geev_interface2(cgeev_, BLAS_C, right) + geev_interface2(zgeev_, BLAS_Z, right) + + geev_interface(sgeev_, BLAS_S, left) + geev_interface(dgeev_, BLAS_D, left) + geev_interface2(cgeev_, BLAS_C, left) + geev_interface2(zgeev_, BLAS_Z, left) + + + /* ********************************************************************** */ + /* SCHUR algorithm: */ + /* A = Q*S*(Q^T), with Q orthogonal and S upper quasi-triangula */ + /* ********************************************************************** */ + +# define geesx_interface(lapack_name, base_type) inline \ + void schur(dense_matrix &A, \ + dense_matrix &S, \ + dense_matrix &Q) { \ + GMMLAPACK_TRACE("geesx_interface"); \ + BLAS_INT m = BLAS_INT(mat_nrows(A)), n = BLAS_INT(mat_ncols(A)); \ + GMM_ASSERT1(m == n, "Schur decomposition requires square matrix"); \ + char jobvs = 'V', sort = 'N', sense = 'N'; \ + bool select = false; \ + BLAS_INT lwork = 8*n, sdim = 0, liwork = 1; \ + std::vector work(lwork), wr(n), wi(n); \ + std::vector iwork(liwork); \ + std::vector bwork(1); \ + resize(S, n, n); copy(A, S); \ + resize(Q, n, n); \ + base_type rconde(0), rcondv(0); \ + BLAS_INT info(0); \ + lapack_name(&jobvs, &sort, &select, &sense, &n, &S(0,0), &n, \ + &sdim, &wr[0], &wi[0], &Q(0,0), &n, &rconde, &rcondv, \ + &work[0], &lwork, &iwork[0], &liwork, &bwork[0], &info);\ + GMM_ASSERT1(!info, "SCHUR algorithm failed"); \ + } + +# define geesx_interface2(lapack_name, base_type) inline \ + void schur(dense_matrix &A, \ + dense_matrix &S, \ + dense_matrix &Q) { \ + GMMLAPACK_TRACE("geesx_interface"); \ + BLAS_INT m = BLAS_INT(mat_nrows(A)), n = BLAS_INT(mat_ncols(A)); \ + GMM_ASSERT1(m == n, "Schur decomposition requires square matrix"); \ + char jobvs = 'V', sort = 'N', sense = 'N'; \ + bool select = false; \ + BLAS_INT lwork = 8*n, sdim = 0; \ + std::vector rwork(lwork); \ + std::vector work(lwork), w(n); \ + std::vector bwork(1); \ + resize(S, n, n); copy(A, S); \ + resize(Q, n, n); \ + base_type rconde(0), rcondv(0); \ + BLAS_INT info(0); \ + lapack_name(&jobvs, &sort, &select, &sense, &n, &S(0,0), &n, \ + &sdim, &w[0], &Q(0,0), &n, &rconde, &rcondv, \ + &work[0], &lwork, &rwork[0], &bwork[0], &info); \ + GMM_ASSERT1(!info, "SCHUR algorithm failed"); \ + } + + geesx_interface(sgeesx_, BLAS_S) + geesx_interface(dgeesx_, BLAS_D) + geesx_interface2(cgeesx_, BLAS_C) + geesx_interface2(zgeesx_, BLAS_Z) + + template + void schur(const MAT &A_, MAT &S, MAT &Q) { + MAT A(A_); + schur(A, S, Q); + } + + + /* ********************************************************************** */ + /* Interface to SVD. Does not correspond to a Gmm++ functionnality. */ + /* Author : Sebastian Nowozin */ + /* ********************************************************************** */ + +# define gesvd_interface(lapack_name, base_type) inline \ + void svd(dense_matrix &X, \ + dense_matrix &U, \ + dense_matrix &Vtransposed, \ + std::vector &sigma) { \ + GMMLAPACK_TRACE("gesvd_interface"); \ + BLAS_INT m = BLAS_INT(mat_nrows(X)), n = BLAS_INT(mat_ncols(X)); \ + BLAS_INT mn_min = m < n ? m : n; \ + sigma.resize(mn_min); \ + std::vector work(15 * mn_min); \ + BLAS_INT lwork = BLAS_INT(work.size()); \ + resize(U, m, m); \ + resize(Vtransposed, n, n); \ + char job = 'A'; \ + BLAS_INT info(0); \ + lapack_name(&job, &job, &m, &n, &X(0,0), &m, &sigma[0], &U(0,0), \ + &m, &Vtransposed(0,0), &n, &work[0], &lwork, &info); \ + } + +# define cgesvd_interface(lapack_name, base_type, base_type2) inline \ + void svd(dense_matrix &X, \ + dense_matrix &U, \ + dense_matrix &Vtransposed, \ + std::vector &sigma) { \ + GMMLAPACK_TRACE("gesvd_interface"); \ + BLAS_INT m = BLAS_INT(mat_nrows(X)), n = BLAS_INT(mat_ncols(X)); \ + BLAS_INT mn_min = m < n ? m : n; \ + sigma.resize(mn_min); \ + std::vector work(15 * mn_min); \ + std::vector rwork(5 * mn_min); \ + BLAS_INT lwork = BLAS_INT(work.size()); \ + resize(U, m, m); \ + resize(Vtransposed, n, n); \ + char job = 'A'; \ + BLAS_INT info(0); \ + lapack_name(&job, &job, &m, &n, &X(0,0), &m, &sigma[0], &U(0,0), \ + &m, &Vtransposed(0,0), &n, &work[0], &lwork, \ + &rwork[0], &info); \ + } + + gesvd_interface(sgesvd_, BLAS_S) + gesvd_interface(dgesvd_, BLAS_D) + cgesvd_interface(cgesvd_, BLAS_C, BLAS_S) + cgesvd_interface(zgesvd_, BLAS_Z, BLAS_D) + + template + void svd(const MAT &X_, MAT &U, MAT &Vtransposed, VEC &sigma) { + MAT X(X_); + svd(X, U, Vtransposed, sigma); + } + + + + +} + +#else + +namespace gmm +{ +template +void schur(const MAT &A_, MAT &S, MAT &Q) +{ + GMM_ASSERT1(false, "Use of function schur(A,S,Q) requires GetFEM " + "to be built with Lapack"); +} + +}// namespace gmm + +#endif // GMM_USES_LAPACK + +#endif // GMM_LAPACK_INTERFACE_H diff --git a/7.x/src/linear_algebra/gmm/gmm_least_squares_cg.h b/7.x/src/linear_algebra/gmm/gmm_least_squares_cg.h new file mode 100644 index 0000000..e4e22ae --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_least_squares_cg.h @@ -0,0 +1,96 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard, Benjamin Schleimer + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_leastsquares_cg.h + @author Benjamin Schleimer + @date January 23, 2007. + @brief Conjugate gradient least squares algorithm. + Algorithm taken from http://www.stat.washington.edu/wxs/Stat538-w05/Notes/conjugate-gradients.pdf page 6 +*/ +#ifndef GMM_LEAST_SQUARES_CG_H__ +#define GMM_LEAST_SQUARES_CG_H__ + +#include "gmm_kernel.h" +#include "gmm_iter.h" +#include "gmm_conjugated.h" + +namespace gmm { + + template + void least_squares_cg(const Matrix& C, Vector1& x, const Vector2& y, + iteration &iter) { + + typedef typename temporary_dense_vector::vector_type temp_vector; + typedef typename linalg_traits::value_type T; + + T rho, rho_1(0), a; + temp_vector p(vect_size(x)), q(vect_size(y)), g(vect_size(x)); + temp_vector r(vect_size(y)); + iter.set_rhsnorm(gmm::sqrt(gmm::abs(vect_hp(y, y)))); + + if (iter.get_rhsnorm() == 0.0) + clear(x); + else { + mult(C, scaled(x, T(-1)), y, r); + mult(conjugated(C), r, g); + rho = vect_hp(g, g); + copy(g, p); + + while (!iter.finished_vect(g)) { + + if (!iter.first()) { + rho = vect_hp(g, g); + add(g, scaled(p, rho / rho_1), p); + } + + mult(C, p, q); + + a = rho / vect_hp(q, q); + add(scaled(p, a), x); + add(scaled(q, -a), r); + // NOTE: how do we minimize the impact to the transpose? + mult(conjugated(C), r, g); + rho_1 = rho; + + ++iter; + } + } + } + + template inline + void least_squares_cg(const Matrix& C, const Vector1& x, const Vector2& y, + iteration &iter) + { least_squares_cg(C, linalg_const_cast(x), y, iter); } +} + + +#endif // GMM_SOLVER_CG_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_matrix.h b/7.x/src/linear_algebra/gmm/gmm_matrix.h new file mode 100644 index 0000000..60b2917 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_matrix.h @@ -0,0 +1,1195 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/** @file gmm_matrix.h + @author Yves Renard + @date October 13, 2002. + @brief Declaration of some matrix types (gmm::dense_matrix, + gmm::row_matrix, gmm::col_matrix, gmm::csc_matrix, etc.) +*/ + +#ifndef GMM_MATRIX_H__ +#define GMM_MATRIX_H__ + +#include "gmm_vector.h" +#include "gmm_sub_vector.h" +#include "gmm_sub_matrix.h" +#include "gmm_transposed.h" + +namespace gmm +{ + + /* ******************************************************************** */ + /* */ + /* Identity matrix */ + /* */ + /* ******************************************************************** */ + + struct identity_matrix { + template void build_with(const MAT &) {} + }; + + template inline + void add(const identity_matrix&, M &v1) { + size_type n = std::min(gmm::mat_nrows(v1), gmm::mat_ncols(v1)); + for (size_type i = 0; i < n; ++i) + v1(i,i) += typename linalg_traits::value_type(1); + } + template inline + void add(const identity_matrix &II, const M &v1) + { add(II, linalg_const_cast(v1)); } + + template inline + void mult(const identity_matrix&, const V1 &v1, V2 &v2) + { copy(v1, v2); } + template inline + void mult(const identity_matrix&, const V1 &v1, const V2 &v2) + { copy(v1, v2); } + template inline + void mult(const identity_matrix&, const V1 &v1, const V2 &v2, V3 &v3) + { add(v1, v2, v3); } + template inline + void mult(const identity_matrix&, const V1 &v1, const V2 &v2, const V3 &v3) + { add(v1, v2, v3); } + template inline + void left_mult(const identity_matrix&, const V1 &v1, V2 &v2) + { copy(v1, v2); } + template inline + void left_mult(const identity_matrix&, const V1 &v1, const V2 &v2) + { copy(v1, v2); } + template inline + void right_mult(const identity_matrix&, const V1 &v1, V2 &v2) + { copy(v1, v2); } + template inline + void right_mult(const identity_matrix&, const V1 &v1, const V2 &v2) + { copy(v1, v2); } + template inline + void transposed_left_mult(const identity_matrix&, const V1 &v1, V2 &v2) + { copy(v1, v2); } + template inline + void transposed_left_mult(const identity_matrix&, const V1 &v1,const V2 &v2) + { copy(v1, v2); } + template inline + void transposed_right_mult(const identity_matrix&, const V1 &v1, V2 &v2) + { copy(v1, v2); } + template inline + void transposed_right_mult(const identity_matrix&,const V1 &v1,const V2 &v2) + { copy(v1, v2); } + template void copy_ident(const identity_matrix&, M &m) { + size_type i = 0, n = std::min(mat_nrows(m), mat_ncols(m)); + clear(m); + for (; i < n; ++i) m(i,i) = typename linalg_traits::value_type(1); + } + template inline void copy(const identity_matrix&, M &m) + { copy_ident(identity_matrix(), m); } + template inline void copy(const identity_matrix &, const M &m) + { copy_ident(identity_matrix(), linalg_const_cast(m)); } + template inline + typename linalg_traits::value_type + vect_sp(const identity_matrix &, const V1 &v1, const V2 &v2) + { return vect_sp(v1, v2); } + template inline + typename linalg_traits::value_type + vect_hp(const identity_matrix &, const V1 &v1, const V2 &v2) + { return vect_hp(v1, v2); } + template inline bool is_identity(const M&) { return false; } + inline bool is_identity(const identity_matrix&) { return true; } + + /* ******************************************************************** */ + /* */ + /* Row matrix */ + /* */ + /* ******************************************************************** */ + + template class row_matrix { + protected : + std::vector li; /* array of rows. */ + size_type nc; + + public : + + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::value_type value_type; + + row_matrix(size_type r, size_type c) : li(r, V(c)), nc(c) {} + row_matrix(void) : nc(0) {} + reference operator ()(size_type l, size_type c) + { return li[l][c]; } + value_type operator ()(size_type l, size_type c) const + { return li[l][c]; } + + void clear_mat(); + void resize(size_type m, size_type n); + + typename std::vector::iterator begin(void) + { return li.begin(); } + typename std::vector::iterator end(void) + { return li.end(); } + typename std::vector::const_iterator begin(void) const + { return li.begin(); } + typename std::vector::const_iterator end(void) const + { return li.end(); } + + + V& row(size_type i) { return li[i]; } + const V& row(size_type i) const { return li[i]; } + V& operator[](size_type i) { return li[i]; } + const V& operator[](size_type i) const { return li[i]; } + + inline size_type nrows(void) const { return li.size(); } + inline size_type ncols(void) const { return nc; } + + void swap(row_matrix &m) { std::swap(li, m.li); std::swap(nc, m.nc); } + void swap_row(size_type i, size_type j) { std::swap(li[i], li[j]); } + }; + + template void row_matrix::resize(size_type m, size_type n) { + size_type nr = std::min(nrows(), m); + li.resize(m); + for (size_type i=nr; i < m; ++i) gmm::resize(li[i], n); + if (n != nc) { + for (size_type i=0; i < nr; ++i) gmm::resize(li[i], n); + nc = n; + } + } + + + template void row_matrix::clear_mat() + { for (size_type i=0; i < nrows(); ++i) clear(li[i]); } + + template struct linalg_traits > { + typedef row_matrix this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::storage_type storage_type; + typedef V & sub_row_type; + typedef const V & const_sub_row_type; + typedef typename std::vector::iterator row_iterator; + typedef typename std::vector::const_iterator const_row_iterator; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_col_iterator; + typedef row_major sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static row_iterator row_begin(this_type &m) { return m.begin(); } + static row_iterator row_end(this_type &m) { return m.end(); } + static const_row_iterator row_begin(const this_type &m) + { return m.begin(); } + static const_row_iterator row_end(const this_type &m) + { return m.end(); } + static const_sub_row_type row(const const_row_iterator &it) + { return const_sub_row_type(*it); } + static sub_row_type row(const row_iterator &it) + { return sub_row_type(*it); } + static origin_type* origin(this_type &m) { return &m; } + static const origin_type* origin(const this_type &m) { return &m; } + static void do_clear(this_type &m) { m.clear_mat(); } + static value_type access(const const_row_iterator &itrow, size_type j) + { return (*itrow)[j]; } + static reference access(const row_iterator &itrow, size_type j) + { return (*itrow)[j]; } + static void resize(this_type &v, size_type m, size_type n) + { v.resize(m, n); } + static void reshape(this_type &, size_type, size_type) + { GMM_ASSERT1(false, "Sorry, to be done"); } + }; + + template std::ostream &operator << + (std::ostream &o, const row_matrix& m) { gmm::write(o,m); return o; } + + /* ******************************************************************** */ + /* */ + /* Column matrix */ + /* */ + /* ******************************************************************** */ + + template class col_matrix { + protected : + std::vector li; /* array of columns. */ + size_type nr; + + public : + + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::value_type value_type; + + col_matrix(size_type r, size_type c) : li(c, V(r)), nr(r) { } + col_matrix(void) : nr(0) {} + reference operator ()(size_type l, size_type c) + { return li[c][l]; } + value_type operator ()(size_type l, size_type c) const + { return li[c][l]; } + + void clear_mat(); + void resize(size_type, size_type); + + V& col(size_type i) { return li[i]; } + const V& col(size_type i) const { return li[i]; } + V& operator[](size_type i) { return li[i]; } + const V& operator[](size_type i) const { return li[i]; } + + typename std::vector::iterator begin(void) + { return li.begin(); } + typename std::vector::iterator end(void) + { return li.end(); } + typename std::vector::const_iterator begin(void) const + { return li.begin(); } + typename std::vector::const_iterator end(void) const + { return li.end(); } + + inline size_type ncols(void) const { return li.size(); } + inline size_type nrows(void) const { return nr; } + + void swap(col_matrix &m) { std::swap(li, m.li); std::swap(nr, m.nr); } + void swap_col(size_type i, size_type j) { std::swap(li[i], li[j]); } + }; + + template void col_matrix::resize(size_type m, size_type n) { + size_type nc = std::min(ncols(), n); + li.resize(n); + for (size_type i=nc; i < n; ++i) gmm::resize(li[i], m); + if (m != nr) { + for (size_type i=0; i < nc; ++i) gmm::resize(li[i], m); + nr = m; + } + } + + template void col_matrix::clear_mat() + { for (size_type i=0; i < ncols(); ++i) clear(li[i]); } + + template struct linalg_traits > { + typedef col_matrix this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::storage_type storage_type; + typedef V &sub_col_type; + typedef const V &const_sub_col_type; + typedef typename std::vector::iterator col_iterator; + typedef typename std::vector::const_iterator const_col_iterator; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_row_iterator; + typedef col_major sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static col_iterator col_begin(this_type &m) { return m.begin(); } + static col_iterator col_end(this_type &m) { return m.end(); } + static const_col_iterator col_begin(const this_type &m) + { return m.begin(); } + static const_col_iterator col_end(const this_type &m) + { return m.end(); } + static const_sub_col_type col(const const_col_iterator &it) + { return *it; } + static sub_col_type col(const col_iterator &it) + { return *it; } + static origin_type* origin(this_type &m) { return &m; } + static const origin_type* origin(const this_type &m) { return &m; } + static void do_clear(this_type &m) { m.clear_mat(); } + static value_type access(const const_col_iterator &itcol, size_type j) + { return (*itcol)[j]; } + static reference access(const col_iterator &itcol, size_type j) + { return (*itcol)[j]; } + static void resize(this_type &v, size_type m, size_type n) + { v.resize(m,n); } + static void reshape(this_type &, size_type, size_type) + { GMM_ASSERT1(false, "Sorry, to be done"); } + }; + + template std::ostream &operator << + (std::ostream &o, const col_matrix& m) { gmm::write(o,m); return o; } + + /* ******************************************************************** */ + /* */ + /* Dense matrix */ + /* */ + /* ******************************************************************** */ + + template class dense_matrix : public std::vector { + public: + typedef typename std::vector::size_type size_type; + typedef typename std::vector::iterator iterator; + typedef typename std::vector::const_iterator const_iterator; + typedef typename std::vector::reference reference; + typedef typename std::vector::const_reference const_reference; + + protected: + size_type nbc, nbl; + + public: + + inline const_reference operator ()(size_type l, size_type c) const { + GMM_ASSERT2(l < nbl && c < nbc, "out of range"); + return *(this->begin() + c*nbl+l); + } + inline reference operator ()(size_type l, size_type c) { + GMM_ASSERT2(l < nbl && c < nbc, "out of range"); + return *(this->begin() + c*nbl+l); + } + + std::vector &as_vector(void) { return *this; } + const std::vector &as_vector(void) const { return *this; } + + void resize(size_type, size_type); + void base_resize(size_type, size_type); + void reshape(size_type, size_type); + + void fill(T a, T b = T(0)); + inline size_type nrows(void) const { return nbl; } + inline size_type ncols(void) const { return nbc; } + void swap(dense_matrix &m) + { std::vector::swap(m); std::swap(nbc, m.nbc); std::swap(nbl, m.nbl); } + + dense_matrix(size_type l, size_type c) + : std::vector(c*l), nbc(c), nbl(l) {} + dense_matrix(void) { nbl = nbc = 0; } + }; + + template void dense_matrix::reshape(size_type m,size_type n) { + GMM_ASSERT2(n*m == nbl*nbc, "dimensions mismatch"); + nbl = m; nbc = n; + } + + template void dense_matrix::base_resize(size_type m, + size_type n) + { std::vector::resize(n*m); nbl = m; nbc = n; } + + template void dense_matrix::resize(size_type m, size_type n) { + if (n*m > nbc*nbl) std::vector::resize(n*m); + if (m < nbl) { + for (size_type i = 1; i < std::min(nbc, n); ++i) + std::copy(this->begin()+i*nbl, this->begin()+(i*nbl+m), + this->begin()+i*m); + for (size_type i = std::min(nbc, n); i < n; ++i) + std::fill(this->begin()+(i*m), this->begin()+(i+1)*m, T(0)); + } + else if (m > nbl) { /* do nothing when the nb of rows does not change */ + for (size_type i = std::min(nbc, n); i > 1; --i) + std::copy(this->begin()+(i-1)*nbl, this->begin()+i*nbl, + this->begin()+(i-1)*m); + for (size_type i = 0; i < std::min(nbc, n); ++i) + std::fill(this->begin()+(i*m+nbl), this->begin()+(i+1)*m, T(0)); + } + if (n*m < nbc*nbl) std::vector::resize(n*m); + nbl = m; nbc = n; + } + + template void dense_matrix::fill(T a, T b) { + std::fill(this->begin(), this->end(), b); + size_type n = std::min(nbl, nbc); + if (a != b) for (size_type i = 0; i < n; ++i) (*this)(i,i) = a; + } + + template struct linalg_traits > { + typedef dense_matrix this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_matrix linalg_type; + typedef T value_type; + typedef T& reference; + typedef abstract_dense storage_type; + typedef tab_ref_reg_spaced_with_origin sub_row_type; + typedef tab_ref_reg_spaced_with_origin const_sub_row_type; + typedef dense_compressed_iterator row_iterator; + typedef dense_compressed_iterator const_row_iterator; + typedef tab_ref_with_origin sub_col_type; + typedef tab_ref_with_origin const_sub_col_type; + typedef dense_compressed_iterator col_iterator; + typedef dense_compressed_iterator const_col_iterator; + typedef col_and_row sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_sub_row_type row(const const_row_iterator &it) + { return const_sub_row_type(*it, it.nrows, it.ncols, it.origin); } + static const_sub_col_type col(const const_col_iterator &it) + { return const_sub_col_type(*it, *it + it.nrows, it.origin); } + static sub_row_type row(const row_iterator &it) + { return sub_row_type(*it, it.nrows, it.ncols, it.origin); } + static sub_col_type col(const col_iterator &it) + { return sub_col_type(*it, *it + it.nrows, it.origin); } + static row_iterator row_begin(this_type &m) + { return row_iterator(m.begin(), m.size() ? 1 : 0, m.nrows(), m.ncols(), 0, &m); } + static row_iterator row_end(this_type &m) + { return row_iterator(m.begin(), m.size() ? 1 : 0, m.nrows(), m.ncols(), m.nrows(), &m); } + static const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(m.begin(), m.size() ? 1 : 0, m.nrows(), m.ncols(), 0, &m); } + static const_row_iterator row_end(const this_type &m) + { return const_row_iterator(m.begin(), m.size() ? 1 : 0, m.nrows(), m.ncols(), m.nrows(), &m); } + static col_iterator col_begin(this_type &m) + { return col_iterator(m.begin(), m.nrows(), m.nrows(), m.ncols(), 0, &m); } + static col_iterator col_end(this_type &m) + { return col_iterator(m.begin(), m.nrows(), m.nrows(), m.ncols(), m.ncols(), &m); } + static const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(m.begin(), m.nrows(), m.nrows(), m.ncols(), 0, &m); } + static const_col_iterator col_end(const this_type &m) + { return const_col_iterator(m.begin(),m.nrows(),m.nrows(),m.ncols(),m.ncols(), &m); } + static origin_type* origin(this_type &m) { return &m; } + static const origin_type* origin(const this_type &m) { return &m; } + static void do_clear(this_type &m) { m.fill(value_type(0)); } + static value_type access(const const_col_iterator &itcol, size_type j) + { return (*itcol)[j]; } + static reference access(const col_iterator &itcol, size_type j) + { return (*itcol)[j]; } + static void resize(this_type &v, size_type m, size_type n) + { v.resize(m,n); } + static void reshape(this_type &v, size_type m, size_type n) + { v.reshape(m, n); } + }; + + template std::ostream &operator << + (std::ostream &o, const dense_matrix& m) { gmm::write(o,m); return o; } + + + /* ******************************************************************** */ + /* */ + /* Read only compressed sparse column matrix */ + /* */ + /* ******************************************************************** */ + + template + struct csc_matrix { + + std::vector pr; + std::vector ir; + std::vector jc; + size_type nc, nr; + + typedef T value_type; + typedef T& access_type; + + template void init_with_good_format(const Matrix &B); + template void init_with(const Matrix &A); + void init_with(const col_matrix > &B) + { init_with_good_format(B); } + void init_with(const col_matrix > &B) + { init_with_good_format(B); } + template + void init_with(const csc_matrix_ref& B) + { init_with_good_format(B); } + template + void init_with(const csc_matrix& B) + { init_with_good_format(B); } + + void init_with_identity(size_type n); + + csc_matrix(void) : nc(0), nr(0) {} + csc_matrix(size_type nnr, size_type nnc); + + size_type nrows(void) const { return nr; } + size_type ncols(void) const { return nc; } + void swap(csc_matrix &m) { + std::swap(pr, m.pr); + std::swap(ir, m.ir); std::swap(jc, m.jc); + std::swap(nc, m.nc); std::swap(nr, m.nr); + } + value_type operator()(size_type i, size_type j) const + { return mat_col(*this, j)[i]; } + }; + + template template + void csc_matrix::init_with_good_format(const Matrix &B) { + typedef typename linalg_traits::const_sub_col_type col_type; + nc = mat_ncols(B); nr = mat_nrows(B); + jc.resize(nc+1); + jc[0] = shift; + for (size_type j = 0; j < nc; ++j) { + jc[j+1] = IND_TYPE(jc[j] + nnz(mat_const_col(B, j))); + } + pr.resize(jc[nc]); + ir.resize(jc[nc]); + for (size_type j = 0; j < nc; ++j) { + col_type col = mat_const_col(B, j); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(col), ite = vect_const_end(col); + for (size_type k = 0; it != ite; ++it, ++k) { + pr[jc[j]-shift+k] = *it; + ir[jc[j]-shift+k] = IND_TYPE(it.index() + shift); + } + } + } + + template + template + void csc_matrix::init_with(const Matrix &A) { + col_matrix > B(mat_nrows(A), mat_ncols(A)); + copy(A, B); + init_with_good_format(B); + } + + template + void csc_matrix::init_with_identity(size_type n) { + nc = nr = n; + pr.resize(nc); ir.resize(nc); jc.resize(nc+1); + for (size_type j = 0; j < nc; ++j) + { ir[j] = jc[j] = shift + j; pr[j] = T(1); } + jc[nc] = shift + nc; + } + + template + csc_matrix::csc_matrix(size_type nnr, size_type nnc) + : nc(nnc), nr(nnr) { + pr.resize(1); ir.resize(1); jc.resize(nc+1); + for (size_type j = 0; j <= nc; ++j) jc[j] = shift; + } + + template + struct linalg_traits > { + typedef csc_matrix this_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef T value_type; + typedef T origin_type; + typedef T reference; + typedef abstract_sparse storage_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_row_iterator; + typedef abstract_null_type sub_col_type; + typedef cs_vector_ref + const_sub_col_type; + typedef sparse_compressed_iterator + const_col_iterator; + typedef abstract_null_type col_iterator; + typedef col_major sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(&m.pr[0],&m.ir[0],&m.jc[0], m.nr, &m.pr[0]); } + static const_col_iterator col_end(const this_type &m) { + return const_col_iterator(&m.pr[0],&m.ir[0],&m.jc[0]+m.nc, + m.nr,&m.pr[0]); + } + static const_sub_col_type col(const const_col_iterator &it) { + return const_sub_col_type(it.pr + *(it.jc) - shift, + it.ir + *(it.jc) - shift, + *(it.jc + 1) - *(it.jc), it.n); + } + static const origin_type* origin(const this_type &m) { return &m.pr[0]; } + static void do_clear(this_type &m) { m.do_clear(); } + static value_type access(const const_col_iterator &itcol, size_type j) + { return col(itcol)[j]; } + }; + + template + std::ostream &operator << + (std::ostream &o, const csc_matrix& m) + { gmm::write(o,m); return o; } + + template + inline void copy(const identity_matrix &, csc_matrix& M) + { M.init_with_identity(mat_nrows(M)); } + + template + inline void copy(const Matrix &A, csc_matrix& M) + { M.init_with(A); } + + /* ******************************************************************** */ + /* */ + /* Read only compressed sparse row matrix */ + /* */ + /* ******************************************************************** */ + + template + struct csr_matrix { + + std::vector pr; // values. + std::vector ir; // col indices. + std::vector jc; // row repartition on pr and ir. + size_type nc, nr; + + typedef T value_type; + typedef T& access_type; + + + template void init_with_good_format(const Matrix &B); + void init_with(const row_matrix > &B) + { init_with_good_format(B); } + void init_with(const row_matrix > &B) + { init_with_good_format(B); } + template + void init_with(const csr_matrix_ref& B) + { init_with_good_format(B); } + template + void init_with(const csr_matrix& B) + { init_with_good_format(B); } + + template void init_with(const Matrix &A); + void init_with_identity(size_type n); + + csr_matrix(void) : nc(0), nr(0) {} + csr_matrix(size_type nnr, size_type nnc); + + size_type nrows(void) const { return nr; } + size_type ncols(void) const { return nc; } + void swap(csr_matrix &m) { + std::swap(pr, m.pr); + std::swap(ir,m.ir); std::swap(jc, m.jc); + std::swap(nc, m.nc); std::swap(nr,m.nr); + } + + value_type operator()(size_type i, size_type j) const + { return mat_row(*this, i)[j]; } + }; + + template template + void csr_matrix::init_with_good_format(const Matrix &B) { + typedef typename linalg_traits::const_sub_row_type row_type; + nc = mat_ncols(B); nr = mat_nrows(B); + jc.resize(nr+1); + jc[0] = shift; + for (size_type j = 0; j < nr; ++j) { + jc[j+1] = IND_TYPE(jc[j] + nnz(mat_const_row(B, j))); + } + pr.resize(jc[nr]); + ir.resize(jc[nr]); + for (size_type j = 0; j < nr; ++j) { + row_type row = mat_const_row(B, j); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(row), ite = vect_const_end(row); + for (size_type k = 0; it != ite; ++it, ++k) { + pr[jc[j]-shift+k] = *it; + ir[jc[j]-shift+k] = IND_TYPE(it.index()+shift); + } + } + } + + template template + void csr_matrix::init_with(const Matrix &A) { + row_matrix > B(mat_nrows(A), mat_ncols(A)); + copy(A, B); + init_with_good_format(B); + } + + template + void csr_matrix::init_with_identity(size_type n) { + nc = nr = n; + pr.resize(nr); ir.resize(nr); jc.resize(nr+1); + for (size_type j = 0; j < nr; ++j) + { ir[j] = jc[j] = shift + j; pr[j] = T(1); } + jc[nr] = shift + nr; + } + + template + csr_matrix::csr_matrix(size_type nnr, size_type nnc) + : nc(nnc), nr(nnr) { + pr.resize(1); ir.resize(1); jc.resize(nr+1); + for (size_type j = 0; j < nr; ++j) jc[j] = shift; + jc[nr] = shift; + } + + + template + struct linalg_traits > { + typedef csr_matrix this_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef T value_type; + typedef T origin_type; + typedef T reference; + typedef abstract_sparse storage_type; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_col_iterator; + typedef abstract_null_type sub_row_type; + typedef cs_vector_ref + const_sub_row_type; + typedef sparse_compressed_iterator + const_row_iterator; + typedef abstract_null_type row_iterator; + typedef row_major sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(&m.pr[0], &m.ir[0], &m.jc[0], m.nc, &m.pr[0]); } + static const_row_iterator row_end(const this_type &m) + { return const_row_iterator(&m.pr[0], &m.ir[0], &m.jc[0] + m.nr, m.nc, &m.pr[0]); } + static const_sub_row_type row(const const_row_iterator &it) { + return const_sub_row_type(it.pr + *(it.jc) - shift, + it.ir + *(it.jc) - shift, + *(it.jc + 1) - *(it.jc), it.n); + } + static const origin_type* origin(const this_type &m) { return &m.pr[0]; } + static void do_clear(this_type &m) { m.do_clear(); } + static value_type access(const const_row_iterator &itrow, size_type j) + { return row(itrow)[j]; } + }; + + template + std::ostream &operator << + (std::ostream &o, const csr_matrix& m) + { gmm::write(o,m); return o; } + + template + inline void copy(const identity_matrix &, csr_matrix& M) + { M.init_with_identity(mat_nrows(M)); } + + template + inline void copy(const Matrix &A, csr_matrix& M) + { M.init_with(A); } + + /* ******************************************************************** */ + /* */ + /* Block matrix */ + /* */ + /* ******************************************************************** */ + + template class block_matrix { + protected : + std::vector blocks; + size_type nrowblocks_; + size_type ncolblocks_; + std::vector introw, intcol; + + public : + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::reference reference; + + size_type nrows(void) const { return introw[nrowblocks_-1].max; } + size_type ncols(void) const { return intcol[ncolblocks_-1].max; } + size_type nrowblocks(void) const { return nrowblocks_; } + size_type ncolblocks(void) const { return ncolblocks_; } + const sub_interval &subrowinterval(size_type i) const { return introw[i]; } + const sub_interval &subcolinterval(size_type i) const { return intcol[i]; } + const MAT &block(size_type i, size_type j) const + { return blocks[j*ncolblocks_+i]; } + MAT &block(size_type i, size_type j) + { return blocks[j*ncolblocks_+i]; } + void do_clear(void); + // to be done : read and write access to a component + value_type operator() (size_type i, size_type j) const { + size_type k, l; + for (k = 0; k < nrowblocks_; ++k) + if (i >= introw[k].min && i < introw[k].max) break; + for (l = 0; l < nrowblocks_; ++l) + if (j >= introw[l].min && j < introw[l].max) break; + return (block(k, l))(i - introw[k].min, j - introw[l].min); + } + reference operator() (size_type i, size_type j) { + size_type k, l; + for (k = 0; k < nrowblocks_; ++k) + if (i >= introw[k].min && i < introw[k].max) break; + for (l = 0; l < nrowblocks_; ++l) + if (j >= introw[l].min && j < introw[l].max) break; + return (block(k, l))(i - introw[k].min, j - introw[l].min); + } + + template void resize(const CONT &c1, const CONT &c2); + template block_matrix(const CONT &c1, const CONT &c2) + { resize(c1, c2); } + block_matrix(void) {} + + }; + + template struct linalg_traits > { + typedef block_matrix this_type; + typedef linalg_false is_reference; + typedef abstract_matrix linalg_type; + typedef this_type origin_type; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::storage_type storage_type; + typedef abstract_null_type sub_row_type; // to be done ... + typedef abstract_null_type const_sub_row_type; // to be done ... + typedef abstract_null_type row_iterator; // to be done ... + typedef abstract_null_type const_row_iterator; // to be done ... + typedef abstract_null_type sub_col_type; // to be done ... + typedef abstract_null_type const_sub_col_type; // to be done ... + typedef abstract_null_type col_iterator; // to be done ... + typedef abstract_null_type const_col_iterator; // to be done ... + typedef abstract_null_type sub_orientation; // to be done ... + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static origin_type* origin(this_type &m) { return &m; } + static const origin_type* origin(const this_type &m) { return &m; } + static void do_clear(this_type &m) { m.do_clear(); } + // access to be done ... + static void resize(this_type &, size_type , size_type) + { GMM_ASSERT1(false, "Sorry, to be done"); } + static void reshape(this_type &, size_type , size_type) + { GMM_ASSERT1(false, "Sorry, to be done"); } + }; + + template void block_matrix::do_clear(void) { + for (size_type j = 0, l = 0; j < ncolblocks_; ++j) + for (size_type i = 0, k = 0; i < nrowblocks_; ++i) + clear(block(i,j)); + } + + template template + void block_matrix::resize(const CONT &c1, const CONT &c2) { + nrowblocks_ = c1.size(); ncolblocks_ = c2.size(); + blocks.resize(nrowblocks_ * ncolblocks_); + intcol.resize(ncolblocks_); + introw.resize(nrowblocks_); + for (size_type j = 0, l = 0; j < ncolblocks_; ++j) { + intcol[j] = sub_interval(l, c2[j]); l += c2[j]; + for (size_type i = 0, k = 0; i < nrowblocks_; ++i) { + if (j == 0) { introw[i] = sub_interval(k, c1[i]); k += c1[i]; } + block(i, j) = MAT(c1[i], c2[j]); + } + } + } + + template + void copy(const block_matrix &m1, M2 &m2) { + for (size_type j = 0; j < m1.ncolblocks(); ++j) + for (size_type i = 0; i < m1.nrowblocks(); ++i) + copy(m1.block(i,j), sub_matrix(m2, m1.subrowinterval(i), + m1.subcolinterval(j))); + } + + template + void copy(const block_matrix &m1, const M2 &m2) + { copy(m1, linalg_const_cast(m2)); } + + + template + void mult(const block_matrix &m, const V1 &v1, V2 &v2) { + clear(v2); + typename sub_vector_type::vector_type sv; + for (size_type i = 0; i < m.nrowblocks() ; ++i) + for (size_type j = 0; j < m.ncolblocks() ; ++j) { + sv = sub_vector(v2, m.subrowinterval(i)); + mult(m.block(i,j), + sub_vector(v1, m.subcolinterval(j)), sv, sv); + } + } + + template + void mult(const block_matrix &m, const V1 &v1, const V2 &v2, V3 &v3) { + typename sub_vector_type::vector_type sv; + for (size_type i = 0; i < m.nrowblocks() ; ++i) + for (size_type j = 0; j < m.ncolblocks() ; ++j) { + sv = sub_vector(v3, m.subrowinterval(i)); + if (j == 0) + mult(m.block(i,j), + sub_vector(v1, m.subcolinterval(j)), + sub_vector(v2, m.subrowinterval(i)), sv); + else + mult(m.block(i,j), + sub_vector(v1, m.subcolinterval(j)), sv, sv); + } + + } + + template + void mult(const block_matrix &m, const V1 &v1, const V2 &v2) + { mult(m, v1, linalg_const_cast(v2)); } + + template + void mult(const block_matrix &m, const V1 &v1, const V2 &v2, + const V3 &v3) + { mult_const(m, v1, v2, linalg_const_cast(v3)); } + +} + /* ******************************************************************** */ + /* */ + /* Distributed matrices */ + /* */ + /* ******************************************************************** */ + +#ifdef GMM_USES_MPI +# include + +namespace gmm { + + + + template inline MPI_Datatype mpi_type(T) + { GMM_ASSERT1(false, "Sorry unsupported type"); return MPI_FLOAT; } + inline MPI_Datatype mpi_type(double) { return MPI_DOUBLE; } + inline MPI_Datatype mpi_type(float) { return MPI_FLOAT; } + inline MPI_Datatype mpi_type(long double) { return MPI_LONG_DOUBLE; } +#ifndef LAM_MPI + inline MPI_Datatype mpi_type(std::complex) { return MPI_COMPLEX; } + inline MPI_Datatype mpi_type(std::complex) { return MPI_DOUBLE_COMPLEX; } +#endif + inline MPI_Datatype mpi_type(int) { return MPI_INT; } + inline MPI_Datatype mpi_type(unsigned int) { return MPI_UNSIGNED; } + inline MPI_Datatype mpi_type(long) { return MPI_LONG; } + inline MPI_Datatype mpi_type(unsigned long) { return MPI_UNSIGNED_LONG; } + + template struct mpi_distributed_matrix { + MAT M; + + mpi_distributed_matrix(size_type n, size_type m) : M(n, m) {} + mpi_distributed_matrix() {} + + const MAT &local_matrix(void) const { return M; } + MAT &local_matrix(void) { return M; } + }; + + template inline MAT &eff_matrix(MAT &m) { return m; } + template inline + const MAT &eff_matrix(const MAT &m) { return m; } + template inline + MAT &eff_matrix(mpi_distributed_matrix &m) { return m.M; } + template inline + const MAT &eff_matrix(const mpi_distributed_matrix &m) { return m.M; } + + + template + inline void copy(const mpi_distributed_matrix &m1, + mpi_distributed_matrix &m2) + { copy(eff_matrix(m1), eff_matrix(m2)); } + template + inline void copy(const mpi_distributed_matrix &m1, + const mpi_distributed_matrix &m2) + { copy(m1.M, m2.M); } + + template + inline void copy(const mpi_distributed_matrix &m1, MAT2 &m2) + { copy(m1.M, m2); } + template + inline void copy(const mpi_distributed_matrix &m1, const MAT2 &m2) + { copy(m1.M, m2); } + + + template inline + typename strongest_value_type3::value_type + vect_sp(const mpi_distributed_matrix &ps, const V1 &v1, + const V2 &v2) { + typedef typename strongest_value_type3::value_type T; + T res = vect_sp(ps.M, v1, v2), rest; + MPI_Allreduce(&res, &rest, 1, mpi_type(T()), MPI_SUM,MPI_COMM_WORLD); + return rest; + } + + template + inline void mult_add(const mpi_distributed_matrix &m, const V1 &v1, + V2 &v2) { + typedef typename linalg_traits::value_type T; + std::vector v3(vect_size(v2)), v4(vect_size(v2)); + static double tmult_tot = 0.0; + static double tmult_tot2 = 0.0; + double t_ref = MPI_Wtime(); + gmm::mult(m.M, v1, v3); + if (is_sparse(v2)) GMM_WARNING2("Using a plain temporary, here."); + double t_ref2 = MPI_Wtime(); + MPI_Allreduce(&(v3[0]), &(v4[0]),gmm::vect_size(v2), mpi_type(T()), + MPI_SUM,MPI_COMM_WORLD); + tmult_tot2 = MPI_Wtime()-t_ref2; + cout << "reduce mult mpi = " << tmult_tot2 << endl; + gmm::add(v4, v2); + tmult_tot = MPI_Wtime()-t_ref; + cout << "tmult mpi = " << tmult_tot << endl; + } + + template + void mult_add(const mpi_distributed_matrix &m, const V1 &v1, + const V2 &v2_) + { mult_add(m, v1, const_cast(v2_)); } + + template + inline void mult(const mpi_distributed_matrix &m, const V1 &v1, + const V2 &v2_) + { V2 &v2 = const_cast(v2_); clear(v2); mult_add(m, v1, v2); } + + template + inline void mult(const mpi_distributed_matrix &m, const V1 &v1, + V2 &v2) + { clear(v2); mult_add(m, v1, v2); } + + template + inline void mult(const mpi_distributed_matrix &m, const V1 &v1, + const V2 &v2, const V3 &v3_) + { V3 &v3 = const_cast(v3_); gmm::copy(v2, v3); mult_add(m, v1, v3); } + + template + inline void mult(const mpi_distributed_matrix &m, const V1 &v1, + const V2 &v2, V3 &v3) + { gmm::copy(v2, v3); mult_add(m, v1, v3); } + + + template inline + size_type mat_nrows(const mpi_distributed_matrix &M) + { return mat_nrows(M.M); } + template inline + size_type mat_ncols(const mpi_distributed_matrix &M) + { return mat_nrows(M.M); } + template inline + void resize(mpi_distributed_matrix &M, size_type m, size_type n) + { resize(M.M, m, n); } + template inline void clear(mpi_distributed_matrix &M) + { clear(M.M); } + + + // For compute reduced system + template inline + void mult(const MAT1 &M1, const mpi_distributed_matrix &M2, + mpi_distributed_matrix &M3) + { mult(M1, M2.M, M3.M); } + template inline + void mult(const mpi_distributed_matrix &M2, + const MAT1 &M1, mpi_distributed_matrix &M3) + { mult(M2.M, M1, M3.M); } + template inline + void mult(const MAT1 &M1, const mpi_distributed_matrix &M2, + MAT3 &M3) + { mult(M1, M2.M, M3); } + template inline + void mult(const MAT1 &M1, const mpi_distributed_matrix &M2, + const MAT3 &M3) + { mult(M1, M2.M, M3); } + + template + struct sub_matrix_type *, SUBI1, SUBI2> + { typedef abstract_null_type matrix_type; }; + + template + struct sub_matrix_type *, SUBI1, SUBI2> + { typedef abstract_null_type matrix_type; }; + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + M *>::return_type + sub_matrix(mpi_distributed_matrix &m, const SUBI1 &si1, const SUBI2 &si2) + { return sub_matrix(m.M, si1, si2); } + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + const MAT *>::return_type + sub_matrix(const mpi_distributed_matrix &m, const SUBI1 &si1, + const SUBI2 &si2) + { return sub_matrix(m.M, si1, si2); } + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + M *>::return_type + sub_matrix(mpi_distributed_matrix &m, const SUBI1 &si1) + { return sub_matrix(m.M, si1, si1); } + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + const M *>::return_type + sub_matrix(const mpi_distributed_matrix &m, const SUBI1 &si1) + { return sub_matrix(m.M, si1, si1); } + + + template struct transposed_return *> + { typedef abstract_null_type return_type; }; + template struct transposed_return *> + { typedef abstract_null_type return_type; }; + + template inline typename transposed_return::return_type + transposed(const mpi_distributed_matrix &l) + { return transposed(l.M); } + + template inline typename transposed_return::return_type + transposed(mpi_distributed_matrix &l) + { return transposed(l.M); } + + + template + struct linalg_traits > { + typedef mpi_distributed_matrix this_type; + typedef MAT origin_type; + typedef linalg_false is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::storage_type storage_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_row_iterator; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_col_iterator; + typedef abstract_null_type sub_orientation; + typedef abstract_null_type index_sorted; + static size_type nrows(const this_type &m) { return nrows(m.M); } + static size_type ncols(const this_type &m) { return ncols(m.M); } + static void do_clear(this_type &m) { clear(m.M); } + }; + +} + + +#endif // GMM_USES_MPI + +namespace std { + template + void swap(gmm::row_matrix &m1, gmm::row_matrix &m2) + { m1.swap(m2); } + template + void swap(gmm::col_matrix &m1, gmm::col_matrix &m2) + { m1.swap(m2); } + template + void swap(gmm::dense_matrix &m1, gmm::dense_matrix &m2) + { m1.swap(m2); } + template void + swap(gmm::csc_matrix &m1, gmm::csc_matrix &m2) + { m1.swap(m2); } + template void + swap(gmm::csr_matrix &m1, gmm::csr_matrix &m2) + { m1.swap(m2); } +} + + + + +#endif /* GMM_MATRIX_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_modified_gram_schmidt.h b/7.x/src/linear_algebra/gmm/gmm_modified_gram_schmidt.h new file mode 100644 index 0000000..fa45917 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_modified_gram_schmidt.h @@ -0,0 +1,127 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_modified_gram_schmidt.h + @author Andrew Lumsdaine , Lie-Quan Lee + @date October 13, 2002. + @brief Modified Gram-Schmidt orthogonalization +*/ + +#ifndef GMM_MODIFIED_GRAM_SCHMIDT_H +#define GMM_MODIFIED_GRAM_SCHMIDT_H + +#include "gmm_kernel.h" + +namespace gmm { + + template + class modified_gram_schmidt { + protected: + typedef dense_matrix MAT; + MAT M; + + public: + + modified_gram_schmidt(int restart, size_t s) : M(s, restart+1) {} + + typename linalg_traits::const_sub_col_type + operator[](size_t i) const { return mat_const_col(M, i); } + + typename linalg_traits::sub_col_type + operator[](size_t i) { return mat_col(M, i); } + + inline size_type nrows(void) const { return M.nrows(); } + inline size_type ncols(void) const { return M.ncols(); } + MAT &mat(void) { return M; } + const MAT &mat(void) const { return M; } + + }; + + template inline + void orthogonalize(modified_gram_schmidt& V, const VecHi& Hi_, size_t i) { + VecHi& Hi = const_cast(Hi_); + + for (size_t k = 0; k <= i; k++) { + Hi[k] = gmm::vect_hp(V[i+1], V[k]); + gmm::add(gmm::scaled(V[k], -Hi[k]), V[i+1]); + } + } + + template + void orthogonalize_with_refinment(modified_gram_schmidt& V, + const VecHi& Hi_, size_t i) { + VecHi& Hi = const_cast(Hi_); + orthogonalize(V, Hi_, i); + + sub_interval SUBI(0, V.nrows()), SUBJ(0, i+1); + std::vector corr(i+1); + gmm::mult(conjugated(sub_matrix(V.mat(), SUBI, SUBJ)), + V[i+1], corr); + gmm::mult(sub_matrix(V.mat(), SUBI, SUBJ), + scaled(corr, T(-1)), V[i+1],V[i+1]); + gmm::add(corr, sub_vector(Hi, SUBJ)); + } + + template + void combine(modified_gram_schmidt& V, const VecS& s, VecX& x, size_t i) + { for (size_t j = 0; j < i; ++j) gmm::add(gmm::scaled(V[j], s[j]), x); } +} + +#endif diff --git a/7.x/src/linear_algebra/gmm/gmm_opt.h b/7.x/src/linear_algebra/gmm/gmm_opt.h new file mode 100644 index 0000000..7be45c4 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_opt.h @@ -0,0 +1,132 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_opt.h + @author Yves Renard + @date July 9, 2003. + @brief Optimization for some small cases (inversion of 2x2 matrices etc.) +*/ +#ifndef GMM_OPT_H__ +#define GMM_OPT_H__ + +#include + +namespace gmm { + + /* ********************************************************************* */ + /* Optimized determinant and inverse for small matrices (2x2 and 3x3) */ + /* with dense_matrix. */ + /* ********************************************************************* */ + + template T lu_det(const dense_matrix &A) { + size_type n(mat_nrows(A)); + if (n) { + const T *p = &(A(0,0)); + switch (n) { + case 1 : return (*p); + case 2 : return (*p) * (*(p+3)) - (*(p+1)) * (*(p+2)); +// Not stable for nearly singular matrices +// case 3 : return (*p) * ((*(p+4)) * (*(p+8)) - (*(p+5)) * (*(p+7))) +// - (*(p+1)) * ((*(p+3)) * (*(p+8)) - (*(p+5)) * (*(p+6))) +// + (*(p+2)) * ((*(p+3)) * (*(p+7)) - (*(p+4)) * (*(p+6))); + default : + { + dense_matrix B(mat_nrows(A), mat_ncols(A)); + lapack_ipvt ipvt(mat_nrows(A)); + gmm::copy(A, B); + lu_factor(B, ipvt); + return lu_det(B, ipvt); + } + } + } + return T(1); + } + + + template T lu_inverse(const dense_matrix &A_, + bool doassert = true) { + dense_matrix& A = const_cast &>(A_); + size_type N = mat_nrows(A); + T det(1); + if (N) { + T *p = &(A(0,0)); + switch (N) { + case 1 : { + det = *p; + if (doassert) GMM_ASSERT1(det!=T(0), "non invertible matrix"); + if (det == T(0)) break; + *p = T(1) / det; + } break; + case 2 : { + det = (*p) * (*(p+3)) - (*(p+1)) * (*(p+2)); + if (doassert) GMM_ASSERT1(det!=T(0), "non invertible matrix"); + if (det == T(0)) break; + std::swap(*p, *(p+3)); + *p++ /= det; *p++ /= -det; *p++ /= -det; *p++ /= det; + } break; + default : { + if (N == 3) { // not stable for nearly singular matrices + T a, b, c, d, e, f, g, h, i; + a = (*(p+4)) * (*(p+8)) - (*(p+5)) * (*(p+7)); + b = - (*(p+1)) * (*(p+8)) + (*(p+2)) * (*(p+7)); + c = (*(p+1)) * (*(p+5)) - (*(p+2)) * (*(p+4)); + d = - (*(p+3)) * (*(p+8)) + (*(p+5)) * (*(p+6)); + e = (*(p+0)) * (*(p+8)) - (*(p+2)) * (*(p+6)); + f = - (*(p+0)) * (*(p+5)) + (*(p+2)) * (*(p+3)); + g = (*(p+3)) * (*(p+7)) - (*(p+4)) * (*(p+6)); + h = - (*(p+0)) * (*(p+7)) + (*(p+1)) * (*(p+6)); + i = (*(p+0)) * (*(p+4)) - (*(p+1)) * (*(p+3)); + det = (*p) * a + (*(p+1)) * d + (*(p+2)) * g; + if (std::abs(det) > 1e-5) { + *p++ = a / det; *p++ = b / det; *p++ = c / det; + *p++ = d / det; *p++ = e / det; *p++ = f / det; + *p++ = g / det; *p++ = h / det; *p++ = i / det; + break; + } + } + dense_matrix B(mat_nrows(A), mat_ncols(A)); + lapack_ipvt ipvt(mat_nrows(A)); + gmm::copy(A, B); + size_type info = lu_factor(B, ipvt); + GMM_ASSERT1(!info, "non invertible matrix"); + lu_inverse(B, ipvt, A); + det = lu_det(B, ipvt); + break; + } + } + } + return det; + } + + +} + +#endif // GMM_OPT_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_precond.h b/7.x/src/linear_algebra/gmm/gmm_precond.h new file mode 100644 index 0000000..17405a2 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond.h @@ -0,0 +1,65 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2004-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ +#ifndef GMM_PRECOND_H +#define GMM_PRECOND_H + +#include "gmm_kernel.h" + +/** @file gmm_precond.h + @author Yves Renard + @date March 29, 2004. + @brief gmm preconditioners. + */ + +/* Preconditioner concept : */ +/* */ +/* A the matrix, P the preconditioner PA well conditioned. */ +/* PRECOND preconditioner type. */ +/* mult(P, v, w) : w <- P v */ +/* transposed_mult(P, v, w) : w <- transposed(P) v */ +/* left_mult(P, v, w) : see qmr solver */ +/* right_mult(P, v, w) : see qmr solver */ +/* transposed_left_mult(P, v, w) : see qmr solver */ +/* transposed_right_mult(P, v, w) : see qmr solver */ +/* */ +/* PRECOND P() : empty preconditioner. */ +/* PRECOND P(A, ...) : preconditioner for the matrix A, with optional */ +/* parameters */ +/* PRECOND(...) : empty precondtioner with parameters set. */ +/* P.build_with(A) : build a precondtioner for A. */ +/* */ +/* *********************************************************************** */ + + + + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_precond_diagonal.h b/7.x/src/linear_algebra/gmm/gmm_precond_diagonal.h new file mode 100644 index 0000000..c8ccebc --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond_diagonal.h @@ -0,0 +1,132 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_precond_diagonal.h + @author Yves Renard + @date June 5, 2003. + @brief Diagonal matrix preconditoner. +*/ + +#ifndef GMM_PRECOND_DIAGONAL_H +#define GMM_PRECOND_DIAGONAL_H + +#include "gmm_precond.h" + +namespace gmm { + + /** Diagonal preconditioner. */ + template struct diagonal_precond { + typedef typename linalg_traits::value_type value_type; + typedef typename number_traits::magnitude_type magnitude_type; + + std::vector diag; + + void build_with(const Matrix &M) { + diag.resize(mat_nrows(M)); + for (size_type i = 0; i < mat_nrows(M); ++i) { + magnitude_type x = gmm::abs(M(i, i)); + if (x == magnitude_type(0)) { + x = magnitude_type(1); + GMM_WARNING2("The matrix has a zero on its diagonal"); + } + diag[i] = magnitude_type(1) / x; + } + } + size_type memsize() const { return sizeof(*this) + diag.size() * sizeof(value_type); } + diagonal_precond(const Matrix &M) { build_with(M); } + diagonal_precond(void) {} + }; + + template inline + void mult_diag_p(const diagonal_precond& P, V2 &v2, abstract_sparse){ + typename linalg_traits::iterator it = vect_begin(v2), + ite = vect_end(v2); + for (; it != ite; ++it) *it *= P.diag[it.index()]; + } + + template inline + void mult_diag_p(const diagonal_precond& P,V2 &v2, abstract_skyline) + { mult_diag_p(P, v2, abstract_sparse()); } + + template inline + void mult_diag_p(const diagonal_precond& P, V2 &v2, abstract_dense){ + for (size_type i = 0; i < P.diag.size(); ++i) v2[i] *= P.diag[i]; + } + + template inline + void mult(const diagonal_precond& P, const V1 &v1, V2 &v2) { + GMM_ASSERT2(P.diag.size() == vect_size(v2),"dimensions mismatch"); + copy(v1, v2); + mult_diag_p(P, v2, typename linalg_traits::storage_type()); + } + + template inline + void transposed_mult(const diagonal_precond& P,const V1 &v1,V2 &v2) { + mult(P, v1, v2); + } + + // # define DIAG_LEFT_MULT_SQRT + + template inline + void left_mult(const diagonal_precond& P, const V1 &v1, V2 &v2) { + GMM_ASSERT2(P.diag.size() == vect_size(v2), "dimensions mismatch"); + copy(v1, v2); +# ifdef DIAG_LEFT_MULT_SQRT + for (size_type i= 0; i < P.diag.size(); ++i) v2[i] *= gmm::sqrt(P.diag[i]); +# else + for (size_type i= 0; i < P.diag.size(); ++i) v2[i] *= P.diag[i]; +# endif + } + + template inline + void transposed_left_mult(const diagonal_precond& P, + const V1 &v1, V2 &v2) + { left_mult(P, v1, v2); } + + template inline + void right_mult(const diagonal_precond& P, const V1 &v1, V2 &v2) { + // typedef typename linalg_traits::value_type T; + GMM_ASSERT2(P.diag.size() == vect_size(v2), "dimensions mismatch"); + copy(v1, v2); +# ifdef DIAG_LEFT_MULT_SQRT + for (size_type i= 0; i < P.diag.size(); ++i) v2[i] *= gmm::sqrt(P.diag[i]); +# endif + } + + template inline + void transposed_right_mult(const diagonal_precond& P, + const V1 &v1, V2 &v2) + { right_mult(P, v1, v2); } + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_precond_ildlt.h b/7.x/src/linear_algebra/gmm/gmm_precond_ildlt.h new file mode 100644 index 0000000..226213e --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond_ildlt.h @@ -0,0 +1,241 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of cholesky.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +#ifndef GMM_PRECOND_ILDLT_H +#define GMM_PRECOND_ILDLT_H + +/**@file gmm_precond_ildlt.h + @author Andrew Lumsdaine + @author Lie-Quan Lee + @author Yves Renard + @date June 5, 2003. + @brief Incomplete Level 0 ILDLT Preconditioner. +*/ + +#include "gmm_precond.h" + +namespace gmm { + + /** Incomplete Level 0 LDLT Preconditioner. + + For use with symmetric real or hermitian complex sparse matrices. + + Notes: The idea under a concrete Preconditioner such as Incomplete + Cholesky is to create a Preconditioner object to use in iterative + methods. + + + Y. Renard : Transformed in LDLT for stability reason. + + U=LT is stored in csr format. D is stored on the diagonal of U. + */ + template + class ildlt_precond { + + public : + typedef typename linalg_traits::value_type value_type; + typedef typename number_traits::magnitude_type magnitude_type; + typedef csr_matrix_ref tm_type; + + tm_type U; + + protected : + std::vector Tri_val; + std::vector Tri_ind, Tri_ptr; + + template void do_ildlt(const M& A, row_major); + void do_ildlt(const Matrix& A, col_major); + + public: + + size_type nrows(void) const { return mat_nrows(U); } + size_type ncols(void) const { return mat_ncols(U); } + value_type &D(size_type i) { return Tri_val[Tri_ptr[i]]; } + const value_type &D(size_type i) const { return Tri_val[Tri_ptr[i]]; } + ildlt_precond(void) {} + void build_with(const Matrix& A) { + Tri_ptr.resize(mat_nrows(A)+1); + do_ildlt(A, typename principal_orientation_type::sub_orientation>::potype()); + } + ildlt_precond(const Matrix& A) { build_with(A); } + size_type memsize() const { + return sizeof(*this) + + Tri_val.size() * sizeof(value_type) + + (Tri_ind.size()+Tri_ptr.size()) * sizeof(size_type); + } + }; + + template template + void ildlt_precond::do_ildlt(const M& A, row_major) { + typedef typename linalg_traits::storage_type store_type; + typedef value_type T; + typedef typename number_traits::magnitude_type R; + + size_type Tri_loc = 0, n = mat_nrows(A), d, g, h, i, j, k; + if (n == 0) return; + T z, zz; + Tri_ptr[0] = 0; + R prec = default_tol(R()); + R max_pivot = gmm::abs(A(0,0)) * prec; + + for (int count = 0; count < 2; ++count) { + if (count) { Tri_val.resize(Tri_loc); Tri_ind.resize(Tri_loc); } + for (Tri_loc = 0, i = 0; i < n; ++i) { + typedef typename linalg_traits::const_sub_row_type row_type; + row_type row = mat_const_row(A, i); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(row), ite = vect_const_end(row); + + if (count) { Tri_val[Tri_loc] = T(0); Tri_ind[Tri_loc] = i; } + ++Tri_loc; // diagonal element + + for (k = 0; it != ite; ++it, ++k) { + j = index_of_it(it, k, store_type()); + if (i == j) { + if (count) Tri_val[Tri_loc-1] = *it; + } + else if (j > i) { + if (count) { Tri_val[Tri_loc] = *it; Tri_ind[Tri_loc]=j; } + ++Tri_loc; + } + } + Tri_ptr[i+1] = Tri_loc; + } + } + + if (A(0,0) == T(0)) { + Tri_val[Tri_ptr[0]] = T(1); + GMM_WARNING2("pivot 0 is too small"); + } + + for (k = 0; k < n; k++) { + d = Tri_ptr[k]; + z = T(gmm::real(Tri_val[d])); Tri_val[d] = z; + if (gmm::abs(z) <= max_pivot) { + Tri_val[d] = z = T(1); + GMM_WARNING2("pivot " << k << " is too small [" << gmm::abs(z) << "]"); + } + max_pivot = std::max(max_pivot, std::min(gmm::abs(z) * prec, R(1))); + + for (i = d + 1; i < Tri_ptr[k+1]; ++i) Tri_val[i] /= z; + for (i = d + 1; i < Tri_ptr[k+1]; ++i) { + zz = gmm::conj(Tri_val[i] * z); + h = Tri_ind[i]; + g = i; + + for (j = Tri_ptr[h] ; j < Tri_ptr[h+1]; ++j) + for ( ; g < Tri_ptr[k+1] && Tri_ind[g] <= Tri_ind[j]; ++g) + if (Tri_ind[g] == Tri_ind[j]) + Tri_val[j] -= zz * Tri_val[g]; + } + } + U = tm_type(&(Tri_val[0]), &(Tri_ind[0]), &(Tri_ptr[0]), + n, mat_ncols(A)); + } + + template + void ildlt_precond::do_ildlt(const Matrix& A, col_major) + { do_ildlt(gmm::conjugated(A), row_major()); } + + template inline + void mult(const ildlt_precond& P, const V1 &v1, V2 &v2) { + gmm::copy(v1, v2); + gmm::lower_tri_solve(gmm::conjugated(P.U), v2, true); + for (size_type i = 0; i < mat_nrows(P.U); ++i) v2[i] /= P.D(i); + gmm::upper_tri_solve(P.U, v2, true); + } + + template inline + void transposed_mult(const ildlt_precond& P,const V1 &v1,V2 &v2) + { mult(P, v1, v2); } + + template inline + void left_mult(const ildlt_precond& P, const V1 &v1, V2 &v2) { + copy(v1, v2); + gmm::lower_tri_solve(gmm::conjugated(P.U), v2, true); + for (size_type i = 0; i < mat_nrows(P.U); ++i) v2[i] /= P.D(i); + } + + template inline + void right_mult(const ildlt_precond& P, const V1 &v1, V2 &v2) + { copy(v1, v2); gmm::upper_tri_solve(P.U, v2, true); } + + template inline + void transposed_left_mult(const ildlt_precond& P, const V1 &v1, + V2 &v2) { + copy(v1, v2); + gmm::upper_tri_solve(P.U, v2, true); + for (size_type i = 0; i < mat_nrows(P.U); ++i) v2[i] /= P.D(i); + } + + template inline + void transposed_right_mult(const ildlt_precond& P, const V1 &v1, + V2 &v2) + { copy(v1, v2); gmm::lower_tri_solve(gmm::conjugated(P.U), v2, true); } + + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_precond_ildltt.h b/7.x/src/linear_algebra/gmm/gmm_precond_ildltt.h new file mode 100644 index 0000000..54713df --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond_ildltt.h @@ -0,0 +1,174 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_precond_ildltt.h + @author Yves Renard + @date June 30, 2003. + @brief incomplete LDL^t (cholesky) preconditioner with fill-in and threshold. +*/ + +#ifndef GMM_PRECOND_ILDLTT_H +#define GMM_PRECOND_ILDLTT_H + +// Store U = LT and D in indiag. On each line, the fill-in is the number +// of non-zero elements on the line of the original matrix plus K, except if +// the matrix is dense. In this case the fill-in is K on each line. + +#include "gmm_precond_ilut.h" + +namespace gmm { + /** incomplete LDL^t (cholesky) preconditioner with fill-in and + threshold. */ + template + class ildltt_precond { + public : + typedef typename linalg_traits::value_type value_type; + typedef typename number_traits::magnitude_type magnitude_type; + + typedef rsvector svector; + + row_matrix U; + std::vector indiag; + + protected: + size_type K; + double eps; + + template void do_ildltt(const M&, row_major); + void do_ildltt(const Matrix&, col_major); + + public: + void build_with(const Matrix& A, int k_ = -1, double eps_ = double(-1)) { + if (k_ >= 0) K = k_; + if (eps_ >= double(0)) eps = eps_; + gmm::resize(U, mat_nrows(A), mat_ncols(A)); + indiag.resize(std::min(mat_nrows(A), mat_ncols(A))); + do_ildltt(A, typename principal_orientation_type::sub_orientation>::potype()); + } + ildltt_precond(const Matrix& A, int k_, double eps_) + : U(mat_nrows(A),mat_ncols(A)), K(k_), eps(eps_) { build_with(A); } + ildltt_precond(void) { K=10; eps = 1E-7; } + ildltt_precond(size_type k_, double eps_) : K(k_), eps(eps_) {} + size_type memsize() const { + return sizeof(*this) + nnz(U)*sizeof(value_type) + indiag.size() * sizeof(magnitude_type); + } + }; + + template template + void ildltt_precond::do_ildltt(const M& A,row_major) { + typedef value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = mat_nrows(A); + if (n == 0) return; + svector w(n); + T tmp; + R prec = default_tol(R()), max_pivot = gmm::abs(A(0,0)) * prec; + + gmm::clear(U); + for (size_type i = 0; i < n; ++i) { + gmm::copy(mat_const_row(A, i), w); + double norm_row = gmm::vect_norm2(w); + + for (size_type krow = 0, k; krow < w.nb_stored(); ++krow) { + typename svector::iterator wk = w.begin() + krow; + if ((k = wk->c) >= i) break; + if (gmm::is_complex(wk->e)) { + tmp = gmm::conj(U(k, i))/indiag[k]; // not completely satisfactory .. + gmm::add(scaled(mat_row(U, k), -tmp), w); + } + else { + tmp = wk->e; + if (gmm::abs(tmp) < eps * norm_row) { w.sup(k); --krow; } + else { wk->e += tmp; gmm::add(scaled(mat_row(U, k), -tmp), w); } + } + } + tmp = w[i]; + + if (gmm::abs(gmm::real(tmp)) <= max_pivot) + { GMM_WARNING2("pivot " << i << " is too small"); tmp = T(1); } + + max_pivot = std::max(max_pivot, std::min(gmm::abs(tmp) * prec, R(1))); + indiag[i] = R(1) / gmm::real(tmp); + gmm::clean(w, eps * norm_row); + gmm::scale(w, T(indiag[i])); + std::sort(w.begin(), w.end(), elt_rsvector_value_less_()); + typename svector::const_iterator wit = w.begin(), wite = w.end(); + for (size_type nnu = 0; wit != wite; ++wit) // copy to be optimized ... + if (wit->c > i) { if (nnu < K) { U(i, wit->c) = wit->e; ++nnu; } } + } + } + + template + void ildltt_precond::do_ildltt(const Matrix& A, col_major) + { do_ildltt(gmm::conjugated(A), row_major()); } + + template inline + void mult(const ildltt_precond& P, const V1 &v1, V2 &v2) { + gmm::copy(v1, v2); + gmm::lower_tri_solve(gmm::conjugated(P.U), v2, true); + for (size_type i = 0; i < P.indiag.size(); ++i) v2[i] *= P.indiag[i]; + gmm::upper_tri_solve(P.U, v2, true); + } + + template inline + void transposed_mult(const ildltt_precond& P,const V1 &v1, V2 &v2) + { mult(P, v1, v2); } + + template inline + void left_mult(const ildltt_precond& P, const V1 &v1, V2 &v2) { + copy(v1, v2); + gmm::lower_tri_solve(gmm::conjugated(P.U), v2, true); + for (size_type i = 0; i < P.indiag.size(); ++i) v2[i] *= P.indiag[i]; + } + + template inline + void right_mult(const ildltt_precond& P, const V1 &v1, V2 &v2) + { copy(v1, v2); gmm::upper_tri_solve(P.U, v2, true); } + + template inline + void transposed_left_mult(const ildltt_precond& P, const V1 &v1, + V2 &v2) { + copy(v1, v2); + gmm::upper_tri_solve(P.U, v2, true); + for (size_type i = 0; i < P.indiag.size(); ++i) v2[i] *= P.indiag[i]; + } + + template inline + void transposed_right_mult(const ildltt_precond& P, const V1 &v1, + V2 &v2) + { copy(v1, v2); gmm::lower_tri_solve(gmm::conjugated(P.U), v2, true); } + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_precond_ilu.h b/7.x/src/linear_algebra/gmm/gmm_precond_ilu.h new file mode 100644 index 0000000..25d322d --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond_ilu.h @@ -0,0 +1,280 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of ilu.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_precond_ilu.h + @author Andrew Lumsdaine + @author Lie-Quan Lee + @author Yves Renard + @date June 5, 2003. + @brief Incomplete LU without fill-in Preconditioner. +*/ + +#ifndef GMM_PRECOND_ILU_H +#define GMM_PRECOND_ILU_H + +// +// Notes: The idea under a concrete Preconditioner such +// as Incomplete LU is to create a Preconditioner +// object to use in iterative methods. +// + +#include "gmm_precond.h" + +namespace gmm { + /** Incomplete LU without fill-in Preconditioner. */ + template + class ilu_precond { + + public : + typedef typename linalg_traits::value_type value_type; + typedef csr_matrix_ref tm_type; + + tm_type U, L; + bool invert; + protected : + std::vector L_val, U_val; + std::vector L_ind, U_ind, L_ptr, U_ptr; + + template void do_ilu(const M& A, row_major); + void do_ilu(const Matrix& A, col_major); + + public: + + size_type nrows(void) const { return mat_nrows(L); } + size_type ncols(void) const { return mat_ncols(U); } + + void build_with(const Matrix& A) { + invert = false; + L_ptr.resize(mat_nrows(A)+1); + U_ptr.resize(mat_nrows(A)+1); + do_ilu(A, typename principal_orientation_type::sub_orientation>::potype()); + } + ilu_precond(const Matrix& A) { build_with(A); } + ilu_precond(void) {} + size_type memsize() const { + return sizeof(*this) + + (L_val.size()+U_val.size()) * sizeof(value_type) + + (L_ind.size()+L_ptr.size()) * sizeof(size_type) + + (U_ind.size()+U_ptr.size()) * sizeof(size_type); + } + }; + + template template + void ilu_precond::do_ilu(const M& A, row_major) { + typedef typename linalg_traits::storage_type store_type; + typedef value_type T; + typedef typename number_traits::magnitude_type R; + + size_type L_loc = 0, U_loc = 0, n = mat_nrows(A), i, j, k; + if (n == 0) return; + L_ptr[0] = 0; U_ptr[0] = 0; + R prec = default_tol(R()); + R max_pivot = gmm::abs(A(0,0)) * prec; + + + for (int count = 0; count < 2; ++count) { + if (count) { + L_val.resize(L_loc); L_ind.resize(L_loc); + U_val.resize(U_loc); U_ind.resize(U_loc); + } + L_loc = U_loc = 0; + for (i = 0; i < n; ++i) { + typedef typename linalg_traits::const_sub_row_type row_type; + row_type row = mat_const_row(A, i); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(row), ite = vect_const_end(row); + + if (count) { U_val[U_loc] = T(0); U_ind[U_loc] = i; } + ++U_loc; // diagonal element + + for (k = 0; it != ite && k < 1000; ++it, ++k) { + // if a plain row is present, retains only the 1000 firsts + // nonzero elements. ---> a sort should be done. + j = index_of_it(it, k, store_type()); + if (j < i) { + if (count) { L_val[L_loc] = *it; L_ind[L_loc] = j; } + L_loc++; + } + else if (i == j) { + if (count) U_val[U_loc-1] = *it; + } + else { + if (count) { U_val[U_loc] = *it; U_ind[U_loc] = j; } + U_loc++; + } + } + L_ptr[i+1] = L_loc; U_ptr[i+1] = U_loc; + } + } + + if (A(0,0) == T(0)) { + U_val[U_ptr[0]] = T(1); + GMM_WARNING2("pivot 0 is too small"); + } + + size_type qn, pn, rn; + for (i = 1; i < n; i++) { + + pn = U_ptr[i]; + if (gmm::abs(U_val[pn]) <= max_pivot) { + U_val[pn] = T(1); + GMM_WARNING2("pivot " << i << " is too small"); + } + max_pivot = std::max(max_pivot, + std::min(gmm::abs(U_val[pn]) * prec, R(1))); + + for (j = L_ptr[i]; j < L_ptr[i+1]; j++) { + pn = U_ptr[L_ind[j]]; + + T multiplier = (L_val[j] /= U_val[pn]); + + qn = j + 1; + rn = U_ptr[i]; + + for (pn++; pn < U_ptr[L_ind[j]+1] && U_ind[pn] < i; pn++) { + while (qn < L_ptr[i+1] && L_ind[qn] < U_ind[pn]) + qn++; + if (qn < L_ptr[i+1] && U_ind[pn] == L_ind[qn]) + L_val[qn] -= multiplier * U_val[pn]; + } + for (; pn < U_ptr[L_ind[j]+1]; pn++) { + while (rn < U_ptr[i+1] && U_ind[rn] < U_ind[pn]) + rn++; + if (rn < U_ptr[i+1] && U_ind[pn] == U_ind[rn]) + U_val[rn] -= multiplier * U_val[pn]; + } + } + } + + L = tm_type(&(L_val[0]), &(L_ind[0]), &(L_ptr[0]), n, mat_ncols(A)); + U = tm_type(&(U_val[0]), &(U_ind[0]), &(U_ptr[0]), n, mat_ncols(A)); + } + + template + void ilu_precond::do_ilu(const Matrix& A, col_major) { + do_ilu(gmm::transposed(A), row_major()); + invert = true; + } + + template inline + void mult(const ilu_precond& P, const V1 &v1, V2 &v2) { + gmm::copy(v1, v2); + if (P.invert) { + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + else { + gmm::lower_tri_solve(P.L, v2, true); + gmm::upper_tri_solve(P.U, v2, false); + } + } + + template inline + void transposed_mult(const ilu_precond& P,const V1 &v1,V2 &v2) { + gmm::copy(v1, v2); + if (P.invert) { + gmm::lower_tri_solve(P.L, v2, true); + gmm::upper_tri_solve(P.U, v2, false); + } + else { + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + } + + template inline + void left_mult(const ilu_precond& P, const V1 &v1, V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + else gmm::lower_tri_solve(P.L, v2, true); + } + + template inline + void right_mult(const ilu_precond& P, const V1 &v1, V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + else gmm::upper_tri_solve(P.U, v2, false); + } + + template inline + void transposed_left_mult(const ilu_precond& P, const V1 &v1, + V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::upper_tri_solve(P.U, v2, false); + else gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + + template inline + void transposed_right_mult(const ilu_precond& P, const V1 &v1, + V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::lower_tri_solve(P.L, v2, true); + else gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + } + + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_precond_ilut.h b/7.x/src/linear_algebra/gmm/gmm_precond_ilut.h new file mode 100644 index 0000000..04bbe7d --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond_ilut.h @@ -0,0 +1,263 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of ilut.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +#ifndef GMM_PRECOND_ILUT_H +#define GMM_PRECOND_ILUT_H + +/**@file gmm_precond_ilut.h + @author Andrew Lumsdaine , Lie-Quan Lee + @date June 5, 2003. + @brief ILUT: Incomplete LU with threshold and K fill-in Preconditioner. +*/ + +/* + Performane comparing for SSOR, ILU and ILUT based on sherman 5 matrix + in Harwell-Boeing collection on Sun Ultra 30 UPA/PCI (UltraSPARC-II 296MHz) + Preconditioner & Factorization time & Number of Iteration \\ \hline + SSOR & 0.010577 & 41 \\ + ILU & 0.019336 & 32 \\ + ILUT with 0 fill-in and threshold of 1.0e-6 & 0.343612 & 23 \\ + ILUT with 5 fill-in and threshold of 1.0e-6 & 0.343612 & 18 \\ \hline +*/ + +#include "gmm_precond.h" + +namespace gmm { + + template struct elt_rsvector_value_less_ { + inline bool operator()(const elt_rsvector_& a, + const elt_rsvector_& b) const + { return (gmm::abs(a.e) > gmm::abs(b.e)); } + }; + + /** Incomplete LU with threshold and K fill-in Preconditioner. + + The algorithm of ILUT(A, 0, 1.0e-6) is slower than ILU(A). If No + fill-in is arrowed, you can use ILU instead of ILUT. + + Notes: The idea under a concrete Preconditioner such as ilut is to + create a Preconditioner object to use in iterative methods. + */ + template + class ilut_precond { + public : + typedef typename linalg_traits::value_type value_type; + typedef wsvector _wsvector; + typedef rsvector _rsvector; + typedef row_matrix<_rsvector> LU_Matrix; + + bool invert; + LU_Matrix L, U; + + protected: + size_type K; + double eps; + + template void do_ilut(const M&, row_major); + void do_ilut(const Matrix&, col_major); + + public: + void build_with(const Matrix& A, int k_ = -1, double eps_ = double(-1)) { + if (k_ >= 0) K = k_; + if (eps_ >= double(0)) eps = eps_; + invert = false; + gmm::resize(L, mat_nrows(A), mat_ncols(A)); + gmm::resize(U, mat_nrows(A), mat_ncols(A)); + do_ilut(A, typename principal_orientation_type::sub_orientation>::potype()); + } + ilut_precond(const Matrix& A, int k_, double eps_) + : L(mat_nrows(A), mat_ncols(A)), U(mat_nrows(A), mat_ncols(A)), + K(k_), eps(eps_) { build_with(A); } + ilut_precond(size_type k_, double eps_) : K(k_), eps(eps_) {} + ilut_precond(void) { K = 10; eps = 1E-7; } + size_type memsize() const { + return sizeof(*this) + (nnz(U)+nnz(L))*sizeof(value_type); + } + }; + + template template + void ilut_precond::do_ilut(const M& A, row_major) { + typedef value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = mat_nrows(A); + if (n == 0) return; + std::vector indiag(n); + _wsvector w(mat_ncols(A)); + _rsvector ww(mat_ncols(A)), wL(mat_ncols(A)), wU(mat_ncols(A)); + T tmp; + gmm::clear(U); gmm::clear(L); + R prec = default_tol(R()); + R max_pivot = gmm::abs(A(0,0)) * prec; + + for (size_type i = 0; i < n; ++i) { + gmm::copy(mat_const_row(A, i), w); + double norm_row = gmm::vect_norm2(w); + + typename _wsvector::iterator wkold = w.end(); + for (typename _wsvector::iterator wk = w.begin(); + wk != w.end() && wk->first < i; ) { + size_type k = wk->first; + tmp = (wk->second) * indiag[k]; + if (gmm::abs(tmp) < eps * norm_row) w.erase(k); + else { wk->second += tmp; gmm::add(scaled(mat_row(U, k), -tmp), w); } + if (wkold == w.end()) wk = w.begin(); else { wk = wkold; ++wk; } + if (wk != w.end() && wk->first == k) + { if (wkold == w.end()) wkold = w.begin(); else ++wkold; ++wk; } + } + tmp = w[i]; + + if (gmm::abs(tmp) <= max_pivot) { + GMM_WARNING2("pivot " << i << " too small. try with ilutp ?"); + w[i] = tmp = T(1); + } + + max_pivot = std::max(max_pivot, std::min(gmm::abs(tmp) * prec, R(1))); + indiag[i] = T(1) / tmp; + gmm::clean(w, eps * norm_row); + gmm::copy(w, ww); + std::sort(ww.begin(), ww.end(), elt_rsvector_value_less_()); + typename _rsvector::const_iterator wit = ww.begin(), wite = ww.end(); + + size_type nnl = 0, nnu = 0; + wL.base_resize(K); wU.base_resize(K+1); + typename _rsvector::iterator witL = wL.begin(), witU = wU.begin(); + for (; wit != wite; ++wit) + if (wit->c < i) { if (nnl < K) { *witL++ = *wit; ++nnl; } } + else { if (nnu < K || wit->c == i) { *witU++ = *wit; ++nnu; } } + wL.base_resize(nnl); wU.base_resize(nnu); + std::sort(wL.begin(), wL.end()); + std::sort(wU.begin(), wU.end()); + gmm::copy(wL, L.row(i)); + gmm::copy(wU, U.row(i)); + } + + } + + template + void ilut_precond::do_ilut(const Matrix& A, col_major) { + do_ilut(gmm::transposed(A), row_major()); + invert = true; + } + + template inline + void mult(const ilut_precond& P, const V1 &v1, V2 &v2) { + gmm::copy(v1, v2); + if (P.invert) { + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + else { + gmm::lower_tri_solve(P.L, v2, true); + gmm::upper_tri_solve(P.U, v2, false); + } + } + + template inline + void transposed_mult(const ilut_precond& P,const V1 &v1,V2 &v2) { + gmm::copy(v1, v2); + if (P.invert) { + gmm::lower_tri_solve(P.L, v2, true); + gmm::upper_tri_solve(P.U, v2, false); + } + else { + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + } + + template inline + void left_mult(const ilut_precond& P, const V1 &v1, V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + else gmm::lower_tri_solve(P.L, v2, true); + } + + template inline + void right_mult(const ilut_precond& P, const V1 &v1, V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + else gmm::upper_tri_solve(P.U, v2, false); + } + + template inline + void transposed_left_mult(const ilut_precond& P, const V1 &v1, + V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::upper_tri_solve(P.U, v2, false); + else gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + + template inline + void transposed_right_mult(const ilut_precond& P, const V1 &v1, + V2 &v2) { + copy(v1, v2); + if (P.invert) gmm::lower_tri_solve(P.L, v2, true); + else gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + } + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_precond_ilutp.h b/7.x/src/linear_algebra/gmm/gmm_precond_ilutp.h new file mode 100644 index 0000000..785bf35 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond_ilutp.h @@ -0,0 +1,284 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2004-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_precond_ilutp.h + @author Yves Renard + @date October 14, 2004. + @brief ILUTP: Incomplete LU with threshold and K fill-in Preconditioner and + column pivoting. + + +*/ +#ifndef GMM_PRECOND_ILUTP_H +#define GMM_PRECOND_ILUTP_H + +#include "gmm_precond_ilut.h" + +namespace gmm { + + /** + ILUTP: Incomplete LU with threshold and K fill-in Preconditioner and + column pivoting. + + See Yousef Saad, Iterative Methods for + sparse linear systems, PWS Publishing Company, section 10.4.4 + + TODO : store the permutation by cycles to avoid the temporary vector + */ + template + class ilutp_precond { + public : + typedef typename linalg_traits::value_type value_type; + typedef wsvector _wsvector; + typedef rsvector _rsvector; + typedef row_matrix<_rsvector> LU_Matrix; + typedef col_matrix<_wsvector> CLU_Matrix; + + bool invert; + LU_Matrix L, U; + gmm::unsorted_sub_index indperm; + gmm::unsorted_sub_index indperminv; + mutable std::vector temporary; + + protected: + size_type K; + double eps; + + template void do_ilutp(const M&, row_major); + void do_ilutp(const Matrix&, col_major); + + public: + void build_with(const Matrix& A, int k_ = -1, double eps_ = double(-1)) { + if (k_ >= 0) K = k_; + if (eps_ >= double(0)) eps = eps_; + invert = false; + gmm::resize(L, mat_nrows(A), mat_ncols(A)); + gmm::resize(U, mat_nrows(A), mat_ncols(A)); + do_ilutp(A, typename principal_orientation_type::sub_orientation>::potype()); + } + ilutp_precond(const Matrix& A, size_type k_, double eps_) + : L(mat_nrows(A), mat_ncols(A)), U(mat_nrows(A), mat_ncols(A)), + K(k_), eps(eps_) { build_with(A); } + ilutp_precond(int k_, double eps_) : K(k_), eps(eps_) {} + ilutp_precond(void) { K = 10; eps = 1E-7; } + size_type memsize() const { + return sizeof(*this) + (nnz(U)+nnz(L))*sizeof(value_type); + } + }; + + + template template + void ilutp_precond::do_ilutp(const M& A, row_major) { + typedef value_type T; + typedef typename number_traits::magnitude_type R; + + size_type n = mat_nrows(A); + CLU_Matrix CU(n,n); + if (n == 0) return; + std::vector indiag(n); + temporary.resize(n); + std::vector ipvt(n), ipvtinv(n); + for (size_type i = 0; i < n; ++i) ipvt[i] = ipvtinv[i] = i; + indperm = unsorted_sub_index(ipvt); + indperminv = unsorted_sub_index(ipvtinv); + _wsvector w(mat_ncols(A)); + _rsvector ww(mat_ncols(A)); + + T tmp = T(0); + gmm::clear(L); gmm::clear(U); + R prec = default_tol(R()); + R max_pivot = gmm::abs(A(0,0)) * prec; + + for (size_type i = 0; i < n; ++i) { + + copy(sub_vector(mat_const_row(A, i), indperm), w); + double norm_row = gmm::vect_norm2(mat_const_row(A, i)); + + typename _wsvector::iterator wkold = w.end(); + for (typename _wsvector::iterator wk = w.begin(); + wk != w.end() && wk->first < i; ) { + size_type k = wk->first; + tmp = (wk->second) * indiag[k]; + if (gmm::abs(tmp) < eps * norm_row) w.erase(k); + else { wk->second += tmp; gmm::add(scaled(mat_row(U, k), -tmp), w); } + if (wkold == w.end()) wk = w.begin(); else { wk = wkold; ++wk; } + if (wk != w.end() && wk->first == k) + { if (wkold == w.end()) wkold = w.begin(); else ++wkold; ++wk; } + } + + gmm::clean(w, eps * norm_row); + gmm::copy(w, ww); + + std::sort(ww.begin(), ww.end(), elt_rsvector_value_less_()); + typename _rsvector::const_iterator wit = ww.begin(), wite = ww.end(); + size_type ip = size_type(-1); + + for (; wit != wite; ++wit) + if (wit->c >= i) { ip = wit->c; tmp = wit->e; break; } + if (ip == size_type(-1) || gmm::abs(tmp) <= max_pivot) + { GMM_WARNING2("pivot " << i << " too small"); ip=i; ww[i]=tmp=T(1); } + max_pivot = std::max(max_pivot, std::min(gmm::abs(tmp) * prec, R(1))); + indiag[i] = T(1) / tmp; + wit = ww.begin(); + + size_type nnl = 0, nnu = 0; + L[i].base_resize(K); U[i].base_resize(K+1); + typename _rsvector::iterator witL = L[i].begin(), witU = U[i].begin(); + for (; wit != wite; ++wit) { + if (wit->c < i) { if (nnl < K) { *witL++ = *wit; ++nnl; } } + else if (nnu < K || wit->c == i) + { CU(i, wit->c) = wit->e; *witU++ = *wit; ++nnu; } + } + L[i].base_resize(nnl); U[i].base_resize(nnu); + std::sort(L[i].begin(), L[i].end()); + std::sort(U[i].begin(), U[i].end()); + + if (ip != i) { + typename _wsvector::const_iterator iti = CU.col(i).begin(); + typename _wsvector::const_iterator itie = CU.col(i).end(); + typename _wsvector::const_iterator itp = CU.col(ip).begin(); + typename _wsvector::const_iterator itpe = CU.col(ip).end(); + + while (iti != itie && itp != itpe) { + if (iti->first < itp->first) + { U.row(iti->first).swap_indices(i, ip); ++iti; } + else if (iti->first > itp->first) + { U.row(itp->first).swap_indices(i,ip);++itp; } + else + { U.row(iti->first).swap_indices(i, ip); ++iti; ++itp; } + } + + for( ; iti != itie; ++iti) U.row(iti->first).swap_indices(i, ip); + for( ; itp != itpe; ++itp) U.row(itp->first).swap_indices(i, ip); + + CU.swap_col(i, ip); + + indperm.swap(i, ip); + indperminv.swap(ipvt[i], ipvt[ip]); + std::swap(ipvtinv[ipvt[i]], ipvtinv[ipvt[ip]]); + std::swap(ipvt[i], ipvt[ip]); + } + } + } + + template + void ilutp_precond::do_ilutp(const Matrix& A, col_major) { + do_ilutp(gmm::transposed(A), row_major()); + invert = true; + } + + template inline + void mult(const ilutp_precond& P, const V1 &v1, V2 &v2) { + if (P.invert) { + gmm::copy(gmm::sub_vector(v1, P.indperm), v2); + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + else { + gmm::copy(v1, P.temporary); + gmm::lower_tri_solve(P.L, P.temporary, true); + gmm::upper_tri_solve(P.U, P.temporary, false); + gmm::copy(gmm::sub_vector(P.temporary, P.indperminv), v2); + } + } + + template inline + void transposed_mult(const ilutp_precond& P,const V1 &v1,V2 &v2) { + if (P.invert) { + gmm::copy(v1, P.temporary); + gmm::lower_tri_solve(P.L, P.temporary, true); + gmm::upper_tri_solve(P.U, P.temporary, false); + gmm::copy(gmm::sub_vector(P.temporary, P.indperminv), v2); + } + else { + gmm::copy(gmm::sub_vector(v1, P.indperm), v2); + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + } + + template inline + void left_mult(const ilutp_precond& P, const V1 &v1, V2 &v2) { + if (P.invert) { + gmm::copy(gmm::sub_vector(v1, P.indperm), v2); + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + } + else { + copy(v1, v2); + gmm::lower_tri_solve(P.L, v2, true); + } + } + + template inline + void right_mult(const ilutp_precond& P, const V1 &v1, V2 &v2) { + if (P.invert) { + copy(v1, v2); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + else { + copy(v1, P.temporary); + gmm::upper_tri_solve(P.U, P.temporary, false); + gmm::copy(gmm::sub_vector(P.temporary, P.indperminv), v2); + } + } + + template inline + void transposed_left_mult(const ilutp_precond& P, const V1 &v1, + V2 &v2) { + if (P.invert) { + copy(v1, P.temporary); + gmm::upper_tri_solve(P.U, P.temporary, false); + gmm::copy(gmm::sub_vector(P.temporary, P.indperminv), v2); + } + else { + copy(v1, v2); + gmm::upper_tri_solve(gmm::transposed(P.L), v2, true); + } + } + + template inline + void transposed_right_mult(const ilutp_precond& P, const V1 &v1, + V2 &v2) { + if (P.invert) { + copy(v1, v2); + gmm::lower_tri_solve(P.L, v2, true); + } + else { + gmm::copy(gmm::sub_vector(v1, P.indperm), v2); + gmm::lower_tri_solve(gmm::transposed(P.U), v2, false); + } + } + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_precond_mr_approx_inverse.h b/7.x/src/linear_algebra/gmm/gmm_precond_mr_approx_inverse.h new file mode 100644 index 0000000..91a749d --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_precond_mr_approx_inverse.h @@ -0,0 +1,149 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + + +// This file is a modified version of approximate_inverse.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_precond_mr_approx_inverse.h + @author Andrew Lumsdaine + @author Lie-Quan Lee + @author Yves Renard + @date June 5, 2003. + @brief Approximate inverse via MR iteration. +*/ + +#ifndef GMM_PRECOND_MR_APPROX_INVERSE_H +#define GMM_PRECOND_MR_APPROX_INVERSE_H + + +#include "gmm_precond.h" + +namespace gmm { + + /** Approximate inverse via MR iteration (see P301 of Saad book). + */ + template + struct mr_approx_inverse_precond { + + typedef typename linalg_traits::value_type value_type; + typedef typename number_traits::magnitude_type magnitude_type; + typedef typename principal_orientation_type::sub_orientation>::potype sub_orientation; + typedef wsvector VVector; + typedef col_matrix MMatrix; + + MMatrix M; + size_type nb_it; + magnitude_type threshold; + + void build_with(const Matrix& A); + mr_approx_inverse_precond(const Matrix& A, size_type nb_it_, + magnitude_type threshold_) + : M(mat_nrows(A), mat_ncols(A)) + { threshold = threshold_; nb_it = nb_it_; build_with(A); } + mr_approx_inverse_precond(void) + { threshold = magnitude_type(1E-7); nb_it = 5; } + mr_approx_inverse_precond(size_type nb_it_, magnitude_type threshold_) + { threshold = threshold_; nb_it = nb_it_; } + const MMatrix &approx_inverse(void) const { return M; } + }; + + template inline + void mult(const mr_approx_inverse_precond& P, const V1 &v1, V2 &v2) + { mult(P.M, v1, v2); } + + template inline + void transposed_mult(const mr_approx_inverse_precond& P, + const V1 &v1,V2 &v2) + { mult(gmm::conjugated(P.M), v1, v2); } + + template + void mr_approx_inverse_precond::build_with(const Matrix& A) { + gmm::resize(M, mat_nrows(A), mat_ncols(A)); + typedef value_type T; + typedef magnitude_type R; + VVector m(mat_ncols(A)),r(mat_ncols(A)),ei(mat_ncols(A)),Ar(mat_ncols(A)); + T alpha = mat_trace(A)/ mat_euclidean_norm_sqr(A); + if (alpha == T(0)) alpha = T(1); + + for (size_type i = 0; i < mat_nrows(A); ++i) { + gmm::clear(m); gmm::clear(ei); + m[i] = alpha; + ei[i] = T(1); + + for (size_type j = 0; j < nb_it; ++j) { + gmm::mult(A, gmm::scaled(m, T(-1)), r); + gmm::add(ei, r); + gmm::mult(A, r, Ar); + T nAr = vect_sp(Ar,Ar); + if (gmm::abs(nAr) > R(0)) { + gmm::add(gmm::scaled(r, gmm::safe_divide(vect_sp(r, Ar), vect_sp(Ar, Ar))), m); + gmm::clean(m, threshold * gmm::vect_norm2(m)); + } else gmm::clear(m); + } + if (gmm::vect_norm2(m) == R(0)) m[i] = alpha; + gmm::copy(m, M.col(i)); + } + } +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_range_basis.h b/7.x/src/linear_algebra/gmm/gmm_range_basis.h new file mode 100644 index 0000000..7d7eeb5 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_range_basis.h @@ -0,0 +1,499 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2009-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_range_basis.h + @author Yves Renard + @date March 10, 2009. + @brief Extract a basis of the range of a (large sparse) matrix from the + columns of this matrix. +*/ +#ifndef GMM_RANGE_BASIS_H +#define GMM_RANGE_BASIS_H +#include "gmm_dense_qr.h" +#include "gmm_dense_lu.h" + +#include "gmm_kernel.h" +#include "gmm_iter.h" +#include +#include + + +namespace gmm { + + + template + void tridiag_qr_algorithm + (std::vector::magnitude_type> diag, + std::vector sdiag, const VECT &eigval_, const MAT1 &eigvect_, + bool compvect, tol_type_for_qr tol = default_tol_for_qr) { + VECT &eigval = const_cast(eigval_); + MAT1 &eigvect = const_cast(eigvect_); + typedef typename number_traits::magnitude_type R; + + if (compvect) gmm::copy(identity_matrix(), eigvect); + + size_type n = diag.size(), q = 0, p, ite = 0; + if (n == 0) return; + if (n == 1) { eigval[0] = gmm::real(diag[0]); return; } + + symmetric_qr_stop_criterion(diag, sdiag, p, q, tol); + + while (q < n) { + sub_interval SUBI(p, n-p-q), SUBJ(0, mat_ncols(eigvect)), SUBK(p, n-p-q); + if (!compvect) SUBK = sub_interval(0,0); + + symmetric_Wilkinson_qr_step(sub_vector(diag, SUBI), + sub_vector(sdiag, SUBI), + sub_matrix(eigvect, SUBJ, SUBK), compvect); + + symmetric_qr_stop_criterion(diag, sdiag, p, q, tol*R(3)); + ++ite; + GMM_ASSERT1(ite < n*100, "QR algorithm failed."); + } + + gmm::copy(diag, eigval); + } + + // Range basis with a restarted Lanczos method + template + void range_basis_eff_Lanczos(const Mat &BB, std::set &columns, + double EPS=1E-12) { + typedef std::set TAB; + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type nc_r = columns.size(), k; + col_matrix< rsvector > B(mat_nrows(BB), mat_ncols(BB)); + + k = 0; + for (TAB::iterator it = columns.begin(); it!=columns.end(); ++it, ++k){ + gmm::copy(scaled(mat_col(BB, *it), T(1)/vect_norm2(mat_col(BB, *it))), + mat_col(B, *it)); + } + std::vector w(mat_nrows(B)); + size_type restart = 120; + std::vector sdiag(restart); + std::vector eigval(restart), diag(restart); + dense_matrix eigvect(restart, restart); + + R rho = R(-1), rho2; + while (nc_r) { + + std::vector v(nc_r), v0(nc_r), wl(nc_r); + dense_matrix lv(nc_r, restart); + + if (rho < R(0)) { // Estimate of the spectral radius of B^* B + gmm::fill_random(v); + for (size_type i = 0; i < 100; ++i) { + gmm::scale(v, T(1)/vect_norm2(v)); + gmm::copy(v, v0); + k = 0; gmm::clear(w); + for (TAB::iterator it=columns.begin(); it!=columns.end(); ++it, ++k) + add(scaled(mat_col(B, *it), v[k]), w); + k = 0; + for (TAB::iterator it=columns.begin(); it!=columns.end(); ++it, ++k) + v[k] = vect_hp(w, mat_col(B, *it)); + rho = gmm::abs(vect_hp(v, v0) / vect_hp(v0, v0)); + } + rho *= R(2); + } + + // Computing vectors of the null space of de B^* B with restarted Lanczos + rho2 = 0; + gmm::fill_random(v); + size_type iter = 0; + for(;;++iter) { + R rho_old = rho2; + R beta = R(0), alpha; + gmm::scale(v, T(1)/vect_norm2(v)); + size_type eff_restart = restart; + if (sdiag.size() != restart) { + sdiag.resize(restart); eigval.resize(restart); diag.resize(restart); gmm::resize(eigvect, restart, restart); + gmm::resize(lv, nc_r, restart); + } + + for (size_type i = 0; i < restart; ++i) { // Lanczos iterations + gmm::copy(v, mat_col(lv, i)); + gmm::clear(w); + k = 0; + for (TAB::iterator it=columns.begin(); it!=columns.end(); ++it, ++k) + add(scaled(mat_col(B, *it), v[k]), w); + + k = 0; + for (TAB::iterator it=columns.begin(); it!=columns.end(); ++it, ++k) + wl[k] = v[k]*rho - vect_hp(w, mat_col(B, *it)) - beta*v0[k]; + alpha = gmm::real(vect_hp(wl, v)); + diag[i] = alpha; + gmm::add(gmm::scaled(v, -alpha), wl); + sdiag[i] = beta = vect_norm2(wl); + gmm::copy(v, v0); + if (beta < EPS) { eff_restart = i+1; break; } + gmm::copy(gmm::scaled(wl, T(1) / beta), v); + } + if (eff_restart != restart) { + sdiag.resize(eff_restart); eigval.resize(eff_restart); diag.resize(eff_restart); + gmm::resize(eigvect, eff_restart, eff_restart); gmm::resize(lv, nc_r, eff_restart); + } + tridiag_qr_algorithm(diag, sdiag, eigval, eigvect, true); + + size_type num = size_type(-1); + rho2 = R(0); + for (size_type j = 0; j < eff_restart; ++j) + { R nvp=gmm::abs(eigval[j]); if (nvp > rho2) { rho2=nvp; num=j; }} + + GMM_ASSERT1(num != size_type(-1), "Internal error"); + + gmm::mult(lv, mat_col(eigvect, num), v); + + if (gmm::abs(rho2-rho_old) < rho_old*R(EPS)) break; + // if (gmm::abs(rho-rho2) < rho*R(gmm::sqrt(EPS))) break; + if (gmm::abs(rho-rho2) < rho*R(EPS)*R(100)) break; + } + + if (gmm::abs(rho-rho2) < rho*R(EPS*10.)) { + size_type j_max = size_type(-1), j = 0; + R val_max = R(0); + for (TAB::iterator it=columns.begin(); it!=columns.end(); ++it, ++j) + if (gmm::abs(v[j]) > val_max) + { val_max = gmm::abs(v[j]); j_max = *it; } + columns.erase(j_max); nc_r = columns.size(); + } + else break; + } + } + + // Range basis with LU decomposition. Not stable from a numerical viewpoint. + // Complex version not verified + template + void range_basis_eff_lu(const Mat &B, std::set &columns, + std::vector &c_ortho, double EPS) { + + typedef std::set TAB; + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type nc_r = 0, nc_o = 0, nc = mat_ncols(B), nr = mat_nrows(B), i, j; + + for (TAB::iterator it=columns.begin(); it!=columns.end(); ++it) + if (!(c_ortho[*it])) ++nc_r; else nc_o++; + + if (nc_r > 0) { + + gmm::row_matrix< gmm::rsvector > Hr(nc, nc_r), Ho(nc, nc_o); + gmm::row_matrix< gmm::rsvector > BBr(nr, nc_r), BBo(nr, nc_o); + + i = j = 0; + for (TAB::iterator it=columns.begin(); it!=columns.end(); ++it) + if (!(c_ortho[*it])) + { Hr(*it, i) = T(1)/ vect_norminf(mat_col(B, *it)); ++i; } + else + { Ho(*it, j) = T(1)/ vect_norm2(mat_col(B, *it)); ++j; } + + gmm::mult(B, Hr, BBr); + gmm::mult(B, Ho, BBo); + gmm::dense_matrix M(nc_r, nc_r), BBB(nc_r, nc_o), MM(nc_r, nc_r); + gmm::mult(gmm::conjugated(BBr), BBr, M); + gmm::mult(gmm::conjugated(BBr), BBo, BBB); + gmm::mult(BBB, gmm::conjugated(BBB), MM); + gmm::add(gmm::scaled(MM, T(-1)), M); + + std::vector ipvt(nc_r); + gmm::lu_factor(M, ipvt); + + R emax = R(0); + for (i = 0; i < nc_r; ++i) emax = std::max(emax, gmm::abs(M(i,i))); + + i = 0; + std::set c = columns; + for (TAB::iterator it = c.begin(); it != c.end(); ++it) + if (!(c_ortho[*it])) { + if (gmm::abs(M(i,i)) <= R(EPS)*emax) columns.erase(*it); + ++i; + } + } + } + + + // Range basis with Gram-Schmidt orthogonalization (sparse version) + // The sparse version is better when the sparsity is high and less efficient + // than the dense version for high degree elements (P3, P4 ...) + // Complex version not verified + template + void range_basis_eff_Gram_Schmidt_sparse(const Mat &BB, + std::set &columns, + std::vector &c_ortho, + double EPS) { + + typedef std::set TAB; + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type nc = mat_ncols(BB), nr = mat_nrows(BB); + std::set c = columns, rc = columns; + + gmm::col_matrix< rsvector > B(nr, nc); + for (std::set::iterator it = columns.begin(); + it != columns.end(); ++it) { + gmm::copy(mat_col(BB, *it), mat_col(B, *it)); + gmm::scale(mat_col(B, *it), T(1)/vect_norm2(mat_col(B, *it))); + } + + for (std::set::iterator it = c.begin(); it != c.end(); ++it) + if (c_ortho[*it]) { + for (std::set::iterator it2 = rc.begin(); + it2 != rc.end(); ++it2) + if (!(c_ortho[*it2])) { + T r = -vect_hp(mat_col(B, *it2), mat_col(B, *it)); + if (r != T(0)) add(scaled(mat_col(B, *it), r), mat_col(B, *it2)); + } + rc.erase(*it); + } + + while (rc.size()) { + R nmax = R(0); size_type cmax = size_type(-1); + for (std::set::iterator it=rc.begin(); it != rc.end();) { + TAB::iterator itnext = it; ++itnext; + R n = vect_norm2(mat_col(B, *it)); + if (nmax < n) { nmax = n; cmax = *it; } + if (n < R(EPS)) { columns.erase(*it); rc.erase(*it); } + it = itnext; + } + + if (nmax < R(EPS)) break; + + gmm::scale(mat_col(B, cmax), T(1)/vect_norm2(mat_col(B, cmax))); + rc.erase(cmax); + for (std::set::iterator it=rc.begin(); it!=rc.end(); ++it) { + T r = -vect_hp(mat_col(B, *it), mat_col(B, cmax)); + if (r != T(0)) add(scaled(mat_col(B, cmax), r), mat_col(B, *it)); + } + } + for (std::set::iterator it=rc.begin(); it!=rc.end(); ++it) + columns.erase(*it); + } + + + // Range basis with Gram-Schmidt orthogonalization (dense version) + template + void range_basis_eff_Gram_Schmidt_dense(const Mat &B, + std::set &columns, + std::vector &c_ortho, + double EPS) { + + typedef std::set TAB; + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type nc_r = columns.size(), nc = mat_ncols(B), nr = mat_nrows(B), i; + std::set rc; + + row_matrix< gmm::rsvector > H(nc, nc_r), BB(nr, nc_r); + std::vector v(nc_r); + std::vector ind(nc_r); + + i = 0; + for (TAB::iterator it = columns.begin(); it != columns.end(); ++it, ++i) + H(*it, i) = T(1) / vect_norm2(mat_col(B, *it)); + + mult(B, H, BB); + dense_matrix M(nc_r, nc_r); + mult(gmm::conjugated(BB), BB, M); + + i = 0; + for (TAB::iterator it = columns.begin(); it != columns.end(); ++it, ++i) + if (c_ortho[*it]) { + gmm::copy(mat_row(M, i), v); + rank_one_update(M, scaled(v, T(-1)), v); + M(i, i) = T(1); + } + else { rc.insert(i); ind[i] = *it; } + + while (rc.size() > 0) { + + // Next pivot + R nmax = R(0); size_type imax = size_type(-1); + for (TAB::iterator it = rc.begin(); it != rc.end();) { + TAB::iterator itnext = it; ++itnext; + R a = gmm::abs(M(*it, *it)); + if (a > nmax) { nmax = a; imax = *it; } + if (a < R(EPS)) { columns.erase(ind[*it]); rc.erase(*it); } + it = itnext; + } + + if (nmax < R(EPS)) break; + + // Normalization + gmm::scale(mat_row(M, imax), T(1) / sqrt(nmax)); + gmm::scale(mat_col(M, imax), T(1) / sqrt(nmax)); + + // orthogonalization + copy(mat_row(M, imax), v); + rank_one_update(M, scaled(v, T(-1)), v); + M(imax, imax) = T(1); + + rc.erase(imax); + } + for (std::set::iterator it=rc.begin(); it!=rc.end(); ++it) + columns.erase(ind[*it]); + } + + template size_type nnz_eps(const L& l, double eps) { + typename linalg_traits::const_iterator it = vect_const_begin(l), + ite = vect_const_end(l); + size_type res(0); + for (; it != ite; ++it) if (gmm::abs(*it) >= eps) ++res; + return res; + } + + template + bool reserve__rb(const L& l, std::vector &b, double eps) { + typename linalg_traits::const_iterator it = vect_const_begin(l), + ite = vect_const_end(l); + bool ok = true; + for (; it != ite; ++it) + if (gmm::abs(*it) >= eps && b[it.index()]) ok = false; + if (ok) { + for (it = vect_const_begin(l); it != ite; ++it) + if (gmm::abs(*it) >= eps) b[it.index()] = true; + } + return ok; + } + + template + void range_basis(const Mat &B, std::set &columns, + double EPS, col_major, bool skip_init=false) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + size_type nc = mat_ncols(B), nr = mat_nrows(B); + + std::vector norms(nc); + std::vector c_ortho(nc), booked(nr); + std::vector< std::set > nnzs(mat_nrows(B)); + + if (!skip_init) { + + R norm_max = R(0); + for (size_type i = 0; i < nc; ++i) { + norms[i] = vect_norminf(mat_col(B, i)); + norm_max = std::max(norm_max, norms[i]); + } + + columns.clear(); + for (size_type i = 0; i < nc; ++i) + if (norms[i] > norm_max*R(EPS)) { + columns.insert(i); + nnzs[nnz_eps(mat_col(B, i), R(EPS) * norms[i])].insert(i); + } + + for (size_type i = 1; i < nr; ++i) + for (std::set::iterator it = nnzs[i].begin(); + it != nnzs[i].end(); ++it) + if (reserve__rb(mat_col(B, *it), booked, R(EPS) * norms[*it])) + c_ortho[*it] = true; + } + + size_type sizesm[7] = {125, 200, 350, 550, 800, 1100, 1500}, actsize; + for (int k = 0; k < 7; ++k) { + size_type nc_r = columns.size(); + std::set c1, cres; + actsize = sizesm[k]; + for (std::set::iterator it = columns.begin(); + it != columns.end(); ++it) { + c1.insert(*it); + if (c1.size() >= actsize) { + range_basis_eff_Gram_Schmidt_dense(B, c1, c_ortho, EPS); + for (std::set::iterator it2=c1.begin(); it2 != c1.end(); + ++it2) cres.insert(*it2); + c1.clear(); + } + } + if (c1.size() > 1) + range_basis_eff_Gram_Schmidt_dense(B, c1, c_ortho, EPS); + for (std::set::iterator it = c1.begin(); it != c1.end(); ++it) + cres.insert(*it); + columns = cres; + if (nc_r <= actsize) return; + if (columns.size() == nc_r) break; + if (sizesm[k] >= 350 && columns.size() > (nc_r*19)/20) break; + } + if (columns.size() > std::max(size_type(10), actsize)) + range_basis_eff_Lanczos(B, columns, EPS); + else + range_basis_eff_Gram_Schmidt_dense(B, columns, c_ortho, EPS); + } + + + template + void range_basis(const Mat &B, std::set &columns, + double EPS, row_major) { + typedef typename linalg_traits::value_type T; + gmm::col_matrix< rsvector > BB(mat_nrows(B), mat_ncols(B)); + GMM_WARNING3("A copy of a row matrix is done into a column matrix " + "for range basis algorithm."); + gmm::copy(B, BB); + range_basis(BB, columns, EPS); + } + + /** Range Basis : + Extract a basis of the range of a (large sparse) matrix selecting some + column vectors of this matrix. This is in particular useful to select + an independent set of linear constraints. + + The algorithm is optimized for two cases : + - when the (non trivial) kernel is small. An iterativ algorithm + based on Lanczos method is applied + - when the (non trivial) kernel is large and most of the dependencies + can be detected locally. A block Gram-Schmidt is applied first then + a restarted Lanczos method when the remaining kernel is greatly + smaller. + The restarted Lanczos method could be improved or replaced by a block + Lanczos method, a block Wiedelann method (in order to be parallelized for + instance) or simply could compute more than one vector of the null + space at each iteration. + The LU decomposition has been tested for local elimination but gives bad + results : the algorithm is unstable and do not permit to give the right + number of vector at the end of the process. Moreover, the number of final + vectors depends greatly on the number of vectors in a block of the local + analysis. + */ + template + void range_basis(const Mat &B, std::set &columns, + double EPS=1E-12) { + range_basis(B, columns, EPS, + typename principal_orientation_type + ::sub_orientation>::potype()); +} + +} + +#endif diff --git a/7.x/src/linear_algebra/gmm/gmm_real_part.h b/7.x/src/linear_algebra/gmm/gmm_real_part.h new file mode 100644 index 0000000..0ea6d4d --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_real_part.h @@ -0,0 +1,608 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_real_part.h + @author Yves Renard + @date September 18, 2003. + @brief extract the real/imaginary part of vectors/matrices +*/ +#ifndef GMM_REAL_PART_H +#define GMM_REAL_PART_H + +#include "gmm_def.h" +#include "gmm_vector.h" +#include + +namespace gmm { + + struct linalg_real_part {}; + struct linalg_imag_part {}; + template struct which_part {}; + + template typename number_traits::magnitude_type + real_or_imag_part(C x, linalg_real_part) { return gmm::real(x); } + template typename number_traits::magnitude_type + real_or_imag_part(C x, linalg_imag_part) { return gmm::imag(x); } + template C + complex_from(T x, C y, OP op, linalg_real_part) { return std::complex(op(std::real(y), x), std::imag(y)); } + template C + complex_from(T x, C y, OP op,linalg_imag_part) { return std::complex(std::real(y), op(std::imag(y), x)); } + + template struct project2nd { + T operator()(T , T b) const { return b; } + }; + + template class ref_elt_vector > { + + R r; + + public : + + operator T() const { return real_or_imag_part(std::complex(r), PART()); } + ref_elt_vector(R r_) : r(r_) {} + inline ref_elt_vector &operator =(T v) + { r = complex_from(v, std::complex(r), gmm::project2nd(), PART()); return *this; } + inline bool operator ==(T v) const { return (r == v); } + inline bool operator !=(T v) const { return (r != v); } + inline ref_elt_vector &operator +=(T v) + { r = complex_from(v, std::complex(r), std::plus(), PART()); return *this; } + inline ref_elt_vector &operator -=(T v) + { r = complex_from(v, std::complex(r), std::minus(), PART()); return *this; } + inline ref_elt_vector &operator /=(T v) + { r = complex_from(v, std::complex(r), std::divides(), PART()); return *this; } + inline ref_elt_vector &operator *=(T v) + { r = complex_from(v, std::complex(r), std::multiplies(), PART()); return *this; } + inline ref_elt_vector &operator =(const ref_elt_vector &re) + { *this = T(re); return *this; } + T operator +() { return T(*this); } // necessary for unknow reason + T operator -() { return -T(*this); } // necessary for unknow reason + T operator +(T v) { return T(*this)+ v; } // necessary for unknow reason + T operator -(T v) { return T(*this)- v; } // necessary for unknow reason + T operator *(T v) { return T(*this)* v; } // necessary for unknow reason + T operator /(T v) { return T(*this)/ v; } // necessary for unknow reason + }; + + template struct ref_or_value_type { + template + static W r(const T &x, linalg_real_part, W) { + return gmm::real(x); + } + template + static W r(const T &x, linalg_imag_part, W) { + return gmm::imag(x); + } + }; + + template + struct ref_or_value_type > > { + template + static const T &r(const T &x, linalg_real_part, W) + { return x; } + template + static const T &r(const T &x, linalg_imag_part, W) { + return x; + } + template + static T &r(T &x, linalg_real_part, W) + { return x; } + template + static T &r(T &x, linalg_imag_part, W) { + return x; + } + }; + + + /* ********************************************************************* */ + /* Reference to the real part of (complex) vectors */ + /* ********************************************************************* */ + + template + struct part_vector_iterator { + typedef typename std::iterator_traits::value_type vtype; + typedef typename gmm::number_traits::magnitude_type value_type; + typedef value_type *pointer; + typedef ref_elt_vector::reference, PART> > reference; + typedef typename std::iterator_traits::difference_type difference_type; + typedef typename std::iterator_traits::iterator_category + iterator_category; + + IT it; + + part_vector_iterator(void) {} + explicit part_vector_iterator(const IT &i) : it(i) {} + part_vector_iterator(const part_vector_iterator &i) + : it(i.it) {} + part_vector_iterator &operator = + (const part_vector_iterator &i) { it = i.it; return *this; } + + size_type index(void) const { return it.index(); } + part_vector_iterator operator ++(int) + { part_vector_iterator tmp = *this; ++it; return tmp; } + part_vector_iterator operator --(int) + { part_vector_iterator tmp = *this; --it; return tmp; } + part_vector_iterator &operator ++() { ++it; return *this; } + part_vector_iterator &operator --() { --it; return *this; } + part_vector_iterator &operator +=(difference_type i) + { it += i; return *this; } + part_vector_iterator &operator -=(difference_type i) + { it -= i; return *this; } + part_vector_iterator operator +(difference_type i) const + { part_vector_iterator itb = *this; return (itb += i); } + part_vector_iterator operator -(difference_type i) const + { part_vector_iterator itb = *this; return (itb -= i); } + difference_type operator -(const part_vector_iterator &i) const + { return difference_type(it - i.it); } + + reference operator *() const { return reference(*it); } + reference operator [](size_type ii) const { return reference(it[ii]); } + + bool operator ==(const part_vector_iterator &i) const + { return (i.it == it); } + bool operator !=(const part_vector_iterator &i) const + { return (i.it != it); } + bool operator < (const part_vector_iterator &i) const + { return (it < i.it); } + }; + + + template struct part_vector { + typedef part_vector this_type; + typedef typename std::iterator_traits::value_type V; + typedef V * CPT; + typedef typename select_ref::const_iterator, + typename linalg_traits::iterator, PT>::ref_type iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + size_type size_; + + size_type size(void) const { return size_; } + + reference operator[](size_type i) const { + return reference(ref_or_value_type::r( + linalg_traits::access(origin, begin_, end_, i), + PART(), value_type())); + } + + part_vector(V &v) + : begin_(vect_begin(v)), end_(vect_end(v)), + origin(linalg_origin(v)), size_(gmm::vect_size(v)) {} + part_vector(const V &v) + : begin_(vect_begin(const_cast(v))), + end_(vect_end(const_cast(v))), + origin(linalg_origin(const_cast(v))), size_(gmm::vect_size(v)) {} + part_vector() {} + part_vector(const part_vector &cr) + : begin_(cr.begin_),end_(cr.end_),origin(cr.origin), size_(cr.size_) {} + }; + + template inline + void set_to_begin(part_vector_iterator &it, + ORG o, part_vector *, linalg_modifiable) { + typedef part_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_begin(it.it, o, typename linalg_traits::pV(), ref_t()); + } + template inline + void set_to_begin(part_vector_iterator &it, + ORG o, const part_vector *, linalg_modifiable) { + typedef part_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_begin(it.it, o, typename linalg_traits::pV(), ref_t()); + } + template inline + void set_to_end(part_vector_iterator &it, + ORG o, part_vector *, linalg_modifiable) { + typedef part_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_end(it.it, o, typename linalg_traits::pV(), ref_t()); + } + template inline + void set_to_end(part_vector_iterator &it, + ORG o, const part_vector *, + linalg_modifiable) { + typedef part_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_end(it.it, o, typename linalg_traits::pV(), ref_t()); + } + + template std::ostream &operator << + (std::ostream &o, const part_vector& m) + { gmm::write(o,m); return o; } + + + /* ********************************************************************* */ + /* Reference to the real or imaginary part of (complex) matrices */ + /* ********************************************************************* */ + + + template struct part_row_ref { + + typedef part_row_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef M * CPT; + typedef typename std::iterator_traits::reference ref_M; + typedef typename select_ref + ::const_row_iterator, typename linalg_traits + ::row_iterator, PT>::ref_type iterator; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + size_type nr, nc; + + part_row_ref(ref_M m) + : begin_(mat_row_begin(m)), end_(mat_row_end(m)), + origin(linalg_origin(m)), nr(mat_nrows(m)), nc(mat_ncols(m)) {} + + part_row_ref(const part_row_ref &cr) : + begin_(cr.begin_),end_(cr.end_), origin(cr.origin),nr(cr.nr),nc(cr.nc) {} + + reference operator()(size_type i, size_type j) const { + return reference(ref_or_value_type::r( + linalg_traits::access(begin_+i, j), + PART(), value_type())); + } + }; + + template std::ostream &operator << + (std::ostream &o, const part_row_ref& m) + { gmm::write(o,m); return o; } + + template struct part_col_ref { + + typedef part_col_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef M * CPT; + typedef typename std::iterator_traits::reference ref_M; + typedef typename select_ref + ::const_col_iterator, typename linalg_traits + ::col_iterator, PT>::ref_type iterator; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + size_type nr, nc; + + part_col_ref(ref_M m) + : begin_(mat_col_begin(m)), end_(mat_col_end(m)), + origin(linalg_origin(m)), nr(mat_nrows(m)), nc(mat_ncols(m)) {} + + part_col_ref(const part_col_ref &cr) : + begin_(cr.begin_),end_(cr.end_), origin(cr.origin),nr(cr.nr),nc(cr.nc) {} + + reference operator()(size_type i, size_type j) const { + return reference(ref_or_value_type::r( + linalg_traits::access(begin_+j, i), + PART(), value_type())); + } + }; + + + + template std::ostream &operator << + (std::ostream &o, const part_col_ref& m) + { gmm::write(o,m); return o; } + + + + + + +template + struct part_return_ { + typedef abstract_null_type return_type; + }; + template + struct part_return_ { + typedef typename std::iterator_traits::value_type L; + typedef typename select_return, + part_row_ref< L *, PART>, PT>::return_type return_type; + }; + template + struct part_return_ { + typedef typename std::iterator_traits::value_type L; + typedef typename select_return, + part_col_ref, PT>::return_type return_type; + }; + + template struct part_return__{ + typedef abstract_null_type return_type; + }; + + template + struct part_return__ { + typedef typename std::iterator_traits::value_type L; + typedef typename part_return_::sub_orientation>::potype, PART, + PT>::return_type return_type; + }; + + template + struct part_return__ { + typedef typename std::iterator_traits::value_type L; + typedef typename select_return, + part_vector, PT>::return_type return_type; + }; + + template struct part_return { + typedef typename std::iterator_traits::value_type L; + typedef typename part_return__::linalg_type>::return_type return_type; + }; + + template inline + typename part_return::return_type + real_part(const L &l) { + return typename part_return::return_type + (linalg_cast(const_cast(l))); + } + + template inline + typename part_return::return_type + real_part(L &l) { + return typename part_return::return_type(linalg_cast(l)); + } + + template inline + typename part_return::return_type + imag_part(const L &l) { + return typename part_return::return_type + (linalg_cast(const_cast(l))); + } + + template inline + typename part_return::return_type + imag_part(L &l) { + return typename part_return::return_type(linalg_cast(l)); + } + + + template + struct linalg_traits > { + typedef part_vector this_type; + typedef this_type * pthis_type; + typedef PT pV; + typedef typename std::iterator_traits::value_type V; + typedef typename linalg_traits::index_sorted index_sorted; + typedef typename linalg_traits::is_reference V_reference; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename linalg_traits::value_type vtype; + typedef typename number_traits::magnitude_type value_type; + typedef typename select_ref::reference, + PART> >, PT>::ref_type reference; + typedef typename select_ref::const_iterator, + typename linalg_traits::iterator, PT>::ref_type pre_iterator; + typedef typename select_ref, + PT>::ref_type iterator; + typedef part_vector_iterator::const_iterator, + pre_iterator, PART> const_iterator; + typedef typename linalg_traits::storage_type storage_type; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { + iterator it; it.it = v.begin_; + if (!is_const_reference(is_reference()) && is_sparse(storage_type())) + set_to_begin(it, v.origin, pthis_type(), is_reference()); + return it; + } + static const_iterator begin(const this_type &v) { + const_iterator it(v.begin_); + if (!is_const_reference(is_reference()) && is_sparse(storage_type())) + { set_to_begin(it, v.origin, pthis_type(), is_reference()); } + return it; + } + static iterator end(this_type &v) { + iterator it(v.end_); + if (!is_const_reference(is_reference()) && is_sparse(storage_type())) + set_to_end(it, v.origin, pthis_type(), is_reference()); + return it; + } + static const_iterator end(const this_type &v) { + const_iterator it(v.end_); + if (!is_const_reference(is_reference()) && is_sparse(storage_type())) + set_to_end(it, v.origin, pthis_type(), is_reference()); + return it; + } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + + static void clear(origin_type* o, const iterator &begin_, + const iterator &end_, abstract_sparse) { + std::deque ind; + iterator it = begin_; + for (; it != end_; ++it) ind.push_front(it.index()); + for (; !(ind.empty()); ind.pop_back()) + access(o, begin_, end_, ind.back()) = value_type(0); + } + static void clear(origin_type* o, const iterator &begin_, + const iterator &end_, abstract_skyline) { + clear(o, begin_, end_, abstract_sparse()); + } + static void clear(origin_type* o, const iterator &begin_, + const iterator &end_, abstract_dense) { + for (iterator it = begin_; it != end_; ++it) *it = value_type(0); + } + + static void clear(origin_type* o, const iterator &begin_, + const iterator &end_) + { clear(o, begin_, end_, storage_type()); } + static void do_clear(this_type &v) { clear(v.origin, begin(v), end(v)); } + static value_type access(const origin_type *o, const const_iterator &it, + const const_iterator &ite, size_type i) { + return real_or_imag_part(linalg_traits::access(o, it.it, ite.it,i), + PART()); + } + static reference access(origin_type *o, const iterator &it, + const iterator &ite, size_type i) + { return reference(linalg_traits::access(o, it.it, ite.it,i)); } + }; + + template + struct linalg_traits > { + typedef part_row_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type vtype; + typedef typename number_traits::magnitude_type value_type; + typedef typename linalg_traits::storage_type storage_type; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_col_iterator; + typedef typename org_type::const_sub_row_type>::t + pre_const_sub_row_type; + typedef typename org_type::sub_row_type>::t pre_sub_row_type; + typedef part_vector + const_sub_row_type; + typedef typename select_ref, PT>::ref_type sub_row_type; + typedef typename linalg_traits::const_row_iterator const_row_iterator; + typedef typename select_ref::row_iterator, PT>::ref_type row_iterator; + typedef typename select_ref< + typename linalg_traits::reference, + typename linalg_traits::reference, + PT>::ref_type reference; + typedef row_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type ncols(const this_type &v) { return v.nc; } + static size_type nrows(const this_type &v) { return v.nr; } + static const_sub_row_type row(const const_row_iterator &it) + { return const_sub_row_type(linalg_traits::row(it)); } + static sub_row_type row(const row_iterator &it) + { return sub_row_type(linalg_traits::row(it)); } + static row_iterator row_begin(this_type &m) { return m.begin_; } + static row_iterator row_end(this_type &m) { return m.end_; } + static const_row_iterator row_begin(const this_type &m) + { return m.begin_; } + static const_row_iterator row_end(const this_type &m) { return m.end_; } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void do_clear(this_type &v); + static value_type access(const const_row_iterator &itrow, size_type i) + { return real_or_imag_part(linalg_traits::access(itrow, i), PART()); } + static reference access(const row_iterator &itrow, size_type i) { + return reference(ref_or_value_type::r( + linalg_traits::access(itrow, i), + PART(), value_type())); + } + }; + + template + struct linalg_traits > { + typedef part_col_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type vtype; + typedef typename number_traits::magnitude_type value_type; + typedef typename linalg_traits::storage_type storage_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_row_iterator; + typedef typename org_type::const_sub_col_type>::t + pre_const_sub_col_type; + typedef typename org_type::sub_col_type>::t pre_sub_col_type; + typedef part_vector + const_sub_col_type; + typedef typename select_ref, PT>::ref_type sub_col_type; + typedef typename linalg_traits::const_col_iterator const_col_iterator; + typedef typename select_ref::col_iterator, PT>::ref_type col_iterator; + typedef typename select_ref< + typename linalg_traits::reference, + typename linalg_traits::reference, + PT>::ref_type reference; + typedef col_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type nrows(const this_type &v) { return v.nr; } + static size_type ncols(const this_type &v) { return v.nc; } + static const_sub_col_type col(const const_col_iterator &it) + { return const_sub_col_type(linalg_traits::col(it)); } + static sub_col_type col(const col_iterator &it) + { return sub_col_type(linalg_traits::col(it)); } + static col_iterator col_begin(this_type &m) { return m.begin_; } + static col_iterator col_end(this_type &m) { return m.end_; } + static const_col_iterator col_begin(const this_type &m) + { return m.begin_; } + static const_col_iterator col_end(const this_type &m) { return m.end_; } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void do_clear(this_type &v); + static value_type access(const const_col_iterator &itcol, size_type i) + { return real_or_imag_part(linalg_traits::access(itcol, i), PART()); } + static reference access(const col_iterator &itcol, size_type i) { + return reference(ref_or_value_type::r( + linalg_traits::access(itcol, i), + PART(), value_type())); + } + }; + + template + void linalg_traits >::do_clear(this_type &v) { + col_iterator it = mat_col_begin(v), ite = mat_col_end(v); + for (; it != ite; ++it) clear(col(it)); + } + + template + void linalg_traits >::do_clear(this_type &v) { + row_iterator it = mat_row_begin(v), ite = mat_row_end(v); + for (; it != ite; ++it) clear(row(it)); + } +} + +#endif // GMM_REAL_PART_H diff --git a/7.x/src/linear_algebra/gmm/gmm_ref.h b/7.x/src/linear_algebra/gmm/gmm_ref.h new file mode 100644 index 0000000..b41fbdd --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_ref.h @@ -0,0 +1,526 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2000-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + + +#ifndef GMM_REF_H__ +#define GMM_REF_H__ + +/** @file gmm_ref.h + @author Yves Renard + @date August 26, 2000. + * @brief Provide some simple pseudo-containers. + * + * WARNING : modifiying the container infirm the validity of references. + */ + + +#include +#include "gmm_except.h" + +namespace gmm { + + /* ********************************************************************* */ + /* Simple reference. */ + /* ********************************************************************* */ + + template class tab_ref { + + protected : + + ITER begin_, end_; + + public : + + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::pointer const_pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::reference const_reference; + typedef typename std::iterator_traits::difference_type + difference_type; + typedef ITER iterator; + typedef ITER const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + + bool empty(void) const { return begin_ == end_; } + size_type size(void) const { return end_ - begin_; } + + const iterator &begin(void) { return begin_; } + const const_iterator &begin(void) const { return begin_; } + const iterator &end(void) { return end_; } + const const_iterator &end(void) const { return end_; } + reverse_iterator rbegin(void) { return reverse_iterator(end()); } + const_reverse_iterator rbegin(void) const + { return const_reverse_iterator(end()); } + reverse_iterator rend(void) { return reverse_iterator(begin()); } + const_reverse_iterator rend(void) const + { return const_reverse_iterator(begin()); } + + reference front(void) { return *begin(); } + const_reference front(void) const { return *begin(); } + reference back(void) { return *(--(end())); } + const_reference back(void) const { return *(--(end())); } + void pop_front(void) { ++begin_; } + + const_reference operator [](size_type ii) const { return *(begin_ + ii);} + reference operator [](size_type ii) { return *(begin_ + ii); } + + tab_ref(void) {} + tab_ref(const ITER &b, const ITER &e) : begin_(b), end_(e) {} + }; + + + /* ********************************************************************* */ + /* Reference with index. */ + /* ********************************************************************* */ + +// template struct tab_ref_index_iterator_ +// : public dynamic_array::const_iterator +// { +// typedef typename std::iterator_traits::value_type value_type; +// typedef typename std::iterator_traits::pointer pointer; +// typedef typename std::iterator_traits::reference reference; +// typedef typename std::iterator_traits::difference_type +// difference_type; +// typedef std::random_access_iterator_tag iterator_category; +// typedef size_t size_type; +// typedef dynamic_array::const_iterator dnas_iterator_; +// typedef tab_ref_index_iterator_ iterator; + + +// ITER piter; + +// iterator operator ++(int) +// { iterator tmp = *this; ++(*((dnas_iterator_ *)(this))); return tmp; } +// iterator operator --(int) +// { iterator tmp = *this; --(*((dnas_iterator_ *)(this))); return tmp; } +// iterator &operator ++() +// { ++(*((dnas_iterator_ *)(this))); return *this; } +// iterator &operator --() +// { --(*((dnas_iterator_ *)(this))); return *this; } +// iterator &operator +=(difference_type i) +// { (*((dnas_iterator_ *)(this))) += i; return *this; } +// iterator &operator -=(difference_type i) +// { (*((dnas_iterator_ *)(this))) -= i; return *this; } +// iterator operator +(difference_type i) const +// { iterator it = *this; return (it += i); } +// iterator operator -(difference_type i) const +// { iterator it = *this; return (it -= i); } +// difference_type operator -(const iterator &i) const +// { return *((dnas_iterator_ *)(this)) - *((dnas_iterator_ *)(&i)); } + +// reference operator *() const +// { return *(piter + *((*((dnas_iterator_ *)(this))))); } +// reference operator [](int ii) +// { return *(piter + *((*((dnas_iterator_ *)(this+ii))))); } + +// bool operator ==(const iterator &i) const +// { +// return ((piter) == ((i.piter)) +// && *((dnas_iterator_ *)(this)) == *((*((dnas_iterator_ *)(this))))); +// } +// bool operator !=(const iterator &i) const +// { return !(i == *this); } +// bool operator < (const iterator &i) const +// { +// return ((piter) == ((i.piter)) +// && *((dnas_iterator_ *)(this)) < *((*((dnas_iterator_ *)(this))))); +// } + +// tab_ref_index_iterator_(void) {} +// tab_ref_index_iterator_(const ITER &iter, const dnas_iterator_ &dnas_iter) +// : dnas_iterator_(dnas_iter), piter(iter) {} +// }; + + +// template class tab_ref_index +// { +// public : + +// typedef typename std::iterator_traits::value_type value_type; +// typedef typename std::iterator_traits::pointer pointer; +// typedef typename std::iterator_traits::pointer const_pointer; +// typedef typename std::iterator_traits::reference reference; +// typedef typename std::iterator_traits::reference const_reference; +// typedef typename std::iterator_traits::difference_type +// difference_type; +// typedef size_t size_type; +// typedef tab_ref_index_iterator_ iterator; +// typedef iterator const_iterator; +// typedef std::reverse_iterator const_reverse_iterator; +// typedef std::reverse_iterator reverse_iterator; + +// protected : + +// ITER begin_; +// dynamic_array index_; + +// public : + +// bool empty(void) const { return index_.empty(); } +// size_type size(void) const { return index_.size(); } + + +// iterator begin(void) { return iterator(begin_, index_.begin()); } +// const_iterator begin(void) const +// { return iterator(begin_, index_.begin()); } +// iterator end(void) { return iterator(begin_, index_.end()); } +// const_iterator end(void) const { return iterator(begin_, index_.end()); } +// reverse_iterator rbegin(void) { return reverse_iterator(end()); } +// const_reverse_iterator rbegin(void) const +// { return const_reverse_iterator(end()); } +// reverse_iterator rend(void) { return reverse_iterator(begin()); } +// const_reverse_iterator rend(void) const +// { return const_reverse_iterator(begin()); } + + +// reference front(void) { return *(begin_ +index_[0]); } +// const_reference front(void) const { return *(begin_ +index_[0]); } +// reference back(void) { return *(--(end())); } +// const_reference back(void) const { return *(--(end())); } + +// tab_ref_index(void) {} +// tab_ref_index(const ITER &b, const dynamic_array &ind) +// { begin_ = b; index_ = ind; } + +// // to be changed in a const_reference ? +// value_type operator [](size_type ii) const +// { return *(begin_ + index_[ii]);} +// reference operator [](size_type ii) { return *(begin_ + index_[ii]); } + +// }; + + + /// iterator over a gmm::tab_ref_index_ref + template + struct tab_ref_index_ref_iterator_ + { + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::difference_type + difference_type; + typedef std::random_access_iterator_tag iterator_category; + typedef tab_ref_index_ref_iterator_ iterator; + typedef size_t size_type; + + ITER piter; + ITER_INDEX iter_index; + + iterator operator ++(int) + { iterator tmp = *this; ++iter_index; return tmp; } + iterator operator --(int) + { iterator tmp = *this; --iter_index; return tmp; } + iterator &operator ++() { ++iter_index; return *this; } + iterator &operator --() { --iter_index; return *this; } + iterator &operator +=(difference_type i) + { iter_index += i; return *this; } + iterator &operator -=(difference_type i) + { iter_index -= i; return *this; } + iterator operator +(difference_type i) const + { iterator it = *this; return (it += i); } + iterator operator -(difference_type i) const + { iterator it = *this; return (it -= i); } + difference_type operator -(const iterator &i) const + { return iter_index - i.iter_index; } + + reference operator *() const + { return *(piter + *iter_index); } + reference operator [](size_type ii) const + { return *(piter + *(iter_index+ii)); } + + bool operator ==(const iterator &i) const + { return ((piter) == ((i.piter)) && iter_index == i.iter_index); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const + { return ((piter) == ((i.piter)) && iter_index < i.iter_index); } + + tab_ref_index_ref_iterator_(void) {} + tab_ref_index_ref_iterator_(const ITER &iter, + const ITER_INDEX &dnas_iter) + : piter(iter), iter_index(dnas_iter) {} + + }; + + /** + convenience template function for quick obtention of a indexed iterator + without having to specify its (long) typename + */ + template + tab_ref_index_ref_iterator_ + index_ref_iterator(ITER it, ITER_INDEX it_i) { + return tab_ref_index_ref_iterator_(it, it_i); + } + + /** indexed array reference (given a container X, and a set of indexes I, + this class provides a pseudo-container Y such that + @code Y[i] = X[I[i]] @endcode + */ + template class tab_ref_index_ref { + public : + + typedef std::iterator_traits traits_type; + typedef typename traits_type::value_type value_type; + typedef typename traits_type::pointer pointer; + typedef typename traits_type::pointer const_pointer; + typedef typename traits_type::reference reference; + typedef typename traits_type::reference const_reference; + typedef typename traits_type::difference_type difference_type; + typedef size_t size_type; + typedef tab_ref_index_ref_iterator_ iterator; + typedef iterator const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + + protected : + + ITER begin_; + ITER_INDEX index_begin_, index_end_; + + public : + + bool empty(void) const { return index_begin_ == index_end_; } + size_type size(void) const { return index_end_ - index_begin_; } + + iterator begin(void) { return iterator(begin_, index_begin_); } + const_iterator begin(void) const + { return iterator(begin_, index_begin_); } + iterator end(void) { return iterator(begin_, index_end_); } + const_iterator end(void) const { return iterator(begin_, index_end_); } + reverse_iterator rbegin(void) { return reverse_iterator(end()); } + const_reverse_iterator rbegin(void) const + { return const_reverse_iterator(end()); } + reverse_iterator rend(void) { return reverse_iterator(begin()); } + const_reverse_iterator rend(void) const + { return const_reverse_iterator(begin()); } + + reference front(void) { return *(begin_ + *index_begin_); } + const_reference front(void) const { return *(begin_ + *index_begin_); } + reference back(void) { return *(--(end())); } + const_reference back(void) const { return *(--(end())); } + void pop_front(void) { ++index_begin_; } + + tab_ref_index_ref(void) {} + tab_ref_index_ref(const ITER &b, const ITER_INDEX &bi, + const ITER_INDEX &ei) + : begin_(b), index_begin_(bi), index_end_(ei) {} + + // to be changed in a const_reference ? + const_reference operator [](size_type ii) const + { return *(begin_ + index_begin_[ii]);} + reference operator [](size_type ii) + { return *(begin_ + index_begin_[ii]); } + + }; + + + /* ********************************************************************* */ + /* Reference on regularly spaced elements. */ + /* ********************************************************************* */ + + template struct tab_ref_reg_spaced_iterator_ { + + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::difference_type + difference_type; + typedef typename std::iterator_traits::iterator_category + iterator_category; + typedef size_t size_type; + typedef tab_ref_reg_spaced_iterator_ iterator; + + ITER it; + size_type N, i; + + iterator operator ++(int) { iterator tmp = *this; i++; return tmp; } + iterator operator --(int) { iterator tmp = *this; i--; return tmp; } + iterator &operator ++() { i++; return *this; } + iterator &operator --() { i--; return *this; } + iterator &operator +=(difference_type ii) { i+=ii; return *this; } + iterator &operator -=(difference_type ii) { i-=ii; return *this; } + iterator operator +(difference_type ii) const + { iterator itt = *this; return (itt += ii); } + iterator operator -(difference_type ii) const + { iterator itt = *this; return (itt -= ii); } + difference_type operator -(const iterator &ii) const + { return (N ? (it - ii.it) / N : 0) + i - ii.i; } + + reference operator *() const { return *(it + i*N); } + reference operator [](size_type ii) const { return *(it + (i+ii)*N); } + + bool operator ==(const iterator &ii) const + { return (*this - ii) == difference_type(0); } + bool operator !=(const iterator &ii) const + { return (*this - ii) != difference_type(0); } + bool operator < (const iterator &ii) const + { return (*this - ii) < difference_type(0); } + + tab_ref_reg_spaced_iterator_(void) {} + tab_ref_reg_spaced_iterator_(const ITER &iter, size_type n, size_type ii) + : it(iter), N(n), i(ii) { } + + }; + + /** + convenience template function for quick obtention of a strided iterator + without having to specify its (long) typename + */ + template tab_ref_reg_spaced_iterator_ + reg_spaced_iterator(ITER it, size_t stride) { + return tab_ref_reg_spaced_iterator_(it, stride); + } + + /** + provide a "strided" view a of container + */ + template class tab_ref_reg_spaced { + public : + + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::pointer const_pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::reference const_reference; + typedef typename std::iterator_traits::difference_type + difference_type; + typedef size_t size_type; + typedef tab_ref_reg_spaced_iterator_ iterator; + typedef iterator const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + + protected : + + ITER begin_; + size_type N, size_; + + public : + + bool empty(void) const { return size_ == 0; } + size_type size(void) const { return size_; } + + iterator begin(void) { return iterator(begin_, N, 0); } + const_iterator begin(void) const { return iterator(begin_, N, 0); } + iterator end(void) { return iterator(begin_, N, size_); } + const_iterator end(void) const { return iterator(begin_, N, size_); } + reverse_iterator rbegin(void) { return reverse_iterator(end()); } + const_reverse_iterator rbegin(void) const + { return const_reverse_iterator(end()); } + reverse_iterator rend(void) { return reverse_iterator(begin()); } + const_reverse_iterator rend(void) const + { return const_reverse_iterator(begin()); } + + reference front(void) { return *begin_; } + const_reference front(void) const { return *begin_; } + reference back(void) { return *(begin_ + N * (size_-1)); } + const_reference back(void) const { return *(begin_ + N * (size_-1)); } + void pop_front(void) { begin_ += N; } + + tab_ref_reg_spaced(void) {} + tab_ref_reg_spaced(const ITER &b, size_type n, size_type s) + : begin_(b), N(n), size_(s) {} + + + const_reference operator [](size_type ii) const + { return *(begin_ + ii * N);} + reference operator [](size_type ii) { return *(begin_ + ii * N); } + + }; + + /// iterator over a tab_ref_with_selection + template + struct tab_ref_with_selection_iterator_ : public ITER { + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::difference_type + difference_type; + typedef std::forward_iterator_tag iterator_category; + typedef tab_ref_with_selection_iterator_ iterator; + const COND cond; + + void forward(void) { while (!(cond)(*this)) ITER::operator ++(); } + iterator &operator ++() + { ITER::operator ++(); forward(); return *this; } + iterator operator ++(int) + { iterator tmp = *this; ++(*this); return tmp; } + + tab_ref_with_selection_iterator_(void) {} + tab_ref_with_selection_iterator_(const ITER &iter, const COND c) + : ITER(iter), cond(c) {} + + }; + + /** + given a container X and a predicate P, provide pseudo-container Y + of all elements of X such that P(X[i]). + */ + template class tab_ref_with_selection { + + protected : + + ITER begin_, end_; + COND cond; + + public : + + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::pointer const_pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::reference const_reference; + typedef size_t size_type; + typedef tab_ref_with_selection_iterator_ iterator; + typedef iterator const_iterator; + + iterator begin(void) const + { iterator it(begin_, cond); it.forward(); return it; } + iterator end(void) const { return iterator(end_, cond); } + bool empty(void) const { return begin_ == end_; } + + value_type front(void) const { return *begin(); } + void pop_front(void) { ++begin_; begin_ = begin(); } + + COND &condition(void) { return cond; } + const COND &condition(void) const { return cond; } + + tab_ref_with_selection(void) {} + tab_ref_with_selection(const ITER &b, const ITER &e, const COND &c) + : begin_(b), end_(e), cond(c) { begin_ = begin(); } + + }; + +} + +#endif /* GMM_REF_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_scaled.h b/7.x/src/linear_algebra/gmm/gmm_scaled.h new file mode 100644 index 0000000..0d7d563 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_scaled.h @@ -0,0 +1,434 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_scaled.h + @author Yves Renard + @date November 10, 2002. + @brief get a scaled view of a vector/matrix. +*/ +#ifndef GMM_SCALED_H__ +#define GMM_SCALED_H__ + +#include "gmm_def.h" + +namespace gmm { + + /* ********************************************************************* */ + /* Scaled references on vectors */ + /* ********************************************************************* */ + + template struct scaled_const_iterator { + typedef typename strongest_numeric_type::value_type, + S>::T value_type; + + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::difference_type difference_type; + typedef typename std::iterator_traits::iterator_category + iterator_category; + + IT it; + S r; + + scaled_const_iterator(void) {} + scaled_const_iterator(const IT &i, S x) : it(i), r(x) {} + + inline size_type index(void) const { return it.index(); } + inline scaled_const_iterator operator ++(int) + { scaled_const_iterator tmp = *this; ++it; return tmp; } + inline scaled_const_iterator operator --(int) + { scaled_const_iterator tmp = *this; --it; return tmp; } + inline scaled_const_iterator &operator ++() { ++it; return *this; } + inline scaled_const_iterator &operator --() { --it; return *this; } + inline scaled_const_iterator &operator +=(difference_type i) + { it += i; return *this; } + inline scaled_const_iterator &operator -=(difference_type i) + { it -= i; return *this; } + inline scaled_const_iterator operator +(difference_type i) const + { scaled_const_iterator itb = *this; return (itb += i); } + inline scaled_const_iterator operator -(difference_type i) const + { scaled_const_iterator itb = *this; return (itb -= i); } + inline difference_type operator -(const scaled_const_iterator &i) const + { return difference_type(it - i.it); } + + inline value_type operator *() const { return (*it) * value_type(r); } + inline value_type operator [](size_type ii) const { return it[ii] * r; } + + inline bool operator ==(const scaled_const_iterator &i) const + { return (i.it == it); } + inline bool operator !=(const scaled_const_iterator &i) const + { return (i.it != it); } + inline bool operator < (const scaled_const_iterator &i) const + { return (it < i.it); } + }; + + template struct scaled_vector_const_ref { + typedef scaled_vector_const_ref this_type; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::const_iterator iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::origin_type origin_type; + + iterator begin_, end_; + const origin_type *origin; + size_type size_; + S r; + + scaled_vector_const_ref(const V &v, S rr) + : begin_(vect_const_begin(v)), end_(vect_const_end(v)), + origin(linalg_origin(v)), size_(vect_size(v)), r(rr) {} + + reference operator[](size_type i) const + { return value_type(r) * linalg_traits::access(origin, begin_, end_, i); } + }; + + + template std::ostream &operator << + (std::ostream &o, const scaled_vector_const_ref& m) + { gmm::write(o,m); return o; } + + /* ********************************************************************* */ + /* Scaled references on matrices */ + /* ********************************************************************* */ + + template struct scaled_row_const_iterator { + typedef scaled_row_const_iterator iterator; + typedef typename linalg_traits::const_row_iterator ITER; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + + ITER it; + S r; + + inline iterator operator ++(int) { iterator tmp=*this; it++; return tmp; } + inline iterator operator --(int) { iterator tmp=*this; it--; return tmp; } + inline iterator &operator ++() { it++; return *this; } + inline iterator &operator --() { it--; return *this; } + iterator &operator +=(difference_type i) { it += i; return *this; } + iterator &operator -=(difference_type i) { it -= i; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const + { return it - i.it; } + + inline ITER operator *() const { return it; } + inline ITER operator [](int i) { return it + i; } + + inline bool operator ==(const iterator &i) const { return (it == i.it); } + inline bool operator !=(const iterator &i) const { return !(i == *this); } + inline bool operator < (const iterator &i) const { return (it < i.it); } + + scaled_row_const_iterator(void) {} + scaled_row_const_iterator(const ITER &i, S rr) + : it(i), r(rr) { } + + }; + + template struct scaled_row_matrix_const_ref { + + typedef scaled_row_matrix_const_ref this_type; + typedef typename linalg_traits::const_row_iterator iterator; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::origin_type origin_type; + + iterator begin_, end_; + const origin_type *origin; + S r; + size_type nr, nc; + + scaled_row_matrix_const_ref(const M &m, S rr) + : begin_(mat_row_begin(m)), end_(mat_row_end(m)), + origin(linalg_origin(m)), r(rr), nr(mat_nrows(m)), nc(mat_ncols(m)) {} + + value_type operator()(size_type i, size_type j) const + { return r * linalg_traits::access(begin_+i, j); } + }; + + + template std::ostream &operator << + (std::ostream &o, const scaled_row_matrix_const_ref& m) + { gmm::write(o,m); return o; } + + + template struct scaled_col_const_iterator { + typedef scaled_col_const_iterator iterator; + typedef typename linalg_traits::const_col_iterator ITER; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + + ITER it; + S r; + + iterator operator ++(int) { iterator tmp = *this; it++; return tmp; } + iterator operator --(int) { iterator tmp = *this; it--; return tmp; } + iterator &operator ++() { it++; return *this; } + iterator &operator --() { it--; return *this; } + iterator &operator +=(difference_type i) { it += i; return *this; } + iterator &operator -=(difference_type i) { it -= i; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const + { return it - i.it; } + + ITER operator *() const { return it; } + ITER operator [](int i) { return it + i; } + + bool operator ==(const iterator &i) const { return (it == i.it); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (it < i.it); } + + scaled_col_const_iterator(void) {} + scaled_col_const_iterator(const ITER &i, S rr) + : it(i), r(rr) { } + + }; + + template struct scaled_col_matrix_const_ref { + + typedef scaled_col_matrix_const_ref this_type; + typedef typename linalg_traits::const_col_iterator iterator; + typedef typename linalg_traits::value_type value_type; + typedef typename linalg_traits::origin_type origin_type; + + iterator begin_, end_; + const origin_type *origin; + S r; + size_type nr, nc; + + scaled_col_matrix_const_ref(const M &m, S rr) + : begin_(mat_col_begin(m)), end_(mat_col_end(m)), + origin(linalg_origin(m)), r(rr), nr(mat_nrows(m)), nc(mat_ncols(m)) {} + + value_type operator()(size_type i, size_type j) const + { return r * linalg_traits::access(begin_+j, i); } + }; + + + + template std::ostream &operator << + (std::ostream &o, const scaled_col_matrix_const_ref& m) + { gmm::write(o,m); return o; } + + + template struct scaled_return__ { + typedef abstract_null_type return_type; + }; + template struct scaled_return__ + { typedef scaled_row_matrix_const_ref return_type; }; + template struct scaled_return__ + { typedef scaled_col_matrix_const_ref return_type; }; + + + template struct scaled_return_ { + typedef abstract_null_type return_type; + }; + template struct scaled_return_ + { typedef scaled_vector_const_ref return_type; }; + template struct scaled_return_ { + typedef typename scaled_return__::sub_orientation>::potype>::return_type return_type; + }; + + template struct scaled_return { + typedef typename scaled_return_::linalg_type>::return_type return_type; + }; + + template inline + typename scaled_return::return_type + scaled(const L &v, S x) + { return scaled(v, x, typename linalg_traits::linalg_type()); } + + template inline + typename scaled_return::return_type + scaled(const V &v, S x, abstract_vector) + { return scaled_vector_const_ref(v, x); } + + template inline + typename scaled_return::return_type + scaled(const M &m, S x,abstract_matrix) { + return scaled(m, x, typename principal_orientation_type::sub_orientation>::potype()); + } + + template inline + typename scaled_return::return_type + scaled(const M &m, S x, row_major) { + return scaled_row_matrix_const_ref(m, x); + } + + template inline + typename scaled_return::return_type + scaled(const M &m, S x, col_major) { + return scaled_col_matrix_const_ref(m, x); + } + + + /* ******************************************************************** */ + /* matrix or vector scale */ + /* ******************************************************************** */ + + template inline + void scale(L& l, typename linalg_traits::value_type a) + { scale(l, a, typename linalg_traits::linalg_type()); } + + template inline + void scale(const L& l, typename linalg_traits::value_type a) + { scale(linalg_const_cast(l), a); } + + template inline + void scale(L& l, typename linalg_traits::value_type a, abstract_vector) { + typename linalg_traits::iterator it = vect_begin(l), ite = vect_end(l); + for ( ; it != ite; ++it) *it *= a; + } + + template + void scale(L& l, typename linalg_traits::value_type a, abstract_matrix) { + scale(l, a, typename principal_orientation_type::sub_orientation>::potype()); + } + + template + void scale(L& l, typename linalg_traits::value_type a, row_major) { + typename linalg_traits::row_iterator it = mat_row_begin(l), + ite = mat_row_end(l); + for ( ; it != ite; ++it) scale(linalg_traits::row(it), a); + } + + template + void scale(L& l, typename linalg_traits::value_type a, col_major) { + typename linalg_traits::col_iterator it = mat_col_begin(l), + ite = mat_col_end(l); + for ( ; it != ite; ++it) scale(linalg_traits::col(it), a); + } + + template struct linalg_traits > { + typedef scaled_vector_const_ref this_type; + typedef linalg_const is_reference; + typedef abstract_vector linalg_type; + typedef typename strongest_numeric_type::value_type>::T value_type; + typedef typename linalg_traits::origin_type origin_type; + typedef value_type reference; + typedef abstract_null_type iterator; + typedef scaled_const_iterator::const_iterator, S> + const_iterator; + typedef typename linalg_traits::storage_type storage_type; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type size(const this_type &v) { return v.size_; } + static const_iterator begin(const this_type &v) + { return const_iterator(v.begin_, v.r); } + static const_iterator end(const this_type &v) + { return const_iterator(v.end_, v.r); } + static const origin_type* origin(const this_type &v) { return v.origin; } + static value_type access(const origin_type *o, const const_iterator &it, + const const_iterator &ite, size_type i) + { return it.r * (linalg_traits::access(o, it.it, ite.it, i)); } + + }; + + + template struct linalg_traits > { + typedef scaled_row_matrix_const_ref this_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::origin_type origin_type; + typedef typename strongest_numeric_type::value_type>::T value_type; + typedef value_type reference; + typedef typename linalg_traits::storage_type storage_type; + typedef typename org_type::const_sub_row_type>::t vector_type; + typedef scaled_vector_const_ref sub_row_type; + typedef scaled_vector_const_ref const_sub_row_type; + typedef scaled_row_const_iterator row_iterator; + typedef scaled_row_const_iterator const_row_iterator; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_col_iterator; + typedef abstract_null_type col_iterator; + typedef row_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type nrows(const this_type &m) + { return m.nr; } + static size_type ncols(const this_type &m) + { return m.nc; } + static const_sub_row_type row(const const_row_iterator &it) + { return scaled(linalg_traits::row(it.it), it.r); } + static const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(m.begin_, m.r); } + static const_row_iterator row_end(const this_type &m) + { return const_row_iterator(m.end_, m.r); } + static const origin_type* origin(const this_type &m) { return m.origin; } + static value_type access(const const_row_iterator &it, size_type i) + { return it.r * (linalg_traits::access(it.it, i)); } + }; + + template struct linalg_traits > { + typedef scaled_col_matrix_const_ref this_type; + typedef linalg_const is_reference; + typedef abstract_matrix linalg_type; + typedef typename strongest_numeric_type::value_type>::T value_type; + typedef typename linalg_traits::origin_type origin_type; + typedef value_type reference; + typedef typename linalg_traits::storage_type storage_type; + typedef typename org_type::const_sub_col_type>::t vector_type; + typedef abstract_null_type sub_col_type; + typedef scaled_vector_const_ref const_sub_col_type; + typedef abstract_null_type col_iterator; + typedef scaled_col_const_iterator const_col_iterator; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_row_iterator; + typedef abstract_null_type row_iterator; + typedef col_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type ncols(const this_type &m) + { return m.nc; } + static size_type nrows(const this_type &m) + { return m.nr; } + static const_sub_col_type col(const const_col_iterator &it) + { return scaled(linalg_traits::col(it.it), it.r); } + static const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(m.begin_, m.r); } + static const_col_iterator col_end(const this_type &m) + { return const_col_iterator(m.end_, m.r); } + static const origin_type* origin(const this_type &m) { return m.origin; } + static value_type access(const const_col_iterator &it, size_type i) + { return it.r * (linalg_traits::access(it.it, i)); } + }; + + +} + +#endif // GMM_SCALED_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_Schwarz_additive.h b/7.x/src/linear_algebra/gmm/gmm_solver_Schwarz_additive.h new file mode 100644 index 0000000..5585e02 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_Schwarz_additive.h @@ -0,0 +1,805 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_solver_Schwarz_additive.h + @author Yves Renard + @author Michel Fournie + @date October 13, 2002. +*/ + +#ifndef GMM_SOLVERS_SCHWARZ_ADDITIVE_H__ +#define GMM_SOLVERS_SCHWARZ_ADDITIVE_H__ + +#include "gmm_kernel.h" +#include "gmm_superlu_interface.h" +#include "gmm_solver_cg.h" +#include "gmm_solver_gmres.h" +#include "gmm_solver_bicgstab.h" +#include "gmm_solver_qmr.h" + +namespace gmm { + + /* ******************************************************************** */ + /* Additive Schwarz interfaced local solvers */ + /* ******************************************************************** */ + + struct using_cg {}; + struct using_gmres {}; + struct using_bicgstab {}; + struct using_qmr {}; + + template + struct actual_precond { + typedef P APrecond; + static const APrecond &transform(const P &PP) { return PP; } + }; + + template + void AS_local_solve(using_cg, const Matrix1 &A, Vector &x, const Vector &b, + const Precond &P, iteration &iter) + { cg(A, x, b, P, iter); } + + template + void AS_local_solve(using_gmres, const Matrix1 &A, Vector &x, + const Vector &b, const Precond &P, iteration &iter) + { gmres(A, x, b, P, 100, iter); } + + template + void AS_local_solve(using_bicgstab, const Matrix1 &A, Vector &x, + const Vector &b, const Precond &P, iteration &iter) + { bicgstab(A, x, b, P, iter); } + + template + void AS_local_solve(using_qmr, const Matrix1 &A, Vector &x, + const Vector &b, const Precond &P, iteration &iter) + { qmr(A, x, b, P, iter); } + +#if defined(GMM_USES_SUPERLU) + struct using_superlu {}; + + template + struct actual_precond { + typedef typename linalg_traits::value_type value_type; + typedef SuperLU_factor APrecond; + template + static APrecond transform(const PR &) { return APrecond(); } + static const APrecond &transform(const APrecond &PP) { return PP; } + }; + + template + void AS_local_solve(using_superlu, const Matrix1 &, Vector &x, + const Vector &b, const Precond &P, iteration &iter) + { P.solve(x, b); iter.set_iteration(1); } +#endif + + /* ******************************************************************** */ + /* Additive Schwarz Linear system */ + /* ******************************************************************** */ + + template + struct add_schwarz_mat{ + typedef typename linalg_traits::value_type value_type; + + const Matrix1 *A; + const std::vector *vB; + std::vector vAloc; + mutable iteration iter; + double residual; + mutable size_type itebilan; + mutable std::vector > gi, fi; + std::vector::APrecond> precond1; + + void init(const Matrix1 &A_, const std::vector &vB_, + iteration iter_, const Precond &P, double residual_); + + add_schwarz_mat(void) {} + add_schwarz_mat(const Matrix1 &A_, const std::vector &vB_, + iteration iter_, const Precond &P, double residual_) + { init(A_, vB_, iter_, P, residual_); } + }; + + template + void add_schwarz_mat::init( + const Matrix1 &A_, const std::vector &vB_, + iteration iter_, const Precond &P, double residual_) { + + vB = &vB_; A = &A_; iter = iter_; + residual = residual_; + + size_type nb_sub = vB->size(); + vAloc.resize(nb_sub); + gi.resize(nb_sub); fi.resize(nb_sub); + precond1.resize(nb_sub); + std::fill(precond1.begin(), precond1.end(), + actual_precond::transform(P)); + itebilan = 0; + + if (iter.get_noisy()) cout << "Init pour sub dom "; +#ifdef GMM_USES_MPI + int size,tranche,borne_sup,borne_inf,rank,tag1=11,tag2=12,tag3=13,sizepr = 0; + // int tab[4]; + double t_ref,t_final; + MPI_Status status; + t_ref=MPI_Wtime(); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &size); + tranche=nb_sub/size; + borne_inf=rank*tranche; + borne_sup=(rank+1)*tranche; + // if (rank==size-1) borne_sup = nb_sub; + + cout << "Nombre de sous domaines " << borne_sup - borne_inf << endl; + + int sizeA = mat_nrows(*A); + gmm::csr_matrix Acsr(sizeA, sizeA), Acsrtemp(sizeA, sizeA); + gmm::copy(gmm::eff_matrix(*A), Acsr); + int next = (rank + 1) % size; + int previous = (rank + size - 1) % size; + //communication of local information on ring pattern + //Each process receive Nproc-1 contributions + + for (int nproc = 0; nproc < size; ++nproc) { + for (size_type i = size_type(borne_inf); i < size_type(borne_sup); ++i) { +// for (size_type i = 0; i < nb_sub/size; ++i) { +// for (size_type i = 0; i < nb_sub; ++i) { + // size_type i=(rank+size*(j-1)+nb_sub)%nb_sub; + + cout << "Sous domaines " << i << " : " << mat_ncols((*vB)[i]) << endl; +#else + for (size_type i = 0; i < nb_sub; ++i) { +#endif + + if (iter.get_noisy()) cout << i << " " << std::flush; + Matrix2 Maux(mat_ncols((*vB)[i]), mat_nrows((*vB)[i])); + +#ifdef GMM_USES_MPI + Matrix2 Maux2(mat_ncols((*vB)[i]), mat_ncols((*vB)[i])); + if (nproc == 0) { + gmm::resize(vAloc[i], mat_ncols((*vB)[i]), mat_ncols((*vB)[i])); + gmm::clear(vAloc[i]); + } + gmm::mult(gmm::transposed((*vB)[i]), Acsr, Maux); + gmm::mult(Maux, (*vB)[i], Maux2); + gmm::add(Maux2, vAloc[i]); +#else + gmm::resize(vAloc[i], mat_ncols((*vB)[i]), mat_ncols((*vB)[i])); + gmm::mult(gmm::transposed((*vB)[i]), *A, Maux); + gmm::mult(Maux, (*vB)[i], vAloc[i]); +#endif + +#ifdef GMM_USES_MPI + if (nproc == size - 1 ) { +#endif + precond1[i].build_with(vAloc[i]); + gmm::resize(fi[i], mat_ncols((*vB)[i])); + gmm::resize(gi[i], mat_ncols((*vB)[i])); +#ifdef GMM_USES_MPI + } +#else + } +#endif +#ifdef GMM_USES_MPI + } + if (nproc != size - 1) { + MPI_Sendrecv(&(Acsr.jc[0]), sizeA+1, MPI_INT, next, tag2, + &(Acsrtemp.jc[0]), sizeA+1, MPI_INT, previous, tag2, + MPI_COMM_WORLD, &status); + if (Acsrtemp.jc[sizeA] > size_type(sizepr)) { + sizepr = Acsrtemp.jc[sizeA]; + gmm::resize(Acsrtemp.pr, sizepr); + gmm::resize(Acsrtemp.ir, sizepr); + } + MPI_Sendrecv(&(Acsr.ir[0]), Acsr.jc[sizeA], MPI_INT, next, tag1, + &(Acsrtemp.ir[0]), Acsrtemp.jc[sizeA], MPI_INT, previous, tag1, + MPI_COMM_WORLD, &status); + + MPI_Sendrecv(&(Acsr.pr[0]), Acsr.jc[sizeA], mpi_type(value_type()), next, tag3, + &(Acsrtemp.pr[0]), Acsrtemp.jc[sizeA], mpi_type(value_type()), previous, tag3, + MPI_COMM_WORLD, &status); + gmm::copy(Acsrtemp, Acsr); + } + } + t_final=MPI_Wtime(); + cout<<"temps boucle precond "<< t_final-t_ref< + void mult(const add_schwarz_mat &M, + const Vector2 &p, Vector3 &q) { + size_type itebilan = 0; +#ifdef GMM_USES_MPI + static double tmult_tot = 0.0; + double t_ref = MPI_Wtime(); +#endif + // cout << "tmult AS begin " << endl; + mult(*(M.A), p, q); +#ifdef GMM_USES_MPI + tmult_tot += MPI_Wtime()-t_ref; + cout << "tmult_tot = " << tmult_tot << endl; +#endif + std::vector qbis(gmm::vect_size(q)); + std::vector qter(gmm::vect_size(q)); +#ifdef GMM_USES_MPI + // MPI_Status status; + // MPI_Request request,request1; + // int tag=111; + int size,tranche,borne_sup,borne_inf,rank; + size_type nb_sub=M.fi.size(); + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &size); + tranche=nb_sub/size; + borne_inf=rank*tranche; + borne_sup=(rank+1)*tranche; + // if (rank==size-1) borne_sup=nb_sub; + // int next = (rank + 1) % size; + // int previous = (rank + size - 1) % size; + t_ref = MPI_Wtime(); + for (size_type i = size_type(borne_inf); i < size_type(borne_sup); ++i) +// for (size_type i = 0; i < nb_sub/size; ++i) + // for (size_type j = 0; j < nb_sub; ++j) +#else + for (size_type i = 0; i < M.fi.size(); ++i) +#endif + { +#ifdef GMM_USES_MPI + // size_type i=j; // (rank+size*(j-1)+nb_sub)%nb_sub; +#endif + gmm::mult(gmm::transposed((*(M.vB))[i]), q, M.fi[i]); + M.iter.init(); + AS_local_solve(local_solver(), (M.vAloc)[i], (M.gi)[i], + (M.fi)[i],(M.precond1)[i],M.iter); + itebilan = std::max(itebilan, M.iter.get_iteration()); + } + +#ifdef GMM_USES_MPI + cout << "First AS loop time " << MPI_Wtime() - t_ref << endl; +#endif + + gmm::clear(q); +#ifdef GMM_USES_MPI + t_ref = MPI_Wtime(); + // for (size_type j = 0; j < nb_sub; ++j) + for (size_type i = size_type(borne_inf); i < size_type(borne_sup); ++i) + +#else + for (size_type i = 0; i < M.gi.size(); ++i) +#endif + { + +#ifdef GMM_USES_MPI + // size_type i=j; // (rank+size*(j-1)+nb_sub)%nb_sub; +// gmm::mult((*(M.vB))[i], M.gi[i], qbis,qbis); + gmm::mult((*(M.vB))[i], M.gi[i], qter); + add(qter,qbis,qbis); +#else + gmm::mult((*(M.vB))[i], M.gi[i], q, q); +#endif + } +#ifdef GMM_USES_MPI + //WARNING this add only if you use the ring pattern below + // need to do this below if using a n explicit ring pattern communication + +// add(qbis,q,q); + cout << "Second AS loop time " << MPI_Wtime() - t_ref << endl; +#endif + + +#ifdef GMM_USES_MPI + // int tag1=11; + static double t_tot = 0.0; + double t_final; + t_ref=MPI_Wtime(); +// int next = (rank + 1) % size; +// int previous = (rank + size - 1) % size; + //communication of local information on ring pattern + //Each process receive Nproc-1 contributions + +// if (size > 1) { +// for (int nproc = 0; nproc < size-1; ++nproc) +// { + +// MPI_Sendrecv(&(qbis[0]), gmm::vect_size(q), MPI_DOUBLE, next, tag1, +// &(qter[0]), gmm::vect_size(q),MPI_DOUBLE,previous,tag1, +// MPI_COMM_WORLD,&status); +// gmm::copy(qter, qbis); +// add(qbis,q,q); +// } +// } + MPI_Allreduce(&(qbis[0]), &(q[0]),gmm::vect_size(q), MPI_DOUBLE, + MPI_SUM,MPI_COMM_WORLD); + t_final=MPI_Wtime(); + t_tot += t_final-t_ref; + cout<<"["<< rank<<"] temps reduce Resol "<< t_final-t_ref << " t_tot = " << t_tot << endl; +#endif + + if (M.iter.get_noisy() > 0) cout << "itebloc = " << itebilan << endl; + M.itebilan += itebilan; + M.iter.set_resmax((M.iter.get_resmax() + M.residual) * 0.5); + } + + template + void mult(const add_schwarz_mat &M, + const Vector2 &p, const Vector3 &q) { + mult(M, p, const_cast(q)); + } + + template + void mult(const add_schwarz_mat &M, + const Vector2 &p, const Vector3 &p2, Vector4 &q) + { mult(M, p, q); add(p2, q); } + + template + void mult(const add_schwarz_mat &M, + const Vector2 &p, const Vector3 &p2, const Vector4 &q) + { mult(M, p, const_cast(q)); add(p2, q); } + + /* ******************************************************************** */ + /* Additive Schwarz interfaced global solvers */ + /* ******************************************************************** */ + + template + void AS_global_solve(using_cg, const ASM_type &ASM, Vect &x, + const Vect &b, iteration &iter) + { cg(ASM, x, b, *(ASM.A), identity_matrix(), iter); } + + template + void AS_global_solve(using_gmres, const ASM_type &ASM, Vect &x, + const Vect &b, iteration &iter) + { gmres(ASM, x, b, identity_matrix(), 100, iter); } + + template + void AS_global_solve(using_bicgstab, const ASM_type &ASM, Vect &x, + const Vect &b, iteration &iter) + { bicgstab(ASM, x, b, identity_matrix(), iter); } + + template + void AS_global_solve(using_qmr,const ASM_type &ASM, Vect &x, + const Vect &b, iteration &iter) + { qmr(ASM, x, b, identity_matrix(), iter); } + +#if defined(GMM_USES_SUPERLU) + template + void AS_global_solve(using_superlu, const ASM_type &, Vect &, + const Vect &, iteration &) { + GMM_ASSERT1(false, "You cannot use SuperLU as " + "global solver in additive Schwarz meethod"); + } +#endif + + /* ******************************************************************** */ + /* Linear Additive Schwarz method */ + /* ******************************************************************** */ + /* ref : Domain decomposition algorithms for the p-version finite */ + /* element method for elliptic problems, Luca F. Pavarino, */ + /* PhD thesis, Courant Institute of Mathematical Sciences, 1992. */ + /* ******************************************************************** */ + + /** Function to call if the ASM matrix is precomputed for successive solve + * with the same system. + */ + template + void additive_schwarz( + add_schwarz_mat &ASM, Vector3 &u, + const Vector2 &f, iteration &iter, const global_solver&) { + + typedef typename linalg_traits::value_type value_type; + + size_type nb_sub = ASM.vB->size(), nb_dof = gmm::vect_size(f); + ASM.itebilan = 0; + std::vector g(nb_dof); + std::vector gbis(nb_dof); +#ifdef GMM_USES_MPI + double t_init=MPI_Wtime(); + int size,tranche,borne_sup,borne_inf,rank; + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &size); + tranche=nb_sub/size; + borne_inf=rank*tranche; + borne_sup=(rank+1)*tranche; + // if (rank==size-1) borne_sup=nb_sub*size; + for (size_type i = size_type(borne_inf); i < size_type(borne_sup); ++i) +// for (size_type i = 0; i < nb_sub/size; ++i) + // for (size_type j = 0; j < nb_sub; ++j) + // for (size_type i = rank; i < nb_sub; i+=size) +#else + for (size_type i = 0; i < nb_sub; ++i) +#endif + { + +#ifdef GMM_USES_MPI + // size_type i=j; // (rank+size*(j-1)+nb_sub)%nb_sub; +#endif + gmm::mult(gmm::transposed((*(ASM.vB))[i]), f, ASM.fi[i]); + ASM.iter.init(); + AS_local_solve(local_solver(), ASM.vAloc[i], ASM.gi[i], ASM.fi[i], + ASM.precond1[i], ASM.iter); + ASM.itebilan = std::max(ASM.itebilan, ASM.iter.get_iteration()); +#ifdef GMM_USES_MPI + gmm::mult((*(ASM.vB))[i], ASM.gi[i], gbis,gbis); +#else + gmm::mult((*(ASM.vB))[i], ASM.gi[i], g, g); +#endif + } +#ifdef GMM_USES_MPI + cout<<"temps boucle init "<< MPI_Wtime()-t_init< + void additive_schwarz(const Matrix1 &A, Vector3 &u, + const Vector2 &f, const Precond &P, + const std::vector &vB, + iteration &iter, local_solver, + global_solver) { + iter.set_rhsnorm(vect_norm2(f)); + if (iter.get_rhsnorm() == 0.0) { gmm::clear(u); return; } + iteration iter2 = iter; iter2.reduce_noisy(); + iter2.set_maxiter(size_type(-1)); + add_schwarz_mat + ASM(A, vB, iter2, P, iter.get_resmax()); + additive_schwarz(ASM, u, f, iter, global_solver()); + } + + /* ******************************************************************** */ + /* Sequential Non-Linear Additive Schwarz method */ + /* ******************************************************************** */ + /* ref : Nonlinearly Preconditionned Inexact Newton Algorithms, */ + /* Xiao-Chuan Cai, David E. Keyes, */ + /* SIAM J. Sci. Comp. 24: p183-200. l */ + /* ******************************************************************** */ + + template + class NewtonAS_struct { + + public : + typedef Matrixt tangent_matrix_type; + typedef MatrixBi B_matrix_type; + typedef typename linalg_traits::value_type value_type; + typedef std::vector Vector; + + virtual size_type size(void) = 0; + virtual const std::vector &get_vB() = 0; + + virtual void compute_F(Vector &f, Vector &x) = 0; + virtual void compute_tangent_matrix(Matrixt &M, Vector &x) = 0; + // compute Bi^T grad(F(X)) Bi + virtual void compute_sub_tangent_matrix(Matrixt &Mloc, Vector &x, + size_type i) = 0; + // compute Bi^T F(X) + virtual void compute_sub_F(Vector &fi, Vector &x, size_type i) = 0; + + virtual ~NewtonAS_struct() {} + }; + + template + struct AS_exact_gradient { + const std::vector &vB; + std::vector vM; + std::vector vMloc; + + void init(void) { + for (size_type i = 0; i < vB.size(); ++i) { + Matrixt aux(gmm::mat_ncols(vB[i]), gmm::mat_ncols(vM[i])); + gmm::resize(vMloc[i], gmm::mat_ncols(vB[i]), gmm::mat_ncols(vB[i])); + gmm::mult(gmm::transposed(vB[i]), vM[i], aux); + gmm::mult(aux, vB[i], vMloc[i]); + } + } + AS_exact_gradient(const std::vector &vB_) : vB(vB_) { + vM.resize(vB.size()); vMloc.resize(vB.size()); + for (size_type i = 0; i < vB.size(); ++i) { + gmm::resize(vM[i], gmm::mat_nrows(vB[i]), gmm::mat_nrows(vB[i])); + } + } + }; + + template + void mult(const AS_exact_gradient &M, + const Vector2 &p, Vector3 &q) { + gmm::clear(q); + typedef typename gmm::linalg_traits::value_type T; + std::vector v(gmm::vect_size(p)), w, x; + for (size_type i = 0; i < M.vB.size(); ++i) { + w.resize(gmm::mat_ncols(M.vB[i])); + x.resize(gmm::mat_ncols(M.vB[i])); + gmm::mult(M.vM[i], p, v); + gmm::mult(gmm::transposed(M.vB[i]), v, w); + double rcond; + SuperLU_solve(M.vMloc[i], x, w, rcond); + // gmm::iteration iter(1E-10, 0, 100000); + //gmm::gmres(M.vMloc[i], x, w, gmm::identity_matrix(), 50, iter); + gmm::mult_add(M.vB[i], x, q); + } + } + + template + void mult(const AS_exact_gradient &M, + const Vector2 &p, const Vector3 &q) { + mult(M, p, const_cast(q)); + } + + template + void mult(const AS_exact_gradient &M, + const Vector2 &p, const Vector3 &p2, Vector4 &q) + { mult(M, p, q); add(p2, q); } + + template + void mult(const AS_exact_gradient &M, + const Vector2 &p, const Vector3 &p2, const Vector4 &q) + { mult(M, p, const_cast(q)); add(p2, q); } + + struct S_default_newton_line_search { + + double conv_alpha, conv_r; + size_t it, itmax, glob_it; + + double alpha, alpha_old, alpha_mult, first_res, alpha_max_ratio; + double alpha_min_ratio, alpha_min; + size_type count, count_pat; + bool max_ratio_reached; + double alpha_max_ratio_reached, r_max_ratio_reached; + size_type it_max_ratio_reached; + + + double converged_value(void) { return conv_alpha; }; + double converged_residual(void) { return conv_r; }; + + virtual void init_search(double r, size_t git, double = 0.0) { + alpha_min_ratio = 0.9; + alpha_min = 1e-10; + alpha_max_ratio = 10.0; + alpha_mult = 0.25; + itmax = size_type(-1); + glob_it = git; if (git <= 1) count_pat = 0; + conv_alpha = alpha = alpha_old = 1.; + conv_r = first_res = r; it = 0; + count = 0; + max_ratio_reached = false; + } + virtual double next_try(void) { + alpha_old = alpha; + if (alpha >= 0.4) alpha *= 0.5; else alpha *= alpha_mult; ++it; + return alpha_old; + } + virtual bool is_converged(double r, double = 0.0) { + // cout << "r = " << r << " alpha = " << alpha / alpha_mult << " count_pat = " << count_pat << endl; + if (!max_ratio_reached && r < first_res * alpha_max_ratio) { + alpha_max_ratio_reached = alpha_old; r_max_ratio_reached = r; + it_max_ratio_reached = it; max_ratio_reached = true; + } + if (max_ratio_reached && r < r_max_ratio_reached * 0.5 + && r > first_res * 1.1 && it <= it_max_ratio_reached+1) { + alpha_max_ratio_reached = alpha_old; r_max_ratio_reached = r; + it_max_ratio_reached = it; + } + if (count == 0 || r < conv_r) + { conv_r = r; conv_alpha = alpha_old; count = 1; } + if (conv_r < first_res) ++count; + + if (r < first_res * alpha_min_ratio) + { count_pat = 0; return true; } + if (count >= 5 || (alpha < alpha_min && max_ratio_reached)) { + if (conv_r < first_res * 0.99) count_pat = 0; + if (/*gmm::random() * 50. < -log(conv_alpha)-4.0 ||*/ count_pat >= 3) + { conv_r=r_max_ratio_reached; conv_alpha=alpha_max_ratio_reached; } + if (conv_r >= first_res * 0.9999) count_pat++; + return true; + } + return false; + } + S_default_newton_line_search(void) { count_pat = 0; } + }; + + + + template + void Newton_additive_Schwarz(NewtonAS_struct &NS, + const Vector &u_, + iteration &iter, const Precond &P, + local_solver, global_solver) { + Vector &u = const_cast(u_); + typedef typename linalg_traits::value_type value_type; + typedef typename number_traits::magnitude_type mtype; + typedef actual_precond chgt_precond; + + double residual = iter.get_resmax(); + + S_default_newton_line_search internal_ls; + S_default_newton_line_search external_ls; + + typename chgt_precond::APrecond PP = chgt_precond::transform(P); + iter.set_rhsnorm(mtype(1)); + iteration iternc(iter); + iternc.reduce_noisy(); iternc.set_maxiter(size_type(-1)); + iteration iter2(iternc); + iteration iter3(iter2); iter3.reduce_noisy(); + iteration iter4(iter3); + iternc.set_name("Local Newton"); + iter2.set_name("Linear System for Global Newton"); + iternc.set_resmax(residual/100.0); + iter3.set_resmax(residual/10000.0); + iter2.set_resmax(residual/1000.0); + iter4.set_resmax(residual/1000.0); + std::vector rhs(NS.size()), x(NS.size()), d(NS.size()); + std::vector xi, xii, fi, di; + + std::vector< std::vector > vx(NS.get_vB().size()); + for (size_type i = 0; i < NS.get_vB().size(); ++i) // for exact gradient + vx[i].resize(NS.size()); // for exact gradient + + Matrixt Mloc, M(NS.size(), NS.size()); + NS.compute_F(rhs, u); + mtype act_res=gmm::vect_norm2(rhs), act_res_new(0), precond_res = act_res; + mtype alpha; + + while(!iter.finished(std::min(act_res, precond_res))) { + for (int SOR_step = 0; SOR_step >= 0; --SOR_step) { + gmm::clear(rhs); + for (size_type isd = 0; isd < NS.get_vB().size(); ++isd) { + const MatrixBi &Bi = (NS.get_vB())[isd]; + size_type si = mat_ncols(Bi); + gmm::resize(Mloc, si, si); + xi.resize(si); xii.resize(si); fi.resize(si); di.resize(si); + + iternc.init(); + iternc.set_maxiter(30); // ? + if (iternc.get_noisy()) + cout << "Non-linear local problem " << isd << endl; + gmm::clear(xi); + gmm::copy(u, x); + NS.compute_sub_F(fi, x, isd); gmm::scale(fi, value_type(-1)); + mtype r = gmm::vect_norm2(fi), r_t(r); + if (r > value_type(0)) { + iternc.set_rhsnorm(std::max(r, mtype(1))); + while(!iternc.finished(r)) { + NS.compute_sub_tangent_matrix(Mloc, x, isd); + + PP.build_with(Mloc); + iter3.init(); + AS_local_solve(local_solver(), Mloc, di, fi, PP, iter3); + + internal_ls.init_search(r, iternc.get_iteration()); + do { + alpha = internal_ls.next_try(); + gmm::add(xi, gmm::scaled(di, -alpha), xii); + gmm::mult(Bi, gmm::scaled(xii, -1.0), u, x); + NS.compute_sub_F(fi, x, isd); gmm::scale(fi, value_type(-1)); + r_t = gmm::vect_norm2(fi); + } while (!internal_ls.is_converged(r_t)); + + if (alpha != internal_ls.converged_value()) { + alpha = internal_ls.converged_value(); + gmm::add(xi, gmm::scaled(di, -alpha), xii); + gmm::mult(Bi, gmm::scaled(xii, -1.0), u, x); + NS.compute_sub_F(fi, x, isd); gmm::scale(fi, value_type(-1)); + r_t = gmm::vect_norm2(fi); + } + gmm::copy(x, vx[isd]); // for exact gradient + + if (iternc.get_noisy()) cout << "(step=" << alpha << ")\t"; + ++iternc; r = r_t; gmm::copy(xii, xi); + } + if (SOR_step) gmm::mult(Bi, gmm::scaled(xii, -1.0), u, u); + gmm::mult(Bi, gmm::scaled(xii, -1.0), rhs, rhs); + } + } + precond_res = gmm::vect_norm2(rhs); + if (SOR_step) cout << "SOR step residual = " << precond_res << endl; + if (precond_res < residual) break; + cout << "Precond residual = " << precond_res << endl; + } + + iter2.init(); + // solving linear system for the global Newton method + if (0) { + NS.compute_tangent_matrix(M, u); + add_schwarz_mat + ASM(M, NS.get_vB(), iter4, P, iter.get_resmax()); + AS_global_solve(global_solver(), ASM, d, rhs, iter2); + } + else { // for exact gradient + AS_exact_gradient eg(NS.get_vB()); + for (size_type i = 0; i < NS.get_vB().size(); ++i) { + NS.compute_tangent_matrix(eg.vM[i], vx[i]); + } + eg.init(); + gmres(eg, d, rhs, gmm::identity_matrix(), 50, iter2); + } + + // gmm::add(gmm::scaled(rhs, 0.1), u); ++iter; + external_ls.init_search(act_res, iter.get_iteration()); + do { + alpha = external_ls.next_try(); + gmm::add(gmm::scaled(d, alpha), u, x); + NS.compute_F(rhs, x); + act_res_new = gmm::vect_norm2(rhs); + } while (!external_ls.is_converged(act_res_new)); + + if (alpha != external_ls.converged_value()) { + alpha = external_ls.converged_value(); + gmm::add(gmm::scaled(d, alpha), u, x); + NS.compute_F(rhs, x); + act_res_new = gmm::vect_norm2(rhs); + } + + if (iter.get_noisy() > 1) cout << endl; + act_res = act_res_new; + if (iter.get_noisy()) cout << "(step=" << alpha << ")\t unprecond res = " << act_res << " "; + + + ++iter; gmm::copy(x, u); + } + } + +} + + +#endif // GMM_SOLVERS_SCHWARZ_ADDITIVE_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_bfgs.h b/7.x/src/linear_algebra/gmm/gmm_solver_bfgs.h new file mode 100644 index 0000000..d92abbc --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_bfgs.h @@ -0,0 +1,210 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2004-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_solver_bfgs.h + @author Yves Renard + @date October 14 2004. + @brief Implements BFGS (Broyden, Fletcher, Goldfarb, Shanno) algorithm. + */ +#ifndef GMM_BFGS_H +#define GMM_BFGS_H + +#include "gmm_kernel.h" +#include "gmm_iter.h" + +namespace gmm { + + // BFGS algorithm (Broyden, Fletcher, Goldfarb, Shanno) + // Quasi Newton method for optimization problems. + // with Wolfe Line search. + + + // delta[k] = x[k+1] - x[k] + // gamma[k] = grad f(x[k+1]) - grad f(x[k]) + // H[0] = I + // BFGS : zeta[k] = delta[k] - H[k] gamma[k] + // DFP : zeta[k] = H[k] gamma[k] + // tau[k] = gamma[k]^T zeta[k] + // rho[k] = 1 / gamma[k]^T delta[k] + // BFGS : H[k+1] = H[k] + rho[k](zeta[k] delta[k]^T + delta[k] zeta[k]^T) + // - rho[k]^2 tau[k] delta[k] delta[k]^T + // DFP : H[k+1] = H[k] + rho[k] delta[k] delta[k]^T + // - (1/tau[k])zeta[k] zeta[k]^T + + // Object representing the inverse of the Hessian + template struct bfgs_invhessian { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + std::vector delta, gamma, zeta; + std::vector tau, rho; + int version; + + template void hmult(const VEC1 &X, VEC2 &Y) { + copy(X, Y); + for (size_type k = 0 ; k < delta.size(); ++k) { + T xdelta = vect_sp(X, delta[k]), xzeta = vect_sp(X, zeta[k]); + switch (version) { + case 0 : // BFGS + add(scaled(zeta[k], rho[k]*xdelta), Y); + add(scaled(delta[k], rho[k]*(xzeta-rho[k]*tau[k]*xdelta)), Y); + break; + case 1 : // DFP + add(scaled(delta[k], rho[k]*xdelta), Y); + add(scaled(zeta[k], -xzeta/tau[k]), Y); + break; + } + } + } + + void restart(void) { + delta.resize(0); gamma.resize(0); zeta.resize(0); + tau.resize(0); rho.resize(0); + } + + template + void update(const VECT1 &deltak, const VECT2 &gammak) { + T vsp = vect_sp(deltak, gammak); + if (vsp == T(0)) return; + size_type N = vect_size(deltak), k = delta.size(); + VECTOR Y(N); + hmult(gammak, Y); + delta.resize(k+1); gamma.resize(k+1); zeta.resize(k+1); + tau.resize(k+1); rho.resize(k+1); + resize(delta[k], N); resize(gamma[k], N); resize(zeta[k], N); + gmm::copy(deltak, delta[k]); + gmm::copy(gammak, gamma[k]); + rho[k] = R(1) / vsp; + if (version == 0) + add(delta[k], scaled(Y, -1), zeta[k]); + else + gmm::copy(Y, zeta[k]); + tau[k] = vect_sp(gammak, zeta[k]); + } + + bfgs_invhessian(int v = 0) { version = v; } + }; + + + template + void bfgs(const FUNCTION &f, const DERIVATIVE &grad, VECTOR &x, + int restart, iteration& iter, int version = 0, + double lambda_init=0.001, double print_norm=1.0) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + bfgs_invhessian invhessian(version); + VECTOR r(vect_size(x)), d(vect_size(x)), y(vect_size(x)), r2(vect_size(x)); + grad(x, r); + R lambda = lambda_init, valx = f(x), valy; + int nb_restart(0); + + if (iter.get_noisy() >= 1) cout << "value " << valx / print_norm << " "; + while (! iter.finished_vect(r)) { + + invhessian.hmult(r, d); gmm::scale(d, T(-1)); + + // Wolfe Line search + R derivative = gmm::vect_sp(r, d); + R lambda_min(0), lambda_max(0), m1 = 0.27, m2 = 0.57; + bool unbounded = true, blocked = false, grad_computed = false; + + for(;;) { + add(x, scaled(d, lambda), y); + valy = f(y); + if (iter.get_noisy() >= 2) { + cout.precision(15); + cout << "Wolfe line search, lambda = " << lambda + << " value = " << valy /print_norm << endl; +// << " derivative = " << derivative +// << " lambda min = " << lambda_min << " lambda max = " +// << lambda_max << endl; getchar(); + } + if (valy <= valx + m1 * lambda * derivative) { + grad(y, r2); grad_computed = true; + T derivative2 = gmm::vect_sp(r2, d); + if (derivative2 >= m2*derivative) break; + lambda_min = lambda; + } + else { + lambda_max = lambda; + unbounded = false; + } + if (unbounded) lambda *= R(10); + else lambda = (lambda_max + lambda_min) / R(2); + if (lambda == lambda_max || lambda == lambda_min) break; + // valy <= R(2)*valx replaced by + // valy <= valx + gmm::abs(derivative)*lambda_init + // for compatibility with negative values (08.24.07). + if (valy <= valx + R(2)*gmm::abs(derivative)*lambda && + (lambda < R(lambda_init*1E-8) || + (!unbounded && lambda_max-lambda_min < R(lambda_init*1E-8)))) + { blocked = true; lambda = lambda_init; break; } + } + + // Rank two update + ++iter; + if (!grad_computed) grad(y, r2); + gmm::add(scaled(r2, -1), r); + if ((iter.get_iteration() % restart) == 0 || blocked) { + if (iter.get_noisy() >= 1) cout << "Restart\n"; + invhessian.restart(); + if (++nb_restart > 10) { + if (iter.get_noisy() >= 1) cout << "BFGS is blocked, exiting\n"; + return; + } + } + else { + invhessian.update(gmm::scaled(d,lambda), gmm::scaled(r,-1)); + nb_restart = 0; + } + copy(r2, r); copy(y, x); valx = valy; + if (iter.get_noisy() >= 1) + cout << "BFGS value " << valx/print_norm << "\t"; + } + + } + + + template + inline void dfp(const FUNCTION &f, const DERIVATIVE &grad, VECTOR &x, + int restart, iteration& iter, int version = 1) { + bfgs(f, grad, x, restart, iter, version); + + } + + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_bicgstab.h b/7.x/src/linear_algebra/gmm/gmm_solver_bicgstab.h new file mode 100644 index 0000000..7581847 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_bicgstab.h @@ -0,0 +1,160 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of bicgstab.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_solver_bicgstab.h + @author Andrew Lumsdaine + @author Lie-Quan Lee + @author Yves Renard + @date October 13, 2002. + @brief BiCGStab iterative solver. +*/ + +#ifndef GMM_SOLVER_BICGSTAB_H__ +#define GMM_SOLVER_BICGSTAB_H__ + +#include "gmm_kernel.h" +#include "gmm_iter.h" + +namespace gmm { + + /* ******************************************************************** */ + /* BiConjugate Gradient Stabilized */ + /* (preconditionned, with parametrable scalar product) */ + /* ******************************************************************** */ + + template + void bicgstab(const Matrix& A, Vector& x, const VectorB& b, + const Preconditioner& M, iteration &iter) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + typedef typename temporary_dense_vector::vector_type temp_vector; + + T rho_1, rho_2(0), alpha(0), beta, omega(0); + temp_vector p(vect_size(x)), phat(vect_size(x)), s(vect_size(x)), + shat(vect_size(x)), + t(vect_size(x)), v(vect_size(x)), r(vect_size(x)), rtilde(vect_size(x)); + + gmm::mult(A, gmm::scaled(x, -T(1)), b, r); + gmm::copy(r, rtilde); + R norm_r = gmm::vect_norm2(r); + iter.set_rhsnorm(gmm::vect_norm2(b)); + + if (iter.get_rhsnorm() == 0.0) { clear(x); return; } + + while (!iter.finished(norm_r)) { + + rho_1 = gmm::vect_sp(rtilde, r); + if (rho_1 == T(0)) { + if (iter.get_maxiter() == size_type(-1)) + { GMM_ASSERT1(false, "Bicgstab failed to converge"); } + else { GMM_WARNING1("Bicgstab failed to converge"); return; } + } + + if (iter.first()) + gmm::copy(r, p); + else { + if (omega == T(0)) { + if (iter.get_maxiter() == size_type(-1)) + { GMM_ASSERT1(false, "Bicgstab failed to converge"); } + else { GMM_WARNING1("Bicgstab failed to converge"); return; } + } + + beta = (rho_1 / rho_2) * (alpha / omega); + + gmm::add(gmm::scaled(v, -omega), p); + gmm::add(r, gmm::scaled(p, beta), p); + } + gmm::mult(M, p, phat); + gmm::mult(A, phat, v); + alpha = rho_1 / gmm::vect_sp(v, rtilde); + gmm::add(r, gmm::scaled(v, -alpha), s); + + if (iter.finished_vect(s)) + { gmm::add(gmm::scaled(phat, alpha), x); break; } + + gmm::mult(M, s, shat); + gmm::mult(A, shat, t); + omega = gmm::vect_sp(t, s) / gmm::vect_norm2_sqr(t); + + gmm::add(gmm::scaled(phat, alpha), x); + gmm::add(gmm::scaled(shat, omega), x); + gmm::add(s, gmm::scaled(t, -omega), r); + norm_r = gmm::vect_norm2(r); + rho_2 = rho_1; + + ++iter; + } + } + + template + void bicgstab(const Matrix& A, const Vector& x, const VectorB& b, + const Preconditioner& M, iteration &iter) + { bicgstab(A, linalg_const_cast(x), b, M, iter); } + +} + + +#endif // GMM_SOLVER_BICGSTAB_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_cg.h b/7.x/src/linear_algebra/gmm/gmm_solver_cg.h new file mode 100644 index 0000000..c81a6e9 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_cg.h @@ -0,0 +1,180 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of cg.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_solver_cg.h + @author Andrew Lumsdaine + @author Lie-Quan Lee + @author Yves Renard + @date October 13, 2002. + @brief Conjugate gradient iterative solver. +*/ +#ifndef GMM_SOLVER_CG_H__ +#define GMM_SOLVER_CG_H__ + +#include "gmm_kernel.h" +#include "gmm_iter.h" + +namespace gmm { + + /* ******************************************************************** */ + /* conjugate gradient */ + /* (preconditionned, with parametrable additional scalar product) */ + /* ******************************************************************** */ + + template + void cg(const Matrix& A, Vector1& x, const Vector2& b, const Matps& PS, + const Precond &P, iteration &iter) { + + typedef typename temporary_dense_vector::vector_type temp_vector; + typedef typename linalg_traits::value_type T; + + T rho, rho_1(0), a; + temp_vector p(vect_size(x)), q(vect_size(x)), r(vect_size(x)), + z(vect_size(x)); + iter.set_rhsnorm(gmm::sqrt(gmm::abs(vect_hp(PS, b, b)))); + + if (iter.get_rhsnorm() == 0.0) + clear(x); + else { + mult(A, scaled(x, T(-1)), b, r); + mult(P, r, z); + rho = vect_hp(PS, z, r); + copy(z, p); + + while (!iter.finished_vect(r)) { + + if (!iter.first()) { + mult(P, r, z); + rho = vect_hp(PS, z, r); + add(z, scaled(p, rho / rho_1), p); + } + mult(A, p, q); + + a = rho / vect_hp(PS, q, p); + add(scaled(p, a), x); + add(scaled(q, -a), r); + rho_1 = rho; + + ++iter; + } + } + } + + template + void cg(const Matrix& A, Vector1& x, const Vector2& b, const Matps& PS, + const gmm::identity_matrix &, iteration &iter) { + + typedef typename temporary_dense_vector::vector_type temp_vector; + typedef typename linalg_traits::value_type T; + + T rho, rho_1(0), a; + temp_vector p(vect_size(x)), q(vect_size(x)), r(vect_size(x)); + iter.set_rhsnorm(gmm::sqrt(gmm::abs(vect_hp(PS, b, b)))); + + if (iter.get_rhsnorm() == 0.0) + clear(x); + else { + mult(A, scaled(x, T(-1)), b, r); + rho = vect_hp(PS, r, r); + copy(r, p); + + while (!iter.finished_vect(r)) { + + if (!iter.first()) { + rho = vect_hp(PS, r, r); + add(r, scaled(p, rho / rho_1), p); + } + mult(A, p, q); + a = rho / vect_hp(PS, q, p); + add(scaled(p, a), x); + add(scaled(q, -a), r); + rho_1 = rho; + ++iter; + } + } + } + + template inline + void cg(const Matrix& A, const Vector1& x, const Vector2& b, const Matps& PS, + const Precond &P, iteration &iter) + { cg(A, linalg_const_cast(x), b, PS, P, iter); } + + template inline + void cg(const Matrix& A, Vector1& x, const Vector2& b, + const Precond &P, iteration &iter) + { cg(A, x , b, identity_matrix(), P, iter); } + + template inline + void cg(const Matrix& A, const Vector1& x, const Vector2& b, + const Precond &P, iteration &iter) + { cg(A, x , b , identity_matrix(), P , iter); } + +} + + +#endif // GMM_SOLVER_CG_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_constrained_cg.h b/7.x/src/linear_algebra/gmm/gmm_solver_constrained_cg.h new file mode 100644 index 0000000..c599bc9 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_constrained_cg.h @@ -0,0 +1,165 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_solver_constrained_cg.h + @author Yves Renard + @date October 13, 2002. + @brief Constrained conjugate gradient. */ +// preconditionning does not work + +#ifndef GMM_SOLVER_CCG_H__ +#define GMM_SOLVER_CCG_H__ + +#include "gmm_kernel.h" +#include "gmm_iter.h" + +namespace gmm { + + template + void pseudo_inverse(const CMatrix &C, CINVMatrix &CINV, + const Matps& /* PS */, VectorX&) { + // compute the pseudo inverse of the non-square matrix C such + // CINV = inv(C * trans(C)) * C. + // based on a conjugate gradient method. + + // optimisable : copie de la ligne, precalcul de C * trans(C). + + typedef VectorX TmpVec; + typedef typename linalg_traits::value_type value_type; + + size_type nr = mat_nrows(C), nc = mat_ncols(C); + + TmpVec d(nr), e(nr), l(nc), p(nr), q(nr), r(nr); + value_type rho, rho_1, alpha; + clear(d); + clear(CINV); + + for (size_type i = 0; i < nr; ++i) { + d[i] = 1.0; rho = 1.0; + clear(e); + copy(d, r); + copy(d, p); + + while (rho >= 1E-38) { /* conjugate gradient to compute e */ + /* which is the i nd row of inv(C * trans(C)) */ + mult(gmm::transposed(C), p, l); + mult(C, l, q); + alpha = rho / vect_sp(p, q); + add(scaled(p, alpha), e); + add(scaled(q, -alpha), r); + rho_1 = rho; + rho = vect_sp(r, r); + add(r, scaled(p, rho / rho_1), p); + } + + mult(transposed(C), e, l); /* l is the i nd row of CINV */ + // cout << "l = " << l << endl; + clean(l, 1E-15); + copy(l, mat_row(CINV, i)); + + d[i] = 0.0; + } + } + + /** Compute the minimum of @f$ 1/2((Ax).x) - bx @f$ under the contraint @f$ Cx <= f @f$ */ + template < typename Matrix, typename CMatrix, typename Matps, + typename VectorX, typename VectorB, typename VectorF, + typename Preconditioner > + void constrained_cg(const Matrix& A, const CMatrix& C, VectorX& x, + const VectorB& b, const VectorF& f,const Matps& PS, + const Preconditioner& M, iteration &iter) { + typedef typename temporary_dense_vector::vector_type TmpVec; + typedef typename temporary_vector::vector_type TmpCVec; + typedef row_matrix TmpCmat; + + typedef typename linalg_traits::value_type value_type; + value_type rho = 1.0, rho_1, lambda, gamma; + TmpVec p(vect_size(x)), q(vect_size(x)), q2(vect_size(x)), + r(vect_size(x)), old_z(vect_size(x)), z(vect_size(x)), + memox(vect_size(x)); + std::vector satured(mat_nrows(C)); + clear(p); + iter.set_rhsnorm(sqrt(vect_sp(PS, b, b))); + if (iter.get_rhsnorm() == 0.0) iter.set_rhsnorm(1.0); + + TmpCmat CINV(mat_nrows(C), mat_ncols(C)); + pseudo_inverse(C, CINV, PS, x); + + while(true) { + // computation of residu + copy(z, old_z); + copy(x, memox); + mult(A, scaled(x, -1.0), b, r); + mult(M, r, z); // preconditionner not coherent + bool transition = false; + for (size_type i = 0; i < mat_nrows(C); ++i) { + value_type al = vect_sp(mat_row(C, i), x) - f[i]; + if (al >= -1.0E-15) { + if (!satured[i]) { satured[i] = true; transition = true; } + value_type bb = vect_sp(mat_row(CINV, i), z); + if (bb > 0.0) add(scaled(mat_row(C, i), -bb), z); + } + else + satured[i] = false; + } + + // descent direction + rho_1 = rho; rho = vect_sp(PS, r, z); // ... + + if (iter.finished(rho)) break; + + if (iter.get_noisy() > 0 && transition) std::cout << "transition\n"; + if (transition || iter.first()) gamma = 0.0; + else gamma = std::max(0.0, (rho - vect_sp(PS, old_z, z) ) / rho_1); + // std::cout << "gamma = " << gamma << endl; + // itl::add(r, itl::scaled(p, gamma), p); + add(z, scaled(p, gamma), p); // ... + + ++iter; + // one dimensional optimization + mult(A, p, q); + lambda = rho / vect_sp(PS, q, p); + for (size_type i = 0; i < mat_nrows(C); ++i) + if (!satured[i]) { + value_type bb = vect_sp(mat_row(C, i), p) - f[i]; + if (bb > 0.0) + lambda = std::min(lambda, (f[i]-vect_sp(mat_row(C, i), x)) / bb); + } + add(x, scaled(p, lambda), x); + add(memox, scaled(x, -1.0), memox); + + } + } + +} + +#endif // GMM_SOLVER_CCG_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_gmres.h b/7.x/src/linear_algebra/gmm/gmm_solver_gmres.h new file mode 100644 index 0000000..96f8115 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_gmres.h @@ -0,0 +1,173 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of gmres.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1998-2020, University of Notre Dame. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_solver_gmres.h + @author Andrew Lumsdaine + @author Lie-Quan Lee + @author Yves Renard + @date October 13, 2002. + @brief GMRES (Generalized Minimum Residual) iterative solver. +*/ +#ifndef GMM_KRYLOV_GMRES_H +#define GMM_KRYLOV_GMRES_H + +#include "gmm_kernel.h" +#include "gmm_iter.h" +#include "gmm_modified_gram_schmidt.h" + +namespace gmm { + + /** Generalized Minimum Residual + + This solve the unsymmetric linear system Ax = b using restarted GMRES. + + See: Y. Saad and M. Schulter. GMRES: A generalized minimum residual + algorithm for solving nonsysmmetric linear systems, SIAM + J. Sci. Statist. Comp. 7(1986), pp, 856-869 + */ + template + void gmres(const Mat &A, Vec &x, const VecB &b, const Precond &M, + int restart, iteration &outer, Basis& KS) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + std::vector w(vect_size(x)), r(vect_size(x)), u(vect_size(x)); + std::vector c_rot(restart+1), s_rot(restart+1), s(restart+1); + gmm::dense_matrix H(restart+1, restart); +#ifdef GMM_USES_MPI + double t_ref, t_prec = MPI_Wtime(), t_tot = 0; + static double tmult_tot = 0.0; +t_ref = MPI_Wtime(); + cout << "GMRES " << endl; +#endif + mult(M,b,r); + outer.set_rhsnorm(gmm::vect_norm2(r)); + if (outer.get_rhsnorm() == 0.0) { clear(x); return; } + + mult(A, scaled(x, T(-1)), b, w); + mult(M, w, r); + R beta = gmm::vect_norm2(r), beta_old = beta; + int blocked = 0; + + iteration inner = outer; + inner.reduce_noisy(); + inner.set_maxiter(restart); + inner.set_name("GMRes inner"); + + while (! outer.finished(beta)) { + + gmm::copy(gmm::scaled(r, R(1)/beta), KS[0]); + gmm::clear(s); + s[0] = beta; + + size_type i = 0; inner.init(); + + do { + mult(A, KS[i], u); + mult(M, u, KS[i+1]); + orthogonalize(KS, mat_col(H, i), i); + R a = gmm::vect_norm2(KS[i+1]); + H(i+1, i) = T(a); + gmm::scale(KS[i+1], T(1) / a); + for (size_type k = 0; k < i; ++k) + Apply_Givens_rotation_left(H(k,i), H(k+1,i), c_rot[k], s_rot[k]); + + Givens_rotation(H(i,i), H(i+1,i), c_rot[i], s_rot[i]); + Apply_Givens_rotation_left(H(i,i), H(i+1,i), c_rot[i], s_rot[i]); + Apply_Givens_rotation_left(s[i], s[i+1], c_rot[i], s_rot[i]); + + ++inner, ++outer, ++i; + } while (! inner.finished(gmm::abs(s[i]))); + + upper_tri_solve(H, s, i, false); + combine(KS, s, x, i); + mult(A, gmm::scaled(x, T(-1)), b, w); + mult(M, w, r); + beta_old = std::min(beta, beta_old); beta = gmm::vect_norm2(r); + if (int(inner.get_iteration()) < restart -1 || beta_old <= beta) + ++blocked; else blocked = 0; + if (blocked > 10) { + if (outer.get_noisy()) cout << "Gmres is blocked, exiting\n"; + break; + } +#ifdef GMM_USES_MPI + t_tot = MPI_Wtime() - t_ref; + cout << "temps GMRES : " << t_tot << endl; +#endif + } + } + + + template + void gmres(const Mat &A, Vec &x, const VecB &b, + const Precond &M, int restart, iteration& outer) { + typedef typename linalg_traits::value_type T; + modified_gram_schmidt orth(restart, vect_size(x)); + gmres(A, x, b, M, restart, outer, orth); + } + +} + +#endif diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_idgmres.h b/7.x/src/linear_algebra/gmm/gmm_solver_idgmres.h new file mode 100644 index 0000000..d6cc046 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_idgmres.h @@ -0,0 +1,805 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard, Caroline Lecalvez + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_solver_idgmres.h + @author Caroline Lecalvez + @author Yves Renard + @date October 6, 2003. + @brief Implicitly restarted and deflated Generalized Minimum Residual. +*/ +#ifndef GMM_IDGMRES_H +#define GMM_IDGMRES_H + +#include "gmm_kernel.h" +#include "gmm_iter.h" +#include "gmm_dense_sylvester.h" + +namespace gmm { + + template compare_vp { + bool operator()(const std::pair &a, + const std::pair &b) const + { return (gmm::abs(a.first) > gmm::abs(b.first)); } + } + + struct idgmres_state { + size_type m, tb_deb, tb_def, p, k, nb_want, nb_unwant; + size_type nb_nolong, tb_deftot, tb_defwant, conv, nb_un, fin; + bool ok; + + idgmres_state(size_type mm, size_type pp, size_type kk) + : m(mm), tb_deb(1), tb_def(0), p(pp), k(kk), nb_want(0), + nb_unwant(0), nb_nolong(0), tb_deftot(0), tb_defwant(0), + conv(0), nb_un(0), fin(0), ok(false); {} + } + + idgmres_state(size_type mm, size_type pp, size_type kk) + : m(mm), tb_deb(1), tb_def(0), p(pp), k(kk), nb_want(0), + nb_unwant(0), nb_nolong(0), tb_deftot(0), tb_defwant(0), + conv(0), nb_un(0), fin(0), ok(false); {} + + + template + apply_permutation(CONT &cont, const IND &ind) { + size_type m = ind.end() - ind.begin(); + std::vector sorted(m, false); + + for (size_type l = 0; l < m; ++l) + if (!sorted[l] && ind[l] != l) { + + typeid(cont[0]) aux = cont[l]; + k = ind[l]; + cont[l] = cont[k]; + sorted[l] = true; + + for(k2 = ind[k]; k2 != l; k2 = ind[k]) { + cont[k] = cont[k2]; + sorted[k] = true; + k = k2; + } + cont[k] = aux; + } + } + + + /** Implicitly restarted and deflated Generalized Minimum Residual + + See: C. Le Calvez, B. Molina, Implicitly restarted and deflated + FOM and GMRES, numerical applied mathematics, + (30) 2-3 (1999) pp191-212. + + @param A Real or complex unsymmetric matrix. + @param x initial guess vector and final result. + @param b right hand side + @param M preconditionner + @param m size of the subspace between two restarts + @param p number of converged ritz values seeked + @param k size of the remaining Krylov subspace when the p ritz values + have not yet converged 0 <= p <= k < m. + @param tol_vp : tolerance on the ritz values. + @param outer + @param KS + */ + template < typename Mat, typename Vec, typename VecB, typename Precond, + typename Basis > + void idgmres(const Mat &A, Vec &x, const VecB &b, const Precond &M, + size_type m, size_type p, size_type k, double tol_vp, + iteration &outer, Basis& KS) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + R a, beta; + idgmres_state st(m, p, k); + + std::vector w(vect_size(x)), r(vect_size(x)), u(vect_size(x)); + std::vector c_rot(m+1), s_rot(m+1), s(m+1); + std::vector y(m+1), ztest(m+1), gam(m+1); + std::vector gamma(m+1); + gmm::dense_matrix H(m+1, m), Hess(m+1, m), + Hobl(m+1, m), W(vect_size(x), m+1); + + gmm::clear(H); + + outer.set_rhsnorm(gmm::vect_norm2(b)); + if (outer.get_rhsnorm() == 0.0) { clear(x); return; } + + mult(A, scaled(x, -1.0), b, w); + mult(M, w, r); + beta = gmm::vect_norm2(r); + + iteration inner = outer; + inner.reduce_noisy(); + inner.set_maxiter(m); + inner.set_name("GMRes inner iter"); + + while (! outer.finished(beta)) { + + gmm::copy(gmm::scaled(r, 1.0/beta), KS[0]); + gmm::clear(s); + s[0] = beta; + gmm::copy(s, gamma); + + inner.set_maxiter(m - st.tb_deb + 1); + size_type i = st.tb_deb - 1; inner.init(); + + do { + mult(A, KS[i], u); + mult(M, u, KS[i+1]); + orthogonalize_with_refinment(KS, mat_col(H, i), i); + H(i+1, i) = a = gmm::vect_norm2(KS[i+1]); + gmm::scale(KS[i+1], R(1) / a); + + gmm::copy(mat_col(H, i), mat_col(Hess, i)); + gmm::copy(mat_col(H, i), mat_col(Hobl, i)); + + + for (size_type l = 0; l < i; ++l) + Apply_Givens_rotation_left(H(l,i), H(l+1,i), c_rot[l], s_rot[l]); + + Givens_rotation(H(i,i), H(i+1,i), c_rot[i], s_rot[i]); + Apply_Givens_rotation_left(H(i,i), H(i+1,i), c_rot[i], s_rot[i]); + H(i+1, i) = T(0); + Apply_Givens_rotation_left(s[i], s[i+1], c_rot[i], s_rot[i]); + + ++inner, ++outer, ++i; + } while (! inner.finished(gmm::abs(s[i]))); + + if (inner.converged()) { + gmm::copy(s, y); + upper_tri_solve(H, y, i, false); + combine(KS, y, x, i); + mult(A, gmm::scaled(x, T(-1)), b, w); + mult(M, w, r); + beta = gmm::vect_norm2(r); // + verif sur beta ... à faire + break; + } + + gmm::clear(gam); gam[m] = s[i]; + for (size_type l = m; l > 0; --l) + Apply_Givens_rotation_left(gam[l-1], gam[l], gmm::conj(c_rot[l-1]), + -s_rot[l-1]); + + mult(KS.mat(), gam, r); + beta = gmm::vect_norm2(r); + + mult(Hess, scaled(y, T(-1)), gamma, ztest); + // En fait, d'après Caroline qui s'y connait ztest et gam devrait + // être confondus + // Quand on aura vérifié que ça marche, il faudra utiliser gam à la + // place de ztest. + if (st.tb_def < p) { + T nss = H(m,m-1) / ztest[m]; + nss /= gmm::abs(nss); // ns à calculer plus tard aussi + gmm::copy(KS.mat(), W); gmm::copy(scaled(r, nss /beta), mat_col(W, m)); + + // Computation of the oblique matrix + sub_interval SUBI(0, m); + add(scaled(sub_vector(ztest, SUBI), -Hobl(m, m-1) / ztest[m]), + sub_vector(mat_col(Hobl, m-1), SUBI)); + Hobl(m, m-1) *= nss * beta / ztest[m]; + + /* **************************************************************** */ + /* Locking */ + /* **************************************************************** */ + + // Computation of the Ritz eigenpairs. + std::vector > eval(m); + dense_matrix YB(m-st.tb_def, m-st.tb_def); + std::vector pure(m-st.tb_def, 0); + gmm::clear(YB); + + select_eval(Hobl, eval, YB, pure, st); + + if (st.conv != 0) { + // DEFLATION using the QR Factorization of YB + + T alpha = Lock(W, Hobl, + sub_matrix(YB, sub_interval(0, m-st.tb_def)), + sub_interval(st.tb_def, m-st.tb_def), + (st.tb_defwant < p)); + // ns *= alpha; // à calculer plus tard ?? + // V(:,m+1) = alpha*V(:, m+1); ça devait servir à qlq chose ... + + + // Clean the portions below the diagonal corresponding + // to the lock Schur vectors + + for (size_type j = st.tb_def; j < st.tb_deftot; ++j) { + if ( pure[j-st.tb_def] == 0) + gmm::clear(sub_vector(mat_col(Hobl,j), sub_interval(j+1,m-j))); + else if (pure[j-st.tb_def] == 1) { + gmm::clear(sub_matrix(Hobl, sub_interval(j+2,m-j-1), + sub_interval(j, 2))); + ++j; + } + else GMM_ASSERT3(false, "internal error"); + } + + if (!st.ok) { + + // attention si m = 0; + size_type mm = std::min(k+st.nb_unwant+st.nb_nolong, m-1); + + if (eval_sort[m-mm-1].second != R(0) + && eval_sort[m-mm-1].second == -eval_sort[m-mm].second) ++mm; + + std::vector > shifts(m-mm); + for (size_type i = 0; i < m-mm; ++i) + shifts[i] = eval_sort[i].second; + + apply_shift_to_Arnoldi_factorization(W, Hobl, shifts, mm, + m-mm, true); + + st.fin = mm; + } + else + st.fin = st.tb_deftot; + + + /* ************************************************************** */ + /* Purge */ + /* ************************************************************** */ + + if (st.nb_nolong + st.nb_unwant > 0) { + + std::vector > eval(m); + dense_matrix YB(st.fin, st.tb_deftot); + std::vector pure(st.tb_deftot, 0); + gmm::clear(YB); + st.nb_un = st.nb_nolong + st.nb_unwant; + + select_eval_for_purging(Hobl, eval, YB, pure, st); + + T alpha = Lock(W, Hobl, YB, sub_interval(0, st.fin), ok); + + // Clean the portions below the diagonal corresponding + // to the unwanted lock Schur vectors + + for (size_type j = 0; j < st.tb_deftot; ++j) { + if ( pure[j] == 0) + gmm::clear(sub_vector(mat_col(Hobl,j), sub_interval(j+1,m-j))); + else if (pure[j] == 1) { + gmm::clear(sub_matrix(Hobl, sub_interval(j+2,m-j-1), + sub_interval(j, 2))); + ++j; + } + else GMM_ASSERT3(false, "internal error"); + } + + gmm::dense_matrix z(st.nb_un, st.fin - st.nb_un); + sub_interval SUBI(0, st.nb_un), SUBJ(st.nb_un, st.fin - st.nb_un); + sylvester(sub_matrix(Hobl, SUBI), + sub_matrix(Hobl, SUBJ), + sub_matrix(gmm::scaled(Hobl, -T(1)), SUBI, SUBJ), z); + + } + + } + + } + } + } + + + template < typename Mat, typename Vec, typename VecB, typename Precond > + void idgmres(const Mat &A, Vec &x, const VecB &b, + const Precond &M, size_type m, iteration& outer) { + typedef typename linalg_traits::value_type T; + modified_gram_schmidt orth(m, vect_size(x)); + gmres(A, x, b, M, m, outer, orth); + } + + + // Lock stage of an implicit restarted Arnoldi process. + // 1- QR factorization of YB through Householder matrices + // Q(Rl) = YB + // (0 ) + // 2- Update of the Arnoldi factorization. + // H <- Q*HQ, W <- WQ + // 3- Restore the Hessemberg form of H. + + template + void Lock(gmm::dense_matrix &W, gmm::dense_matrix &H, + const MATYB &YB, const sub_interval SUB, + bool restore, T &ns) { + + size_type n = mat_nrows(W), m = mat_ncols(W) - 1; + size_type ncols = mat_ncols(YB), nrows = mat_nrows(YB); + size_type begin = min(SUB); end = max(SUB) - 1; + sub_interval SUBR(0, nrows), SUBC(0, ncols); + T alpha(1); + + GMM_ASSERT2(((end-begin) == ncols) && (m == mat_nrows(H)) + && (m+1 == mat_ncols(H)), "dimensions mismatch"); + + // DEFLATION using the QR Factorization of YB + + dense_matrix QR(n_rows, n_rows); + gmmm::copy(YB, sub_matrix(QR, SUBR, SUBC)); + gmm::clear(submatrix(QR, SUBR, sub_interval(ncols, nrows-ncols))); + qr_factor(QR); + + + apply_house_left(QR, sub_matrix(H, SUB)); + apply_house_right(QR, sub_matrix(H, SUBR, SUB)); + apply_house_right(QR, sub_matrix(W, sub_interval(0, n), SUB)); + + // Restore to the initial block hessenberg form + + if (restore) { + + // verifier quand m = 0 ... + gmm::dense_matrix tab_p(end - st.tb_deftot, end - st.tb_deftot); + gmm::copy(identity_matrix(), tab_p); + + for (size_type j = end-1; j >= st.tb_deftot+2; --j) { + + size_type jm = j-1; + std::vector v(jm - st.tb_deftot); + sub_interval SUBtot(st.tb_deftot, jm - st.tb_deftot); + sub_interval SUBtot2(st.tb_deftot, end - st.tb_deftot); + gmm::copy(sub_vector(mat_row(H, j), SUBtot), v); + house_vector_last(v); + w.resize(end); + col_house_update(sub_matrix(H, SUBI, SUBtot), v, w); + w.resize(end - st.tb_deftot); + row_house_update(sub_matrix(H, SUBtot, SUBtot2), v, w); + gmm::clear(sub_vector(mat_row(H, j), + sub_interval(st.tb_deftot, j-1-st.tb_deftot))); + w.resize(end - st.tb_deftot); + col_house_update(sub_matrix(tab_p, sub_interval(0, end-st.tb_deftot), + sub_interval(0, jm-st.tb_deftot)), v, w); + w.resize(n); + col_house_update(sub_matrix(W, sub_interval(0, n), SUBtot), v, w); + } + + // restore positive subdiagonal elements + + std::vector d(fin-st.tb_deftot); d[0] = T(1); + + // We compute d[i+1] in order + // (d[i+1] * H(st.tb_deftot+i+1,st.tb_deftoti)) / d[i] + // be equal to |H(st.tb_deftot+i+1,st.tb_deftot+i))|. + for (size_type j = 0; j+1 < end-st.tb_deftot; ++j) { + T e = H(st.tb_deftot+j, st.tb_deftot+j-1); + d[j+1] = (e == T(0)) ? T(1) : d[j] * gmm::abs(e) / e; + scale(sub_vector(mat_row(H, st.tb_deftot+j+1), + sub_interval(st.tb_deftot, m-st.tb_deftot)), d[j+1]); + scale(mat_col(H, st.tb_deftot+j+1), T(1) / d[j+1]); + scale(mat_col(W, st.tb_deftot+j+1), T(1) / d[j+1]); + } + + alpha = tab_p(end-st.tb_deftot-1, end-st.tb_deftot-1) / d[end-st.tb_deftot-1]; + alpha /= gmm::abs(alpha); + scale(mat_col(W, m), alpha); + + } + + return alpha; + } + + + + + + + + + // Apply p implicit shifts to the Arnoldi factorization + // AV = VH+H(k+p+1,k+p) V(:,k+p+1) e_{k+p}* + // and produces the following new Arnoldi factorization + // A(VQ) = (VQ)(Q*HQ)+H(k+p+1,k+p) V(:,k+p+1) e_{k+p}* Q + // where only the first k columns are relevant. + // + // Dan Sorensen and Richard J. Radke, 11/95 + template + apply_shift_to_Arnoldi_factorization(dense_matrix V, dense_matrix H, + std::vector Lambda, size_type &k, + size_type p, bool true_shift = false) { + + + size_type k1 = 0, num = 0, kend = k+p, kp1 = k + 1; + bool mark = false; + T c, s, x, y, z; + + dense_matrix q(1, kend); + gmm::clear(q); q(0,kend-1) = T(1); + std::vector hv(3), w(std::max(kend, mat_nrows(V))); + + for(size_type jj = 0; jj < p; ++jj) { + // compute and apply a bulge chase sweep initiated by the + // implicit shift held in w(jj) + + if (abs(Lambda[jj].real()) == 0.0) { + // apply a real shift using 2 by 2 Givens rotations + + for (size_type k1 = 0, k2 = 0; k2 != kend-1; k1 = k2+1) { + k2 = k1; + while (h(k2+1, k2) != T(0) && k2 < kend-1) ++k2; + + Givens_rotation(H(k1, k1) - Lambda[jj], H(k1+1, k1), c, s); + + for (i = k1; i <= k2; ++i) { + if (i > k1) Givens_rotation(H(i, i-1), H(i+1, i-1), c, s); + + // Ne pas oublier de nettoyer H(i+1,i-1) (le mettre à zéro). + // Vérifier qu'au final H(i+1,i) est bien un réel positif. + + // apply rotation from left to rows of H + row_rot(sub_matrix(H, sub_interval(i,2), sub_interval(i, kend-i)), + c, s, 0, 0); + + // apply rotation from right to columns of H + size_type ip2 = std::min(i+2, kend); + col_rot(sub_matrix(H, sub_interval(0, ip2), sub_interval(i, 2)) + c, s, 0, 0); + + // apply rotation from right to columns of V + col_rot(V, c, s, i, i+1); + + // accumulate e' Q so residual can be updated k+p + Apply_Givens_rotation_left(q(0,i), q(0,i+1), c, s); + // peut être que nous utilisons G au lieu de G* et que + // nous allons trop loin en k2. + } + } + + num = num + 1; + } + else { + + // Apply a double complex shift using 3 by 3 Householder + // transformations + + if (jj == p || mark) + mark = false; // skip application of conjugate shift + else { + num = num + 2; // mark that a complex conjugate + mark = true; // pair has been applied + + // Indices de fin de boucle à surveiller... de près ! + for (size_type k1 = 0, k3 = 0; k3 != kend-2; k1 = k3+1) { + k3 = k1; + while (h(k3+1, k3) != T(0) && k3 < kend-2) ++k3; + size_type k2 = k1+1; + + + x = H(k1,k1) * H(k1,k1) + H(k1,k2) * H(k2,k1) + - 2.0*Lambda[jj].real() * H(k1,k1) + gmm::abs_sqr(Lambda[jj]); + y = H(k2,k1) * (H(k1,k1) + H(k2,k2) - 2.0*Lambda[jj].real()); + z = H(k2+1,k2) * H(k2,k1); + + for (size_type i = k1; i <= k3; ++i) { + if (i > k1) { + x = H(i, i-1); + y = H(i+1, i-1); + z = H(i+2, i-1); + // Ne pas oublier de nettoyer H(i+1,i-1) et H(i+2,i-1) + // (les mettre à zéro). + } + + hv[0] = x; hv[1] = y; hv[2] = z; + house_vector(v); + + // Vérifier qu'au final H(i+1,i) est bien un réel positif + + // apply transformation from left to rows of H + w.resize(kend-i); + row_house_update(sub_matrix(H, sub_interval(i, 2), + sub_interval(i, kend-i)), v, w); + + // apply transformation from right to columns of H + + size_type ip3 = std::min(kend, i + 3); + w.resize(ip3); + col_house_update(sub_matrix(H, sub_interval(0, ip3), + sub_interval(i, 2)), v, w); + + // apply transformation from right to columns of V + + w.resize(mat_nrows(V)); + col_house_update(sub_matrix(V, sub_interval(0, mat_nrows(V)), + sub_interval(i, 2)), v, w); + + // accumulate e' Q so residual can be updated k+p + + w.resize(1); + col_house_update(sub_matrix(q, sub_interval(0,1), + sub_interval(i,2)), v, w); + + } + } + + // clean up step with Givens rotation + + i = kend-2; + c = x; s = y; + if (i > k1) Givens_rotation(H(i, i-1), H(i+1, i-1), c, s); + + // Ne pas oublier de nettoyer H(i+1,i-1) (le mettre à zéro). + // Vérifier qu'au final H(i+1,i) est bien un réel positif. + + // apply rotation from left to rows of H + row_rot(sub_matrix(H, sub_interval(i,2), sub_interval(i, kend-i)), + c, s, 0, 0); + + // apply rotation from right to columns of H + size_type ip2 = std::min(i+2, kend); + col_rot(sub_matrix(H, sub_interval(0, ip2), sub_interval(i, 2)) + c, s, 0, 0); + + // apply rotation from right to columns of V + col_rot(V, c, s, i, i+1); + + // accumulate e' Q so residual can be updated k+p + Apply_Givens_rotation_left(q(0,i), q(0,i+1), c, s); + + } + } + } + + // update residual and store in the k+1 -st column of v + + k = kend - num; + scale(mat_col(V, kend), q(0, k)); + + if (k < mat_nrows(H)) { + if (true_shift) + gmm::copy(mat_col(V, kend), mat_col(V, k)); + else + // v(:,k+1) = v(:,kend+1) + v(:,k+1)*h(k+1,k); + // v(:,k+1) = v(:,kend+1) ; + gmm::add(scaled(mat_col(V, kend), H(kend, kend-1)), + scaled(mat_col(V, k), H(k, k-1)), mat_col(V, k)); + } + + H(k, k-1) = vect_norm2(mat_col(V, k)); + scale(mat_col(V, kend), T(1) / H(k, k-1)); + } + + + + template + void select_eval(const MAT &Hobl, EVAL &eval, MAT &YB, PURE &pure, + idgmres_state &st) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + size_type m = st.m; + + // Computation of the Ritz eigenpairs. + + col_matrix< std::vector > evect(m-st.tb_def, m-st.tb_def); + // std::vector > eval(m); + std::vector ritznew(m, T(-1)); + + // dense_matrix evect_lock(st.tb_def, st.tb_def); + + sub_interval SUB1(st.tb_def, m-st.tb_def); + implicit_qr_algorithm(sub_matrix(Hobl, SUB1), + sub_vector(eval, SUB1), evect); + sub_interval SUB2(0, st.tb_def); + implicit_qr_algorithm(sub_matrix(Hobl, SUB2), + sub_vector(eval, SUB2), /* evect_lock */); + + for (size_type l = st.tb_def; l < m; ++l) + ritznew[l] = gmm::abs(evect(m-st.tb_def-1, l-st.tb_def) * Hobl(m, m-1)); + + std::vector< std::pair > eval_sort(m); + for (size_type l = 0; l < m; ++l) + eval_sort[l] = std::pair(eval[l], l); + std::sort(eval_sort.begin(), eval_sort.end(), compare_vp()); + + std::vector index(m); + for (size_type l = 0; l < m; ++l) index[l] = eval_sort[l].second; + + std::vector kept(m, false); + std::fill(kept.begin(), kept.begin()+st.tb_def, true); + + apply_permutation(eval, index); + apply_permutation(evect, index); + apply_permutation(ritznew, index); + apply_permutation(kept, index); + + // Which are the eigenvalues that converged ? + // + // nb_want is the number of eigenvalues of + // Hess(tb_def+1:n,tb_def+1:n) that converged and are WANTED + // + // nb_unwant is the number of eigenvalues of + // Hess(tb_def+1:n,tb_def+1:n) that converged and are UNWANTED + // + // nb_nolong is the number of eigenvalues of + // Hess(1:tb_def,1:tb_def) that are NO LONGER WANTED. + // + // tb_deftot is the number of the deflated eigenvalues + // that is tb_def + nb_want + nb_unwant + // + // tb_defwant is the number of the wanted deflated eigenvalues + // that is tb_def + nb_want - nb_nolong + + st.nb_want = 0, st.nb_unwant = 0, st.nb_nolong = 0; + size_type j, ind; + + for (j = 0, ind = 0; j < m-p; ++j) { + if (ritznew[j] == R(-1)) { + if (std::imag(eval[j]) != R(0)) { + st.nb_nolong += 2; ++j; // à adapter dans le cas complexe ... + } + else st.nb_nolong++; + } + else { + if (ritznew[j] + < tol_vp * gmm::abs(eval[j])) { + + for (size_type l = 0, l < m-st.tb_def; ++l) + YB(l, ind) = std::real(evect(l, j)); + kept[j] = true; + ++j; ++st.nb_unwant; ind++; + + if (std::imag(eval[j]) != R(0)) { + for (size_type l = 0, l < m-st.tb_def; ++l) + YB(l, ind) = std::imag(evect(l, j)); + pure[ind-1] = 1; + pure[ind] = 2; + + kept[j] = true; + + st.nb_unwant++; + ++ind; + } + } + } + } + + + for (; j < m; ++j) { + if (ritznew[j] != R(-1)) { + + for (size_type l = 0, l < m-st.tb_def; ++l) + YB(l, ind) = std::real(evect(l, j)); + pure[ind] = 1; + ++ind; + kept[j] = true; + ++st.nb_want; + + if (ritznew[j] + < tol_vp * gmm::abs(eval[j])) { + for (size_type l = 0, l < m-st.tb_def; ++l) + YB(l, ind) = std::imag(evect(l, j)); + pure[ind] = 2; + + j++; + kept[j] = true; + + st.nb_want++; + ++ind; + } + } + } + + std::vector shift(m - st.tb_def - st.nb_want - st.nb_unwant); + for (size_type j = 0, i = 0; j < m; ++j) + if (!kept[j]) shift[i++] = eval[j]; + + // st.conv (st.nb_want+st.nb_unwant) is the number of eigenpairs that + // have just converged. + // st.tb_deftot is the total number of eigenpairs that have converged. + + size_type st.conv = ind; + size_type st.tb_deftot = st.tb_def + st.conv; + size_type st.tb_defwant = st.tb_def + st.nb_want - st.nb_nolong; + + sub_interval SUBYB(0, st.conv); + + if ( st.tb_defwant >= p ) { // An invariant subspace has been found. + + st.nb_unwant = 0; + st.nb_want = p + st.nb_nolong - st.tb_def; + st.tb_defwant = p; + + if ( pure[st.conv - st.nb_want + 1] == 2 ) { + ++st.nb_want; st.tb_defwant = ++p;// il faudrait que ce soit un p local + } + + SUBYB = sub_interval(st.conv - st.nb_want, st.nb_want); + // YB = YB(:, st.conv-st.nb_want+1 : st.conv); // On laisse en suspend .. + // pure = pure(st.conv-st.nb_want+1 : st.conv,1); // On laisse suspend .. + st.conv = st.nb_want; + st.tb_deftot = st.tb_def + st.conv; + st.ok = true; + } + + } + + + + template + void select_eval_for_purging(const MAT &Hobl, EVAL &eval, MAT &YB, + PURE &pure, idgmres_state &st) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + size_type m = st.m; + + // Computation of the Ritz eigenpairs. + + col_matrix< std::vector > evect(st.tb_deftot, st.tb_deftot); + + sub_interval SUB1(0, st.tb_deftot); + implicit_qr_algorithm(sub_matrix(Hobl, SUB1), + sub_vector(eval, SUB1), evect); + std::fill(eval.begin() + st.tb_deftot, eval.end(), std::complex(0)); + + std::vector< std::pair > eval_sort(m); + for (size_type l = 0; l < m; ++l) + eval_sort[l] = std::pair(eval[l], l); + std::sort(eval_sort.begin(), eval_sort.end(), compare_vp()); + + std::vector sorted(m); + std::fill(sorted.begin(), sorted.end(), false); + + std::vector ind(m); + for (size_type l = 0; l < m; ++l) ind[l] = eval_sort[l].second; + + std::vector kept(m, false); + std::fill(kept.begin(), kept.begin()+st.tb_def, true); + + apply_permutation(eval, ind); + apply_permutation(evect, ind); + + size_type j; + for (j = 0; j < st.tb_deftot; ++j) { + + for (size_type l = 0, l < st.tb_deftot; ++l) + YB(l, j) = std::real(evect(l, j)); + + if (std::imag(eval[j]) != R(0)) { + for (size_type l = 0, l < m-st.tb_def; ++l) + YB(l, j+1) = std::imag(evect(l, j)); + pure[j] = 1; + pure[j+1] = 2; + + j += 2; + } + else ++j; + } + } + + + + + + +} + +#endif diff --git a/7.x/src/linear_algebra/gmm/gmm_solver_qmr.h b/7.x/src/linear_algebra/gmm/gmm_solver_qmr.h new file mode 100644 index 0000000..9ff0ddc --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_solver_qmr.h @@ -0,0 +1,210 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +// This file is a modified version of qmr.h from ITL. +// See http://osl.iu.edu/research/itl/ +// Following the corresponding Copyright notice. +//=========================================================================== +// +// Copyright (c) 1997-2020, The Trustees of Indiana University. +// All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of the University of Notre Dame nor the +// names of its contributors may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE TRUSTEES OF INDIANA UNIVERSITY AND +// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +// BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES +// OF INDIANA UNIVERSITY AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +//=========================================================================== + +/**@file gmm_solver_qmr.h + @author Andrew Lumsdaine + @author Lie-Quan Lee + @author Yves Renard + @date October 13, 2002. + @brief Quasi-Minimal Residual iterative solver. +*/ +#ifndef GMM_QMR_H +#define GMM_QMR_H + +#include "gmm_kernel.h" +#include "gmm_iter.h" + +namespace gmm { + + /** Quasi-Minimal Residual. + + This routine solves the unsymmetric linear system Ax = b using + the Quasi-Minimal Residual method. + + See: R. W. Freund and N. M. Nachtigal, A quasi-minimal residual + method for non-Hermitian linear systems, Numerical Math., + 60(1991), pp. 315-339 + + Preconditioner - Incomplete LU, Incomplete LU with threshold, + SSOR or identity_preconditioner. + */ + template + void qmr(const Matrix &A, Vector &x, const VectorB &b, const Precond1 &M1, + iteration& iter) { + + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + T delta(0), ep(0), beta(0), theta_1(0), gamma_1(0); + T theta(0), gamma(1), eta(-1); + R rho_1(0), rho, xi; + + typedef typename temporary_vector::vector_type TmpVec; + size_type nn = vect_size(x); + TmpVec r(nn), v_tld(nn), y(nn), w_tld(nn), z(nn), v(nn), w(nn); + TmpVec y_tld(nn), z_tld(nn), p(nn), q(nn), p_tld(nn), d(nn), s(nn); + + iter.set_rhsnorm(double(gmm::vect_norm2(b))); + if (iter.get_rhsnorm() == 0.0) { clear(x); return; } + + gmm::mult(A, gmm::scaled(x, T(-1)), b, r); + gmm::copy(r, v_tld); + + gmm::left_mult(M1, v_tld, y); + rho = gmm::vect_norm2(y); + + gmm::copy(r, w_tld); + gmm::transposed_right_mult(M1, w_tld, z); + xi = gmm::vect_norm2(z); + + while (! iter.finished_vect(r)) { + + if (rho == R(0) || xi == R(0)) { + if (iter.get_maxiter() == size_type(-1)) + { GMM_ASSERT1(false, "QMR failed to converge"); } + else { GMM_WARNING1("QMR failed to converge"); return; } + } + gmm::copy(gmm::scaled(v_tld, T(R(1)/rho)), v); + gmm::scale(y, T(R(1)/rho)); + + gmm::copy(gmm::scaled(w_tld, T(R(1)/xi)), w); + gmm::scale(z, T(R(1)/xi)); + + delta = gmm::vect_sp(z, y); + if (delta == T(0)) { + if (iter.get_maxiter() == size_type(-1)) + { GMM_ASSERT1(false, "QMR failed to converge"); } + else { GMM_WARNING1("QMR failed to converge"); return; } + } + gmm::right_mult(M1, y, y_tld); + gmm::transposed_left_mult(M1, z, z_tld); + + if (iter.first()) { + gmm::copy(y_tld, p); + gmm::copy(z_tld, q); + } else { + gmm::add(y_tld, gmm::scaled(p, -(T(xi * delta) / ep)), p); + gmm::add(z_tld, gmm::scaled(q, -(T(rho * delta) / ep)), q); + } + + gmm::mult(A, p, p_tld); + + ep = gmm::vect_sp(q, p_tld); + if (ep == T(0)) { + if (iter.get_maxiter() == size_type(-1)) + { GMM_ASSERT1(false, "QMR failed to converge"); } + else { GMM_WARNING1("QMR failed to converge"); return; } + } + beta = ep / delta; + if (beta == T(0)) { + if (iter.get_maxiter() == size_type(-1)) + { GMM_ASSERT1(false, "QMR failed to converge"); } + else { GMM_WARNING1("QMR failed to converge"); return; } + } + gmm::add(p_tld, gmm::scaled(v, -beta), v_tld); + gmm::left_mult(M1, v_tld, y); + + rho_1 = rho; + rho = gmm::vect_norm2(y); + + gmm::mult(gmm::transposed(A), q, w_tld); + gmm::add(w_tld, gmm::scaled(w, -beta), w_tld); + gmm::transposed_right_mult(M1, w_tld, z); + + xi = gmm::vect_norm2(z); + + gamma_1 = gamma; + theta_1 = theta; + + theta = rho / (gamma_1 * beta); + gamma = T(1) / gmm::sqrt(T(1) + gmm::sqr(theta)); + + if (gamma == T(0)) { + if (iter.get_maxiter() == size_type(-1)) + { GMM_ASSERT1(false, "QMR failed to converge"); } + else { GMM_WARNING1("QMR failed to converge"); return; } + } + eta = -eta * T(rho_1) * gmm::sqr(gamma) / (beta * gmm::sqr(gamma_1)); + + if (iter.first()) { + gmm::copy(gmm::scaled(p, eta), d); + gmm::copy(gmm::scaled(p_tld, eta), s); + } else { + T tmp = gmm::sqr(theta_1 * gamma); + gmm::add(gmm::scaled(p, eta), gmm::scaled(d, tmp), d); + gmm::add(gmm::scaled(p_tld, eta), gmm::scaled(s, tmp), s); + } + gmm::add(d, x); + gmm::add(gmm::scaled(s, T(-1)), r); + + ++iter; + } + } + + +} + +#endif + diff --git a/7.x/src/linear_algebra/gmm/gmm_std.h b/7.x/src/linear_algebra/gmm/gmm_std.h new file mode 100644 index 0000000..413df77 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_std.h @@ -0,0 +1,352 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_std.h +@author Yves Renard , +@author Julien Pommier +@date June 01, 1995. +@brief basic setup for gmm (includes, typedefs etc.) +*/ +#ifndef GMM_STD_H__ +#define GMM_STD_H__ + +#ifndef __USE_STD_IOSTREAM +# define __USE_STD_IOSTREAM +#endif + +#ifndef __USE_BSD +# define __USE_BSD +#endif + +#ifndef __USE_ISOC99 +# define __USE_ISOC99 +#endif + +#if defined(_MSC_VER) && _MSC_VER >= 1400 // Secure versions for VC++ +# define GMM_SECURE_CRT +# define SECURE_NONCHAR_SSCANF sscanf_s +# define SECURE_NONCHAR_FSCANF fscanf_s +# define SECURE_STRNCPY(a, la, b, lb) strncpy_s(a, la, b, lb) +# define SECURE_FOPEN(F, filename, mode) (*(F) = 0, fopen_s(F, filename, mode)) +# define SECURE_SPRINTF1(S, l, st, p1) sprintf_s(S, l, st, p1) +# define SECURE_SPRINTF2(S, l, st, p1, p2) sprintf_s(S, l, st, p1, p2) +# define SECURE_SPRINTF4(S, l, st, p1, p2, p3, p4) sprintf_s(S, l, st, p1, p2, p3, p4) +# define SECURE_STRDUP(s) _strdup(s) +# ifndef _SCL_SECURE_NO_DEPRECATE +# error Add the option /D_SCL_SECURE_NO_DEPRECATE to the compilation command +# endif +#else +# define SECURE_NONCHAR_SSCANF sscanf +# define SECURE_NONCHAR_FSCANF fscanf +# define SECURE_STRNCPY(a, la, b, lb) strncpy(a, b, lb) +# define SECURE_FOPEN(F, filename, mode) ((*(F)) = fopen(filename, mode)) +# define SECURE_SPRINTF1(S, l, st, p1) sprintf(S, st, p1) +# define SECURE_SPRINTF2(S, l, st, p1, p2) sprintf(S, st, p1, p2) +# define SECURE_SPRINTF4(S, l, st, p1, p2, p3, p4) sprintf(S, st, p1, p2, p3, p4) +# define SECURE_STRDUP(s) strdup(s) +#endif + +inline void GMM_NOPERATION_(int) { } +#define GMM_NOPERATION(a) { GMM_NOPERATION_(abs(&(a) != &(a))); } + +/* ********************************************************************** */ +/* Compilers detection. */ +/* ********************************************************************** */ + +/* for VISUAL C++ ... +#if defined(_MSC_VER) // && !defined(__MWERKS__) +#define _GETFEM_MSVCPP_ _MSC_VER +#endif +*/ + +#if defined(__GNUC__) +# if (__GNUC__ < 4) +# error : PLEASE UPDATE g++ TO AT LEAST 4.8 VERSION +# endif +#endif + +/* ********************************************************************** */ +/* C++ Standard Headers. */ +/* ********************************************************************** */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace std { +#if defined(__GNUC__) && (__cplusplus <= 201103L) + template + struct _MakeUniq + { typedef unique_ptr<_Tp> __single_object; }; + template + struct _MakeUniq<_Tp[]> + { typedef unique_ptr<_Tp[]> __array; }; + template + struct _MakeUniq<_Tp[_Bound]> + { struct __invalid_type { }; }; + /// std::make_unique for single objects + template + inline typename _MakeUniq<_Tp>::__single_object + make_unique(_Args&&... __args) + { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } + /// std::make_unique for arrays of unknown bound + template + inline typename _MakeUniq<_Tp>::__array + make_unique(size_t __num) + { return unique_ptr<_Tp>(new typename remove_extent<_Tp>::type[__num]()); } + /// Disable std::make_unique for arrays of known bound + template + inline typename _MakeUniq<_Tp>::__invalid_type + make_unique(_Args&&...) = delete; +#endif + + + // Should simply be replaced by std::shared_ptr when it will be supported + // by the STL + template class shared_array_ptr : shared_ptr { + public: + shared_array_ptr() {} + shared_array_ptr(T *q) : std::shared_ptr(q, default_delete()) {} + template shared_array_ptr(const std::shared_ptr &p, T *q) + : std::shared_ptr(p, q) {} + T *get() const { return shared_ptr::get(); } + T& operator*() const { return shared_ptr::operator*(); } + T* operator->() const { return shared_ptr::operator->(); } + }; + + template shared_array_ptr make_shared_array(size_t num) + { return shared_array_ptr(new T[num]); } +} + +namespace gmm { + + using std::endl; using std::cout; using std::cerr; + using std::ends; using std::cin; using std::isnan; + + class standard_locale { + std::string cloc; + std::locale cinloc; + + public : + inline standard_locale(void) + : cloc(setlocale(LC_NUMERIC, 0)), cinloc(cin.getloc()) + { setlocale(LC_NUMERIC,"C"); cin.imbue(std::locale("C")); } + inline ~standard_locale() + { setlocale(LC_NUMERIC, cloc.c_str()); cin.imbue(cinloc); } + }; + + class stream_standard_locale { + std::locale cloc; + std::ios &io; + + public : + inline stream_standard_locale(std::ios &i) + : cloc(i.getloc()), io(i) { io.imbue(std::locale("C")); } + inline ~stream_standard_locale() { io.imbue(cloc); } + }; + + /* ******************************************************************* */ + /* Clock functions. */ + /* ******************************************************************* */ + +# if defined(HAVE_SYS_TIMES) + inline double uclock_sec(void) { + static double ttclk = 0.; + if (ttclk == 0.) ttclk = sysconf(_SC_CLK_TCK); + tms t; times(&t); return double(t.tms_utime) / ttclk; + } +# else + inline double uclock_sec(void) + { return double(clock())/double(CLOCKS_PER_SEC); } +# endif + + /* ******************************************************************** */ + /* Fixed size integer types. */ + /* ******************************************************************** */ + // Remark : the test program dynamic_array tests the length of + // resulting integers + + template struct fixed_size_integer_generator { + typedef void int_base_type; + typedef void uint_base_type; + }; + + template <> struct fixed_size_integer_generator { + typedef signed char int_base_type; + typedef unsigned char uint_base_type; + }; + + template <> struct fixed_size_integer_generator { + typedef signed short int int_base_type; + typedef unsigned short int uint_base_type; +}; + +template <> struct fixed_size_integer_generator { + typedef signed int int_base_type; + typedef unsigned int uint_base_type; + }; + +template <> struct fixed_size_integer_generator { + typedef signed long int_base_type; + typedef unsigned long uint_base_type; + }; + +template <> struct fixed_size_integer_generator { + typedef signed long long int_base_type; + typedef unsigned long long uint_base_type; + }; + +typedef fixed_size_integer_generator<1>::int_base_type int8_type; +typedef fixed_size_integer_generator<1>::uint_base_type uint8_type; +typedef fixed_size_integer_generator<2>::int_base_type int16_type; +typedef fixed_size_integer_generator<2>::uint_base_type uint16_type; +typedef fixed_size_integer_generator<4>::int_base_type int32_type; +typedef fixed_size_integer_generator<4>::uint_base_type uint32_type; +typedef fixed_size_integer_generator<8>::int_base_type int64_type; +typedef fixed_size_integer_generator<8>::uint_base_type uint64_type; + +// #if INT_MAX == 32767 +// typedef signed int int16_type; +// typedef unsigned int uint16_type; +// #elif SHRT_MAX == 32767 +// typedef signed short int int16_type; +// typedef unsigned short int uint16_type; +// #else +// # error "impossible to build a 16 bits integer" +// #endif + +// #if INT_MAX == 2147483647 +// typedef signed int int32_type; +// typedef unsigned int uint32_type; +// #elif SHRT_MAX == 2147483647 +// typedef signed short int int32_type; +// typedef unsigned short int uint32_type; +// #elif LONG_MAX == 2147483647 +// typedef signed long int int32_type; +// typedef unsigned long int uint32_type; +// #else +// # error "impossible to build a 32 bits integer" +// #endif + +// #if INT_MAX == 9223372036854775807L || INT_MAX == 9223372036854775807 +// typedef signed int int64_type; +// typedef unsigned int uint64_type; +// #elif LONG_MAX == 9223372036854775807L || LONG_MAX == 9223372036854775807 +// typedef signed long int int64_type; +// typedef unsigned long int uint64_type; +// #elif LLONG_MAX == 9223372036854775807LL || LLONG_MAX == 9223372036854775807L || LLONG_MAX == 9223372036854775807 +// typedef signed long long int int64_type; +// typedef unsigned long long int uint64_type; +// #else +// # error "impossible to build a 64 bits integer" +// #endif + +#if defined(__GNUC__) && !defined(__ICC) +/* + g++ can issue a warning at each usage of a function declared with this special attribute + (also works with typedefs and variable declarations) +*/ +# define IS_DEPRECATED __attribute__ ((__deprecated__)) +/* + the specified function is inlined at any optimization level +*/ +# define ALWAYS_INLINE __attribute__((always_inline)) +#else +# define IS_DEPRECATED +# define ALWAYS_INLINE +#endif + +} + + /* ******************************************************************** */ + /* Import/export classes and interfaces from a shared library */ + /* ******************************************************************** */ + +#if defined(EXPORTED_TO_SHARED_LIB) +# if defined(_MSC_VER) || defined(__INTEL_COMPILER) +# define APIDECL __declspec(dllexport) +# elif defined(__GNUC__) +# define __attribute__((visibility("default"))) +# else +# define APIDECL +# endif +# if defined(IMPORTED_FROM_SHARED_LIB) +# error INTENTIONAL COMPILCATION ERROR, DLL IMPORT AND EXPORT ARE INCOMPITABLE +# endif +#endif + +#if defined(IMPORTED_FROM_SHARED_LIB) +# if defined(_MSC_VER) || defined(__INTEL_COMPILER) +# define APIDECL __declspec(dllimport) +# else +# define APIDECL +# endif +# if defined(EXPORTED_TO_SHARED_LIB) +# error INTENTIONAL COMPILCATION ERROR, DLL IMPORT AND EXPORT ARE INCOMPITABLE +# endif +#endif + +#ifndef EXPORTED_TO_SHARED_LIB +# ifndef IMPORTED_FROM_SHARED_LIB +# define APIDECL //empty, used during static linking +# endif +#endif + +#endif /* GMM_STD_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_sub_index.h b/7.x/src/linear_algebra/gmm/gmm_sub_index.h new file mode 100644 index 0000000..28c95e0 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_sub_index.h @@ -0,0 +1,224 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_sub_index.h + @author Yves Renard + @date October 13, 2002. + @brief sub-indices. +*/ + +#ifndef GMM_SUB_INDEX_H__ +#define GMM_SUB_INDEX_H__ + +#include "gmm_def.h" + +namespace gmm { + + /* ******************************************************************** */ + /* sub indices */ + /* ******************************************************************** */ + + struct basic_index : public std::vector { + + mutable size_type nb_ref; + // size_type key1; faire la somme des composantes + // const basic_index *rind; rindex s'il existe + + + size_t operator[](size_type i) const { + return (i < size()) ? std::vector::operator[](i) : size_type(-1); + } + + basic_index() : nb_ref(1) {} + basic_index(size_type j) : std::vector(j), nb_ref(1) {} + template basic_index(IT b, IT e) + : std::vector(e-b), nb_ref(1) { std::copy(b, e, begin()); } + basic_index(const basic_index *pbi) : nb_ref(1) { + const_iterator it = pbi->begin(), ite = pbi->end(); + size_type i = 0; + for ( ; it != ite; ++it) i = std::max(i, *it); + resize(i+1); std::fill(begin(), end(), size_type(-1)); + for (it = pbi->begin(), i = 0; it != ite; ++it, ++i) + std::vector::operator[](*it) = i; + } + void swap(size_type i, size_type j) { + std::swap(std::vector::operator[](i), + std::vector::operator[](j)); + } + + }; + + typedef basic_index *pbasic_index; + + struct index_generator { + + template static pbasic_index create_index(IT begin, IT end) + { return new basic_index(begin, end); } + static pbasic_index create_rindex(pbasic_index pbi) + { return new basic_index(pbi); } + static void attach(pbasic_index pbi) { if (pbi) pbi->nb_ref++; } + static void unattach(pbasic_index pbi) + { if (pbi && --(pbi->nb_ref) == 0) delete pbi; } + + }; + + struct sub_index { + + size_type first_, last_; + typedef basic_index base_type; + typedef base_type::const_iterator const_iterator; + + mutable pbasic_index ind; + mutable pbasic_index rind; + + void comp_extr(void) { + std::vector::const_iterator it = ind->begin(), ite = ind->end(); + if (it != ite) { first_=last_= *it; ++it; } else { first_=last_= 0; } + for (; it != ite; ++it) + { first_ = std::min(first_, *it); last_ = std::max(last_, *it); } + } + + inline void test_rind(void) const + { if (!rind) rind = index_generator::create_rindex(ind); } + size_type size(void) const { return ind->size(); } + size_type first(void) const { return first_; } + size_type last(void) const { return last_; } + size_type index(size_type i) const { return (*ind)[i]; } + size_type rindex(size_type i) const { + test_rind(); + if (i < rind->size()) return (*rind)[i]; else return size_type(-1); + } + + const_iterator begin(void) const { return ind->begin(); } + const_iterator end(void) const { return ind->end(); } + const_iterator rbegin(void) const { test_rind(); return rind->begin(); } + const_iterator rend(void) const { test_rind(); return rind->end(); } + + sub_index() : ind(0), rind(0) {} + template sub_index(IT it, IT ite) + : ind(index_generator::create_index(it, ite)), + rind(0) { comp_extr(); } + template sub_index(const CONT &c) + : ind(index_generator::create_index(c.begin(), c.end())), + rind(0) { comp_extr(); } + ~sub_index() { + index_generator::unattach(rind); + index_generator::unattach(ind); + } + sub_index(const sub_index &si) : first_(si.first_), last_(si.last_), + ind(si.ind), rind(si.rind) + { index_generator::attach(rind); index_generator::attach(ind); } + sub_index &operator =(const sub_index &si) { + index_generator::unattach(rind); + index_generator::unattach(ind); + ind = si.ind; rind = si.rind; + index_generator::attach(rind); + index_generator::attach(ind); + first_ = si.first_; last_ = si.last_; + return *this; + } + }; + + struct unsorted_sub_index : public sub_index { + typedef basic_index base_type; + typedef base_type::const_iterator const_iterator; + + template unsorted_sub_index(IT it, IT ite) + : sub_index(it, ite) {} + template unsorted_sub_index(const CONT &c) + : sub_index(c) {} + unsorted_sub_index() {} + unsorted_sub_index(const unsorted_sub_index &si) : sub_index((const sub_index &)(si)) { } + unsorted_sub_index &operator =(const unsorted_sub_index &si) + { sub_index::operator =(si); return *this; } + void swap(size_type i, size_type j) { + GMM_ASSERT2(ind->nb_ref <= 1, "Operation not allowed on this index"); + if (rind) rind->swap((*ind)[i], (*ind)[j]); + ind->swap(i, j); + } + }; + + inline std::ostream &operator << (std::ostream &o, const sub_index &si) { + o << "sub_index("; + if (si.size() != 0) o << si.index(0); + for (size_type i = 1; i < si.size(); ++i) o << ", " << si.index(i); + o << ")"; + return o; + } + + struct sub_interval { + size_type min, max; + + size_type size(void) const { return max - min; } + size_type first(void) const { return min; } + size_type last(void) const { return max; } + size_type index(size_type i) const { return min + i; } + size_type step(void) const { return 1; } + size_type rindex(size_type i) const + { if (i >= min && i < max) return i - min; return size_type(-1); } + sub_interval(size_type mi, size_type l) : min(mi), max(mi+l) {} + sub_interval() {} + }; + + inline std::ostream &operator << (std::ostream &o, const sub_interval &si) + { o << "sub_interval(" << si.min << ", " << si.size() << ")"; return o; } + + struct sub_slice { + size_type min, max, N; + + size_type size(void) const { return (max - min) / N; } + size_type first(void) const { return min; } + size_type last(void) const { return (min == max) ? max : max+1-N; } + size_type step(void) const { return N; } + size_type index(size_type i) const { return min + N * i; } + size_type rindex(size_type i) const { + if (i >= min && i < max) + { size_type j = (i - min); if (j % N == 0) return j / N; } + return size_type(-1); + } + sub_slice(size_type mi, size_type l, size_type n) + : min(mi), max(mi+l*n), N(n) {} + sub_slice(void) {} + }; + + inline std::ostream &operator << (std::ostream &o, const sub_slice &si) { + o << "sub_slice(" << si.min << ", " << si.size() << ", " << si.step() + << ")"; return o; + } + + template struct index_is_sorted + { typedef linalg_true bool_type; }; + template<> struct index_is_sorted + { typedef linalg_false bool_type; }; + +} + +#endif // GMM_SUB_INDEX_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_sub_matrix.h b/7.x/src/linear_algebra/gmm/gmm_sub_matrix.h new file mode 100644 index 0000000..998a766 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_sub_matrix.h @@ -0,0 +1,406 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_sub_matrix.h + @author Yves Renard + @date October 13, 2002. + @brief Generic sub-matrices. +*/ + +#ifndef GMM_SUB_MATRIX_H__ +#define GMM_SUB_MATRIX_H__ + +#include "gmm_sub_vector.h" + +namespace gmm { + + /* ********************************************************************* */ + /* sub row matrices type */ + /* ********************************************************************* */ + + template + struct gen_sub_row_matrix { + typedef gen_sub_row_matrix this_type; + typedef typename std::iterator_traits::value_type M; + typedef M * CPT; + typedef typename std::iterator_traits::reference ref_M; + typedef typename select_ref + ::const_row_iterator, typename linalg_traits::row_iterator, + PT>::ref_type iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + SUBI1 si1; + SUBI2 si2; + iterator begin_; + porigin_type origin; + + reference operator()(size_type i, size_type j) const + { return linalg_traits::access(begin_ + si1.index(i), si2.index(j)); } + + size_type nrows(void) const { return si1.size(); } + size_type ncols(void) const { return si2.size(); } + + gen_sub_row_matrix(ref_M m, const SUBI1 &s1, const SUBI2 &s2) + : si1(s1), si2(s2), begin_(mat_row_begin(m)), + origin(linalg_origin(m)) {} + gen_sub_row_matrix() {} + gen_sub_row_matrix(const gen_sub_row_matrix &cr) : + si1(cr.si1), si2(cr.si2), begin_(cr.begin_),origin(cr.origin) {} + }; + + template + struct gen_sub_row_matrix_iterator { + typedef gen_sub_row_matrix this_type; + typedef typename modifiable_pointer::pointer MPT; + typedef typename std::iterator_traits::value_type M; + typedef typename select_ref + ::const_row_iterator, typename linalg_traits::row_iterator, + PT>::ref_type ITER; + typedef ITER value_type; + typedef ITER *pointer; + typedef ITER &reference; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef std::random_access_iterator_tag iterator_category; + typedef gen_sub_row_matrix_iterator iterator; + + ITER it; + SUBI1 si1; + SUBI2 si2; + size_type ii; + + iterator operator ++(int) { iterator tmp = *this; ii++; return tmp; } + iterator operator --(int) { iterator tmp = *this; ii--; return tmp; } + iterator &operator ++() { ii++; return *this; } + iterator &operator --() { ii--; return *this; } + iterator &operator +=(difference_type i) { ii += i; return *this; } + iterator &operator -=(difference_type i) { ii -= i; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const { return ii - i.ii; } + + ITER operator *() const { return it + si1.index(ii); } + ITER operator [](int i) { return it + si1.index(ii+i); } + + bool operator ==(const iterator &i) const { return (ii == i.ii); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (ii < i.ii); } + + gen_sub_row_matrix_iterator(void) {} + gen_sub_row_matrix_iterator(const + gen_sub_row_matrix_iterator &itm) + : it(itm.it), si1(itm.si1), si2(itm.si2), ii(itm.ii) {} + gen_sub_row_matrix_iterator(const ITER &iter, const SUBI1 &s1, + const SUBI2 &s2, size_type i) + : it(iter), si1(s1), si2(s2), ii(i) { } + + }; + + template + struct linalg_traits > { + typedef gen_sub_row_matrix this_type; + typedef typename std::iterator_traits::value_type M; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type const_col_iterator; + typedef typename sub_vector_type::const_sub_row_type>::t *, SUBI2>::vector_type + const_sub_row_type; + typedef typename select_ref::sub_row_type>::t *, + SUBI2>::vector_type, PT>::ref_type sub_row_type; + typedef gen_sub_row_matrix_iterator::pointer, + SUBI1, SUBI2> const_row_iterator; + typedef typename select_ref, PT>::ref_type + row_iterator; + typedef typename linalg_traits::storage_type + storage_type; + typedef row_major sub_orientation; + typedef linalg_true index_sorted; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_sub_row_type row(const const_row_iterator &it) + { return const_sub_row_type(linalg_traits::row(*it), it.si2); } + static sub_row_type row(const row_iterator &it) + { return sub_row_type(linalg_traits::row(*it), it.si2); } + static const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(m.begin_, m.si1, m.si2, 0); } + static row_iterator row_begin(this_type &m) + { return row_iterator(m.begin_, m.si1, m.si2, 0); } + static const_row_iterator row_end(const this_type &m) + { return const_row_iterator(m.begin_, m.si1, m.si2, m.nrows()); } + static row_iterator row_end(this_type &m) + { return row_iterator(m.begin_, m.si1, m.si2, m.nrows()); } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void do_clear(this_type &m) { + row_iterator it = mat_row_begin(m), ite = mat_row_end(m); + for (; it != ite; ++it) clear(row(it)); + } + static value_type access(const const_row_iterator &itrow, size_type i) + { return linalg_traits::access(*itrow, itrow.si2.index(i)); } + static reference access(const row_iterator &itrow, size_type i) + { return linalg_traits::access(*itrow, itrow.si2.index(i)); } + }; + + template + std::ostream &operator <<(std::ostream &o, + const gen_sub_row_matrix& m) + { gmm::write(o,m); return o; } + + + /* ********************************************************************* */ + /* sub column matrices type */ + /* ********************************************************************* */ + + template + struct gen_sub_col_matrix { + typedef gen_sub_col_matrix this_type; + typedef typename std::iterator_traits::value_type M; + typedef M * CPT; + typedef typename std::iterator_traits::reference ref_M; + typedef typename select_ref + ::const_col_iterator, typename linalg_traits::col_iterator, + PT>::ref_type iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + SUBI1 si1; + SUBI2 si2; + iterator begin_; + porigin_type origin; + + reference operator()(size_type i, size_type j) const + { return linalg_traits::access(begin_ + si2.index(j), si1.index(i)); } + + size_type nrows(void) const { return si1.size(); } + size_type ncols(void) const { return si2.size(); } + + gen_sub_col_matrix(ref_M m, const SUBI1 &s1, const SUBI2 &s2) + : si1(s1), si2(s2), begin_(mat_col_begin(m)), + origin(linalg_origin(m)) {} + gen_sub_col_matrix() {} + gen_sub_col_matrix(const gen_sub_col_matrix &cr) : + si1(cr.si1), si2(cr.si2), begin_(cr.begin_),origin(cr.origin) {} + }; + + template + struct gen_sub_col_matrix_iterator { + typedef gen_sub_col_matrix this_type; + typedef typename modifiable_pointer::pointer MPT; + typedef typename std::iterator_traits::value_type M; + typedef typename select_ref::const_col_iterator, + typename linalg_traits::col_iterator, + PT>::ref_type ITER; + typedef ITER value_type; + typedef ITER *pointer; + typedef ITER &reference; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef std::random_access_iterator_tag iterator_category; + typedef gen_sub_col_matrix_iterator iterator; + + ITER it; + SUBI1 si1; + SUBI2 si2; + size_type ii; + + iterator operator ++(int) { iterator tmp = *this; ii++; return tmp; } + iterator operator --(int) { iterator tmp = *this; ii--; return tmp; } + iterator &operator ++() { ii++; return *this; } + iterator &operator --() { ii--; return *this; } + iterator &operator +=(difference_type i) { ii += i; return *this; } + iterator &operator -=(difference_type i) { ii -= i; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const { return ii - i.ii; } + + ITER operator *() const { return it + si2.index(ii); } + ITER operator [](int i) { return it + si2.index(ii+i); } + + bool operator ==(const iterator &i) const { return (ii == i.ii); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (ii < i.ii); } + + gen_sub_col_matrix_iterator(void) {} + gen_sub_col_matrix_iterator(const + gen_sub_col_matrix_iterator &itm) + : it(itm.it), si1(itm.si1), si2(itm.si2), ii(itm.ii) {} + gen_sub_col_matrix_iterator(const ITER &iter, const SUBI1 &s1, + const SUBI2 &s2, size_type i) + : it(iter), si1(s1), si2(s2), ii(i) { } + }; + + template + struct linalg_traits > { + typedef gen_sub_col_matrix this_type; + typedef typename std::iterator_traits::value_type M; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type const_row_iterator; + typedef typename sub_vector_type::const_sub_col_type>::t *, SUBI1>::vector_type const_sub_col_type; + typedef typename select_ref::sub_col_type>::t *, SUBI1>::vector_type, PT>::ref_type sub_col_type; + typedef gen_sub_col_matrix_iterator::pointer, + SUBI1, SUBI2> const_col_iterator; + typedef typename select_ref, PT>::ref_type + col_iterator; + typedef col_major sub_orientation; + typedef linalg_true index_sorted; + typedef typename linalg_traits::storage_type + storage_type; + static size_type nrows(const this_type &m) { return m.nrows(); } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_sub_col_type col(const const_col_iterator &it) + { return const_sub_col_type(linalg_traits::col(*it), it.si1); } + static sub_col_type col(const col_iterator &it) + { return sub_col_type(linalg_traits::col(*it), it.si1); } + static const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(m.begin_, m.si1, m.si2, 0); } + static col_iterator col_begin(this_type &m) + { return col_iterator(m.begin_, m.si1, m.si2, 0); } + static const_col_iterator col_end(const this_type &m) + { return const_col_iterator(m.begin_, m.si1, m.si2, m.ncols()); } + static col_iterator col_end(this_type &m) + { return col_iterator(m.begin_, m.si1, m.si2, m.ncols()); } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void do_clear(this_type &m) { + col_iterator it = mat_col_begin(m), ite = mat_col_end(m); + for (; it != ite; ++it) clear(col(it)); + } + static value_type access(const const_col_iterator &itcol, size_type i) + { return linalg_traits::access(*itcol, itcol.si1.index(i)); } + static reference access(const col_iterator &itcol, size_type i) + { return linalg_traits::access(*itcol, itcol.si1.index(i)); } + }; + + template std::ostream &operator << + (std::ostream &o, const gen_sub_col_matrix& m) + { gmm::write(o,m); return o; } + + /* ******************************************************************** */ + /* sub matrices */ + /* ******************************************************************** */ + + template + struct sub_matrix_type_ { + typedef abstract_null_type return_type; + }; + template + struct sub_matrix_type_ + { typedef gen_sub_col_matrix matrix_type; }; + template + struct sub_matrix_type_ + { typedef gen_sub_row_matrix matrix_type; }; + template + struct sub_matrix_type { + typedef typename std::iterator_traits::value_type M; + typedef typename sub_matrix_type_::sub_orientation>::potype>::matrix_type matrix_type; + }; + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + M *>::return_type + sub_matrix(M &m, const SUBI1 &si1, const SUBI2 &si2) { + GMM_ASSERT2(si1.last() <= mat_nrows(m) && si2.last() <= mat_ncols(m), + "sub matrix too large"); + return typename select_return::matrix_type, typename sub_matrix_type + ::matrix_type, M *>::return_type(linalg_cast(m), si1, si2); + } + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + const M *>::return_type + sub_matrix(const M &m, const SUBI1 &si1, const SUBI2 &si2) { + GMM_ASSERT2(si1.last() <= mat_nrows(m) && si2.last() <= mat_ncols(m), + "sub matrix too large"); + return typename select_return::matrix_type, typename sub_matrix_type + ::matrix_type, const M *>::return_type(linalg_cast(m), si1, si2); + } + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + M *>::return_type + sub_matrix(M &m, const SUBI1 &si1) { + GMM_ASSERT2(si1.last() <= mat_nrows(m) && si1.last() <= mat_ncols(m), + "sub matrix too large"); + return typename select_return::matrix_type, typename sub_matrix_type + ::matrix_type, M *>::return_type(linalg_cast(m), si1, si1); + } + + template inline + typename select_return + ::matrix_type, typename sub_matrix_type::matrix_type, + const M *>::return_type + sub_matrix(const M &m, const SUBI1 &si1) { + GMM_ASSERT2(si1.last() <= mat_nrows(m) && si1.last() <= mat_ncols(m), + "sub matrix too large"); + return typename select_return::matrix_type, typename sub_matrix_type + ::matrix_type, const M *>::return_type(linalg_cast(m), si1, si1); + } + +} + +#endif // GMM_SUB_MATRIX_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_sub_vector.h b/7.x/src/linear_algebra/gmm/gmm_sub_vector.h new file mode 100644 index 0000000..2ca8df8 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_sub_vector.h @@ -0,0 +1,565 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_sub_vector.h + @author Yves Renard + @date October 13, 2002. + @brief Generic sub-vectors. +*/ + +#ifndef GMM_SUB_VECTOR_H__ +#define GMM_SUB_VECTOR_H__ + +#include "gmm_interface.h" +#include "gmm_sub_index.h" + +namespace gmm { + + /* ********************************************************************* */ + /* sparse sub-vectors */ + /* ********************************************************************* */ + + template + struct sparse_sub_vector_iterator { + + IT itb, itbe; + SUBI si; + + typedef std::iterator_traits traits_type; + typedef typename traits_type::value_type value_type; + typedef typename traits_type::pointer pointer; + typedef typename traits_type::reference reference; + typedef typename traits_type::difference_type difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef size_t size_type; + typedef sparse_sub_vector_iterator iterator; + + size_type index(void) const { return si.rindex(itb.index()); } + void forward(void); + void backward(void); + iterator &operator ++() + { ++itb; forward(); return *this; } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator &operator --() + { --itb; backward(); return *this; } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + reference operator *() const { return *itb; } + + bool operator ==(const iterator &i) const { return itb == i.itb; } + bool operator !=(const iterator &i) const { return !(i == *this); } + + sparse_sub_vector_iterator(void) {} + sparse_sub_vector_iterator(const IT &it, const IT &ite, const SUBI &s) + : itb(it), itbe(ite), si(s) { forward(); } + sparse_sub_vector_iterator + (const sparse_sub_vector_iterator &it) + : itb(it.itb), itbe(it.itbe), si(it.si) {} + sparse_sub_vector_iterator &operator = + (const sparse_sub_vector_iterator &it) + { itb = it.itb; itbe = it.itbe; si = it.si; return *this; } + + }; + + template + void sparse_sub_vector_iterator::forward(void) + { while(itb!=itbe && index()==size_type(-1)) { ++itb; } } + + template + void sparse_sub_vector_iterator::backward(void) + { while(itb!=itbe && index()==size_type(-1)) --itb; } + + template struct sparse_sub_vector { + typedef sparse_sub_vector this_type; + typedef typename std::iterator_traits::value_type V; + typedef V * CPT; + typedef typename select_ref::const_iterator, + typename linalg_traits::iterator, PT>::ref_type iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + SUBI si; + + size_type size(void) const { return si.size(); } + + reference operator[](size_type i) const + { return linalg_traits::access(origin, begin_, end_, si.index(i)); } + + sparse_sub_vector(V &v, const SUBI &s) : begin_(vect_begin(v)), + end_(vect_end(v)), origin(linalg_origin(v)), si(s) {} + sparse_sub_vector(const V &v, const SUBI &s) + : begin_(vect_begin(const_cast(v))), + end_(vect_end(const_cast(v))), + origin(linalg_origin(const_cast(v))), si(s) {} + sparse_sub_vector() {} + sparse_sub_vector(const sparse_sub_vector &cr) + : begin_(cr.begin_),end_(cr.end_),origin(cr.origin), si(cr.si) {} + }; + + template inline + void set_to_begin(sparse_sub_vector_iterator &it, + ORG o, sparse_sub_vector *, + linalg_modifiable) { + typedef sparse_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_begin(it.itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(it.itbe, o, typename linalg_traits::pV(), ref_t()); + it.forward(); + } + template inline + void set_to_begin(sparse_sub_vector_iterator &it, + ORG o, const sparse_sub_vector *, + linalg_modifiable) { + typedef sparse_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_begin(it.itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(it.itbe, o, typename linalg_traits::pV(), ref_t()); + it.forward(); + } + + template inline + void set_to_end(sparse_sub_vector_iterator &it, + ORG o, sparse_sub_vector *, linalg_modifiable) { + typedef sparse_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_end(it.itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(it.itbe, o, typename linalg_traits::pV(), ref_t()); + it.forward(); + } + template inline + void set_to_end(sparse_sub_vector_iterator &it, + ORG o, const sparse_sub_vector *, + linalg_modifiable) { + typedef sparse_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + set_to_end(it.itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(it.itbe, o, typename linalg_traits::pV(), ref_t()); + it.forward(); + } + + template + struct linalg_traits > { + typedef sparse_sub_vector this_type; + typedef this_type * pthis_type; + typedef PT pV; + typedef typename std::iterator_traits::value_type V; + typedef typename linalg_and::bool_type, + typename linalg_traits::index_sorted>::bool_type index_sorted; + typedef typename linalg_traits::is_reference V_reference; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef typename select_ref::const_iterator, + typename linalg_traits::iterator, PT>::ref_type pre_iterator; + typedef typename select_ref, + PT>::ref_type iterator; + typedef sparse_sub_vector_iterator + ::const_iterator, pre_iterator, SUBI> const_iterator; + typedef abstract_sparse storage_type; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { + iterator it; + it.itb = v.begin_; it.itbe = v.end_; it.si = v.si; + if (!is_const_reference(is_reference())) + set_to_begin(it, v.origin, pthis_type(), is_reference()); + else it.forward(); + return it; + } + static const_iterator begin(const this_type &v) { + const_iterator it; it.itb = v.begin_; it.itbe = v.end_; it.si = v.si; + if (!is_const_reference(is_reference())) + { set_to_begin(it, v.origin, pthis_type(), is_reference()); } + else it.forward(); + return it; + } + static iterator end(this_type &v) { + iterator it; + it.itb = v.end_; it.itbe = v.end_; it.si = v.si; + if (!is_const_reference(is_reference())) + set_to_end(it, v.origin, pthis_type(), is_reference()); + else it.forward(); + return it; + } + static const_iterator end(const this_type &v) { + const_iterator it; it.itb = v.end_; it.itbe = v.end_; it.si = v.si; + if (!is_const_reference(is_reference())) + set_to_end(it, v.origin, pthis_type(), is_reference()); + else it.forward(); + return it; + } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void clear(origin_type* o, const iterator &begin_, + const iterator &end_) { + std::deque ind; + iterator it = begin_; + for (; it != end_; ++it) ind.push_front(it.index()); + for (; !(ind.empty()); ind.pop_back()) + access(o, begin_, end_, ind.back()) = value_type(0); + } + static void do_clear(this_type &v) { clear(v.origin, begin(v), end(v)); } + static value_type access(const origin_type *o, const const_iterator &it, + const const_iterator &ite, size_type i) + { return linalg_traits::access(o, it.itb, ite.itb, it.si.index(i)); } + static reference access(origin_type *o, const iterator &it, + const iterator &ite, size_type i) + { return linalg_traits::access(o, it.itb, ite.itb, it.si.index(i)); } + }; + + template std::ostream &operator << + (std::ostream &o, const sparse_sub_vector& m) + { gmm::write(o,m); return o; } + + /* ********************************************************************* */ + /* skyline sub-vectors */ + /* ********************************************************************* */ + + template + struct skyline_sub_vector_iterator { + + IT itb; + SUBI si; + + typedef std::iterator_traits traits_type; + typedef typename traits_type::value_type value_type; + typedef typename traits_type::pointer pointer; + typedef typename traits_type::reference reference; + typedef typename traits_type::difference_type difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef size_t size_type; + typedef skyline_sub_vector_iterator iterator; + + size_type index(void) const + { return (itb.index() - si.min + si.step() - 1) / si.step(); } + void backward(void); + iterator &operator ++() + { itb += si.step(); return *this; } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator &operator --() + { itb -= si.step(); return *this; } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + + iterator &operator +=(difference_type i) + { itb += si.step() * i; return *this; } + iterator &operator -=(difference_type i) + { itb -= si.step() * i; return *this; } + iterator operator +(difference_type i) const + { iterator ii = *this; return (ii += i); } + iterator operator -(difference_type i) const + { iterator ii = *this; return (ii -= i); } + difference_type operator -(const iterator &i) const + { return (itb - i.itb) / si.step(); } + + reference operator *() const { return *itb; } + reference operator [](int ii) { return *(itb + ii * si.step()); } + + bool operator ==(const iterator &i) const { return index() == i.index();} + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return index() < i.index();} + + skyline_sub_vector_iterator(void) {} + skyline_sub_vector_iterator(const IT &it, const SUBI &s) + : itb(it), si(s) {} + skyline_sub_vector_iterator(const skyline_sub_vector_iterator &it) : itb(it.itb), si(it.si) {} + }; + + template + void update_for_sub_skyline(IT &it, IT &ite, const SUBI &si) { + if (it.index() >= si.max || ite.index() <= si.min) { it = ite; return; } + ptrdiff_t dec1 = si.min - it.index(), dec2 = ite.index() - si.max; + it += (dec1 < 0) ? ((si.step()-((-dec1) % si.step())) % si.step()) : dec1; + ite -= (dec2 < 0) ? -((-dec2) % si.step()) : dec2; + } + + template struct skyline_sub_vector { + typedef skyline_sub_vector this_type; + typedef typename std::iterator_traits::value_type V; + typedef V * pV; + typedef typename select_ref::const_iterator, + typename linalg_traits::iterator, PT>::ref_type iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + SUBI si; + + size_type size(void) const { return si.size(); } + + reference operator[](size_type i) const + { return linalg_traits::access(origin, begin_, end_, si.index(i)); } + + skyline_sub_vector(V &v, const SUBI &s) : begin_(vect_begin(v)), + end_(vect_end(v)), origin(linalg_origin(v)), si(s) { + update_for_sub_skyline(begin_, end_, si); + } + skyline_sub_vector(const V &v, const SUBI &s) + : begin_(vect_begin(const_cast(v))), + end_(vect_end(const_cast(v))), + origin(linalg_origin(const_cast(v))), si(s) { + update_for_sub_skyline(begin_, end_, si); + } + skyline_sub_vector() {} + skyline_sub_vector(const skyline_sub_vector &cr) + : begin_(cr.begin_),end_(cr.end_),origin(cr.origin), si(cr.si) {} + }; + + template inline + void set_to_begin(skyline_sub_vector_iterator &it, + ORG o, skyline_sub_vector *, + linalg_modifiable) { + typedef skyline_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + IT itbe = it.itb; + set_to_begin(it.itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(itbe, o, typename linalg_traits::pV(), ref_t()); + update_for_sub_skyline(it.itb, itbe, it.si); + } + template inline + void set_to_begin(skyline_sub_vector_iterator &it, + ORG o, const skyline_sub_vector *, + linalg_modifiable) { + typedef skyline_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + IT itbe = it.itb; + set_to_begin(it.itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(itbe, o, typename linalg_traits::pV(), ref_t()); + update_for_sub_skyline(it.itb, itbe, it.si); + } + + template inline + void set_to_end(skyline_sub_vector_iterator &it, + ORG o, skyline_sub_vector *, + linalg_modifiable) { + typedef skyline_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + IT itb = it.itb; + set_to_begin(itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(it.itb, o, typename linalg_traits::pV(), ref_t()); + update_for_sub_skyline(itb, it.itb, it.si); + } + template inline + void set_to_end(skyline_sub_vector_iterator &it, + ORG o, const skyline_sub_vector *, + linalg_modifiable) { + typedef skyline_sub_vector VECT; + typedef typename linalg_traits::V_reference ref_t; + IT itb = it.itb; + set_to_begin(itb, o, typename linalg_traits::pV(), ref_t()); + set_to_end(it.itb, o, typename linalg_traits::pV(), ref_t()); + update_for_sub_skyline(itb, it.itb, it.si); + } + + + template + struct linalg_traits > { + typedef skyline_sub_vector this_type; + typedef this_type *pthis_type; + typedef typename std::iterator_traits::value_type V; + typedef typename linalg_traits::is_reference V_reference; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef V * pV; + typedef typename which_reference::is_reference is_reference; + typedef abstract_vector linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef typename linalg_traits::const_iterator const_V_iterator; + typedef typename linalg_traits::iterator V_iterator; + typedef typename select_ref::ref_type pre_iterator; + typedef typename select_ref, + PT>::ref_type iterator; + typedef skyline_sub_vector_iterator + const_iterator; + typedef abstract_skyline storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { + iterator it; + it.itb = v.begin_; it.si = v.si; + if (!is_const_reference(is_reference())) + set_to_begin(it, v.origin, pthis_type(), is_reference()); + return it; + } + static const_iterator begin(const this_type &v) { + const_iterator it; it.itb = v.begin_; it.si = v.si; + if (!is_const_reference(is_reference())) + { set_to_begin(it, v.origin, pthis_type(), is_reference()); } + return it; + } + static iterator end(this_type &v) { + iterator it; + it.itb = v.end_; it.si = v.si; + if (!is_const_reference(is_reference())) + set_to_end(it, v.origin, pthis_type(), is_reference()); + return it; + } + static const_iterator end(const this_type &v) { + const_iterator it; it.itb = v.end_; it.si = v.si; + if (!is_const_reference(is_reference())) + set_to_end(it, v.origin, pthis_type(), is_reference()); + return it; + } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void clear(origin_type*, const iterator &it, const iterator &ite) + { std::fill(it, ite, value_type(0)); } + static void do_clear(this_type &v) { clear(v.origin, begin(v), end(v)); } + static value_type access(const origin_type *o, const const_iterator &it, + const const_iterator &ite, size_type i) + { return linalg_traits::access(o, it.itb, ite.itb, it.si.index(i)); } + static reference access(origin_type *o, const iterator &it, + const iterator &ite, size_type i) + { return linalg_traits::access(o, it.itb, ite.itb, it.si.index(i)); } + }; + + template std::ostream &operator << + (std::ostream &o, const skyline_sub_vector& m) + { gmm::write(o,m); return o; } + + /* ******************************************************************** */ + /* sub vector. */ + /* ******************************************************************** */ + /* sub_vector_type::vector_type is the sub vector type */ + /* returned by sub_vector(v, sub_index) */ + /************************************************************************/ + + template struct svrt_ir { + typedef abstract_null_type vector_type; + }; + + template + struct svrt_ir { + typedef typename std::iterator_traits::value_type V; + typedef typename vect_ref_type::iterator iterator; + typedef tab_ref_index_ref_with_origin vector_type; + }; + + template + struct svrt_ir { + typedef typename std::iterator_traits::value_type V; + typedef typename vect_ref_type::iterator iterator; + typedef tab_ref_index_ref_with_origin vector_type; + }; + + template + struct svrt_ir { + typedef typename std::iterator_traits::value_type V; + typedef typename vect_ref_type::iterator iterator; + typedef tab_ref_with_origin vector_type; + }; + + template + struct svrt_ir { + typedef typename std::iterator_traits::value_type V; + typedef typename vect_ref_type::iterator iterator; + typedef tab_ref_reg_spaced_with_origin vector_type; + }; + + template + struct svrt_ir { + typedef skyline_sub_vector vector_type; + }; + + template + struct svrt_ir { + typedef sparse_sub_vector vector_type; + }; + + template + struct svrt_ir { + typedef sparse_sub_vector vector_type; + }; + + + template + struct svrt_ir { + typedef sparse_sub_vector vector_type; + }; + + template + struct sub_vector_type { + typedef typename std::iterator_traits::value_type V; + typedef typename svrt_ir::storage_type>::vector_type vector_type; + }; + + template + typename select_return< + typename sub_vector_type::vector_type, + typename sub_vector_type::vector_type, const V *>::return_type + sub_vector(const V &v, const SUBI &si) { + GMM_ASSERT2(si.last() <= vect_size(v), + "sub vector too large, " << si.last() << " > " << vect_size(v)); + return typename select_return< + typename sub_vector_type::vector_type, + typename sub_vector_type::vector_type, const V *>::return_type + (linalg_cast(v), si); + } + + template + typename select_return< + typename sub_vector_type::vector_type, + typename sub_vector_type::vector_type, V *>::return_type + sub_vector(V &v, const SUBI &si) { + GMM_ASSERT2(si.last() <= vect_size(v), + "sub vector too large, " << si.last() << " > " << vect_size(v)); + return typename select_return< + typename sub_vector_type::vector_type, + typename sub_vector_type::vector_type, V *>::return_type + (linalg_cast(v), si); + } + +} + +#endif // GMM_SUB_VECTOR_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_superlu_interface.h b/7.x/src/linear_algebra/gmm/gmm_superlu_interface.h new file mode 100644 index 0000000..2a7a2a4 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_superlu_interface.h @@ -0,0 +1,410 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_superlu_interface.h + @author Yves Renard + @date October 17, 2003. + @brief Interface with SuperLU (LU direct solver for sparse matrices). +*/ +#if defined(GMM_USES_SUPERLU) && !defined(GETFEM_VERSION) + +#ifndef GMM_SUPERLU_INTERFACE_H +#define GMM_SUPERLU_INTERFACE_H + +#include "gmm_kernel.h" + +typedef int int_t; + +/* because SRC/util.h defines TRUE and FALSE ... */ +#ifdef TRUE +# undef TRUE +#endif +#ifdef FALSE +# undef FALSE +#endif + +#include "superlu/slu_Cnames.h" +#include "superlu/supermatrix.h" +#include "superlu/slu_util.h" + +namespace SuperLU_S { +#include "superlu/slu_sdefs.h" +} +namespace SuperLU_D { +#include "superlu/slu_ddefs.h" +} +namespace SuperLU_C { +#include "superlu/slu_cdefs.h" +} +namespace SuperLU_Z { +#include "superlu/slu_zdefs.h" +} + + + +namespace gmm { + + /* interface for Create_CompCol_Matrix */ + + inline void Create_CompCol_Matrix(SuperMatrix *A, int m, int n, int nnz, + float *a, int *ir, int *jc) { + SuperLU_S::sCreate_CompCol_Matrix(A, m, n, nnz, a, ir, jc, + SLU_NC, SLU_S, SLU_GE); + } + + inline void Create_CompCol_Matrix(SuperMatrix *A, int m, int n, int nnz, + double *a, int *ir, int *jc) { + SuperLU_D::dCreate_CompCol_Matrix(A, m, n, nnz, a, ir, jc, + SLU_NC, SLU_D, SLU_GE); + } + + inline void Create_CompCol_Matrix(SuperMatrix *A, int m, int n, int nnz, + std::complex *a, int *ir, int *jc) { + SuperLU_C::cCreate_CompCol_Matrix(A, m, n, nnz, (SuperLU_C::complex *)(a), + ir, jc, SLU_NC, SLU_C, SLU_GE); + } + + inline void Create_CompCol_Matrix(SuperMatrix *A, int m, int n, int nnz, + std::complex *a, int *ir, int *jc) { + SuperLU_Z::zCreate_CompCol_Matrix(A, m, n, nnz, + (SuperLU_Z::doublecomplex *)(a), ir, jc, + SLU_NC, SLU_Z, SLU_GE); + } + + /* interface for Create_Dense_Matrix */ + + inline void Create_Dense_Matrix(SuperMatrix *A, int m, int n, float *a, int k) + { SuperLU_S::sCreate_Dense_Matrix(A, m, n, a, k, SLU_DN, SLU_S, SLU_GE); } + inline void Create_Dense_Matrix(SuperMatrix *A, int m, int n, double *a, int k) + { SuperLU_D::dCreate_Dense_Matrix(A, m, n, a, k, SLU_DN, SLU_D, SLU_GE); } + inline void Create_Dense_Matrix(SuperMatrix *A, int m, int n, + std::complex *a, int k) { + SuperLU_C::cCreate_Dense_Matrix(A, m, n, (SuperLU_C::complex *)(a), + k, SLU_DN, SLU_C, SLU_GE); + } + inline void Create_Dense_Matrix(SuperMatrix *A, int m, int n, + std::complex *a, int k) { + SuperLU_Z::zCreate_Dense_Matrix(A, m, n, (SuperLU_Z::doublecomplex *)(a), + k, SLU_DN, SLU_Z, SLU_GE); + } + + /* interface for gssv */ + +#define DECL_GSSV(NAMESPACE,FNAME,FLOATTYPE,KEYTYPE) \ + inline void SuperLU_gssv(superlu_options_t *options, SuperMatrix *A, int *p, \ + int *q, SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, \ + SuperLUStat_t *stats, int *info, KEYTYPE) { \ + NAMESPACE::FNAME(options, A, p, q, L, U, B, stats, info); \ + } + + DECL_GSSV(SuperLU_S,sgssv,float,float) + DECL_GSSV(SuperLU_C,cgssv,float,std::complex) + DECL_GSSV(SuperLU_D,dgssv,double,double) + DECL_GSSV(SuperLU_Z,zgssv,double,std::complex) + + /* interface for gssvx */ + +#define DECL_GSSVX(NAMESPACE,FNAME,FLOATTYPE,KEYTYPE) \ + inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A, \ + int *perm_c, int *perm_r, int *etree, char *equed, \ + FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L, \ + SuperMatrix *U, void *work, int lwork, \ + SuperMatrix *B, SuperMatrix *X, \ + FLOATTYPE *recip_pivot_growth, \ + FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr, \ + SuperLUStat_t *stats, int *info, KEYTYPE) { \ + NAMESPACE::mem_usage_t mem_usage; \ + NAMESPACE::FNAME(options, A, perm_c, perm_r, etree, equed, R, C, L, \ + U, work, lwork, B, X, recip_pivot_growth, rcond, \ + ferr, berr, &mem_usage, stats, info); \ + return mem_usage.for_lu; /* bytes used by the factor storage */ \ + } + + DECL_GSSVX(SuperLU_S,sgssvx,float,float) + DECL_GSSVX(SuperLU_C,cgssvx,float,std::complex) + DECL_GSSVX(SuperLU_D,dgssvx,double,double) + DECL_GSSVX(SuperLU_Z,zgssvx,double,std::complex) + + /* ********************************************************************* */ + /* SuperLU solve interface */ + /* ********************************************************************* */ + + template + int SuperLU_solve(const MAT &A, const VECTX &X_, const VECTB &B, + double& rcond_, int permc_spec = 3) { + VECTX &X = const_cast(X_); + /* + * Get column permutation vector perm_c[], according to permc_spec: + * permc_spec = 0: use the natural ordering + * permc_spec = 1: use minimum degree ordering on structure of A'*A + * permc_spec = 2: use minimum degree ordering on structure of A'+A + * permc_spec = 3: use approximate minimum degree column ordering + */ + typedef typename linalg_traits::value_type T; + typedef typename number_traits::magnitude_type R; + + int m = mat_nrows(A), n = mat_ncols(A), nrhs = 1, info = 0; + + csc_matrix csc_A(m, n); gmm::copy(A, csc_A); + std::vector rhs(m), sol(m); + gmm::copy(B, rhs); + + int nz = nnz(csc_A); + if ((2 * nz / n) >= m) + GMM_WARNING2("CAUTION : it seems that SuperLU has a problem" + " for nearly dense sparse matrices"); + + superlu_options_t options; + set_default_options(&options); + options.ColPerm = NATURAL; + options.PrintStat = NO; + options.ConditionNumber = YES; + switch (permc_spec) { + case 1 : options.ColPerm = MMD_ATA; break; + case 2 : options.ColPerm = MMD_AT_PLUS_A; break; + case 3 : options.ColPerm = COLAMD; break; + } + SuperLUStat_t stat; + StatInit(&stat); + + SuperMatrix SA, SL, SU, SB, SX; // SuperLU format. + Create_CompCol_Matrix(&SA, m, n, nz, (double *)(&(csc_A.pr[0])), + (int *)(&(csc_A.ir[0])), (int *)(&(csc_A.jc[0]))); + Create_Dense_Matrix(&SB, m, nrhs, &rhs[0], m); + Create_Dense_Matrix(&SX, m, nrhs, &sol[0], m); + memset(&SL,0,sizeof SL); + memset(&SU,0,sizeof SU); + + std::vector etree(n); + char equed[] = "B"; + std::vector Rscale(m),Cscale(n); // row scale factors + std::vector ferr(nrhs), berr(nrhs); + R recip_pivot_gross, rcond; + std::vector perm_r(m), perm_c(n); + + SuperLU_gssvx(&options, &SA, &perm_c[0], &perm_r[0], + &etree[0] /* output */, equed /* output */, + &Rscale[0] /* row scale factors (output) */, + &Cscale[0] /* col scale factors (output) */, + &SL /* fact L (output)*/, &SU /* fact U (output)*/, + NULL /* work */, + 0 /* lwork: superlu auto allocates (input) */, + &SB /* rhs */, &SX /* solution */, + &recip_pivot_gross /* reciprocal pivot growth */ + /* factor max_j( norm(A_j)/norm(U_j) ). */, + &rcond /*estimate of the reciprocal condition */ + /* number of the matrix A after equilibration */, + &ferr[0] /* estimated forward error */, + &berr[0] /* relative backward error */, + &stat, &info, T()); + rcond_ = rcond; + Destroy_SuperMatrix_Store(&SB); + Destroy_SuperMatrix_Store(&SX); + Destroy_SuperMatrix_Store(&SA); + Destroy_SuperNode_Matrix(&SL); + Destroy_CompCol_Matrix(&SU); + StatFree(&stat); + GMM_ASSERT1(info >= 0, "SuperLU solve failed: info =" << info); + if (info > 0) GMM_WARNING1("SuperLU solve failed: info =" << info); + gmm::copy(sol, X); + return info; + } + + template class SuperLU_factor { + typedef typename number_traits::magnitude_type R; + + csc_matrix csc_A; + mutable SuperMatrix SA, SL, SB, SU, SX; + mutable SuperLUStat_t stat; + mutable superlu_options_t options; + float memory_used; + mutable std::vector etree, perm_r, perm_c; + mutable std::vector Rscale, Cscale; + mutable std::vector ferr, berr; + mutable std::vector rhs; + mutable std::vector sol; + mutable bool is_init; + mutable char equed; + + public : + enum { LU_NOTRANSP, LU_TRANSP, LU_CONJUGATED }; + void free_supermatrix(void); + template void build_with(const MAT &A, int permc_spec = 3); + template + /* transp = LU_NOTRANSP -> solves Ax = B + transp = LU_TRANSP -> solves A'x = B + transp = LU_CONJUGATED -> solves conj(A)X = B */ + void solve(const VECTX &X_, const VECTB &B, int transp=LU_NOTRANSP) const; + SuperLU_factor(void) { is_init = false; } + SuperLU_factor(const SuperLU_factor& other) { + GMM_ASSERT2(!(other.is_init), + "copy of initialized SuperLU_factor is forbidden"); + is_init = false; + } + SuperLU_factor& operator=(const SuperLU_factor& other) { + GMM_ASSERT2(!(other.is_init) && !is_init, + "assignment of initialized SuperLU_factor is forbidden"); + return *this; + } + ~SuperLU_factor() { free_supermatrix(); } + float memsize() { return memory_used; } + }; + + + template void SuperLU_factor::free_supermatrix(void) { + if (is_init) { + if (SB.Store) Destroy_SuperMatrix_Store(&SB); + if (SX.Store) Destroy_SuperMatrix_Store(&SX); + if (SA.Store) Destroy_SuperMatrix_Store(&SA); + if (SL.Store) Destroy_SuperNode_Matrix(&SL); + if (SU.Store) Destroy_CompCol_Matrix(&SU); + } + } + + + template template + void SuperLU_factor::build_with(const MAT &A, int permc_spec) { + /* + * Get column permutation vector perm_c[], according to permc_spec: + * permc_spec = 0: use the natural ordering + * permc_spec = 1: use minimum degree ordering on structure of A'*A + * permc_spec = 2: use minimum degree ordering on structure of A'+A + * permc_spec = 3: use approximate minimum degree column ordering + */ + free_supermatrix(); + int n = mat_nrows(A), m = mat_ncols(A), info = 0; + csc_A.init_with(A); + + rhs.resize(m); sol.resize(m); + gmm::clear(rhs); + int nz = nnz(csc_A); + + set_default_options(&options); + options.ColPerm = NATURAL; + options.PrintStat = NO; + options.ConditionNumber = NO; + switch (permc_spec) { + case 1 : options.ColPerm = MMD_ATA; break; + case 2 : options.ColPerm = MMD_AT_PLUS_A; break; + case 3 : options.ColPerm = COLAMD; break; + } + StatInit(&stat); + + Create_CompCol_Matrix(&SA, m, n, nz, (double *)(&(csc_A.pr[0])), + (int *)(&(csc_A.ir[0])), (int *)(&(csc_A.jc[0]))); + + Create_Dense_Matrix(&SB, m, 0, &rhs[0], m); + Create_Dense_Matrix(&SX, m, 0, &sol[0], m); + memset(&SL,0,sizeof SL); + memset(&SU,0,sizeof SU); + equed = 'B'; + Rscale.resize(m); Cscale.resize(n); etree.resize(n); + ferr.resize(1); berr.resize(1); + R recip_pivot_gross, rcond; + perm_r.resize(m); perm_c.resize(n); + memory_used = SuperLU_gssvx(&options, &SA, &perm_c[0], &perm_r[0], + &etree[0] /* output */, &equed /* output */, + &Rscale[0] /* row scale factors (output) */, + &Cscale[0] /* col scale factors (output) */, + &SL /* fact L (output)*/, &SU /* fact U (output)*/, + NULL /* work */, + 0 /* lwork: superlu auto allocates (input) */, + &SB /* rhs */, &SX /* solution */, + &recip_pivot_gross /* reciprocal pivot growth */ + /* factor max_j( norm(A_j)/norm(U_j) ). */, + &rcond /*estimate of the reciprocal condition */ + /* number of the matrix A after equilibration */, + &ferr[0] /* estimated forward error */, + &berr[0] /* relative backward error */, + &stat, &info, T()); + + Destroy_SuperMatrix_Store(&SB); + Destroy_SuperMatrix_Store(&SX); + Create_Dense_Matrix(&SB, m, 1, &rhs[0], m); + Create_Dense_Matrix(&SX, m, 1, &sol[0], m); + StatFree(&stat); + + GMM_ASSERT1(info == 0, "SuperLU solve failed: info=" << info); + is_init = true; + } + + template template + void SuperLU_factor::solve(const VECTX &X_, const VECTB &B, + int transp) const { + VECTX &X = const_cast(X_); + gmm::copy(B, rhs); + options.Fact = FACTORED; + options.IterRefine = NOREFINE; + switch (transp) { + case LU_NOTRANSP: options.Trans = NOTRANS; break; + case LU_TRANSP: options.Trans = TRANS; break; + case LU_CONJUGATED: options.Trans = CONJ; break; + default: GMM_ASSERT1(false, "invalid value for transposition option"); + } + StatInit(&stat); + int info = 0; + R recip_pivot_gross, rcond; + SuperLU_gssvx(&options, &SA, &perm_c[0], &perm_r[0], + &etree[0] /* output */, &equed /* output */, + &Rscale[0] /* row scale factors (output) */, + &Cscale[0] /* col scale factors (output) */, + &SL /* fact L (output)*/, &SU /* fact U (output)*/, + NULL /* work */, + 0 /* lwork: superlu auto allocates (input) */, + &SB /* rhs */, &SX /* solution */, + &recip_pivot_gross /* reciprocal pivot growth */ + /* factor max_j( norm(A_j)/norm(U_j) ). */, + &rcond /*estimate of the reciprocal condition */ + /* number of the matrix A after equilibration */, + &ferr[0] /* estimated forward error */, + &berr[0] /* relative backward error */, + &stat, &info, T()); + StatFree(&stat); + GMM_ASSERT1(info == 0, "SuperLU solve failed: info=" << info); + gmm::copy(sol, X); + } + + template inline + void mult(const SuperLU_factor& P, const V1 &v1, const V2 &v2) { + P.solve(v2,v1); + } + + template inline + void transposed_mult(const SuperLU_factor& P,const V1 &v1,const V2 &v2) { + P.solve(v2, v1, SuperLU_factor::LU_TRANSP); + } + +} + + +#endif // GMM_SUPERLU_INTERFACE_H + +#endif // GMM_USES_SUPERLU diff --git a/7.x/src/linear_algebra/gmm/gmm_transposed.h b/7.x/src/linear_algebra/gmm/gmm_transposed.h new file mode 100644 index 0000000..77cf460 --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_transposed.h @@ -0,0 +1,244 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_transposed.h + @author Yves Renard + @date November 10, 2002. + @brief Generic transposed matrices +*/ +#ifndef GMM_TRANSPOSED_H__ +#define GMM_TRANSPOSED_H__ + +#include "gmm_def.h" + +namespace gmm { + + /* ********************************************************************* */ + /* transposed reference */ + /* ********************************************************************* */ + + template struct transposed_row_ref { + + typedef transposed_row_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef M * CPT; + typedef typename std::iterator_traits::reference ref_M; + typedef typename select_ref + ::const_col_iterator, typename linalg_traits + ::col_iterator, PT>::ref_type iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + size_type nr, nc; + + transposed_row_ref(ref_M m) + : begin_(mat_row_begin(m)), end_(mat_row_end(m)), + origin(linalg_origin(m)), nr(mat_ncols(m)), nc(mat_nrows(m)) {} + + transposed_row_ref(const transposed_row_ref &cr) : + begin_(cr.begin_),end_(cr.end_), origin(cr.origin),nr(cr.nr),nc(cr.nc) {} + + reference operator()(size_type i, size_type j) const + { return linalg_traits::access(begin_+j, i); } + }; + + template struct linalg_traits > { + typedef transposed_row_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef typename linalg_traits::storage_type storage_type; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_row_iterator; + typedef typename linalg_traits::const_sub_row_type const_sub_col_type; + typedef typename select_ref::sub_row_type, PT>::ref_type sub_col_type; + typedef typename linalg_traits::const_row_iterator const_col_iterator; + typedef typename select_ref::row_iterator, PT>::ref_type col_iterator; + typedef col_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type ncols(const this_type &v) { return v.nc; } + static size_type nrows(const this_type &v) { return v.nr; } + static const_sub_col_type col(const const_col_iterator &it) + { return linalg_traits::row(it); } + static sub_col_type col(const col_iterator &it) + { return linalg_traits::row(it); } + static col_iterator col_begin(this_type &m) { return m.begin_; } + static col_iterator col_end(this_type &m) { return m.end_; } + static const_col_iterator col_begin(const this_type &m) + { return m.begin_; } + static const_col_iterator col_end(const this_type &m) { return m.end_; } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void do_clear(this_type &v); + static value_type access(const const_col_iterator &itcol, size_type i) + { return linalg_traits::access(itcol, i); } + static reference access(const col_iterator &itcol, size_type i) + { return linalg_traits::access(itcol, i); } + }; + + template + void linalg_traits >::do_clear(this_type &v) { + col_iterator it = mat_col_begin(v), ite = mat_col_end(v); + for (; it != ite; ++it) clear(col(it)); + } + + template std::ostream &operator << + (std::ostream &o, const transposed_row_ref& m) + { gmm::write(o,m); return o; } + + template struct transposed_col_ref { + + typedef transposed_col_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef M * CPT; + typedef typename std::iterator_traits::reference ref_M; + typedef typename select_ref + ::const_row_iterator, typename linalg_traits + ::row_iterator, PT>::ref_type iterator; + typedef typename linalg_traits::reference reference; + typedef typename linalg_traits::porigin_type porigin_type; + + iterator begin_, end_; + porigin_type origin; + size_type nr, nc; + + transposed_col_ref(ref_M m) + : begin_(mat_col_begin(m)), end_(mat_col_end(m)), + origin(linalg_origin(m)), nr(mat_ncols(m)), nc(mat_nrows(m)) {} + + transposed_col_ref(const transposed_col_ref &cr) : + begin_(cr.begin_),end_(cr.end_), origin(cr.origin),nr(cr.nr),nc(cr.nc) {} + + reference operator()(size_type i, size_type j) const + { return linalg_traits::access(begin_+i, j); } + }; + + template struct linalg_traits > { + typedef transposed_col_ref this_type; + typedef typename std::iterator_traits::value_type M; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef typename linalg_traits::storage_type storage_type; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_col_iterator; + typedef typename linalg_traits::const_sub_col_type const_sub_row_type; + typedef typename select_ref::sub_col_type, PT>::ref_type sub_row_type; + typedef typename linalg_traits::const_col_iterator const_row_iterator; + typedef typename select_ref::col_iterator, PT>::ref_type row_iterator; + typedef row_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type nrows(const this_type &v) + { return v.nr; } + static size_type ncols(const this_type &v) + { return v.nc; } + static const_sub_row_type row(const const_row_iterator &it) + { return linalg_traits::col(it); } + static sub_row_type row(const row_iterator &it) + { return linalg_traits::col(it); } + static row_iterator row_begin(this_type &m) { return m.begin_; } + static row_iterator row_end(this_type &m) { return m.end_; } + static const_row_iterator row_begin(const this_type &m) + { return m.begin_; } + static const_row_iterator row_end(const this_type &m) { return m.end_; } + static origin_type* origin(this_type &v) { return v.origin; } + static const origin_type* origin(const this_type &v) { return v.origin; } + static void do_clear(this_type &m); + static value_type access(const const_row_iterator &itrow, size_type i) + { return linalg_traits::access(itrow, i); } + static reference access(const row_iterator &itrow, size_type i) + { return linalg_traits::access(itrow, i); } + }; + + template + void linalg_traits >::do_clear(this_type &v) { + row_iterator it = mat_row_begin(v), ite = mat_row_end(v); + for (; it != ite; ++it) clear(row(it)); + } + + template std::ostream &operator << + (std::ostream &o, const transposed_col_ref& m) + { gmm::write(o,m); return o; } + + template struct transposed_return_ { + typedef abstract_null_type return_type; + }; + template struct transposed_return_ { + typedef typename std::iterator_traits::value_type L; + typedef typename select_return, + transposed_row_ref< L *>, PT>::return_type return_type; + }; + template struct transposed_return_ { + typedef typename std::iterator_traits::value_type L; + typedef typename select_return, + transposed_col_ref< L *>, PT>::return_type return_type; + }; + template struct transposed_return { + typedef typename std::iterator_traits::value_type L; + typedef typename transposed_return_::sub_orientation>::potype, + PT>::return_type return_type; + }; + + template inline + typename transposed_return::return_type transposed(const L &l) { + return typename transposed_return::return_type + (linalg_cast(const_cast(l))); + } + + template inline + typename transposed_return::return_type transposed(L &l) + { return typename transposed_return::return_type(linalg_cast(l)); } + +} + +#endif // GMM_TRANSPOSED_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_tri_solve.h b/7.x/src/linear_algebra/gmm/gmm_tri_solve.h new file mode 100644 index 0000000..ad2590f --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_tri_solve.h @@ -0,0 +1,222 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_tri_solve.h + @author Yves Renard + @date October 13, 2002. + @brief Solve triangular linear system for dense matrices. +*/ + +#ifndef GMM_TRI_SOLVE_H__ +#define GMM_TRI_SOLVE_H__ + +#include "gmm_interface.h" + +namespace gmm { + + template + void upper_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + col_major, abstract_sparse, bool is_unit) { + typename linalg_traits::value_type x_j; + for (int j = int(k) - 1; j >= 0; --j) { + typedef typename linalg_traits::const_sub_col_type COL; + COL c = mat_const_col(T, j); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c), ite = vect_const_end(c); + if (!is_unit) x[j] /= c[j]; + for (x_j = x[j]; it != ite ; ++it) + if (int(it.index()) < j) x[it.index()] -= x_j * (*it); + } + } + + template + void upper_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + col_major, abstract_dense, bool is_unit) { + typename linalg_traits::value_type x_j; + for (int j = int(k) - 1; j >= 0; --j) { + typedef typename linalg_traits::const_sub_col_type COL; + COL c = mat_const_col(T, j); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c), ite = it + j; + typename linalg_traits::iterator itx = vect_begin(x); + if (!is_unit) x[j] /= c[j]; + for (x_j = x[j]; it != ite ; ++it, ++itx) *itx -= x_j * (*it); + } + } + + template + void lower_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + col_major, abstract_sparse, bool is_unit) { + typename linalg_traits::value_type x_j; + // cout << "(lower col)The Tri Matrix = " << T << endl; + // cout << "k = " << endl; + for (int j = 0; j < int(k); ++j) { + typedef typename linalg_traits::const_sub_col_type COL; + COL c = mat_const_col(T, j); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c), ite = vect_const_end(c); + if (!is_unit) x[j] /= c[j]; + for (x_j = x[j]; it != ite ; ++it) + if (int(it.index()) > j && it.index() < k) x[it.index()] -= x_j*(*it); + } + } + + template + void lower_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + col_major, abstract_dense, bool is_unit) { + typename linalg_traits::value_type x_j; + for (int j = 0; j < int(k); ++j) { + typedef typename linalg_traits::const_sub_col_type COL; + COL c = mat_const_col(T, j); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c) + (j+1), ite = vect_const_begin(c) + k; + typename linalg_traits::iterator itx = vect_begin(x) + (j+1); + if (!is_unit) x[j] /= c[j]; + for (x_j = x[j]; it != ite ; ++it, ++itx) *itx -= x_j * (*it); + } + } + + + template + void upper_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + row_major, abstract_sparse, bool is_unit) { + typedef typename linalg_traits::const_sub_row_type ROW; + typename linalg_traits::value_type t; + typename linalg_traits::const_row_iterator + itr = mat_row_const_end(T); + for (int i = int(k) - 1; i >= 0; --i) { + --itr; + ROW c = linalg_traits::row(itr); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c), ite = vect_const_end(c); + for (t = x[i]; it != ite; ++it) + if (int(it.index()) > i && it.index() < k) t -= (*it) * x[it.index()]; + if (!is_unit) x[i] = t / c[i]; else x[i] = t; + } + } + + template + void upper_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + row_major, abstract_dense, bool is_unit) { + typename linalg_traits::value_type t; + + for (int i = int(k) - 1; i >= 0; --i) { + typedef typename linalg_traits::const_sub_row_type ROW; + ROW c = mat_const_row(T, i); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c) + (i + 1), ite = vect_const_begin(c) + k; + typename linalg_traits::iterator itx = vect_begin(x) + (i+1); + + for (t = x[i]; it != ite; ++it, ++itx) t -= (*it) * (*itx); + if (!is_unit) x[i] = t / c[i]; else x[i] = t; + } + } + + template + void lower_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + row_major, abstract_sparse, bool is_unit) { + typename linalg_traits::value_type t; + + for (int i = 0; i < int(k); ++i) { + typedef typename linalg_traits::const_sub_row_type ROW; + ROW c = mat_const_row(T, i); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c), ite = vect_const_end(c); + + for (t = x[i]; it != ite; ++it) + if (int(it.index()) < i) t -= (*it) * x[it.index()]; + if (!is_unit) x[i] = t / c[i]; else x[i] = t; + } + } + + template + void lower_tri_solve__(const TriMatrix& T, VecX& x, size_t k, + row_major, abstract_dense, bool is_unit) { + typename linalg_traits::value_type t; + + for (int i = 0; i < int(k); ++i) { + typedef typename linalg_traits::const_sub_row_type ROW; + ROW c = mat_const_row(T, i); + typename linalg_traits::t>::const_iterator + it = vect_const_begin(c), ite = it + i; + typename linalg_traits::iterator itx = vect_begin(x); + + for (t = x[i]; it != ite; ++it, ++itx) t -= (*it) * (*itx); + if (!is_unit) x[i] = t / c[i]; else x[i] = t; + } + } + + +// Triangular Solve: x <-- T^{-1} * x + + template inline + void upper_tri_solve(const TriMatrix& T, VecX &x_, bool is_unit = false) + { upper_tri_solve(T, x_, mat_nrows(T), is_unit); } + + template inline + void lower_tri_solve(const TriMatrix& T, VecX &x_, bool is_unit = false) + { lower_tri_solve(T, x_, mat_nrows(T), is_unit); } + + template inline + void upper_tri_solve(const TriMatrix& T, VecX &x_, size_t k, + bool is_unit) { + VecX& x = const_cast(x_); + GMM_ASSERT2(mat_nrows(T) >= k && vect_size(x) >= k + && mat_ncols(T) >= k && !is_sparse(x_), "dimensions mismatch"); + upper_tri_solve__(T, x, k, + typename principal_orientation_type::sub_orientation>::potype(), + typename linalg_traits::storage_type(), + is_unit); + } + + template inline + void lower_tri_solve(const TriMatrix& T, VecX &x_, size_t k, + bool is_unit) { + VecX& x = const_cast(x_); + GMM_ASSERT2(mat_nrows(T) >= k && vect_size(x) >= k + && mat_ncols(T) >= k && !is_sparse(x_), "dimensions mismatch"); + lower_tri_solve__(T, x, k, + typename principal_orientation_type::sub_orientation>::potype(), + typename linalg_traits::storage_type(), + is_unit); + } + + + + + + +} + + +#endif // GMM_TRI_SOLVE_H__ diff --git a/7.x/src/linear_algebra/gmm/gmm_vector.h b/7.x/src/linear_algebra/gmm/gmm_vector.h new file mode 100644 index 0000000..2e4919b --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_vector.h @@ -0,0 +1,1590 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2002-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ +/**@file gmm_vector.h + @author Yves Renard + @date October 13, 2002. + @brief Declaration of the vector types (gmm::rsvector, gmm::wsvector, + gmm::slvector ,..) +*/ +#ifndef GMM_VECTOR_H__ +#define GMM_VECTOR_H__ + +#include +#include "gmm_interface.h" + +namespace gmm { + + /*************************************************************************/ + /* */ + /* Class ref_elt_vector: reference on a vector component. */ + /* */ + /*************************************************************************/ + + + template class ref_elt_vector { + + V *pm; + size_type l; + + public : + + operator T() const { return pm->r(l); } + ref_elt_vector(V *p, size_type ll) : pm(p), l(ll) {} + inline bool operator ==(T v) const { return ((*pm).r(l) == v); } + inline bool operator !=(T v) const { return ((*pm).r(l) != v); } + inline bool operator ==(std::complex v) const + { return ((*pm).r(l) == v); } + inline bool operator !=(std::complex v) const + { return ((*pm).r(l) != v); } + inline ref_elt_vector &operator +=(T v) + { (*pm).wa(l, v); return *this; } + inline ref_elt_vector &operator -=(T v) + { (*pm).wa(l, -v); return *this; } + inline ref_elt_vector &operator /=(T v) + { (*pm).w(l,(*pm).r(l) / v); return *this; } + inline ref_elt_vector &operator *=(T v) + { (*pm).w(l,(*pm).r(l) * v); return *this; } + inline ref_elt_vector &operator =(const ref_elt_vector &re) + { *this = T(re); return *this; } + inline ref_elt_vector &operator =(T v) + { (*pm).w(l,v); return *this; } + T operator +() { return T(*this); } + T operator -() { return -T(*this); } + T operator +(T v) { return T(*this)+ v; } + T operator -(T v) { return T(*this)- v; } + T operator *(T v) { return T(*this)* v; } + T operator /(T v) { return T(*this)/ v; } + std::complex operator +(std::complex v) { return T(*this)+ v; } + std::complex operator -(std::complex v) { return T(*this)- v; } + std::complex operator *(std::complex v) { return T(*this)* v; } + std::complex operator /(std::complex v) { return T(*this)/ v; } + }; + + template class ref_elt_vector,V> { + + V *pm; + size_type l; + + public : + + operator std::complex() const { return pm->r(l); } + ref_elt_vector(V *p, size_type ll) : pm(p), l(ll) {} + ref_elt_vector(const ref_elt_vector &re) : pm(re.pm), l(re.l) {} + inline bool operator ==(std::complex v) const + { return ((*pm).r(l) == v); } + inline bool operator !=(std::complex v) const + { return ((*pm).r(l) != v); } + inline bool operator ==(T v) const { return ((*pm).r(l) == v); } + inline bool operator !=(T v) const { return ((*pm).r(l) != v); } + inline ref_elt_vector &operator +=(std::complex v) + { (*pm).w(l,(*pm).r(l) + v); return *this; } + inline ref_elt_vector &operator -=(std::complex v) + { (*pm).w(l,(*pm).r(l) - v); return *this; } + inline ref_elt_vector &operator /=(std::complex v) + { (*pm).w(l,(*pm).r(l) / v); return *this; } + inline ref_elt_vector &operator *=(std::complex v) + { (*pm).w(l,(*pm).r(l) * v); return *this; } + inline ref_elt_vector &operator =(const ref_elt_vector &re) + { *this = std::complex(re); return *this; } + inline ref_elt_vector &operator =(std::complex v) + { (*pm).w(l,v); return *this; } + inline ref_elt_vector &operator =(T v) + { (*pm).w(l,std::complex(v)); return *this; } + inline ref_elt_vector &operator +=(T v) + { (*pm).w(l,(*pm).r(l) + v); return *this; } + inline ref_elt_vector &operator -=(T v) + { (*pm).w(l,(*pm).r(l) - v); return *this; } + inline ref_elt_vector &operator /=(T v) + { (*pm).w(l,(*pm).r(l) / v); return *this; } + inline ref_elt_vector &operator *=(T v) + { (*pm).w(l,(*pm).r(l) * v); return *this; } + std::complex operator +() { return std::complex(*this); } + std::complex operator -() { return -std::complex(*this); } + std::complex operator +(T v) { return std::complex(*this)+ v; } + std::complex operator -(T v) { return std::complex(*this)- v; } + std::complex operator *(T v) { return std::complex(*this)* v; } + std::complex operator /(T v) { return std::complex(*this)/ v; } + std::complex operator +(std::complex v) + { return std::complex(*this)+ v; } + std::complex operator -(std::complex v) + { return std::complex(*this)- v; } + std::complex operator *(std::complex v) + { return std::complex(*this)* v; } + std::complex operator /(std::complex v) + { return std::complex(*this)/ v; } + }; + + + template inline + bool operator ==(T v, const ref_elt_vector &re) { return (v==T(re)); } + template inline + bool operator !=(T v, const ref_elt_vector &re) { return (v!=T(re)); } + template inline + T &operator +=(T &v, const ref_elt_vector &re) + { v += T(re); return v; } + template inline + T &operator -=(T &v, const ref_elt_vector &re) + { v -= T(re); return v; } + template inline + T &operator *=(T &v, const ref_elt_vector &re) + { v *= T(re); return v; } + template inline + T &operator /=(T &v, const ref_elt_vector &re) + { v /= T(re); return v; } + template inline + T operator +(T v, const ref_elt_vector &re) { return v+ T(re); } + template inline + T operator -(T v, const ref_elt_vector &re) { return v- T(re); } + template inline + T operator *(T v, const ref_elt_vector &re) { return v* T(re); } + template inline + T operator /(T v, const ref_elt_vector &re) { return v/ T(re); } + template inline + std::complex operator +(std::complex v, const ref_elt_vector &re) + { return v+ T(re); } + template inline + std::complex operator -(std::complex v, const ref_elt_vector &re) + { return v- T(re); } + template inline + std::complex operator *(std::complex v, const ref_elt_vector &re) + { return v* T(re); } + template inline + std::complex operator /(std::complex v, const ref_elt_vector &re) + { return v/ T(re); } + template inline + std::complex operator +(T v, const ref_elt_vector, V> &re) + { return v+ std::complex(re); } + template inline + std::complex operator -(T v, const ref_elt_vector, V> &re) + { return v- std::complex(re); } + template inline + std::complex operator *(T v, const ref_elt_vector, V> &re) + { return v* std::complex(re); } + template inline + std::complex operator /(T v, const ref_elt_vector, V> &re) + { return v/ std::complex(re); } + template inline + typename number_traits::magnitude_type + abs(const ref_elt_vector &re) { return gmm::abs(T(re)); } + template inline + T sqr(const ref_elt_vector &re) { return gmm::sqr(T(re)); } + template inline + typename number_traits::magnitude_type + abs_sqr(const ref_elt_vector &re) { return gmm::abs_sqr(T(re)); } + template inline + T conj(const ref_elt_vector &re) { return gmm::conj(T(re)); } + template std::ostream &operator << + (std::ostream &o, const ref_elt_vector &re) { o << T(re); return o; } + template inline + typename number_traits::magnitude_type + real(const ref_elt_vector &re) { return gmm::real(T(re)); } + template inline + typename number_traits::magnitude_type + imag(const ref_elt_vector &re) { return gmm::imag(T(re)); } + + /*************************************************************************/ + /* */ + /* Class dsvector: sparse vector optimized for random write operations */ + /* with constant complexity for read and write operations. */ + /* Based on distribution sort principle. */ + /* Cheap for densely populated vectors. */ + /* */ + /*************************************************************************/ + + template class dsvector; + + template struct dsvector_iterator { + size_type i; // Current index. + T* p; // Pointer to the current position. + dsvector *v; // Pointer to the vector. + + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + // typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef dsvector_iterator iterator; + + reference operator *() const { return *p; } + pointer operator->() const { return &(operator*()); } + + iterator &operator ++() { + for (size_type k = (i & 15); k < 15; ++k) + { ++p; ++i; if (*p != T(0)) return *this; } + v->next_pos(*(const_cast(&(p))), i); + return *this; + } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator &operator --() { + for (size_type k = (i & 15); k > 0; --k) + { --p; --i; if (*p != T(0)) return *this; } + v->previous_pos(p, i); + return *this; + } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + + bool operator ==(const iterator &it) const + { return (i == it.i && p == it.p && v == it.v); } + bool operator !=(const iterator &it) const + { return !(it == *this); } + + size_type index() const { return i; } + + dsvector_iterator() : i(size_type(-1)), p(0), v(0) {} + dsvector_iterator(dsvector &w) : i(size_type(-1)), p(0), v(&w) {}; + }; + + + template struct dsvector_const_iterator { + size_type i; // Current index. + const T* p; // Pointer to the current position. + const dsvector *v; // Pointer to the vector. + + typedef T value_type; + typedef const value_type* pointer; + typedef const value_type& reference; + // typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef dsvector_const_iterator iterator; + + reference operator *() const { return *p; } + pointer operator->() const { return &(operator*()); } + iterator &operator ++() { + for (size_type k = (i & 15); k < 15; ++k) + { ++p; ++i; if (*p != T(0)) return *this; } + v->next_pos(p, i); + return *this; + } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator &operator --() { + for (size_type k = (i & 15); k > 0; --k) + { --p; --i; if (*p != T(0)) return *this; } + v->previous_pos(p, i); + return *this; + } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + + bool operator ==(const iterator &it) const + { return (i == it.i && p == it.p && v == it.v); } + bool operator !=(const iterator &it) const + { return !(it == *this); } + + size_type index() const { return i; } + + dsvector_const_iterator() : i(size_type(-1)), p(0) {} + dsvector_const_iterator(const dsvector_iterator &it) + : i(it.i), p(it.p), v(it.v) {} + dsvector_const_iterator(const dsvector &w) + : i(size_type(-1)), p(0), v(&w) {}; + }; + + + /** + Sparse vector built on distribution sort principle. + Read and write access have a constant complexity depending only on the + vector size. + */ + template class dsvector { + + typedef dsvector_iterator iterator; + typedef dsvector_const_iterator const_iterator; + typedef dsvector this_type; + typedef T * pointer; + typedef const T * const_pointer; + typedef void * void_pointer; + typedef const void * const_void_pointer; + + protected: + size_type n; // Potential vector size + size_type depth; // Number of row of pointer arrays + size_type mask; // Mask for the first pointer array + size_type shift; // Shift for the first pointer array + void_pointer root_ptr; // Root pointer + + const T *read_access(size_type i) const { + GMM_ASSERT1(i < n, "index out of range"); + size_type my_mask = mask, my_shift = shift; + void_pointer p = root_ptr; + if (!p) return 0; + for (size_type k = 0; k < depth; ++k) { + p = ((void **)(p))[(i & my_mask) >> my_shift]; + if (!p) return 0; + my_mask = (my_mask >> 4); + my_shift -= 4; + } + GMM_ASSERT1(my_shift == 0, "internal error"); + GMM_ASSERT1(my_mask == 15, "internal error"); + return &(((const T *)(p))[i & 15]); + } + + T *write_access(size_type i) { + GMM_ASSERT1(i < n, "index " << i << " out of range (size " << n << ")"); + size_type my_mask = mask, my_shift = shift; + if (!root_ptr) { + if (depth) { + root_ptr = new void_pointer[16]; + std::memset(root_ptr, 0, 16*sizeof(void_pointer)); + } else { + root_ptr = new T[16]; + for (size_type l = 0; l < 16; ++l) ((T *)(root_ptr))[l] = T(0); + } + } + + void_pointer p = root_ptr; + for (size_type k = 0; k < depth; ++k) { + size_type j = (i & my_mask) >> my_shift; + void_pointer q = ((void_pointer *)(p))[j]; + if (!q) { + if (k+1 != depth) { + q = new void_pointer[16]; + std::memset(q, 0, 16*sizeof(void_pointer)); + } else { + q = new T[16]; + for (size_type l = 0; l < 16; ++l) ((T *)(q))[l] = T(0); + } + ((void_pointer *)(p))[j] = q; + } + p = q; + my_mask = (my_mask >> 4); + my_shift -= 4; + } + GMM_ASSERT1(my_shift == 0, "internal error"); + GMM_ASSERT1(my_mask == 15, "internal error " << my_mask); + return &(((T *)(p))[i & 15]); + } + + void init(size_type n_) { + n = n_; depth = 0; shift = 0; mask = 1; if (n_) --n_; + while (n_) { n_ /= 16; ++depth; shift += 4; mask *= 16; } + mask--; if (shift) shift -= 4; if (depth) --depth; + root_ptr = 0; + } + + void rec_del(void_pointer p, size_type my_depth) { + if (my_depth) { + for (size_type k = 0; k < 16; ++k) + if (((void_pointer *)(p))[k]) + rec_del(((void_pointer *)(p))[k], my_depth-1); + delete[] ((void_pointer *)(p)); + } else { + delete[] ((T *)(p)); + } + } + + void rec_clean(void_pointer p, size_type my_depth, double eps) { + if (my_depth) { + for (size_type k = 0; k < 16; ++k) + if (((void_pointer *)(p))[k]) + rec_clean(((void_pointer *)(p))[k], my_depth-1, eps); + } else { + for (size_type k = 0; k < 16; ++k) + if (gmm::abs(((T *)(p))[k]) <= eps) ((T *)(p))[k] = T(0); + } + } + + void rec_clean_i(void_pointer p, size_type my_depth, size_type my_mask, + size_type i, size_type base) { + if (my_depth) { + my_mask = (my_mask >> 4); + for (size_type k = 0; k < 16; ++k) + if (((void_pointer *)(p))[k] && (base + (k+1)*(mask+1)) >= i) + rec_clean_i(((void_pointer *)(p))[k], my_depth-1, my_mask, + i, base + k*(my_mask+1)); + } else { + for (size_type k = 0; k < 16; ++k) + if (base+k > i) ((T *)(p))[k] = T(0); + } + } + + + size_type rec_nnz(void_pointer p, size_type my_depth) const { + size_type nn = 0; + if (my_depth) { + for (size_type k = 0; k < 16; ++k) + if (((void_pointer *)(p))[k]) + nn += rec_nnz(((void_pointer *)(p))[k], my_depth-1); + } else { + for (size_type k = 0; k < 16; ++k) + if (((const T *)(p))[k] != T(0)) nn++; + } + return nn; + } + + void copy_rec(void_pointer &p, const_void_pointer q, size_type my_depth) { + if (my_depth) { + p = new void_pointer[16]; + std::memset(p, 0, 16*sizeof(void_pointer)); + for (size_type l = 0; l < 16; ++l) + if (((const const_void_pointer *)(q))[l]) + copy_rec(((void_pointer *)(p))[l], + ((const const_void_pointer *)(q))[l], my_depth-1); + } else { + p = new T[16]; + for (size_type l = 0; l < 16; ++l) ((T *)(p))[l] = ((const T *)(q))[l]; + } + } + + void copy(const dsvector &v) { + if (root_ptr) rec_del(root_ptr, depth); + root_ptr = 0; + mask = v.mask; depth = v.depth; n = v.n; shift = v.shift; + if (v.root_ptr) copy_rec(root_ptr, v.root_ptr, depth); + } + + void next_pos_rec(void_pointer p, size_type my_depth, size_type my_mask, + const_pointer &pp, size_type &i, size_type base) const { + size_type ii = i; + if (my_depth) { + my_mask = (my_mask >> 4); + for (size_type k = 0; k < 16; ++k) + if (((void_pointer *)(p))[k] && (base + (k+1)*(my_mask+1)) >= i) { + next_pos_rec(((void_pointer *)(p))[k], my_depth-1, my_mask, + pp, i, base + k*(my_mask+1)); + if (i != size_type(-1)) return; else i = ii; + } + i = size_type(-1); pp = 0; + } else { + for (size_type k = 0; k < 16; ++k) + if (base+k > i && ((const_pointer)(p))[k] != T(0)) + { i = base+k; pp = &(((const_pointer)(p))[k]); return; } + i = size_type(-1); pp = 0; + } + } + + void previous_pos_rec(void_pointer p, size_type my_depth, size_type my_mask, + const_pointer &pp, size_type &i, + size_type base) const { + size_type ii = i; + if (my_depth) { + my_mask = (my_mask >> 4); + for (size_type k = 15; k != size_type(-1); --k) + if (((void_pointer *)(p))[k] && ((base + k*(my_mask+1)) < i)) { + previous_pos_rec(((void_pointer *)(p))[k], my_depth-1, + my_mask, pp, i, base + k*(my_mask+1)); + if (i != size_type(-1)) return; else i = ii; + } + i = size_type(-1); pp = 0; + } else { + for (size_type k = 15; k != size_type(-1); --k) + if (base+k < i && ((const_pointer)(p))[k] != T(0)) + { i = base+k; pp = &(((const_pointer)(p))[k]); return; } + i = size_type(-1); pp = 0; + } + } + + + public: + void clean(double eps) { if (root_ptr) rec_clean(root_ptr, depth); } + void resize(size_type n_) { + if (n_ != n) { + n = n_; + if (n_ < n) { // Depth unchanged (a choice) + if (root_ptr) rec_clean_i(root_ptr, depth, mask, n_, 0); + } else { + // may change the depth (add some levels) + size_type my_depth = 0, my_shift = 0, my_mask = 1; if (n_) --n_; + while (n_) { n_ /= 16; ++my_depth; my_shift += 4; my_mask *= 16; } + my_mask--; if (my_shift) my_shift -= 4; if (my_depth) --my_depth; + if (my_depth > depth || depth == 0) { + if (root_ptr) { + for (size_type k = depth; k < my_depth; ++k) { + void_pointer *q = new void_pointer [16]; + std::memset(q, 0, 16*sizeof(void_pointer)); + q[0] = root_ptr; root_ptr = q; + } + } + mask = my_mask; depth = my_depth; shift = my_shift; + } + } + } + } + + void clear() { if (root_ptr) rec_del(root_ptr, depth); root_ptr = 0; } + + void next_pos(const_pointer &pp, size_type &i) const { + if (!root_ptr || i >= n) { pp = 0, i = size_type(-1); return; } + next_pos_rec(root_ptr, depth, mask, pp, i, 0); + } + + void previous_pos(const_pointer &pp, size_type &i) const { + if (!root_ptr) { pp = 0, i = size_type(-1); return; } + if (i == size_type(-1)) { i = n; } + previous_pos_rec(root_ptr, depth, mask, pp, i, 0); + } + + iterator begin() { + iterator it(*this); + if (n && root_ptr) { + it.i = 0; it.p = const_cast(read_access(0)); + if (!(it.p) || *(it.p) == T(0)) + next_pos(*(const_cast(&(it.p))), it.i); + } + return it; + } + + iterator end() { return iterator(*this); } + + const_iterator begin() const { + const_iterator it(*this); + if (n && root_ptr) { + it.i = 0; it.p = read_access(0); + if (!(it.p) || *(it.p) == T(0)) next_pos(it.p, it.i); + } + return it; + } + + const_iterator end() const { return const_iterator(*this); } + + inline ref_elt_vector > operator [](size_type c) + { return ref_elt_vector >(this, c); } + + inline void w(size_type c, const T &e) { + if (e == T(0)) { if (read_access(c)) *(write_access(c)) = e; } + else *(write_access(c)) = e; + } + + inline void wa(size_type c, const T &e) + { if (e != T(0)) { *(write_access(c)) += e; } } + + inline T r(size_type c) const + { const T *p = read_access(c); if (p) return *p; else return T(0); } + + inline T operator [](size_type c) const { return r(c); } + + size_type nnz() const + { if (root_ptr) return rec_nnz(root_ptr, depth); else return 0; } + size_type size() const { return n; } + + void swap(dsvector &v) { + std::swap(n, v.n); std::swap(root_ptr, v.root_ptr); + std::swap(depth, v.depth); std::swap(shift, v.shift); + std::swap(mask, v.mask); + } + + /* Constructors */ + dsvector(const dsvector &v) { init(0); copy(v); } + dsvector &operator =(const dsvector &v) { copy(v); return *this; } + explicit dsvector(size_type l){ init(l); } + dsvector() { init(0); } + ~dsvector() { if (root_ptr) rec_del(root_ptr, depth); root_ptr = 0; } + }; + + template struct linalg_traits> { + typedef dsvector this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_vector linalg_type; + typedef T value_type; + typedef ref_elt_vector > reference; + typedef dsvector_iterator iterator; + typedef dsvector_const_iterator const_iterator; + typedef abstract_sparse storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static origin_type* origin(this_type &v) { return &v; } + static const origin_type* origin(const this_type &v) { return &v; } + static void clear(origin_type* o, const iterator &, const iterator &) + { o->clear(); } + static void do_clear(this_type &v) { v.clear(); } + static value_type access(const origin_type *o, const const_iterator &, + const const_iterator &, size_type i) + { return (*o)[i]; } + static reference access(origin_type *o, const iterator &, const iterator &, + size_type i) + { return (*o)[i]; } + static void resize(this_type &v, size_type n) { v.resize(n); } + }; + + template std::ostream &operator << + (std::ostream &o, const dsvector& v) { gmm::write(o,v); return o; } + + /******* Optimized operations for dsvector ****************************/ + + template inline void copy(const dsvector &v1, + dsvector &v2) { + GMM_ASSERT2(v1.size() == v2.size(), "dimensions mismatch"); + v2 = v1; + } + template inline void copy(const dsvector &v1, + const dsvector &v2) { + GMM_ASSERT2(v1.size() == v2.size(), "dimensions mismatch"); + v2 = const_cast &>(v1); + } + template inline + void copy(const dsvector &v1, const simple_vector_ref *> &v2){ + simple_vector_ref *> + *svr = const_cast *> *>(&v2); + dsvector + *pv = const_cast *>((v2.origin)); + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch"); + *pv = v1; svr->begin_ = vect_begin(*pv); svr->end_ = vect_end(*pv); + } + template inline + void copy(const simple_vector_ref *> &v1, + dsvector &v2) + { copy(*(v1.origin), v2); } + template inline + void copy(const simple_vector_ref *> &v1, dsvector &v2) + { copy(*(v1.origin), v2); } + template inline + void copy(const simple_vector_ref *> &v1, + const simple_vector_ref *> &v2) + { copy(*(v1.origin), v2); } + template inline + void copy(const simple_vector_ref *> &v1, + const simple_vector_ref *> &v2) + { copy(*(v1.origin), v2); } + + template + inline size_type nnz(const dsvector& l) { return l.nnz(); } + + /*************************************************************************/ + /* */ + /* Class wsvector: sparse vector optimized for random write operations, */ + /* with log(n) complexity for read and write operations. */ + /* Based on std::map */ + /* */ + /*************************************************************************/ + + template struct wsvector_iterator + : public std::map::iterator { + typedef typename std::map::iterator base_it_type; + typedef T value_type; + typedef value_type* pointer; + typedef value_type& reference; + // typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + + reference operator *() const { return (base_it_type::operator*()).second; } + pointer operator->() const { return &(operator*()); } + size_type index() const { return (base_it_type::operator*()).first; } + + wsvector_iterator() {} + wsvector_iterator(const base_it_type &it) : base_it_type(it) {} + }; + + template struct wsvector_const_iterator + : public std::map::const_iterator { + typedef typename std::map::const_iterator base_it_type; + typedef T value_type; + typedef const value_type* pointer; + typedef const value_type& reference; + // typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + + reference operator *() const { return (base_it_type::operator*()).second; } + pointer operator->() const { return &(operator*()); } + size_type index() const { return (base_it_type::operator*()).first; } + + wsvector_const_iterator() {} + wsvector_const_iterator(const wsvector_iterator &it) + : base_it_type(typename std::map::iterator(it)) {} + wsvector_const_iterator(const base_it_type &it) : base_it_type(it) {} + }; + + + /** + sparse vector built upon std::map. + Read and write access are quite fast (log n) + */ + template class wsvector : public std::map { + public: + + typedef typename std::map::size_type size_type; + typedef std::map base_type; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + + protected: + size_type nbl; + + public: + void clean(double eps); + void resize(size_type); + + inline ref_elt_vector > operator [](size_type c) + { return ref_elt_vector >(this, c); } + + inline void w(size_type c, const T &e) { + GMM_ASSERT2(c < nbl, "out of range"); + if (e == T(0)) { this->erase(c); } + else base_type::operator [](c) = e; + } + + inline void wa(size_type c, const T &e) { + GMM_ASSERT2(c < nbl, "out of range"); + if (e != T(0)) { + iterator it = this->lower_bound(c); + if (it != this->end() && it->first == c) it->second += e; + else base_type::operator [](c) = e; + } + } + + inline T r(size_type c) const { + GMM_ASSERT2(c < nbl, "out of range"); + const_iterator it = this->lower_bound(c); + if (it != this->end() && c == it->first) return it->second; + else return T(0); + } + + inline T operator [](size_type c) const { return r(c); } + + size_type nb_stored() const { return base_type::size(); } + size_type size() const { return nbl; } + + void swap(wsvector &v) + { std::swap(nbl, v.nbl); std::map::swap(v); } + + + /* Constructors */ + void init(size_type l) { nbl = l; this->clear(); } + explicit wsvector(size_type l){ init(l); } + wsvector() { init(0); } + }; + + template void wsvector::clean(double eps) { + iterator it = this->begin(), itf = it, ite = this->end(); + while (it != ite) { + ++itf; if (gmm::abs(it->second) <= eps) this->erase(it); it = itf; + } + } + + template void wsvector::resize(size_type n) { + if (n < nbl) { + iterator it = this->begin(), itf = it, ite = this->end(); + while (it != ite) { ++itf; if (it->first >= n) this->erase(it); it=itf; } + } + nbl = n; + } + + template struct linalg_traits > { + typedef wsvector this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_vector linalg_type; + typedef T value_type; + typedef ref_elt_vector > reference; + typedef wsvector_iterator iterator; + typedef wsvector_const_iterator const_iterator; + typedef abstract_sparse storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return v.begin(); } + static const_iterator begin(const this_type &v) { return v.begin(); } + static iterator end(this_type &v) { return v.end(); } + static const_iterator end(const this_type &v) { return v.end(); } + static origin_type* origin(this_type &v) { return &v; } + static const origin_type* origin(const this_type &v) { return &v; } + static void clear(origin_type* o, const iterator &, const iterator &) + { o->clear(); } + static void do_clear(this_type &v) { v.clear(); } + static value_type access(const origin_type *o, const const_iterator &, + const const_iterator &, size_type i) + { return (*o)[i]; } + static reference access(origin_type *o, const iterator &, const iterator &, + size_type i) + { return (*o)[i]; } + static void resize(this_type &v, size_type n) { v.resize(n); } + }; + + template std::ostream &operator << + (std::ostream &o, const wsvector& v) { gmm::write(o,v); return o; } + + /******* Optimized BLAS for wsvector **********************************/ + + template inline void copy(const wsvector &v1, + wsvector &v2) { + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch"); + v2 = v1; + } + template inline + void copy(const wsvector &v1, const simple_vector_ref *> &v2){ + simple_vector_ref *> + *svr = const_cast *> *>(&v2); + wsvector + *pv = const_cast *>(v2.origin); + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch"); + *pv = v1; svr->begin_ = vect_begin(*pv); svr->end_ = vect_end(*pv); + } + template inline + void copy(const simple_vector_ref *> &v1, + wsvector &v2) + { copy(*(v1.origin), v2); } + template inline + void copy(const simple_vector_ref *> &v1, wsvector &v2) + { copy(*(v1.origin), v2); } + + template inline void clean(wsvector &v, double eps) { + typedef typename number_traits::magnitude_type R; + typename wsvector::iterator it = v.begin(), ite = v.end(), itc; + while (it != ite) + if (gmm::abs((*it).second) <= R(eps)) + { itc=it; ++it; v.erase(itc); } else ++it; + } + + template + inline void clean(const simple_vector_ref *> &l, double eps) { + simple_vector_ref *> + *svr = const_cast *> *>(&l); + wsvector + *pv = const_cast *>((l.origin)); + clean(*pv, eps); + svr->begin_ = vect_begin(*pv); svr->end_ = vect_end(*pv); + } + + template + inline size_type nnz(const wsvector& l) { return l.nb_stored(); } + + /*************************************************************************/ + /* */ + /* rsvector: sparse vector optimized for linear algebra operations. */ + /* */ + /*************************************************************************/ + + template struct elt_rsvector_ { + size_type c; T e; + /* e is initialized by default to avoid some false warnings of valgrind. + (from http://valgrind.org/docs/manual/mc-manual.html: + + When memory is read into the CPU's floating point registers, the + relevant V bits are read from memory and they are immediately + checked. If any are invalid, an uninitialised value error is + emitted. This precludes using the floating-point registers to copy + possibly-uninitialised memory, but simplifies Valgrind in that it + does not have to track the validity status of the floating-point + registers. + */ + elt_rsvector_() : e(0) {} + elt_rsvector_(size_type cc) : c(cc), e(0) {} + elt_rsvector_(size_type cc, const T &ee) : c(cc), e(ee) {} + bool operator < (const elt_rsvector_ &a) const { return c < a.c; } + bool operator == (const elt_rsvector_ &a) const { return c == a.c; } + bool operator != (const elt_rsvector_ &a) const { return c != a.c; } + }; + + template struct rsvector_iterator { + typedef typename std::vector >::iterator IT; + typedef T value_type; + typedef value_type* pointer; + typedef value_type& reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef rsvector_iterator iterator; + + IT it; + + reference operator *() const { return it->e; } + pointer operator->() const { return &(operator*()); } + + iterator &operator ++() { ++it; return *this; } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator &operator --() { --it; return *this; } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + + bool operator ==(const iterator &i) const { return it == i.it; } + bool operator !=(const iterator &i) const { return !(i == *this); } + + size_type index() const { return it->c; } + rsvector_iterator() {} + rsvector_iterator(const IT &i) : it(i) {} + }; + + template struct rsvector_const_iterator { + typedef typename std::vector >::const_iterator IT; + typedef T value_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + typedef rsvector_const_iterator iterator; + + IT it; + + reference operator *() const { return it->e; } + pointer operator->() const { return &(operator*()); } + size_type index() const { return it->c; } + + iterator &operator ++() { ++it; return *this; } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator &operator --() { --it; return *this; } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + + bool operator ==(const iterator &i) const { return it == i.it; } + bool operator !=(const iterator &i) const { return !(i == *this); } + + rsvector_const_iterator() {} + rsvector_const_iterator(const rsvector_iterator &i) : it(i.it) {} + rsvector_const_iterator(const IT &i) : it(i) {} + }; + + /** + sparse vector built upon std::vector. Read access is fast, + but insertion is O(n) + */ + template class rsvector : public std::vector > { + public: + + typedef std::vector > base_type_; + typedef typename base_type_::iterator iterator; + typedef typename base_type_::const_iterator const_iterator; + typedef typename base_type_::size_type size_type; + typedef T value_type; + + protected: + size_type nbl; // size of the vector + + public: + + void sup(size_type j); + void base_resize(size_type n) { base_type_::resize(n); } + void resize(size_type); + + ref_elt_vector > operator [](size_type c) + { return ref_elt_vector >(this, c); } + + void w(size_type c, const T &e); + void wa(size_type c, const T &e); + T r(size_type c) const; + void swap_indices(size_type i, size_type j); + + inline T operator [](size_type c) const { return r(c); } + + size_type nb_stored() const { return base_type_::size(); } + size_type size() const { return nbl; } + void clear() { base_type_::resize(0); } + void swap(rsvector &v) + { std::swap(nbl, v.nbl); std::vector >::swap(v); } + + /* Constructeurs */ + explicit rsvector(size_type l) : nbl(l) { } + rsvector() : nbl(0) { } + }; + + template + void rsvector::swap_indices(size_type i, size_type j) { + if (i > j) std::swap(i, j); + if (i != j) { + int situation = 0; + elt_rsvector_ ei(i), ej(j), a; + iterator it, ite, iti, itj; + iti = std::lower_bound(this->begin(), this->end(), ei); + if (iti != this->end() && iti->c == i) situation += 1; + itj = std::lower_bound(this->begin(), this->end(), ej); + if (itj != this->end() && itj->c == j) situation += 2; + + switch (situation) { + case 1 : a = *iti; a.c = j; it = iti; ++it; ite = this->end(); + for (; it != ite && it->c <= j; ++it, ++iti) *iti = *it; + *iti = a; + break; + case 2 : a = *itj; a.c = i; it = itj; ite = this->begin(); + if (it != ite) { + --it; + while (it->c >= i) { *itj = *it; --itj; if (it==ite) break; --it; } + } + *itj = a; + break; + case 3 : std::swap(iti->e, itj->e); + break; + } + } + } + + template void rsvector::sup(size_type j) { + if (nb_stored() != 0) { + elt_rsvector_ ev(j); + iterator it = std::lower_bound(this->begin(), this->end(), ev); + if (it != this->end() && it->c == j) { + for (iterator ite = this->end() - 1; it != ite; ++it) *it = *(it+1); + base_resize(nb_stored()-1); + } + } + } + + template void rsvector::resize(size_type n) { + if (n < nbl) { + for (size_type i = 0; i < nb_stored(); ++i) + if (base_type_::operator[](i).c >= n) { base_resize(i); break; } + } + nbl = n; + } + + template void rsvector::w(size_type c, const T &e) { + GMM_ASSERT2(c < nbl, "out of range"); + if (e == T(0)) sup(c); + else { + elt_rsvector_ ev(c, e); + if (nb_stored() == 0) { + base_type_::push_back(ev); + } + else { + iterator it = std::lower_bound(this->begin(), this->end(), ev); + if (it != this->end() && it->c == c) it->e = e; + else { + size_type ind = it - this->begin(), nb = this->nb_stored(); + if (nb - ind > 1100) + GMM_WARNING2("Inefficient addition of element in rsvector with " + << this->nb_stored() - ind << " non-zero entries"); + base_type_::push_back(ev); + if (ind != nb) { + it = this->begin() + ind; + iterator ite = this->end(); --ite; iterator itee = ite; + for (; ite != it; --ite) { --itee; *ite = *itee; } + *it = ev; + } + } + } + } + } + + template void rsvector::wa(size_type c, const T &e) { + GMM_ASSERT2(c < nbl, "out of range"); + if (e != T(0)) { + elt_rsvector_ ev(c, e); + if (nb_stored() == 0) { + base_type_::push_back(ev); + } + else { + iterator it = std::lower_bound(this->begin(), this->end(), ev); + if (it != this->end() && it->c == c) it->e += e; + else { + size_type ind = it - this->begin(), nb = this->nb_stored(); + if (nb - ind > 1100) + GMM_WARNING2("Inefficient addition of element in rsvector with " + << this->nb_stored() - ind << " non-zero entries"); + base_type_::push_back(ev); + if (ind != nb) { + it = this->begin() + ind; + iterator ite = this->end(); --ite; iterator itee = ite; + for (; ite != it; --ite) { --itee; *ite = *itee; } + *it = ev; + } + } + } + } + } + + template T rsvector::r(size_type c) const { + GMM_ASSERT2(c < nbl, "out of range. Index " << c + << " for a length of " << nbl); + if (nb_stored() != 0) { + elt_rsvector_ ev(c); + const_iterator it = std::lower_bound(this->begin(), this->end(), ev); + if (it != this->end() && it->c == c) return it->e; + } + return T(0); + } + + template struct linalg_traits > { + typedef rsvector this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_vector linalg_type; + typedef T value_type; + typedef ref_elt_vector > reference; + typedef rsvector_iterator iterator; + typedef rsvector_const_iterator const_iterator; + typedef abstract_sparse storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) { return iterator(v.begin()); } + static const_iterator begin(const this_type &v) + { return const_iterator(v.begin()); } + static iterator end(this_type &v) { return iterator(v.end()); } + static const_iterator end(const this_type &v) + { return const_iterator(v.end()); } + static origin_type* origin(this_type &v) { return &v; } + static const origin_type* origin(const this_type &v) { return &v; } + static void clear(origin_type* o, const iterator &, const iterator &) + { o->clear(); } + static void do_clear(this_type &v) { v.clear(); } + static value_type access(const origin_type *o, const const_iterator &, + const const_iterator &, size_type i) + { return (*o)[i]; } + static reference access(origin_type *o, const iterator &, const iterator &, + size_type i) + { return (*o)[i]; } + static void resize(this_type &v, size_type n) { v.resize(n); } + }; + + template std::ostream &operator << + (std::ostream &o, const rsvector& v) { gmm::write(o,v); return o; } + + /******* Optimized operations for rsvector ****************************/ + + template inline void copy(const rsvector &v1, + rsvector &v2) { + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch"); + v2 = v1; + } + template inline + void copy(const rsvector &v1, const simple_vector_ref *> &v2){ + simple_vector_ref *> + *svr = const_cast *> *>(&v2); + rsvector + *pv = const_cast *>((v2.origin)); + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch"); + *pv = v1; svr->begin_ = vect_begin(*pv); svr->end_ = vect_end(*pv); + } + template inline + void copy(const simple_vector_ref *> &v1, + rsvector &v2) + { copy(*(v1.origin), v2); } + template inline + void copy(const simple_vector_ref *> &v1, rsvector &v2) + { copy(*(v1.origin), v2); } + + template inline void add(const V &v1, + rsvector &v2) { + if ((const void *)(&v1) != (const void *)(&v2)) { + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch"); + add_rsvector(v1, v2, typename linalg_traits::storage_type()); + } + } + + template + inline void add_rsvector(const V &v1, rsvector &v2, abstract_dense) + { add(v1, v2, abstract_dense(), abstract_sparse()); } + + template + inline void add_rsvector(const V &v1, rsvector &v2, abstract_skyline) + { add(v1, v2, abstract_skyline(), abstract_sparse()); } + + template + void add_rsvector(const V &v1, rsvector &v2, abstract_sparse) { + add_rsvector(v1, v2, typename linalg_traits::index_sorted()); + } + + template + void add_rsvector(const V &v1, rsvector &v2, linalg_false) { + add(v1, v2, abstract_sparse(), abstract_sparse()); + } + + template + void add_rsvector(const V &v1, rsvector &v2, linalg_true) { + typename linalg_traits::const_iterator it1 = vect_const_begin(v1), + ite1 = vect_const_end(v1); + typename rsvector::iterator it2 = v2.begin(), ite2 = v2.end(), it3; + size_type nbc = 0, old_nbc = v2.nb_stored(); + for (; it1 != ite1 && it2 != ite2 ; ++nbc) + if (it1.index() == it2->c) { ++it1; ++it2; } + else if (it1.index() < it2->c) ++it1; else ++it2; + for (; it1 != ite1; ++it1) ++nbc; + for (; it2 != ite2; ++it2) ++nbc; + + v2.base_resize(nbc); + it3 = v2.begin() + old_nbc; + it2 = v2.end(); + ite2 = v2.begin(); + it1 = vect_end(v1); + ite1 = vect_const_begin(v1); + while (it1 != ite1 && it2 != ite2 && it3 != ite2){ + --it3; + --it1; + --it2; + if (it3->c > it1.index()) { + *it2 = *it3; + ++it1; + } + else if (it3->c == it1.index()) { + *it2=*it3; + it2->e+=*it1; + } + else { + it2->c = it1.index(); + it2->e = *it1; ++it3; + } + } + while (it1 != ite1 && it2 != ite2) { + --it1; + --it2; + it2->c = it1.index(); + it2->e = *it1; + } + } + + template void copy(const V &v1, rsvector &v2) { + if ((const void *)(&v1) != (const void *)(&v2)) { + GMM_ASSERT2(vect_size(v1) == vect_size(v2), "dimensions mismatch"); + if (same_origin(v1, v2)) + GMM_WARNING2("a conflict is possible in vector copy\n"); + copy_rsvector(v1, v2, typename linalg_traits::storage_type()); + } + } + + template + void copy_rsvector(const V &v1, rsvector &v2, abstract_dense) + { copy_vect(v1, v2, abstract_dense(), abstract_sparse()); } + + template + void copy_rsvector(const V &v1, rsvector &v2, abstract_skyline) + { copy_vect(v1, v2, abstract_skyline(), abstract_sparse()); } + + template + void copy_rsvector(const V &v1, rsvector &v2, abstract_sparse) { + copy_rsvector(v1, v2, typename linalg_traits::index_sorted()); + } + + template + void copy_rsvector(const V &v1, rsvector &v2, linalg_true) { + typedef typename linalg_traits::value_type T1; + typename linalg_traits::const_iterator it = vect_const_begin(v1), + ite = vect_const_end(v1); + v2.base_resize(nnz(v1)); + typename rsvector::iterator it2 = v2.begin(); + size_type nn = 0; + for (; it != ite; ++it) + if ((*it) != T1(0)) { it2->c = it.index(); it2->e = *it; ++it2; ++nn; } + v2.base_resize(nn); + } + + template + void copy_rsvector(const V &v1, rsvector &v2, linalg_false) { + typedef typename linalg_traits::value_type T1; + typename linalg_traits::const_iterator it = vect_const_begin(v1), + ite = vect_const_end(v1); + v2.base_resize(nnz(v1)); + typename rsvector::iterator it2 = v2.begin(); + size_type nn = 0; + for (; it != ite; ++it) + if ((*it) != T1(0)) { it2->c = it.index(); it2->e = *it; ++it2; ++nn; } + v2.base_resize(nn); + std::sort(v2.begin(), v2.end()); + } + + template inline void clean(rsvector &v, double eps) { + typedef typename number_traits::magnitude_type R; + typename rsvector::iterator it = v.begin(), ite = v.end(); + for (; it != ite; ++it) if (gmm::abs((*it).e) <= eps) break; + if (it != ite) { + typename rsvector::iterator itc = it; + size_type erased = 1; + for (++it; it != ite; ++it) + { *itc = *it; if (gmm::abs((*it).e) <= R(eps)) ++erased; else ++itc; } + v.base_resize(v.nb_stored() - erased); + } + } + + template + inline void clean(const simple_vector_ref *> &l, double eps) { + simple_vector_ref *> + *svr = const_cast *> *>(&l); + rsvector + *pv = const_cast *>((l.origin)); + clean(*pv, eps); + svr->begin_ = vect_begin(*pv); svr->end_ = vect_end(*pv); + } + + template + inline size_type nnz(const rsvector& l) { return l.nb_stored(); } + + /*************************************************************************/ + /* */ + /* Class slvector: 'sky-line' vector. */ + /* */ + /*************************************************************************/ + + template struct slvector_iterator { + typedef T value_type; + typedef T *pointer; + typedef T &reference; + typedef ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; + typedef size_t size_type; + typedef slvector_iterator iterator; + typedef typename std::vector::iterator base_iterator; + + base_iterator it; + size_type shift; + + + iterator &operator ++() + { ++it; ++shift; return *this; } + iterator &operator --() + { --it; --shift; return *this; } + iterator operator ++(int) + { iterator tmp = *this; ++(*(this)); return tmp; } + iterator operator --(int) + { iterator tmp = *this; --(*(this)); return tmp; } + iterator &operator +=(difference_type i) + { it += i; shift += i; return *this; } + iterator &operator -=(difference_type i) + { it -= i; shift -= i; return *this; } + iterator operator +(difference_type i) const + { iterator tmp = *this; return (tmp += i); } + iterator operator -(difference_type i) const + { iterator tmp = *this; return (tmp -= i); } + difference_type operator -(const iterator &i) const + { return it - i.it; } + + reference operator *() const + { return *it; } + reference operator [](int ii) + { return *(it + ii); } + + bool operator ==(const iterator &i) const + { return it == i.it; } + bool operator !=(const iterator &i) const + { return !(i == *this); } + bool operator < (const iterator &i) const + { return it < i.it; } + size_type index() const { return shift; } + + slvector_iterator() {} + slvector_iterator(const base_iterator &iter, size_type s) + : it(iter), shift(s) {} + }; + + template struct slvector_const_iterator { + typedef T value_type; + typedef const T *pointer; + typedef value_type reference; + typedef ptrdiff_t difference_type; + typedef std::random_access_iterator_tag iterator_category; + typedef size_t size_type; + typedef slvector_const_iterator iterator; + typedef typename std::vector::const_iterator base_iterator; + + base_iterator it; + size_type shift; + + + iterator &operator ++() + { ++it; ++shift; return *this; } + iterator &operator --() + { --it; --shift; return *this; } + iterator operator ++(int) + { iterator tmp = *this; ++(*(this)); return tmp; } + iterator operator --(int) + { iterator tmp = *this; --(*(this)); return tmp; } + iterator &operator +=(difference_type i) + { it += i; shift += i; return *this; } + iterator &operator -=(difference_type i) + { it -= i; shift -= i; return *this; } + iterator operator +(difference_type i) const + { iterator tmp = *this; return (tmp += i); } + iterator operator -(difference_type i) const + { iterator tmp = *this; return (tmp -= i); } + difference_type operator -(const iterator &i) const + { return it - i.it; } + + value_type operator *() const + { return *it; } + value_type operator [](int ii) + { return *(it + ii); } + + bool operator ==(const iterator &i) const + { return it == i.it; } + bool operator !=(const iterator &i) const + { return !(i == *this); } + bool operator < (const iterator &i) const + { return it < i.it; } + size_type index() const { return shift; } + + slvector_const_iterator() {} + slvector_const_iterator(const slvector_iterator& iter) + : it(iter.it), shift(iter.shift) {} + slvector_const_iterator(const base_iterator &iter, size_type s) + : it(iter), shift(s) {} + }; + + + /** skyline vector. + */ + template class slvector { + + public : + typedef slvector_iterator iterators; + typedef slvector_const_iterator const_iterators; + typedef typename std::vector::size_type size_type; + typedef T value_type; + + protected : + std::vector data; + size_type shift; + size_type size_; + + + public : + + size_type size() const { return size_; } + size_type first() const { return shift; } + size_type last() const { return shift + data.size(); } + ref_elt_vector > operator [](size_type c) + { return ref_elt_vector >(this, c); } + + typename std::vector::iterator data_begin() { return data.begin(); } + typename std::vector::iterator data_end() { return data.end(); } + typename std::vector::const_iterator data_begin() const + { return data.begin(); } + typename std::vector::const_iterator data_end() const + { return data.end(); } + + void w(size_type c, const T &e); + void wa(size_type c, const T &e); + T r(size_type c) const { + GMM_ASSERT2(c < size_, "out of range"); + if (c < shift || c >= shift + data.size()) return T(0); + return data[c - shift]; + } + + inline T operator [](size_type c) const { return r(c); } + void resize(size_type); + void clear() { data.resize(0); shift = 0; } + void swap(slvector &v) { + std::swap(data, v.data); + std::swap(shift, v.shift); + std::swap(size_, v.size_); + } + + + slvector() : data(0), shift(0), size_(0) {} + explicit slvector(size_type l) : data(0), shift(0), size_(l) {} + slvector(size_type l, size_type d, size_type s) + : data(d), shift(s), size_(l) {} + + }; + + template void slvector::resize(size_type n) { + if (n < last()) { + if (shift >= n) clear(); else { data.resize(n-shift); } + } + size_ = n; + } + + template void slvector::w(size_type c, const T &e) { + GMM_ASSERT2(c < size_, "out of range"); + size_type s = data.size(); + if (!s) { data.resize(1); shift = c; } + else if (c < shift) { + data.resize(s + shift - c); + typename std::vector::iterator it = data.begin(),it2=data.end()-1; + typename std::vector::iterator it3 = it2 - shift + c; + for (; it3 >= it; --it3, --it2) *it2 = *it3; + std::fill(it, it + shift - c, T(0)); + shift = c; + } + else if (c >= shift + s) { + data.resize(c - shift + 1, T(0)); + // std::fill(data.begin() + s, data.end(), T(0)); + } + data[c - shift] = e; + } + + template void slvector::wa(size_type c, const T &e) { + GMM_ASSERT2(c < size_, "out of range"); + size_type s = data.size(); + if (!s) { data.resize(1, e); shift = c; return; } + else if (c < shift) { + data.resize(s + shift - c); + typename std::vector::iterator it = data.begin(),it2=data.end()-1; + typename std::vector::iterator it3 = it2 - shift + c; + for (; it3 >= it; --it3, --it2) *it2 = *it3; + std::fill(it, it + shift - c, T(0)); + shift = c; + data[c - shift] = e; + return; + } + else if (c >= shift + s) { + data.resize(c - shift + 1, T(0)); + data[c - shift] = e; + return; + // std::fill(data.begin() + s, data.end(), T(0)); + } + data[c - shift] += e; + } + + + template struct linalg_traits > { + typedef slvector this_type; + typedef this_type origin_type; + typedef linalg_false is_reference; + typedef abstract_vector linalg_type; + typedef T value_type; + typedef ref_elt_vector > reference; + typedef slvector_iterator iterator; + typedef slvector_const_iterator const_iterator; + typedef abstract_skyline storage_type; + typedef linalg_true index_sorted; + static size_type size(const this_type &v) { return v.size(); } + static iterator begin(this_type &v) + { return iterator(v.data_begin(), v.first()); } + static const_iterator begin(const this_type &v) + { return const_iterator(v.data_begin(), v.first()); } + static iterator end(this_type &v) + { return iterator(v.data_end(), v.last()); } + static const_iterator end(const this_type &v) + { return const_iterator(v.data_end(), v.last()); } + static origin_type* origin(this_type &v) { return &v; } + static const origin_type* origin(const this_type &v) { return &v; } + static void clear(origin_type* o, const iterator &, const iterator &) + { o->clear(); } + static void do_clear(this_type &v) { v.clear(); } + static value_type access(const origin_type *o, const const_iterator &, + const const_iterator &, size_type i) + { return (*o)[i]; } + static reference access(origin_type *o, const iterator &, const iterator &, + size_type i) + { return (*o)[i]; } + static void resize(this_type &v, size_type n) { v.resize(n); } + }; + + template std::ostream &operator << + (std::ostream &o, const slvector& v) { gmm::write(o,v); return o; } + + template + inline size_type nnz(const slvector& l) { return l.last() - l.first(); } + +} + +namespace std { + template void swap(gmm::wsvector &v, gmm::wsvector &w) + { v.swap(w);} + template void swap(gmm::rsvector &v, gmm::rsvector &w) + { v.swap(w);} + template void swap(gmm::slvector &v, gmm::slvector &w) + { v.swap(w);} +} + + + +#endif /* GMM_VECTOR_H__ */ diff --git a/7.x/src/linear_algebra/gmm/gmm_vector_to_matrix.h b/7.x/src/linear_algebra/gmm/gmm_vector_to_matrix.h new file mode 100644 index 0000000..95b0bea --- /dev/null +++ b/7.x/src/linear_algebra/gmm/gmm_vector_to_matrix.h @@ -0,0 +1,340 @@ +/* -*- c++ -*- (enables emacs c++ mode) */ +/*=========================================================================== + + Copyright (C) 2003-2020 Yves Renard + + This file is a part of GetFEM + + GetFEM is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 3 of the License, or + (at your option) any later version along with the GCC Runtime Library + Exception either version 3.1 or (at your option) any later version. + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + License and GCC Runtime Library Exception for more details. + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + + As a special exception, you may use this file as it is a part of a free + software library without restriction. Specifically, if other files + instantiate templates or use macros or inline functions from this file, + or you compile this file and link it with other files to produce an + executable, this file does not by itself cause the resulting executable + to be covered by the GNU Lesser General Public License. This exception + does not however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + +===========================================================================*/ + +/**@file gmm_vector_to_matrix.h + @author Yves Renard + @date December 6, 2003. + @brief View vectors as row or column matrices. */ +#ifndef GMM_VECTOR_TO_MATRIX_H__ +#define GMM_VECTOR_TO_MATRIX_H__ + +#include "gmm_interface.h" + +namespace gmm { + + /* ********************************************************************* */ + /* row vector -> transform a vector in a (1, n) matrix. */ + /* ********************************************************************* */ + + template struct gen_row_vector { + typedef gen_row_vector this_type; + typedef typename std::iterator_traits::value_type V; + typedef V * CPT; + typedef typename std::iterator_traits::reference ref_V; + typedef typename linalg_traits::reference reference; + + simple_vector_ref vec; + + reference operator()(size_type, size_type j) const { return vec[j]; } + + size_type nrows(void) const { return 1; } + size_type ncols(void) const { return vect_size(vec); } + + gen_row_vector(ref_V v) : vec(v) {} + gen_row_vector() {} + gen_row_vector(const gen_row_vector &cr) : vec(cr.vec) {} + }; + + template + struct gen_row_vector_iterator { + typedef gen_row_vector this_type; + typedef typename modifiable_pointer::pointer MPT; + typedef typename std::iterator_traits::value_type V; + typedef simple_vector_ref value_type; + typedef const simple_vector_ref *pointer; + typedef const simple_vector_ref &reference; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef std::random_access_iterator_tag iterator_category; + typedef gen_row_vector_iterator iterator; + + simple_vector_ref vec; + bool isend; + + iterator &operator ++() { isend = true; return *this; } + iterator &operator --() { isend = false; return *this; } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + iterator &operator +=(difference_type i) + { if (i) isend = false; return *this; } + iterator &operator -=(difference_type i) + { if (i) isend = true; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const { + return (isend == true) ? ((i.isend == true) ? 0 : 1) + : ((i.isend == true) ? -1 : 0); + } + + const simple_vector_ref& operator *() const { return vec; } + const simple_vector_ref& operator [](int i) { return vec; } + + bool operator ==(const iterator &i) const { return (isend == i.isend); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (*this - i < 0); } + + gen_row_vector_iterator(void) {} + gen_row_vector_iterator(const gen_row_vector_iterator &itm) + : vec(itm.vec), isend(itm.isend) {} + gen_row_vector_iterator(const gen_row_vector &m, bool iis_end) + : vec(m.vec), isend(iis_end) { } + + }; + + template + struct linalg_traits > { + typedef gen_row_vector this_type; + typedef typename std::iterator_traits::value_type V; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef abstract_null_type sub_col_type; + typedef abstract_null_type col_iterator; + typedef abstract_null_type const_sub_col_type; + typedef abstract_null_type const_col_iterator; + typedef simple_vector_ref const_sub_row_type; + typedef typename select_ref, PT>::ref_type sub_row_type; + typedef gen_row_vector_iterator::pointer> + const_row_iterator; + typedef typename select_ref, PT>::ref_type row_iterator; + typedef typename linalg_traits::storage_type storage_type; + typedef row_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type nrows(const this_type &) { return 1; } + static size_type ncols(const this_type &m) { return m.ncols(); } + static const_sub_row_type row(const const_row_iterator &it) { return *it; } + static sub_row_type row(const row_iterator &it) { return *it; } + static const_row_iterator row_begin(const this_type &m) + { return const_row_iterator(m, false); } + static row_iterator row_begin(this_type &m) + { return row_iterator(m, false); } + static const_row_iterator row_end(const this_type &m) + { return const_row_iterator(m, true); } + static row_iterator row_end(this_type &m) + { return row_iterator(m, true); } + static origin_type* origin(this_type &m) { return m.vec.origin; } + static const origin_type* origin(const this_type &m) + { return m.vec.origin; } + static void do_clear(this_type &m) + { clear(row(mat_row_begin(m))); } + static value_type access(const const_row_iterator &itrow, size_type i) + { return itrow.vec[i]; } + static reference access(const row_iterator &itrow, size_type i) + { return itrow.vec[i]; } + }; + + template + std::ostream &operator <<(std::ostream &o, const gen_row_vector& m) + { gmm::write(o,m); return o; } + + /* ********************************************************************* */ + /* col vector -> transform a vector in a (n, 1) matrix. */ + /* ********************************************************************* */ + + template struct gen_col_vector { + typedef gen_col_vector this_type; + typedef typename std::iterator_traits::value_type V; + typedef V * CPT; + typedef typename std::iterator_traits::reference ref_V; + typedef typename linalg_traits::reference reference; + + simple_vector_ref vec; + + reference operator()(size_type i, size_type) const { return vec[i]; } + + size_type ncols(void) const { return 1; } + size_type nrows(void) const { return vect_size(vec); } + + gen_col_vector(ref_V v) : vec(v) {} + gen_col_vector() {} + gen_col_vector(const gen_col_vector &cr) : vec(cr.vec) {} + }; + + template + struct gen_col_vector_iterator { + typedef gen_col_vector this_type; + typedef typename modifiable_pointer::pointer MPT; + typedef typename std::iterator_traits::value_type V; + typedef simple_vector_ref value_type; + typedef const simple_vector_ref *pointer; + typedef const simple_vector_ref &reference; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef std::random_access_iterator_tag iterator_category; + typedef gen_col_vector_iterator iterator; + + simple_vector_ref vec; + bool isend; + + iterator &operator ++() { isend = true; return *this; } + iterator &operator --() { isend = false; return *this; } + iterator operator ++(int) { iterator tmp = *this; ++(*this); return tmp; } + iterator operator --(int) { iterator tmp = *this; --(*this); return tmp; } + iterator &operator +=(difference_type i) + { if (i) isend = false; return *this; } + iterator &operator -=(difference_type i) + { if (i) isend = true; return *this; } + iterator operator +(difference_type i) const + { iterator itt = *this; return (itt += i); } + iterator operator -(difference_type i) const + { iterator itt = *this; return (itt -= i); } + difference_type operator -(const iterator &i) const { + return (isend == true) ? ((i.isend == true) ? 0 : 1) + : ((i.isend == true) ? -1 : 0); + } + + const simple_vector_ref& operator *() const { return vec; } + const simple_vector_ref& operator [](int i) { return vec; } + + bool operator ==(const iterator &i) const { return (isend == i.isend); } + bool operator !=(const iterator &i) const { return !(i == *this); } + bool operator < (const iterator &i) const { return (*this - i < 0); } + + gen_col_vector_iterator(void) {} + gen_col_vector_iterator(const gen_col_vector_iterator &itm) + : vec(itm.vec), isend(itm.isend) {} + gen_col_vector_iterator(const gen_col_vector &m, bool iis_end) + : vec(m.vec), isend(iis_end) { } + + }; + + template + struct linalg_traits > { + typedef gen_col_vector this_type; + typedef typename std::iterator_traits::value_type V; + typedef typename which_reference::is_reference is_reference; + typedef abstract_matrix linalg_type; + typedef typename linalg_traits::origin_type origin_type; + typedef typename select_ref::ref_type porigin_type; + typedef typename linalg_traits::value_type value_type; + typedef typename select_ref::reference, PT>::ref_type reference; + typedef abstract_null_type sub_row_type; + typedef abstract_null_type row_iterator; + typedef abstract_null_type const_sub_row_type; + typedef abstract_null_type const_row_iterator; + typedef simple_vector_ref const_sub_col_type; + typedef typename select_ref, PT>::ref_type sub_col_type; + typedef gen_col_vector_iterator::pointer> + const_col_iterator; + typedef typename select_ref, PT>::ref_type col_iterator; + typedef typename linalg_traits::storage_type storage_type; + typedef col_major sub_orientation; + typedef typename linalg_traits::index_sorted index_sorted; + static size_type ncols(const this_type &) { return 1; } + static size_type nrows(const this_type &m) { return m.nrows(); } + static const_sub_col_type col(const const_col_iterator &it) { return *it; } + static sub_col_type col(const col_iterator &it) { return *it; } + static const_col_iterator col_begin(const this_type &m) + { return const_col_iterator(m, false); } + static col_iterator col_begin(this_type &m) + { return col_iterator(m, false); } + static const_col_iterator col_end(const this_type &m) + { return const_col_iterator(m, true); } + static col_iterator col_end(this_type &m) + { return col_iterator(m, true); } + static origin_type* origin(this_type &m) { return m.vec.origin; } + static const origin_type* origin(const this_type &m) + { return m.vec.origin; } + static void do_clear(this_type &m) + { clear(col(mat_col_begin(m))); } + static value_type access(const const_col_iterator &itcol, size_type i) + { return itcol.vec[i]; } + static reference access(const col_iterator &itcol, size_type i) + { return itcol.vec[i]; } + }; + + template + std::ostream &operator <<(std::ostream &o, const gen_col_vector& m) + { gmm::write(o,m); return o; } + + /* ******************************************************************** */ + /* col and row vectors */ + /* ******************************************************************** */ + + + template inline + typename select_return< gen_row_vector, gen_row_vector, + const V *>::return_type + row_vector(const V& v) { + return typename select_return< gen_row_vector, + gen_row_vector, const V *>::return_type(linalg_cast(v)); + } + + template inline + typename select_return< gen_row_vector, gen_row_vector, + V *>::return_type + row_vector(V& v) { + return typename select_return< gen_row_vector, + gen_row_vector, V *>::return_type(linalg_cast(v)); + } + + template inline gen_row_vector + const_row_vector(V& v) + { return gen_row_vector(v); } + + + template inline + typename select_return< gen_col_vector, gen_col_vector, + const V *>::return_type + col_vector(const V& v) { + return typename select_return< gen_col_vector, + gen_col_vector, const V *>::return_type(linalg_cast(v)); + } + + template inline + typename select_return< gen_col_vector, gen_col_vector, + V *>::return_type + col_vector(V& v) { + return typename select_return< gen_col_vector, + gen_col_vector, V *>::return_type(linalg_cast(v)); + } + + template inline gen_col_vector + const_col_vector(V& v) + { return gen_col_vector(v); } + + +} + +#endif // GMM_VECTOR_TO_MATRIX_H__ diff --git a/7.x/vcpkg b/7.x/vcpkg new file mode 160000 index 0000000..f6a5d4e --- /dev/null +++ b/7.x/vcpkg @@ -0,0 +1 @@ +Subproject commit f6a5d4e8eb7476b8d7fc12a56dff300c1c986131 diff --git a/7.x/vcpkg.json b/7.x/vcpkg.json new file mode 100644 index 0000000..642b683 --- /dev/null +++ b/7.x/vcpkg.json @@ -0,0 +1,10 @@ +{ + "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json", + "name": "csound-plugins", + "version-string": "7.0.0", + "builtin-baseline": "f6a5d4e8eb7476b8d7fc12a56dff300c1c986131", + "dependencies": [ + "eigen3", + "fluidsynth" + ] +} diff --git a/7.x/x64-windows-csound.cmake b/7.x/x64-windows-csound.cmake new file mode 100644 index 0000000..dc862f9 --- /dev/null +++ b/7.x/x64-windows-csound.cmake @@ -0,0 +1,8 @@ +set(VCPKG_TARGET_ARCHITECTURE x64) +set(VCPKG_CRT_LINKAGE dynamic) + +if(${PORT} MATCHES "fluidsynth|glib|zlib|pcre|libffi|gettext|libiconv|portmidi|portaudio|liblo") + set(VCPKG_LIBRARY_LINKAGE dynamic) +else() + set(VCPKG_LIBRARY_LINKAGE static) +endif() From 015cc99c07e8ca74aa7efa83d37fc4b7470ade6e Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 14:50:56 +0100 Subject: [PATCH 04/72] Fix vcpkg macOS triplet detection and bump vcpkg baseline Detect the host architecture with uname before project() (CMAKE_HOST_SYSTEM_PROCESSOR is empty there) so Apple Silicon runners use arm64-osx. Bump vcpkg submodule/baseline to 2026.07.29 to fix the portable 7zip download (404) on Windows. --- 7.x/CMakeLists.txt | 5 ++++- 7.x/vcpkg | 2 +- 7.x/vcpkg.json | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 7c0967e..9756b40 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -10,7 +10,10 @@ if (USE_VCPKG) set(VCPKG_TARGET_TRIPLET "x64-windows-csound") set(CSOUND_INCLUDE_DIR_HINT "C:/Program Files/Csound6_x64") elseif(APPLE) - if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "arm64") + # CMAKE_HOST_SYSTEM_PROCESSOR is not yet set before project(), so query + # the host architecture directly to pick the right vcpkg triplet. + execute_process(COMMAND uname -m OUTPUT_VARIABLE _host_arch OUTPUT_STRIP_TRAILING_WHITESPACE) + if(_host_arch STREQUAL "arm64") set(VCPKG_HOST_TRIPLET "arm64-osx" CACHE STRING "") set(VCPKG_TARGET_TRIPLET "arm64-osx") else() diff --git a/7.x/vcpkg b/7.x/vcpkg index f6a5d4e..9e593bb 160000 --- a/7.x/vcpkg +++ b/7.x/vcpkg @@ -1 +1 @@ -Subproject commit f6a5d4e8eb7476b8d7fc12a56dff300c1c986131 +Subproject commit 9e593bb18ea69cc5095e012465dcd675a822ed0d diff --git a/7.x/vcpkg.json b/7.x/vcpkg.json index 642b683..b20abef 100644 --- a/7.x/vcpkg.json +++ b/7.x/vcpkg.json @@ -2,7 +2,7 @@ "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json", "name": "csound-plugins", "version-string": "7.0.0", - "builtin-baseline": "f6a5d4e8eb7476b8d7fc12a56dff300c1c986131", + "builtin-baseline": "9e593bb18ea69cc5095e012465dcd675a822ed0d", "dependencies": [ "eigen3", "fluidsynth" From 162115863fab43b427edb1d021ff34584b2cc402 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 14:56:29 +0100 Subject: [PATCH 05/72] Fix CI plugin build: fluidsynth config target and Csound hint on Windows Link fluidOpcodes against the FluidSynth CMake target so transitive deps (macOS CoreAudio/CoreMIDI frameworks) propagate, and drop the hardcoded Csound6 include hint that clobbered the CI-provided CSOUND_INCLUDE_DIR_HINT on Windows. --- 7.x/CMakeLists.txt | 1 - 7.x/src/fluidOpcodes/CMakeLists.txt | 13 +++++++++++-- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 9756b40..8e3d340 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -8,7 +8,6 @@ if (USE_VCPKG) if (WIN32) set(VCPKG_HOST_TRIPLET "x64-windows-csound" CACHE STRING "") set(VCPKG_TARGET_TRIPLET "x64-windows-csound") - set(CSOUND_INCLUDE_DIR_HINT "C:/Program Files/Csound6_x64") elseif(APPLE) # CMAKE_HOST_SYSTEM_PROCESSOR is not yet set before project(), so query # the host architecture directly to pick the right vcpkg triplet. diff --git a/7.x/src/fluidOpcodes/CMakeLists.txt b/7.x/src/fluidOpcodes/CMakeLists.txt index b8beae6..d19f135 100644 --- a/7.x/src/fluidOpcodes/CMakeLists.txt +++ b/7.x/src/fluidOpcodes/CMakeLists.txt @@ -1,12 +1,21 @@ # Build fluidsynth opcodes option(BUILD_FLUID_OPCODES "Build the fluidsynth opcodes" ON) -find_package(FLUIDSYNTH) +# Prefer the CMake config package (e.g. from vcpkg or a system install), which +# carries the required transitive dependencies (system frameworks, glib, ...). +find_package(FluidSynth CONFIG QUIET) +if(TARGET FluidSynth::libfluidsynth) + set(FLUIDSYNTH_FOUND TRUE) + set(FLUIDSYNTH_LINK_LIBRARIES FluidSynth::libfluidsynth) +else() + find_package(FLUIDSYNTH) + set(FLUIDSYNTH_LINK_LIBRARIES ${FLUIDSYNTH_LIBRARIES}) +endif() check_deps(BUILD_FLUID_OPCODES FLUIDSYNTH_FOUND) if(BUILD_FLUID_OPCODES AND FLUIDSYNTH_FOUND) make_plugin(fluidOpcodes fluidOpcodes.cpp) target_include_directories(fluidOpcodes PRIVATE ${FLUIDSYNTH_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) target_compile_definitions(fluidOpcodes PRIVATE BUILD_PLUGINS) - target_link_libraries(fluidOpcodes PRIVATE ${FLUIDSYNTH_LIBRARIES}) + target_link_libraries(fluidOpcodes PRIVATE ${FLUIDSYNTH_LINK_LIBRARIES}) endif() From 31f90efce6e3ebe94e470745825ad330c73999fe Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 15:03:44 +0100 Subject: [PATCH 06/72] Fix vcpkg detection of eigen and fluidsynth in CI Only use the FluidSynth CMake config under vcpkg (Debian ships an incomplete config), and set EIGEN3_FOUND after the Eigen3 config package so chua is not silently disabled under vcpkg. --- 7.x/src/chua/CMakeLists.txt | 2 ++ 7.x/src/fluidOpcodes/CMakeLists.txt | 9 +++++---- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/7.x/src/chua/CMakeLists.txt b/7.x/src/chua/CMakeLists.txt index f690fd9..54c277b 100644 --- a/7.x/src/chua/CMakeLists.txt +++ b/7.x/src/chua/CMakeLists.txt @@ -3,6 +3,8 @@ option(BUILD_CHUA_OPCODES "Build the chua opcodes" ON) if(USE_VCPKG) find_package(Eigen3 CONFIG REQUIRED) + # The Eigen3 config package sets Eigen3_FOUND; normalise for check_deps(). + set(EIGEN3_FOUND TRUE) else() find_package(EIGEN3) endif() diff --git a/7.x/src/fluidOpcodes/CMakeLists.txt b/7.x/src/fluidOpcodes/CMakeLists.txt index d19f135..bb9b49e 100644 --- a/7.x/src/fluidOpcodes/CMakeLists.txt +++ b/7.x/src/fluidOpcodes/CMakeLists.txt @@ -1,10 +1,11 @@ # Build fluidsynth opcodes option(BUILD_FLUID_OPCODES "Build the fluidsynth opcodes" ON) -# Prefer the CMake config package (e.g. from vcpkg or a system install), which -# carries the required transitive dependencies (system frameworks, glib, ...). -find_package(FluidSynth CONFIG QUIET) -if(TARGET FluidSynth::libfluidsynth) +# With vcpkg prefer the CMake config package, which carries the required +# transitive dependencies (e.g. macOS CoreAudio/CoreMIDI frameworks). System +# packages may ship an incomplete config, so fall back to FindFLUIDSYNTH. +if(USE_VCPKG) + find_package(FluidSynth CONFIG REQUIRED) set(FLUIDSYNTH_FOUND TRUE) set(FLUIDSYNTH_LINK_LIBRARIES FluidSynth::libfluidsynth) else() From 6f8e8ee846e6286c12c3791996a1b1e7bd60a74e Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 15:29:56 +0100 Subject: [PATCH 07/72] Disable automatic 6.x plugin builds (EOL) --- .github/workflows/plugins_build.yml | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/.github/workflows/plugins_build.yml b/.github/workflows/plugins_build.yml index eb7fe35..afcbb88 100644 --- a/.github/workflows/plugins_build.yml +++ b/.github/workflows/plugins_build.yml @@ -4,12 +4,7 @@ env: VCPKG_BINARY_SOURCES: "clear;nuget,GitHub,readwrite" on: - push: - branches: - - master - pull_request: - branches: - - master + workflow_dispatch: jobs: build_package: From f26e071865ec105aa30c1b65a09c9ba67273fab5 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sat, 10 Oct 2026 15:29:56 +0100 Subject: [PATCH 08/72] Add beta/full release automation to Csound 7 CI --- .github/actions/check-pr-label/action.yml | 50 ++++++++++ .github/workflows/plugins_build_7.yml | 110 +++++++++++++++++++--- 2 files changed, 147 insertions(+), 13 deletions(-) create mode 100644 .github/actions/check-pr-label/action.yml diff --git a/.github/actions/check-pr-label/action.yml b/.github/actions/check-pr-label/action.yml new file mode 100644 index 0000000..6cd7be4 --- /dev/null +++ b/.github/actions/check-pr-label/action.yml @@ -0,0 +1,50 @@ +name: 'Check PR Label on Merge Commit' +description: 'Checks if the merged PR associated with the current commit has a specific label.' +inputs: + label: + description: 'Label to check for (e.g., release)' + required: true + github_token: + description: 'GitHub token' + required: true +outputs: + has_label: + description: 'true if label exists, false otherwise' + value: ${{ steps.check_label.outputs.has_label }} +runs: + using: "composite" + steps: + - name: Find PR and check label + id: check_label + shell: bash + env: + GITHUB_TOKEN: ${{ inputs.github_token }} + LABEL_TO_CHECK: ${{ inputs.label }} + run: | + command -v gh >/dev/null 2>&1 || { + curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \ + | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg + echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \ + | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null + sudo apt-get update + sudo apt-get install -y gh + } + + PR_NUMBER=$(gh pr list --state merged --limit 100 --json number,mergeCommit \ + -q ".[] | select(.mergeCommit.oid==\"${GITHUB_SHA}\") | .number") + + if [ -z "$PR_NUMBER" ]; then + echo "No merged PR found for commit $GITHUB_SHA" + echo "has_label=false" >> "$GITHUB_OUTPUT" + exit 0 + fi + + LABELS=$(gh pr view "$PR_NUMBER" --json labels -q '.labels[].name') + + if echo "$LABELS" | grep -qw "$LABEL_TO_CHECK"; then + echo "Label $LABEL_TO_CHECK found for PR #$PR_NUMBER" + echo "has_label=true" >> "$GITHUB_OUTPUT" + else + echo "Label $LABEL_TO_CHECK not found for PR #$PR_NUMBER" + echo "has_label=false" >> "$GITHUB_OUTPUT" + fi diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 82f87f1..d2815d6 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -11,11 +11,11 @@ on: push: branches: - develop - - master + - main pull_request: branches: - develop - - master + - main workflow_dispatch: env: @@ -23,8 +23,41 @@ env: VCPKG_BINARY_SOURCES: "clear;files,${{ github.workspace }}/vcpkg-cache,readwrite" jobs: + update_version: + name: Update plugin version + runs-on: ubuntu-latest + permissions: + contents: write + outputs: + version: ${{ steps.tag.outputs.new_tag }} + release: ${{ steps.check_pr.outputs.has_label }} + steps: + - name: Checkout source + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Compute next version + id: tag + uses: anothrNick/github-tag-action@1.75.0 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + DEFAULT_BUMP: patch + DEFAULT_BRANCH: main + PRERELEASE: ${{ github.ref != 'refs/heads/main' }} + PRERELEASE_SUFFIX: beta + DRY_RUN: true + + - name: Check for release label + id: check_pr + uses: ./.github/actions/check-pr-label + with: + label: release + github_token: ${{ secrets.GITHUB_TOKEN }} + linux: name: Linux (ubuntu-latest) + needs: update_version runs-on: ubuntu-latest steps: - name: Checkout source @@ -71,19 +104,24 @@ jobs: -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" cmake --build build --parallel "$(nproc)" + - name: Stage plugins + run: | + mkdir -p package + cp build/src/chua/*.so \ + build/src/linear_algebra/*.so \ + build/src/fluidOpcodes/*.so \ + build/src/py/*.so package/ + - name: Upload plugins uses: actions/upload-artifact@v4 with: name: csound7-plugins-linux - path: | - build/src/chua/*.so - build/src/linear_algebra/*.so - build/src/fluidOpcodes/*.so - build/src/py/*.so + path: package/ if-no-files-found: error macos: name: macOS (macos-latest) + needs: update_version runs-on: macos-latest steps: - name: Checkout source @@ -165,24 +203,24 @@ jobs: -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" cmake --build build --parallel "$(sysctl -n hw.ncpu)" - - name: Package plugins + - name: Stage plugins run: | mkdir -p package cp build/src/chua/*.dylib \ build/src/linear_algebra/*.dylib \ build/src/fluidOpcodes/*.dylib \ build/src/py/*.dylib package/ - ( cd package && zip -r ../csound7-plugins-macos.zip . ) - name: Upload plugins uses: actions/upload-artifact@v4 with: name: csound7-plugins-macos - path: csound7-plugins-macos.zip + path: package/ if-no-files-found: error windows: name: Windows (windows-latest) + needs: update_version runs-on: windows-latest defaults: run: @@ -260,7 +298,7 @@ jobs: -DCSOUND_LIBRARY_DIR_HINT="$env:CSOUND_LIBRARY_DIR_HINT" cmake --build build --config Release --parallel - - name: Package plugins + - name: Stage plugins run: | $package = 'package' New-Item -ItemType Directory -Force -Path $package | Out-Null @@ -271,11 +309,57 @@ jobs: if (Test-Path $vcpkgBin) { Copy-Item (Join-Path $vcpkgBin '*.dll') -Destination $package -ErrorAction SilentlyContinue } - Compress-Archive -Path "$package\*" -DestinationPath csound7-plugins-windows.zip -Force - name: Upload plugins uses: actions/upload-artifact@v4 with: name: csound7-plugins-windows - path: csound7-plugins-windows.zip + path: package/ if-no-files-found: error + + publish_release: + name: Publish release + if: ${{ (github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main') && needs.update_version.outputs.release == 'true' }} + needs: [update_version, linux, macos, windows] + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - name: Download Linux plugins + uses: actions/download-artifact@v4 + with: + name: csound7-plugins-linux + path: release/linux + + - name: Download macOS plugins + uses: actions/download-artifact@v4 + with: + name: csound7-plugins-macos + path: release/macos + + - name: Download Windows plugins + uses: actions/download-artifact@v4 + with: + name: csound7-plugins-windows + path: release/windows + + - name: Package release assets + run: | + version="${{ needs.update_version.outputs.version }}" + ( cd release/linux && zip -r "../../csound7-plugins-${version}-linux-x86_64.zip" . ) + ( cd release/macos && zip -r "../../csound7-plugins-${version}-macos.zip" . ) + ( cd release/windows && zip -r "../../csound7-plugins-${version}-windows.zip" . ) + ls -l csound7-plugins-*.zip + + - name: Create release + uses: softprops/action-gh-release@v3.0.3 + with: + token: ${{ secrets.GITHUB_TOKEN }} + tag_name: ${{ needs.update_version.outputs.version }} + name: ${{ needs.update_version.outputs.version }} + generate_release_notes: true + prerelease: ${{ github.ref != 'refs/heads/main' }} + files: | + csound7-plugins-${{ needs.update_version.outputs.version }}-linux-x86_64.zip + csound7-plugins-${{ needs.update_version.outputs.version }}-macos.zip + csound7-plugins-${{ needs.update_version.outputs.version }}-windows.zip From 1961e578332a3077d84560d2009d4ee9176acc1c Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 08:47:25 +0100 Subject: [PATCH 09/72] Avoid leaking fluidSynth engines and SoundFonts on recompile Make engine creation and SoundFont loading idempotent across header re-evaluations (e.g. rt recompiles via csoundCompileOrc). Keep per-instance state keyed in Csound global memory and reuse a matching existing engine, and deduplicate SoundFont loads per engine. Fixes #5 --- 7.x/src/fluidOpcodes/fluidOpcodes.cpp | 194 ++++++++++++++++++-------- 1 file changed, 137 insertions(+), 57 deletions(-) diff --git a/7.x/src/fluidOpcodes/fluidOpcodes.cpp b/7.x/src/fluidOpcodes/fluidOpcodes.cpp index 5a33bed..e98789a 100644 --- a/7.x/src/fluidOpcodes/fluidOpcodes.cpp +++ b/7.x/src/fluidOpcodes/fluidOpcodes.cpp @@ -43,21 +43,45 @@ #include #include -static std::vector &fluidsynths_for_ids() { - static std::vector fluidsynths_for_ids_; - return fluidsynths_for_ids_; -} +// Per-instance state shared by the fluid* opcodes. Stored in a +// Csound-global pointer so recompiling a CSD through the API can reuse the +// engines and SoundFonts already loaded instead of growing memory each +// csoundCompileCsd/csoundCompileOrc call (github issue #5). +struct FluidSynthEngineState { + double sampleRate; + int32_t chorusEnabled; + int32_t reverbEnabled; + int32_t channelCount; + int32_t voiceCount; + std::map soundfonts; // resolved file path -> sf id +}; -static void tof(fluid_synth_t *f, cs_float *a) { - auto &instances = fluidsynths_for_ids(); - instances.push_back(f); - *a = instances.size() - 1; +struct FluidSynthState { + std::vector synths; // engine instances + std::vector engines; // parallel to synths }; -static void toa(cs_float *f, fluid_synth_t *&a) { - auto &instances = fluidsynths_for_ids(); - int index = *f; - a = instances[index]; +static void tof(CSOUND *csound, fluid_synth_t *f, cs_float *a) { + FluidSynthState *state = 0; + if (csound::QueryGlobalPointer(csound, "fluid_synth_state", state) && + state) { + state->synths.push_back(f); + *a = (cs_float)(state->synths.size() - 1); + } else { + *a = FL(0.0); + } +}; + +static void toa(CSOUND *csound, cs_float *f, fluid_synth_t *&a) { + a = 0; + FluidSynthState *state = 0; + if (csound::QueryGlobalPointer(csound, "fluid_synth_state", state) && + state) { + int index = (int)*f; + if (index >= 0 && index < (int)state->synths.size()) { + a = state->synths[index]; + } + } }; class FluidEngine : public csound::OpcodeBase { @@ -102,10 +126,37 @@ class FluidEngine : public csound::OpcodeBase { } else if (voiceCount > 4096) { voiceCount = 4096; } + double sampleRate = (double)csound->GetEngineSr(csound); + void *fluid_synths_mutex = 0; + csound::QueryGlobalPointer(csound, "fluid_synths_mutex", + fluid_synths_mutex); + csound::LockGuard synthsGuard(csound, fluid_synths_mutex); + FluidSynthState *state = 0; + csound::QueryGlobalPointer(csound, "fluid_synth_state", state); + if (state) { + for (size_t i = 0, n = state->engines.size(); i < n; i++) { + FluidSynthEngineState &engine = state->engines[i]; + if (engine.sampleRate == sampleRate && + engine.chorusEnabled == chorusEnabled && + engine.reverbEnabled == reverbEnabled && + engine.channelCount == channelCount && + engine.voiceCount == voiceCount) { + fluidSynth = state->synths[i]; + *iFluidSynth = (cs_float)i; + log(csound, "Reusing existing fluidEngine %ld (0x%p): " + "sampling rate = %f, chorus %s, reverb %s, " + "channels %d, voices %d.\n", + (long)i, fluidSynth, sampleRate, + chorusEnabled ? "on" : "off", reverbEnabled ? "on" : "off", + channelCount, voiceCount); + return OK; + } + } + } fluidSettings = new_fluid_settings(); if (fluidSettings != NULL) { fluid_settings_setnum(fluidSettings, (char *)"synth.sample-rate", - (double)csound->GetEngineSr(csound)); + sampleRate); fluid_settings_setint(fluidSettings, (char *)"synth.midi-channels", channelCount); fluid_settings_setint(fluidSettings, (char *)"synth.polyphony", @@ -129,19 +180,19 @@ class FluidEngine : public csound::OpcodeBase { #endif log(csound, "Created fluidEngine 0x%p with sampling rate = %f, " "chorus %s, reverb %s, channels %d, voices %d.\n", - fluidSynth, (double)csound->GetEngineSr(csound), + fluidSynth, sampleRate, chorusEnabled ? "on" : "off", reverbEnabled ? "on" : "off", channelCount, voiceCount); - tof(fluidSynth, iFluidSynth); - { - void *fluid_synths_mutex = 0; - csound::QueryGlobalPointer(csound, "fluid_synths_mutex", - fluid_synths_mutex); - csound::LockGuard synthsGuard(csound, fluid_synths_mutex); - std::vector *fluid_synths = 0; - csound::QueryGlobalPointer(csound, "fluid_synths", fluid_synths); - fluid_synths->push_back(fluidSynth); + if (state) { + FluidSynthEngineState engine; + engine.sampleRate = sampleRate; + engine.chorusEnabled = chorusEnabled; + engine.reverbEnabled = reverbEnabled; + engine.channelCount = channelCount; + engine.voiceCount = voiceCount; + state->engines.push_back(engine); } + tof(csound, fluidSynth, iFluidSynth); } return result; } @@ -168,7 +219,7 @@ class FluidLoad : public csound::OpcodeBase { csound::LockGuard guard(csound, mutex); int32_t result = OK; soundFontId = -1; - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); listPresets = (int32_t)*iListPresets; CS_TYPE *argType = GetTypeForArg(iFilename); if (strcmp("S", argType->varTypeName) == 0) { @@ -185,10 +236,37 @@ class FluidLoad : public csound::OpcodeBase { filepath = csound->FindInputFile(csound, filename, "SFDIR;SSDIR"); if (filepath && fluid_is_soundfont(filepath)) { - log(csound, "Loading SoundFont: %s.\n", filepath); - soundFontId = fluid_synth_sfload(fluidSynth, filepath, 0); - log(csound, "fluidSynth: 0x%p soundFontId: %d.\n", fluidSynth, - soundFontId); + void *fluid_synths_mutex = 0; + csound::QueryGlobalPointer(csound, "fluid_synths_mutex", + fluid_synths_mutex); + csound::LockGuard synthsGuard(csound, fluid_synths_mutex); + FluidSynthState *state = 0; + csound::QueryGlobalPointer(csound, "fluid_synth_state", state); + int32_t engineIndex = (int32_t)*iFluidSynth; + std::map *soundfonts = 0; + if (state && engineIndex >= 0 && + engineIndex < (int32_t)state->engines.size()) { + soundfonts = &state->engines[engineIndex].soundfonts; + } + soundFontId = -1; + if (soundfonts) { + std::map::iterator it = + soundfonts->find(filepath); + if (it != soundfonts->end()) { + soundFontId = it->second; + log(csound, "SoundFont %s already loaded as id %d, not reloaded.\n", + filepath, soundFontId); + } + } + if (soundFontId < 0) { + log(csound, "Loading SoundFont: %s.\n", filepath); + soundFontId = fluid_synth_sfload(fluidSynth, filepath, 0); + log(csound, "fluidSynth: 0x%p soundFontId: %d.\n", fluidSynth, + soundFontId); + if (soundFontId >= 0 && soundfonts) { + (*soundfonts)[filepath] = soundFontId; + } + } } *iInstrumentNumber = (cs_float)soundFontId; if (UNLIKELY(soundFontId < 0)) { @@ -249,7 +327,7 @@ class FluidInfo : public csound::OpcodeBase { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); int32_t result = OK; - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); fluid_sfont_t *fluidSoundfont = fluid_synth_get_sfont(fluidSynth, 0); #if FLUIDSYNTH_VERSION_MAJOR < 2 fluid_preset_t fluidPreset; @@ -313,7 +391,7 @@ class FluidProgramSelect : public csound::OpcodeBase { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); channel = (int32_t) *iChannelNumber; instrument = (uint32_t) *iInstrumentNumber; bank = (uint32_t) *iBankNumber; @@ -344,7 +422,7 @@ class FluidCCI : public csound::OpcodeBase { int32_t init(CSOUND *csound) { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); channel = (int32_t)*iChannelNumber; controller = (int32_t)*iControllerNumber; value = (int32_t)*kVal; @@ -371,7 +449,7 @@ class FluidCCK : public csound::OpcodeBase { int32_t init(CSOUND *csound) { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); priorValue = -1; return OK; } @@ -405,7 +483,7 @@ class FluidNote : public csound::OpcodeNoteoffBase { int32_t init(CSOUND *csound) { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); channel = (int32_t)*iChannelNumber; key = (int32_t)*iMidiKeyNumber; velocity = (int32_t)*iVelocity; @@ -437,7 +515,7 @@ class FluidOut : public csound::OpcodeBase { int32_t init(CSOUND *csound) { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); ksmps = opds.insdshead->ksmps; return OK; } @@ -497,8 +575,8 @@ class FluidAllOut : public csound::OpcodeBase { memset(&aLeftOut[ksmps], '\0', early * sizeof(cs_float)); memset(&aRightOut[ksmps], '\0', early * sizeof(cs_float)); } - std::vector *fluid_synths = 0; - csound::QueryGlobalPointer(csound, "fluid_synths", fluid_synths); + FluidSynthState *state = 0; + csound::QueryGlobalPointer(csound, "fluid_synth_state", state); void *fluid_synths_mutex = 0; csound::QueryGlobalPointer(csound, "fluid_synths_mutex", fluid_synths_mutex); @@ -506,14 +584,16 @@ class FluidAllOut : public csound::OpcodeBase { for (frame = offset; frame < ksmps; frame++) { aLeftOut[frame] = FL(0.0); aRightOut[frame] = FL(0.0); - for (size_t i = 0, n = fluid_synths->size(); i < n; i++) { - fluid_synth_t *fluidSynth = (*fluid_synths)[i]; - leftSample = FL(0.0); - rightSample = FL(0.0); - fluid_synth_write_float(fluidSynth, 1, &leftSample, 0, 1, &rightSample, - 0, 1); - aLeftOut[frame] += (cs_float)leftSample /* * csound->e0dbfs */; - aRightOut[frame] += (cs_float)rightSample /* * csound->e0dbfs */; + if (state && frame >= 0) { + for (size_t i = 0, n = state->synths.size(); i < n; i++) { + fluid_synth_t *fluidSynth = state->synths[i]; + leftSample = FL(0.0); + rightSample = FL(0.0); + fluid_synth_write_float(fluidSynth, 1, &leftSample, 0, 1, &rightSample, + 0, 1); + aLeftOut[frame] += (cs_float)leftSample /* * csound->e0dbfs */; + aRightOut[frame] += (cs_float)rightSample /* * csound->e0dbfs */; + } } } return OK; @@ -545,7 +625,7 @@ class FluidControl : public csound::OpcodeBase { int32_t init(CSOUND *csound) { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); priorMidiStatus = -1; priorMidiChannel = -1; priorMidiData1 = -1; @@ -642,7 +722,7 @@ class FluidSetInterpMethod : public csound::OpcodeBase { int32_t init(CSOUND *csound) { mutex = csound->Create_Mutex(0); csound::LockGuard guard(csound, mutex); - toa(iFluidSynth, fluidSynth); + toa(csound, iFluidSynth, fluidSynth); channel = (int32_t)*iChannelNumber; interpolationMethod = (int32_t)*iInterpMethod; if (UNLIKELY(interpolationMethod != 0 && interpolationMethod != 1 && @@ -685,10 +765,9 @@ static OENTRY localops[] = { {NULL, 0, 0, NULL, NULL, (SUBR)0, (SUBR)0, (SUBR)0, NULL, 0}}; PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { - std::vector *fluid_synths = - new std::vector(); + FluidSynthState *state = new FluidSynthState(); int32_t result = 0; - result = csound::CreateGlobalPointer(csound, "fluid_synths", fluid_synths); + result = csound::CreateGlobalPointer(csound, "fluid_synth_state", state); void *fluid_synths_mutex = csound->Create_Mutex(0); result = csound::CreateGlobalPointer(csound, "fluid_synths_mutex", fluid_synths_mutex); @@ -719,20 +798,21 @@ PUBLIC int32_t csoundModuleDestroy(CSOUND *csound) { void *fluid_synths_mutex = 0; csound::QueryGlobalPointer(csound, "fluid_synths_mutex", fluid_synths_mutex); if (fluid_synths_mutex) { - std::vector *fluid_synths = 0; - csound::QueryGlobalPointer(csound, "fluid_synths", fluid_synths); + FluidSynthState *state = 0; + csound::QueryGlobalPointer(csound, "fluid_synth_state", state); csound->LockMutex(fluid_synths_mutex); - if (fluid_synths) { - for (size_t i = 0, n = fluid_synths->size(); i < n; i++) { - fluid_synth_t *fluidSynth = (*fluid_synths)[i]; + if (state) { + for (size_t i = 0, n = state->synths.size(); i < n; i++) { + fluid_synth_t *fluidSynth = state->synths[i]; // printf("deleting engine: %p\n", fluidSynth); fluid_settings_t *fluidSettings = fluid_synth_get_settings(fluidSynth); delete_fluid_synth(fluidSynth); delete_fluid_settings(fluidSettings); } - fluid_synths->clear(); - delete fluid_synths; - fluid_synths = 0; + state->synths.clear(); + state->engines.clear(); + delete state; + state = 0; } csound->UnlockMutex(fluid_synths_mutex); csound->DestroyMutex(fluid_synths_mutex); From 0de17f29e0e3daf88249ab879bd72462e32097b4 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 09:01:59 +0100 Subject: [PATCH 10/72] Only reuse engines from an earlier compile (CodeRabbit) Gate engine reuse on the global-code INSDS identity so two fluidEngine calls with identical settings in the same compile still receive distinct engines (instead of being merged, which broke program/channel assignments and corrupted audio). Each engine records the compile that last claimed it; only a later compile may claim it again. --- 7.x/src/fluidOpcodes/fluidOpcodes.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/7.x/src/fluidOpcodes/fluidOpcodes.cpp b/7.x/src/fluidOpcodes/fluidOpcodes.cpp index e98789a..bb68403 100644 --- a/7.x/src/fluidOpcodes/fluidOpcodes.cpp +++ b/7.x/src/fluidOpcodes/fluidOpcodes.cpp @@ -53,6 +53,12 @@ struct FluidSynthEngineState { int32_t reverbEnabled; int32_t channelCount; int32_t voiceCount; + // Disambiguates reuse within a compile from reuse across compiles. An + // engine may only be reused by a later compile, so repeated matches within + // a single compile (same settings, e.g. two deliberate engines) still get + // distinct engines instead of being silently merged. The token is the + // global-code INSDS identity, which Csound creates afresh per compile. + void *lastClaimed; std::map soundfonts; // resolved file path -> sf id }; @@ -127,6 +133,7 @@ class FluidEngine : public csound::OpcodeBase { voiceCount = 4096; } double sampleRate = (double)csound->GetEngineSr(csound); + void *currentCompile = (void *)opds.insdshead; void *fluid_synths_mutex = 0; csound::QueryGlobalPointer(csound, "fluid_synths_mutex", fluid_synths_mutex); @@ -136,11 +143,13 @@ class FluidEngine : public csound::OpcodeBase { if (state) { for (size_t i = 0, n = state->engines.size(); i < n; i++) { FluidSynthEngineState &engine = state->engines[i]; - if (engine.sampleRate == sampleRate && + if (engine.lastClaimed != currentCompile && + engine.sampleRate == sampleRate && engine.chorusEnabled == chorusEnabled && engine.reverbEnabled == reverbEnabled && engine.channelCount == channelCount && engine.voiceCount == voiceCount) { + engine.lastClaimed = currentCompile; fluidSynth = state->synths[i]; *iFluidSynth = (cs_float)i; log(csound, "Reusing existing fluidEngine %ld (0x%p): " @@ -190,6 +199,7 @@ class FluidEngine : public csound::OpcodeBase { engine.reverbEnabled = reverbEnabled; engine.channelCount = channelCount; engine.voiceCount = voiceCount; + engine.lastClaimed = currentCompile; state->engines.push_back(engine); } tof(csound, fluidSynth, iFluidSynth); From 2db326bf4c9232ded82ad445b8359ffdb08f40b7 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 09:42:57 +0100 Subject: [PATCH 11/72] Add fluidSetting* opcodes for engine settings access (issue #32) --- 7.x/src/fluidOpcodes/fluidOpcodes.cpp | 261 ++++++++++++++++++++++++++ 1 file changed, 261 insertions(+) diff --git a/7.x/src/fluidOpcodes/fluidOpcodes.cpp b/7.x/src/fluidOpcodes/fluidOpcodes.cpp index bb68403..8363539 100644 --- a/7.x/src/fluidOpcodes/fluidOpcodes.cpp +++ b/7.x/src/fluidOpcodes/fluidOpcodes.cpp @@ -90,6 +90,15 @@ static void toa(CSOUND *csound, cs_float *f, fluid_synth_t *&a) { } }; +static void SetStringData(CSOUND *csound, STRINGDAT *sdata, const char *str) { + if (!str) { + str = ""; + } + sdata->data = csound->Strdup(csound, (char *)str); + sdata->size = strlen(str) + 1; + sdata->refcount = 0; +}; + class FluidEngine : public csound::OpcodeBase { // Outputs. cs_float *iFluidSynth; @@ -747,6 +756,247 @@ class FluidSetInterpMethod : public csound::OpcodeBase { } }; +// Access to a fluid engine's settings (github issue #32). Each opcode +// resolves the engine id handed out by fluidEngine to its fluid_settings +// (obtained via fluid_synth_get_settings) and either sets a setting on the +// fly or reads its current value, dispatching on the setting's own type. +// Note: set/get return 1/0 on fluidsynth 1.x and FLUID_OK/FLUID_FAILED on +// 2.x, so failure is checked version-conditionally. +static int32_t SettingSetFailed(int result) { +#if FLUIDSYNTH_VERSION_MAJOR >= 2 + return result < int(FLUID_OK); +#else + return result == 0; +#endif +} + +class FluidSettingNum : public csound::OpcodeBase { + // Inputs. + cs_float *iFluidSynth; + cs_float *iSetting; + cs_float *kValue; + // State. + fluid_synth_t *fluidSynth; + fluid_settings_t *fluidSettings; + char *settingName; + cs_float priorValue; + int32_t initial; + void *mutex; + +public: + int32_t setValue(CSOUND *csound) { + if (UNLIKELY(!fluidSettings)) { + csound->Message(csound, Str("fluidSettingNum: invalid engine id.\n")); + return NOTOK; + } + int32_t type = + fluid_settings_get_type(fluidSettings, (char *)settingName); + if (type == FLUID_NUM_TYPE) { + if (SettingSetFailed(fluid_settings_setnum( + fluidSettings, (char *)settingName, (double)*kValue))) { + csound->Message(csound, + Str("fluidSettingNum: could not set '%s' to %g.\n"), + settingName, *kValue); + return NOTOK; + } + } else if (type == FLUID_INT_TYPE) { + if (SettingSetFailed(fluid_settings_setint( + fluidSettings, (char *)settingName, (int)*kValue))) { + csound->Message( + csound, Str("fluidSettingNum: could not set '%s' to %d.\n"), + settingName, (int)*kValue); + return NOTOK; + } + } else { + csound->Message( + csound, Str("fluidSettingNum: '%s' is not a numeric setting " + "(type %d).\n"), + settingName, type); + return NOTOK; + } + return OK; + } + + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(csound, iFluidSynth, fluidSynth); + fluidSettings = + fluidSynth ? fluid_synth_get_settings(fluidSynth) : (fluid_settings_t *)0; + if (iSetting) { + settingName = ((STRINGDAT *)iSetting)->data; + } + initial = 1; + priorValue = FL(0.0); + int32_t result = setValue(csound); + if (UNLIKELY(result != OK)) { + return csound->InitError(csound, "%s", + Str("fluidSettingNum: cannot set setting.\n")); + } + priorValue = *kValue; + return OK; + } + + int32_t kontrol(CSOUND *csound) { + csound::LockGuard guard(csound, mutex); + if (initial || *kValue != priorValue) { + initial = 0; + priorValue = *kValue; + setValue(csound); + } + return OK; + } +}; + +class FluidSettingString : public csound::OpcodeBase { + // Inputs. + cs_float *iFluidSynth; + cs_float *iSetting; + cs_float *iValue; + // State. + fluid_synth_t *fluidSynth; + fluid_settings_t *fluidSettings; + char *settingName; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(csound, iFluidSynth, fluidSynth); + fluidSettings = + fluidSynth ? fluid_synth_get_settings(fluidSynth) : (fluid_settings_t *)0; + if (iSetting) { + settingName = ((STRINGDAT *)iSetting)->data; + } + if (UNLIKELY(!fluidSettings)) { + return csound->InitError(csound, "%s", + Str("fluidSettingString: invalid engine id.\n")); + } + if (fluid_settings_get_type(fluidSettings, (char *)settingName) != + FLUID_STR_TYPE) { + return csound->InitError( + csound, Str("fluidSettingString: '%s' is not a string setting.\n"), + settingName); + } + char *value = ((STRINGDAT *)iValue)->data; + if (SettingSetFailed(fluid_settings_setstr(fluidSettings, (char *)settingName, + (char *)value))) { + return csound->InitError( + csound, Str("fluidSettingString: could not set '%s' to '%s'.\n"), + settingName, value); + } + return OK; + } +}; + +class FluidSettingGetNum : public csound::OpcodeBase { + // Outputs. + cs_float *kOut; + // Inputs. + cs_float *iFluidSynth; + cs_float *iSetting; + // State. + fluid_synth_t *fluidSynth; + fluid_settings_t *fluidSettings; + char *settingName; + int32_t valid; + void *mutex; + +public: + int32_t getValue(CSOUND *csound) { + if (UNLIKELY(!fluidSettings)) { + if (valid) { + valid = 0; + csound->Message(csound, + Str("fluidSettingGetNum: invalid engine id.\n")); + } + *kOut = FL(0.0); + return NOTOK; + } + int32_t type = + fluid_settings_get_type(fluidSettings, (char *)settingName); + if (type == FLUID_NUM_TYPE) { + double value = 0.0; + fluid_settings_getnum(fluidSettings, (char *)settingName, &value); + *kOut = (cs_float)value; + } else if (type == FLUID_INT_TYPE) { + int value = 0; + fluid_settings_getint(fluidSettings, (char *)settingName, &value); + *kOut = (cs_float)value; + } else { + if (valid) { + valid = 0; + csound->Message(csound, Str("fluidSettingGetNum: '%s' is not a " + "numeric setting.\n"), + settingName); + } + *kOut = FL(0.0); + } + return OK; + } + + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + valid = 1; + toa(csound, iFluidSynth, fluidSynth); + fluidSettings = + fluidSynth ? fluid_synth_get_settings(fluidSynth) : (fluid_settings_t *)0; + if (iSetting) { + settingName = ((STRINGDAT *)iSetting)->data; + } + return getValue(csound); + } + + int32_t kontrol(CSOUND *csound) { + csound::LockGuard guard(csound, mutex); + return getValue(csound); + } +}; + +class FluidSettingGetString : public csound::OpcodeBase { + // Outputs. + STRINGDAT *SOut; + // Inputs. + cs_float *iFluidSynth; + cs_float *iSetting; + // State. + fluid_synth_t *fluidSynth; + fluid_settings_t *fluidSettings; + char *settingName; + void *mutex; + +public: + int32_t init(CSOUND *csound) { + mutex = csound->Create_Mutex(0); + csound::LockGuard guard(csound, mutex); + toa(csound, iFluidSynth, fluidSynth); + fluidSettings = + fluidSynth ? fluid_synth_get_settings(fluidSynth) : (fluid_settings_t *)0; + if (iSetting) { + settingName = ((STRINGDAT *)iSetting)->data; + } + if (UNLIKELY(!fluidSettings)) { + SetStringData(csound, SOut, ""); + return csound->InitError(csound, "%s", + Str("fluidSettingGetString: invalid engine id.\n")); + } + if (fluid_settings_get_type(fluidSettings, (char *)settingName) != + FLUID_STR_TYPE) { + SetStringData(csound, SOut, ""); + return csound->InitError( + csound, + Str("fluidSettingGetString: '%s' is not a string setting.\n"), + settingName); + } + char *value = (char *)""; + fluid_settings_getstr(fluidSettings, (char *)settingName, &value); + SetStringData(csound, SOut, value ? value : ""); + return OK; + } +}; + static OENTRY localops[] = { {(char *)"fluidEngine", sizeof(FluidEngine), 0, (char *)"i", (char *)"ppoo", (SUBR)&FluidEngine::init_, (SUBR)0, (SUBR)0}, @@ -772,6 +1022,17 @@ static OENTRY localops[] = { {(char *)"fluidSetInterpMethod", sizeof(FluidSetInterpMethod), 0, (char *)"", (char *)"iii", (SUBR)&FluidSetInterpMethod::init_, (SUBR)0, (SUBR)0}, + {(char *)"fluidSettingNum", sizeof(FluidSettingNum), 0, (char *)"", + (char *)"iSk", (SUBR)&FluidSettingNum::init_, + (SUBR)&FluidSettingNum::kontrol_, (SUBR)0}, + {(char *)"fluidSettingString", sizeof(FluidSettingString), 0, (char *)"", + (char *)"iSS", (SUBR)&FluidSettingString::init_, (SUBR)0, (SUBR)0}, + {(char *)"fluidSettingGetNum", sizeof(FluidSettingGetNum), 0, (char *)"k", + (char *)"iS", (SUBR)&FluidSettingGetNum::init_, + (SUBR)&FluidSettingGetNum::kontrol_, (SUBR)0}, + {(char *)"fluidSettingGetString", sizeof(FluidSettingGetString), 0, + (char *)"S", (char *)"iS", (SUBR)&FluidSettingGetString::init_, (SUBR)0, + (SUBR)0}, {NULL, 0, 0, NULL, NULL, (SUBR)0, (SUBR)0, (SUBR)0, NULL, 0}}; PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { From bfeafe111d02c3bd61b11e47e9c32ee2b9f5d92c Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 09:44:30 +0100 Subject: [PATCH 12/72] Note versioned layout and 6.x EOL status in README --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 95b09a2..457805f 100644 --- a/README.md +++ b/README.md @@ -5,5 +5,9 @@ This repository contains the code for Csound plugins that require external dependencies, as well as code for new third-party contributed plugins. +The tree is currently organised by major Csound versions. Full and beta releases are available and build artefacts are also accessible from the actions tab. + +NB: Csound 6.x is EOL. It is likely that plugins for that version will be removed from the develop and main branch after the first full release. In that case, we will keep the code solely in the csound6 branch. + From 9d23bf52f303bb2c25540afe15f3defd2ff7643f Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 09:49:24 +0100 Subject: [PATCH 13/72] Use fluid_settings_dupstr on fluidsynth 2.x in fluidSettingGetString --- 7.x/src/fluidOpcodes/fluidOpcodes.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/7.x/src/fluidOpcodes/fluidOpcodes.cpp b/7.x/src/fluidOpcodes/fluidOpcodes.cpp index 8363539..eb3cd77 100644 --- a/7.x/src/fluidOpcodes/fluidOpcodes.cpp +++ b/7.x/src/fluidOpcodes/fluidOpcodes.cpp @@ -990,9 +990,21 @@ class FluidSettingGetString : public csound::OpcodeBase { Str("fluidSettingGetString: '%s' is not a string setting.\n"), settingName); } - char *value = (char *)""; +#if FLUIDSYNTH_VERSION_MAJOR >= 2 + char *value = 0; + if (fluid_settings_dupstr(fluidSettings, (char *)settingName, &value) == + FLUID_OK && + value) { + SetStringData(csound, SOut, value); + fluid_free(value); + } else { + SetStringData(csound, SOut, ""); + } +#else + char *value = 0; fluid_settings_getstr(fluidSettings, (char *)settingName, &value); SetStringData(csound, SOut, value ? value : ""); +#endif return OK; } }; From b1c57413131af63bcf18d2a7f0afbea6f74035c8 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 09:56:09 +0100 Subject: [PATCH 14/72] Update 7.x README: list all plugins and document fluidSetting* opcodes --- 7.x/README.md | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/7.x/README.md b/7.x/README.md index 6679ac0..27cee7b 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -3,10 +3,38 @@ Plugins for Csound 7.x Currently, the plugins available in this tree are +- chua (requires the Eigen library, header-only) +**chuap** + +- fluidOpcodes (requires fluidsynth) +**fluidEngine fluidLoad fluidNote fluidCCi fluidCCk fluidControl fluidProgramSelect fluidAllOut fluidOut fluidInfo fluidSetInterpMethod** + +- linear_algebra (requires the gmm++ library, header-only; vendored under this directory) +**A large family of `la_*` opcodes, with i-rate and k-rate variants, for vector, matrix and tensor operations** + - py (requires a Python 3.x installation with dev libs) **Many opcodes to call Python code** +Fluid settings opcodes +--- + +Besides the engine/SoundFont/MIDI opcodes listed above, `fluidOpcodes` +provides four opcodes to read and write the settings of an engine created by +`fluidEngine` (resolved through `fluid_synth_get_settings`). In each case the +first argument is the engine id and the second is the setting name: + +| Opcode | Outputs | Inputs | Description | +| --- | --- | --- | --- | +| `fluidSettingNum` | – | `iSk` | set an int/num/bool setting | +| `fluidSettingString` | – | `iSS` | set a string setting | +| `fluidSettingGetNum` | `k` | `iS` | read a numeric setting | +| `fluidSettingGetString` | `S` | `iS` | read a string setting | + +The setters fail at init if the setting name is unknown or of the wrong type; +the getters report a message and return 0 (or an empty string) instead. + + Install location -------------- The CMake scripts in this repository use the default CS_USER_PLUGIN @@ -46,10 +74,12 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. -For example, to exclude the XXX plugin, the `cmake` command would be: +The options are `BUILD_CHUA_OPCODES`, `BUILD_FLUID_OPCODES`, +`BUILD_LINEAR_ALGEBRA_OPCODES` and `BUILD_PYTHON_OPCODES`. For example, to +exclude the chua plugin, the `cmake` command would be: ``` -$ cmake -DXXX_OPCODES=OFF ../ +$ cmake -DBUILD_CHUA_OPCODES=OFF ../ ``` From ec45e48d6a2d24cb15f496ba83ce0c1ae8599bde Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 10:25:11 +0100 Subject: [PATCH 15/72] Address remaining CodeRabbit review on fluidOpcodes - Key engine reuse on the fluidEngine opcode's ordinal within the global opcode chain instead of the INSDS address, which Csound may recycle between compiles (CodeRabbit 4240985883). - Reuse the string buffer in SetStringData when capacity suffices, else free the old buffer before reallocating (CodeRabbit 4240985871). - Report wrong-type/invalid settings via Message rather than InitError so a non-fatal lookup does not abort the compile (CodeRabbit 4240985891). - Guard fluid_free behind a version check; earlier fluidsynth releases use free() (CodeRabbit 4240985896). --- 7.x/src/fluidOpcodes/fluidOpcodes.cpp | 77 +++++++++++++++++++++------ 1 file changed, 61 insertions(+), 16 deletions(-) diff --git a/7.x/src/fluidOpcodes/fluidOpcodes.cpp b/7.x/src/fluidOpcodes/fluidOpcodes.cpp index eb3cd77..666f76e 100644 --- a/7.x/src/fluidOpcodes/fluidOpcodes.cpp +++ b/7.x/src/fluidOpcodes/fluidOpcodes.cpp @@ -34,6 +34,8 @@ */ #include +#include +#include #include #include #include @@ -53,12 +55,13 @@ struct FluidSynthEngineState { int32_t reverbEnabled; int32_t channelCount; int32_t voiceCount; - // Disambiguates reuse within a compile from reuse across compiles. An - // engine may only be reused by a later compile, so repeated matches within - // a single compile (same settings, e.g. two deliberate engines) still get - // distinct engines instead of being silently merged. The token is the - // global-code INSDS identity, which Csound creates afresh per compile. - void *lastClaimed; + // Ordinal of the fluidEngine opcode that owns this engine within the + // compiled global (instr 0) opcode chain. Reuse is keyed on this ordinal + // and the configuration, so the same opcode reuses its engine across + // compiles while two deliberately separate engines stay distinct. The + // ordinal comes from the compile's opcode chain, never from a heap address, + // which Csound may recycle between compiles. + int32_t ordinal; std::map soundfonts; // resolved file path -> sf id }; @@ -90,15 +93,56 @@ static void toa(CSOUND *csound, cs_float *f, fluid_synth_t *&a) { } }; +// Position of a fluidEngine opcode among the fluidEngine opcodes of the +// current compile, found by walking the global (instr 0) init chain. The +// ordinal is stable across recompiles of the same orchestra and does not +// depend on any heap address, so a given opcode always maps to the same +// engine. Csound may recycle the INSDS that holds the chain between compiles, +// which makes its address unusable as an identity. +static int32_t FluidEngineOrdinal(OPDS *op) { + OPDS *head = (OPDS *)op->insdshead; + if (!head || !op->optext) { + return 0; + } + OENTRY *entry = op->optext->t.oentry; + int32_t ordinal = 0; + for (OPDS *p = head->nxti; p != 0 && p != op; p = p->nxti) { + if (p->optext && p->optext->t.oentry == entry) { + ordinal++; + } + } + return ordinal; +}; + static void SetStringData(CSOUND *csound, STRINGDAT *sdata, const char *str) { if (!str) { str = ""; } - sdata->data = csound->Strdup(csound, (char *)str); - sdata->size = strlen(str) + 1; + size_t len = strlen(str) + 1; + if (sdata->data == NULL || sdata->size < len) { + if (sdata->data != NULL && sdata->refcount == 0) { + csound->Free(csound, sdata->data); + } + sdata->data = (char *)csound->Calloc(csound, len); + sdata->size = len; + } + memcpy(sdata->data, str, len); sdata->refcount = 0; }; +// fluid_settings_dupstr() allocates a copy the caller owns. Release it with +// fluid_free(), which only exists since fluidsynth 2.0.7; earlier 2.x releases +// must use free() (same allocator). +static void FreeFluidString(char *str) { +#if FLUIDSYNTH_VERSION_MAJOR > 2 || \ + (FLUIDSYNTH_VERSION_MAJOR == 2 && \ + (FLUIDSYNTH_VERSION_MINOR > 0 || FLUIDSYNTH_VERSION_MICRO >= 7)) + fluid_free(str); +#else + free(str); +#endif +}; + class FluidEngine : public csound::OpcodeBase { // Outputs. cs_float *iFluidSynth; @@ -142,7 +186,7 @@ class FluidEngine : public csound::OpcodeBase { voiceCount = 4096; } double sampleRate = (double)csound->GetEngineSr(csound); - void *currentCompile = (void *)opds.insdshead; + int32_t ordinal = FluidEngineOrdinal(&opds); void *fluid_synths_mutex = 0; csound::QueryGlobalPointer(csound, "fluid_synths_mutex", fluid_synths_mutex); @@ -152,13 +196,12 @@ class FluidEngine : public csound::OpcodeBase { if (state) { for (size_t i = 0, n = state->engines.size(); i < n; i++) { FluidSynthEngineState &engine = state->engines[i]; - if (engine.lastClaimed != currentCompile && + if (engine.ordinal == ordinal && engine.sampleRate == sampleRate && engine.chorusEnabled == chorusEnabled && engine.reverbEnabled == reverbEnabled && engine.channelCount == channelCount && engine.voiceCount == voiceCount) { - engine.lastClaimed = currentCompile; fluidSynth = state->synths[i]; *iFluidSynth = (cs_float)i; log(csound, "Reusing existing fluidEngine %ld (0x%p): " @@ -208,7 +251,7 @@ class FluidEngine : public csound::OpcodeBase { engine.reverbEnabled = reverbEnabled; engine.channelCount = channelCount; engine.voiceCount = voiceCount; - engine.lastClaimed = currentCompile; + engine.ordinal = ordinal; state->engines.push_back(engine); } tof(csound, fluidSynth, iFluidSynth); @@ -979,16 +1022,18 @@ class FluidSettingGetString : public csound::OpcodeBase { } if (UNLIKELY(!fluidSettings)) { SetStringData(csound, SOut, ""); - return csound->InitError(csound, "%s", - Str("fluidSettingGetString: invalid engine id.\n")); + csound->Message(csound, "%s", + Str("fluidSettingGetString: invalid engine id.\n")); + return OK; } if (fluid_settings_get_type(fluidSettings, (char *)settingName) != FLUID_STR_TYPE) { SetStringData(csound, SOut, ""); - return csound->InitError( + csound->Message( csound, Str("fluidSettingGetString: '%s' is not a string setting.\n"), settingName); + return OK; } #if FLUIDSYNTH_VERSION_MAJOR >= 2 char *value = 0; @@ -996,7 +1041,7 @@ class FluidSettingGetString : public csound::OpcodeBase { FLUID_OK && value) { SetStringData(csound, SOut, value); - fluid_free(value); + FreeFluidString(value); } else { SetStringData(csound, SOut, ""); } From 08fe4ce20c083e94caa16fb328c60d25ead32e52 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 11:16:45 +0100 Subject: [PATCH 16/72] Port websocket opcode to Csound 7 plugins Add the libwebsockets-based websocket opcode to the Csound 7 plugin tree, updating it to the 7.x plugin API: cs_float, LINKAGE registration with the deinit in the OENTRY slot, GetTypeForArg/GetInput/OutputArgName/GetLocalKsmps, and LWS_PRE instead of the removed send-buffer padding macros. Wire up the build (CMakeLists, vcpkg.json, CI dependencies/staging) and document the plugin in the 7.x README. --- .github/workflows/plugins_build_7.yml | 3 + 7.x/CMakeLists.txt | 1 + 7.x/README.md | 6 +- 7.x/src/websockets/CMakeLists.txt | 42 ++ 7.x/src/websockets/WebSocketOpcode.c | 710 ++++++++++++++++++++++++++ 7.x/src/websockets/WebSocketOpcode.h | 81 +++ 7.x/vcpkg.json | 4 +- 7 files changed, 845 insertions(+), 2 deletions(-) create mode 100644 7.x/src/websockets/CMakeLists.txt create mode 100644 7.x/src/websockets/WebSocketOpcode.c create mode 100644 7.x/src/websockets/WebSocketOpcode.h diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index d2815d6..ccb06a2 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -70,6 +70,7 @@ jobs: build-essential cmake pkg-config \ libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ libeigen3-dev libfluidsynth-dev \ + libwebsockets-dev libuv1-dev \ flex bison - name: Cache Csound install @@ -110,6 +111,7 @@ jobs: cp build/src/chua/*.so \ build/src/linear_algebra/*.so \ build/src/fluidOpcodes/*.so \ + build/src/websockets/*.so \ build/src/py/*.so package/ - name: Upload plugins @@ -209,6 +211,7 @@ jobs: cp build/src/chua/*.dylib \ build/src/linear_algebra/*.dylib \ build/src/fluidOpcodes/*.dylib \ + build/src/websockets/*.dylib \ build/src/py/*.dylib package/ - name: Upload plugins diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 8e3d340..37c3b23 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -305,4 +305,5 @@ endif() add_subdirectory(./src/chua) add_subdirectory(./src/linear_algebra) add_subdirectory(./src/fluidOpcodes) +add_subdirectory(./src/websockets) add_subdirectory(./src/py) diff --git a/7.x/README.md b/7.x/README.md index 27cee7b..7d0046f 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -15,6 +15,9 @@ Currently, the plugins available in this tree are - py (requires a Python 3.x installation with dev libs) **Many opcodes to call Python code** +- websockets (requires libwebsockets) +**websocket** + Fluid settings opcodes --- @@ -75,7 +78,8 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_FLUID_OPCODES`, -`BUILD_LINEAR_ALGEBRA_OPCODES` and `BUILD_PYTHON_OPCODES`. For example, to +`BUILD_LINEAR_ALGEBRA_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and +`BUILD_PYTHON_OPCODES`. For example, to exclude the chua plugin, the `cmake` command would be: ``` diff --git a/7.x/src/websockets/CMakeLists.txt b/7.x/src/websockets/CMakeLists.txt new file mode 100644 index 0000000..bfb4df8 --- /dev/null +++ b/7.x/src/websockets/CMakeLists.txt @@ -0,0 +1,42 @@ +# Build the websocket opcode (websocket), which exposes Csound variables over a +# libwebsockets server. +option(BUILD_WEBSOCKET_OPCODE "Build the websocket opcode" ON) + +if(USE_VCPKG) + find_package(libwebsockets CONFIG) + find_package(libuv CONFIG) + set(WEBSOCKET_DEPS libwebsockets_FOUND libuv_FOUND) +else() + find_path(WEBSOCKETS_H libwebsockets.h /usr/local/include /usr/include) + find_library(websockets_library NAMES websockets) + set(WEBSOCKET_DEPS websockets_library WEBSOCKETS_H) + + if(APPLE) + find_library(ssl_library NAMES ssl) + find_library(crypto_library NAMES crypto) + list(APPEND WEBSOCKET_DEPS ssl_library crypto_library) + endif() +endif() + +check_deps(BUILD_WEBSOCKET_OPCODE ${WEBSOCKET_DEPS}) + +if(BUILD_WEBSOCKET_OPCODE) + make_plugin(websocketIO WebSocketOpcode.c) + target_include_directories(websocketIO PRIVATE ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(websocketIO PRIVATE BUILD_PLUGINS) + + if(USE_VCPKG) + target_link_libraries(websocketIO websockets uv_a) + else() + target_link_libraries(websocketIO ${websockets_library}) + target_include_directories(websocketIO PRIVATE ${WEBSOCKETS_H}) + endif() + + if(APPLE) + if(USE_VCPKG) + target_link_libraries(websocketIO z) + else() + target_link_libraries(websocketIO ${ssl_library} ${crypto_library} z) + endif() + endif() +endif() diff --git a/7.x/src/websockets/WebSocketOpcode.c b/7.x/src/websockets/WebSocketOpcode.c new file mode 100644 index 0000000..b8b9d00 --- /dev/null +++ b/7.x/src/websockets/WebSocketOpcode.c @@ -0,0 +1,710 @@ +/* + WebSocketOpcode.c + WebSocketOpcode + + Copyright (C) 2015, 2016 + Edward Costello + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA + */ + +#include "WebSocketOpcode.h" +#include +#include +#include +#include + +typedef enum ArgumentType +{ + STRING_VAR, + ARATE_VAR, + KRATE_VAR, + IRATE_VAR, + ARATE_ARRAY, + KRATE_ARRAY, + IRATE_ARRAY, + UNKNOWN +} ArgumentType; + + +struct OpcodeArgument{ + + void *dataPointer; + cs_float *argumentPointer; + bool receivedData; + ArgumentType argumentType; + AUXCH auxillaryMemory; + void *circularBuffer; + char *name; + void *readBuffer; + int32_t itemsCount; + uint32_t bytesCount; + uint32_t bytesWritten; + bool iRateVarSent; +}; + +struct WebSocket{ + + struct lws_context *context; + struct lws *websocket; + struct lws_protocols *protocols; + void *processThread; + unsigned char *messageBuffer; + struct lws_context_creation_info info; +}; + +typedef enum ArgumentOffset { + + OUTPUT_OFFSET = 1000, INPUT_OFFSET = 2000 +} ArgumentOffset; + +static const size_t writeBufferBytesCount = 2048; +static const size_t stringVarMaximumBytesCount = 4096; +static const size_t ringBufferItemsCount = 2048 * 16; + +void WebSocketOpcode_initialiseWebSocket(WebSocketOpcode *self, CSOUND *csound); +int32_t WebSocketOpcode_finish(CSOUND *csound, void *opaqueReference); +void WebSocketOpcode_initialiseArguments(WebSocketOpcode *self, CSOUND *csound); +ArgumentType WebSocketOpcode_getArgumentType(CSOUND *csound, cs_float *argument); + +int32_t WebSocketOpcode_initialise(CSOUND *csound, WebSocketOpcode *self) +{ + self->inputArgumentCount = self->INOCOUNT - 1; + self->outputArgumentCount = self->OUTOCOUNT; + self->csound = csound; + WebSocketOpcode_initialiseArguments(self, csound); + WebSocketOpcode_initialiseWebSocket(self, csound); + return OK; +} + +void WebSocketOpcode_sendInputArgumentData(CSOUND *csound, WebSocketOpcode *self) +{ + int32_t i; + for (i = 0; i < self->inputArgumentCount; ++i) { + + OpcodeArgument *currentArgument = &self->inputArguments[i]; + + if (currentArgument->iRateVarSent == true) { + + continue; + } + + int32_t itemsWritten = + csound->WriteCircularBuffer(csound, + currentArgument->circularBuffer, + currentArgument->dataPointer, + currentArgument->itemsCount); + + if (UNLIKELY(itemsWritten != currentArgument->itemsCount)) { + + csound->Message(csound, + Str("websocket: variable %s data not sent, " + "buffer overrrun\n"), currentArgument->name); + } + } +} + +void WebSocketOpcode_receiveOutputArgumentData(CSOUND *csound, + WebSocketOpcode *self) +{ + int32_t i; + for (i = 0; i < self->outputArgumentCount; ++i) { + + OpcodeArgument *currentArgument = &self->outputArguments[i]; + + if (currentArgument->receivedData == true) { + + if (currentArgument->iRateVarSent == true) { + + continue; + } + + csound->ReadCircularBuffer(csound, currentArgument->circularBuffer, + currentArgument->dataPointer, + currentArgument->itemsCount); + + if (currentArgument->argumentType == STRING_VAR) { + + STRINGDAT *string = (STRINGDAT *)currentArgument->argumentPointer; + string->size = strlen((char *)currentArgument->dataPointer); + } + + currentArgument->receivedData = false; + } + + } +} + +int32_t WebSocketOpcode_process(CSOUND *csound, WebSocketOpcode *self) +{ + WebSocketOpcode_sendInputArgumentData(csound, self); + WebSocketOpcode_receiveOutputArgumentData(csound, self); + return OK; +} + +int32_t WebSocketOpcode_finish(CSOUND *csound, void *opaqueReference) +{ + int32_t i; + WebSocketOpcode *self = opaqueReference; + self->isRunning = false; + + csound->JoinThread(self->webSocket->processThread); + + lws_cancel_service(self->webSocket->context); + lws_context_destroy(self->webSocket->context); + + for (i = 0; i < self->outputArgumentCount; ++i) { + + csound->DestroyCircularBuffer(csound, self->outputArguments[i].circularBuffer); + } + + for (i = 0; i < self->inputArgumentCount; ++i) { + + csound->DestroyCircularBuffer(csound, self->inputArguments[i].circularBuffer); + } + + csound->Free(csound, self->webSocket->protocols); + csound->Free(csound, self->webSocket->messageBuffer); + csound->Free(csound, self->webSocket); + if (self->inputArgumentCount > 0) { + + csound->Free(csound, self->inputArguments); + } + if (self->outputArgumentCount > 0) { + + csound->Free(csound, self->outputArguments); + } + return OK; +} + +int32_t WebSocketOpcode_getArrayElementCount(ARRAYDAT *array) +{ + int32_t elementCount = array->sizes[0]; + int32_t i; + for (i = 1; i < array->dimensions; ++i) { + + elementCount *= array->sizes[i]; + } + + return elementCount; +} + + +void WebSocketOpcode_allocateStringArgument(cs_float *argument, + OpcodeArgument *argumentArrayItem, + CSOUND *csound, bool isInputArgument) +{ + STRINGDAT *string = (STRINGDAT *)argument; + + if (UNLIKELY(isInputArgument == true)) { + + csound->Die(csound, + "%s", Str("websocket: this opcode does not send strings, only " + "receiving them is supported\nExiting")); + } + else { + + if (UNLIKELY(string->size != 0)) { + + csound->Die(csound, + Str("websocket: error output string variable %s must not " + "be initialised\nExiting"), + argumentArrayItem->name); + } + else { + + argumentArrayItem->itemsCount = stringVarMaximumBytesCount; + string->data = csound->ReAlloc(csound, string->data, + stringVarMaximumBytesCount); + memset(string->data, 0, stringVarMaximumBytesCount); + } + } + + argumentArrayItem->dataPointer = string->data; + argumentArrayItem->bytesCount = sizeof(char) * stringVarMaximumBytesCount; + argumentArrayItem->circularBuffer = + csound->CreateCircularBuffer(csound, + argumentArrayItem->itemsCount * + ringBufferItemsCount + 1, + sizeof(char)); + csound->AuxAlloc(csound, argumentArrayItem->bytesCount, + &argumentArrayItem->auxillaryMemory); + argumentArrayItem->readBuffer = argumentArrayItem->auxillaryMemory.auxp; +} + +void WebSocketOpcode_allocateArrayArgument(cs_float *argument, + OpcodeArgument *argumentArrayItem, + CSOUND *csound) +{ + ARRAYDAT *array = (ARRAYDAT *)argument; + + if (UNLIKELY(array->dimensions == 0)) { + + csound->Die(csound, + Str("websocket: error array variable %s has not been " + "initialised\nExiting"), + argumentArrayItem->name); + } + + argumentArrayItem->dataPointer = array->data; + argumentArrayItem->itemsCount = WebSocketOpcode_getArrayElementCount(array); + argumentArrayItem->bytesCount = + array->arrayMemberSize * argumentArrayItem->itemsCount; + argumentArrayItem->circularBuffer = + csound->CreateCircularBuffer(csound, + argumentArrayItem->itemsCount * + ringBufferItemsCount + 1, + array->arrayMemberSize); + csound->AuxAlloc(csound, argumentArrayItem->bytesCount, + &argumentArrayItem->auxillaryMemory); + argumentArrayItem->readBuffer = argumentArrayItem->auxillaryMemory.auxp; +} + +void WebSocketOpcode_allocateVariableArgument(cs_float *argument, + OpcodeArgument *argumentArrayItem, + CSOUND *csound, int32_t bytesCount) +{ + argumentArrayItem->dataPointer = argument; + argumentArrayItem->itemsCount = 1; + argumentArrayItem->bytesCount = bytesCount; + argumentArrayItem->circularBuffer = + csound->CreateCircularBuffer(csound, ringBufferItemsCount + 1, + argumentArrayItem->bytesCount); + csound->AuxAlloc(csound, argumentArrayItem->bytesCount, + &argumentArrayItem->auxillaryMemory); + argumentArrayItem->readBuffer = argumentArrayItem->auxillaryMemory.auxp; +} + +void WebSocketOpcode_initialiseArgumentsArray(CSOUND *csound, + WebSocketOpcode *self, + OpcodeArgument *argumentsArray, + size_t argumentsCount, + cs_float **arguments, + bool areInputArguments) +{ + uint32_t i; + for (i = 0; i < argumentsCount; ++i) { + + OpcodeArgument *argumentArrayItem = &argumentsArray[i]; + argumentArrayItem->argumentPointer = arguments[i]; + argumentArrayItem->argumentType = + WebSocketOpcode_getArgumentType(csound, arguments[i]); + argumentArrayItem->name = + areInputArguments ? GetInputArgName(&self->h, i + 1) + : GetOutputArgName(&self->h, i); + + switch (argumentsArray[i].argumentType) { + + case IRATE_ARRAY: + case ARATE_ARRAY: + case KRATE_ARRAY: { + + WebSocketOpcode_allocateArrayArgument(arguments[i], + argumentArrayItem, csound); + break; + } + case STRING_VAR: { + + WebSocketOpcode_allocateStringArgument(arguments[i], + argumentArrayItem, csound, + areInputArguments); + break; + } + case ARATE_VAR: { + + WebSocketOpcode_allocateVariableArgument(arguments[i], + argumentArrayItem, csound, + sizeof(cs_float) * GetLocalKsmps(&self->h)); + break; + } + case IRATE_VAR: + case KRATE_VAR: { + + WebSocketOpcode_allocateVariableArgument(arguments[i], argumentArrayItem, + csound, sizeof(cs_float)); + break; + } + default: { + + csound->Die(csound, "%s", Str("websocket: error, incompatible argument " + "detected\nExiting")); + break; + } + } + } +} + +void WebSocketOpcode_initialiseArguments(WebSocketOpcode *self, CSOUND *csound) +{ + self->inputArguments = + csound->Calloc(csound, sizeof(OpcodeArgument) * self->inputArgumentCount); + self->outputArguments = + csound->Calloc(csound, sizeof(OpcodeArgument) * self->outputArgumentCount); + + WebSocketOpcode_initialiseArgumentsArray(csound, self, self->inputArguments, + self->inputArgumentCount, + &self->arguments[self->outputArgumentCount + 1], + true); + WebSocketOpcode_initialiseArgumentsArray(csound, self, self->outputArguments, + self->outputArgumentCount, + self->arguments, false); +} + +void WebSocketOpcode_writeOnce(WebSocketOpcode *self, OpcodeArgument *inputArgument, + void *messageBuffer, struct lws *websocket) +{ + IGN(self); + unsigned char *inputData = (unsigned char *)inputArgument->readBuffer; + memcpy(messageBuffer, inputData, inputArgument->bytesCount); + lws_write(websocket, messageBuffer, inputArgument->bytesCount, + LWS_WRITE_BINARY); +} + +void WebSocketOpcode_writeFragments(WebSocketOpcode *self, + OpcodeArgument *inputArgument, + void *messageBuffer, struct lws *websocket) +{ + IGN(self); + unsigned char *inputData = + &((unsigned char *)inputArgument->readBuffer)[inputArgument->bytesWritten]; + + // *** FIXME *** signed/usigned comparison + if (inputArgument->bytesWritten + writeBufferBytesCount < + inputArgument->bytesCount) { + + int32_t writeFlags = LWS_WRITE_NO_FIN; + writeFlags |= + inputArgument->bytesWritten==0 ? LWS_WRITE_BINARY : LWS_WRITE_CONTINUATION; + memcpy(messageBuffer, inputData, writeBufferBytesCount); + inputArgument->bytesWritten += lws_write(websocket, messageBuffer, + writeBufferBytesCount, writeFlags); + } + else { + + size_t fragmentBytesCount = + inputArgument->bytesCount - inputArgument->bytesWritten; + memcpy(messageBuffer, inputData, fragmentBytesCount); + lws_write(websocket, messageBuffer, fragmentBytesCount, + LWS_WRITE_CONTINUATION); + inputArgument->bytesWritten = 0; + } +} + +void WebSocketOpcode_writeMessage(WebSocketOpcode *self, + OpcodeArgument *inputArgument, + void *messageBuffer, struct lws *websocket) +{ + if (inputArgument->bytesCount <= writeBufferBytesCount) { + + WebSocketOpcode_writeOnce(self, inputArgument, messageBuffer, websocket); + } + else { + + WebSocketOpcode_writeFragments(self, inputArgument, messageBuffer, websocket); + } +} + +void WebSocketOpcode_handleServerWritable(struct lws *websocket, + WebSocketOpcode *self, CSOUND *csound, + void *messageBuffer) +{ + const struct lws_protocols *protocol = lws_get_protocol(websocket); + + if (protocol->id / OUTPUT_OFFSET == 1) { // If it's an output argument + + usleep(100); + return; + } + + int32_t inputIndex = 0; + + OpcodeArgument *argument = &self->inputArguments[inputIndex]; + + int32_t readItems = 0; + + if (argument->bytesWritten == 0) { + + readItems = csound->ReadCircularBuffer(csound, argument->circularBuffer, + argument->readBuffer, + argument->itemsCount); + } + if (readItems != 0 || argument->bytesWritten != 0) { + + WebSocketOpcode_writeMessage(self, argument, messageBuffer, websocket); + + if (argument->argumentType == IRATE_VAR || + argument->argumentType == IRATE_ARRAY) { + + argument->iRateVarSent = true; + } + } + + usleep(100); + + if (argument->iRateVarSent == false) { + + lws_callback_on_writable(websocket); + } +} + +void WebSocketOpcode_handleReceive(struct lws *websocket, WebSocketOpcode *self, + CSOUND *csound, size_t inputDataSize, + void *inputData) +{ + const struct lws_protocols *protocol = lws_get_protocol(websocket); + + if (protocol->id / OUTPUT_OFFSET != 1) { + + return; + } + + OpcodeArgument *argument = &self->outputArguments[protocol->id - OUTPUT_OFFSET]; + + if (argument->iRateVarSent == true) { + + return; + } + + // *** FIXME *** signed/unsigned comparison + if (UNLIKELY(argument->bytesCount != inputDataSize + && + argument->argumentType != STRING_VAR)) { + + csound->Message(csound, Str("websocket: received message from is not " + "correct size for variable %s, message dumped"), + protocol->name); + return; + } + + if (UNLIKELY(argument->argumentType == STRING_VAR + && + argument->bytesCount > stringVarMaximumBytesCount)) { + + csound->Message(csound, Str("websocket: received string message from " + "%s is too large, message dumped"), + protocol->name); + + return; + } + + int32_t writtenItems = + csound->WriteCircularBuffer(csound, argument->circularBuffer, + inputData, argument->itemsCount); + argument->receivedData = true; + + if (UNLIKELY(writtenItems == 0)) { + + csound->Message(csound, Str("websocket: received message from %s " + "dumped, buffer overrrun"), argument->name); + } + else { + + if (argument->argumentType == IRATE_VAR + || + argument->argumentType == IRATE_ARRAY) { + + argument->iRateVarSent = true; + } + } +} + + +static int32_t Websocket_callback(struct lws *websocket, + enum lws_callback_reasons reason, + void *user, void *inputData, size_t inputDataSize) +{ + + IGN(user); + + if (reason != LWS_CALLBACK_ESTABLISHED && + reason != LWS_CALLBACK_SERVER_WRITEABLE && reason != LWS_CALLBACK_RECEIVE) { + return OK; + } + + const struct lws_protocols *protocol = lws_get_protocol(websocket); + WebSocketOpcode *self = lws_get_protocol(websocket)->user; + CSOUND *csound = self->csound; + + switch (reason) { + + case LWS_CALLBACK_ESTABLISHED: { + + + csound->Message(csound, Str("websocket: connection established for %s\n"), + protocol->name); + break; + } + case LWS_CALLBACK_SERVER_WRITEABLE: { + + void *messageBuffer = + (void *)&self->webSocket->messageBuffer[LWS_PRE]; + + WebSocketOpcode_handleServerWritable(websocket, self, csound, messageBuffer); + break; + } + case LWS_CALLBACK_RECEIVE: { + + WebSocketOpcode_handleReceive(websocket, self, csound, + inputDataSize, inputData); + break; + } + case LWS_CALLBACK_CLOSED: { + + printf("closed\n"); /* Why not sound->Message ? */ + } + default: { + + break; + } + } + + return OK; +} + +uintptr_t WebSocketOpcode_processThread(void *opaquePointer) +{ + WebSocketOpcode *self = opaquePointer; + + while (self->isRunning == 1) { + + + lws_service(self->webSocket->context, 10); + lws_callback_on_writable_all_protocol(self->webSocket->context, + &self->webSocket->protocols[0]); + } + + return 0; +} + +void WebSocketOpcode_initialiseWebSocket(WebSocketOpcode *self, CSOUND *csound) +{ + int32_t i; + size_t argumentsCount = self->inputArgumentCount + self->outputArgumentCount; + + self->webSocket = csound->Calloc(csound, sizeof(WebSocket)); + self->webSocket->protocols = //Last protocol is null + csound->Calloc(csound, sizeof(struct lws_protocols) * (argumentsCount + 1)); + size_t argumentIndex = 0; + + for (i = 0; i < self->inputArgumentCount; ++i, argumentIndex++) { + + self->webSocket->protocols[argumentIndex].name = self->inputArguments[i].name; + self->webSocket->protocols[argumentIndex].callback = Websocket_callback; + self->webSocket->protocols[argumentIndex].id = INPUT_OFFSET + i; + self->webSocket->protocols[argumentIndex].user = self; + self->webSocket->protocols[argumentIndex].per_session_data_size = + sizeof(WebSocketOpcode *); + } + + for (i = 0; i < self->outputArgumentCount; ++i, ++argumentIndex) { + + self->webSocket->protocols[argumentIndex].name = + self->outputArguments[i].name; + self->webSocket->protocols[argumentIndex].callback = Websocket_callback; + self->webSocket->protocols[argumentIndex].id = OUTPUT_OFFSET + i; + self->webSocket->protocols[argumentIndex].user = self; + self->webSocket->protocols[argumentIndex].per_session_data_size = + sizeof(WebSocketOpcode *); + } + + + self->webSocket->info.port = *self->arguments[self->outputArgumentCount]; + self->webSocket->info.protocols = self->webSocket->protocols; + self->webSocket->info.gid = -1; + self->webSocket->info.uid = -1; + + lws_set_log_level(LLL_DEBUG, NULL); + self->webSocket->context = lws_create_context(&self->webSocket->info); + self->webSocket->messageBuffer = + csound->Calloc(csound, LWS_PRE + (sizeof(char) * writeBufferBytesCount)); + if (UNLIKELY(self->webSocket->context == NULL)) { + + csound->Die(csound, + "%s", Str("websocket: could not initialise websocket, Exiting")); + } + + + self->isRunning = true; + self->webSocket->processThread = + csound->CreateThread(WebSocketOpcode_processThread, self); +} + +ArgumentType WebSocketOpcode_getArgumentType(CSOUND *csound, cs_float *argument) +{ + IGN(csound); + const CS_TYPE *csoundType = GetTypeForArg((void *)argument); + const char *type = csoundType->varTypeName; + ArgumentType argumentType = UNKNOWN; + + if (strcmp("S", type) == 0) { + + argumentType = STRING_VAR; + } + else if (strcmp("a", type) == 0) { + + argumentType = ARATE_VAR; + } + else if (strcmp("k", type) == 0) { + + argumentType = KRATE_VAR; + } + else if (strcmp("i", type) == 0) { + + argumentType = IRATE_VAR; + } + else if (strcmp("[", type) == 0) { + + ARRAYDAT *array = (ARRAYDAT *)argument; + + if (strcmp("k", array->arrayType->varTypeName) == 0) { + + argumentType = KRATE_ARRAY; + } + else if (strcmp("a", array->arrayType->varTypeName) == 0) { + + argumentType = ARATE_ARRAY; + } + else if (strcmp("i", array->arrayType->varTypeName) == 0) { + + argumentType = IRATE_ARRAY; + } + } + + + return argumentType; +} + +static OENTRY localops[] = { + + { + (char *)"websocket", + sizeof(WebSocketOpcode), + 0, + (char *)"*", + (char *)"i.", + (SUBR)WebSocketOpcode_initialise, + (SUBR)WebSocketOpcode_process, + (SUBR)WebSocketOpcode_finish, + NULL, + 0 + } + +}; + + +LINKAGE diff --git a/7.x/src/websockets/WebSocketOpcode.h b/7.x/src/websockets/WebSocketOpcode.h new file mode 100644 index 0000000..8df08b8 --- /dev/null +++ b/7.x/src/websockets/WebSocketOpcode.h @@ -0,0 +1,81 @@ +/* + + WebSocketOpcode.h + WebSockets + + Created by Edward Costello on 10/06/2015. + Copyright (c) 2015 Edward Costello. + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA + */ + +#ifndef WEBSOCKET_OPCODE_H +#define WEBSOCKET_OPCODE_H + +#include +#include "csdl.h" + +#if defined(WIN32) || defined(_WIN32) + +#define WIN32_LEAN_AND_MEAN +#include + +static void usleep(unsigned int usec) +{ + HANDLE timer; + LARGE_INTEGER ft; + + ft.QuadPart = -(10 * (__int64)usec); + + timer = CreateWaitableTimer(NULL, TRUE, NULL); + SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0); + WaitForSingleObject(timer, INFINITE); + CloseHandle(timer); +} + +#else +# include +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + typedef struct OpcodeArgument OpcodeArgument; + typedef struct WebSocket WebSocket; + + typedef struct WebSocketOpcode + { + OPDS h; + cs_float *arguments[20]; + int32_t inputArgumentCount; + int32_t outputArgumentCount; + WebSocket *webSocket; + OpcodeArgument *inputArguments; + OpcodeArgument *outputArguments; + bool isRunning; + CSOUND *csound; + } WebSocketOpcode; + + int32_t WebSocketOpcode_initialise(CSOUND *csound, WebSocketOpcode *self); + int32_t WebSocketOpcode_process(CSOUND *csound, WebSocketOpcode *self); +#ifdef __cplusplus +} +#endif + +#endif /* WEBSOCKET_OPCODE_H */ diff --git a/7.x/vcpkg.json b/7.x/vcpkg.json index b20abef..2ddf2db 100644 --- a/7.x/vcpkg.json +++ b/7.x/vcpkg.json @@ -5,6 +5,8 @@ "builtin-baseline": "9e593bb18ea69cc5095e012465dcd675a822ed0d", "dependencies": [ "eigen3", - "fluidsynth" + "fluidsynth", + "libuv", + "libwebsockets" ] } From 925ffb42107d852f84b1d55064e8fc1793a34452 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 11:27:43 +0100 Subject: [PATCH 17/72] Address CodeRabbit review of websocket port - Link the imported libuv target under vcpkg instead of the bare uv_a name - Derive the input index from protocol->id so multiple input protocols each drain their own buffer - Reject oversized received strings and zero-pad short ones so they stay NUL-terminated - Request writable callbacks for every input protocol - Cancel the service and guard NULLs before joining/destroying in deinit - Bound INOCOUNT+OUTOCOUNT (arguments[20]); make intypes variadic ('i*') so multiple inputs are actually accepted - Adapt string output allocation to the 7.x pre-allocated STRINGDAT - Lower the libwebsockets log level to errors and warnings --- 7.x/src/websockets/CMakeLists.txt | 9 ++- 7.x/src/websockets/WebSocketOpcode.c | 103 +++++++++++++++++++-------- 2 files changed, 81 insertions(+), 31 deletions(-) diff --git a/7.x/src/websockets/CMakeLists.txt b/7.x/src/websockets/CMakeLists.txt index bfb4df8..8ef97b3 100644 --- a/7.x/src/websockets/CMakeLists.txt +++ b/7.x/src/websockets/CMakeLists.txt @@ -26,7 +26,14 @@ if(BUILD_WEBSOCKET_OPCODE) target_compile_definitions(websocketIO PRIVATE BUILD_PLUGINS) if(USE_VCPKG) - target_link_libraries(websocketIO websockets uv_a) + target_link_libraries(websocketIO websockets) + if(TARGET libuv::uv_a) + target_link_libraries(websocketIO libuv::uv_a) + elseif(TARGET libuv::uv) + target_link_libraries(websocketIO libuv::uv) + else() + target_link_libraries(websocketIO uv_a) + endif() else() target_link_libraries(websocketIO ${websockets_library}) target_include_directories(websocketIO PRIVATE ${WEBSOCKETS_H}) diff --git a/7.x/src/websockets/WebSocketOpcode.c b/7.x/src/websockets/WebSocketOpcode.c index b8b9d00..88849f3 100644 --- a/7.x/src/websockets/WebSocketOpcode.c +++ b/7.x/src/websockets/WebSocketOpcode.c @@ -84,6 +84,13 @@ ArgumentType WebSocketOpcode_getArgumentType(CSOUND *csound, cs_float *argument) int32_t WebSocketOpcode_initialise(CSOUND *csound, WebSocketOpcode *self) { + if (UNLIKELY(self->INOCOUNT + self->OUTOCOUNT > 20)) { + + return csound->InitError(csound, + Str("websocket: too many arguments " + "(maximum of 20 outputs and inputs)")); + } + self->inputArgumentCount = self->INOCOUNT - 1; self->outputArgumentCount = self->OUTOCOUNT; self->csound = csound; @@ -138,12 +145,6 @@ void WebSocketOpcode_receiveOutputArgumentData(CSOUND *csound, currentArgument->dataPointer, currentArgument->itemsCount); - if (currentArgument->argumentType == STRING_VAR) { - - STRINGDAT *string = (STRINGDAT *)currentArgument->argumentPointer; - string->size = strlen((char *)currentArgument->dataPointer); - } - currentArgument->receivedData = false; } @@ -163,10 +164,23 @@ int32_t WebSocketOpcode_finish(CSOUND *csound, void *opaqueReference) WebSocketOpcode *self = opaqueReference; self->isRunning = false; - csound->JoinThread(self->webSocket->processThread); + if (self->webSocket != NULL) { + + if (self->webSocket->context != NULL) { + + lws_cancel_service(self->webSocket->context); + } - lws_cancel_service(self->webSocket->context); - lws_context_destroy(self->webSocket->context); + if (self->webSocket->processThread != NULL) { + + csound->JoinThread(self->webSocket->processThread); + } + + if (self->webSocket->context != NULL) { + + lws_context_destroy(self->webSocket->context); + } + } for (i = 0; i < self->outputArgumentCount; ++i) { @@ -178,9 +192,12 @@ int32_t WebSocketOpcode_finish(CSOUND *csound, void *opaqueReference) csound->DestroyCircularBuffer(csound, self->inputArguments[i].circularBuffer); } - csound->Free(csound, self->webSocket->protocols); - csound->Free(csound, self->webSocket->messageBuffer); - csound->Free(csound, self->webSocket); + if (self->webSocket != NULL) { + + csound->Free(csound, self->webSocket->protocols); + csound->Free(csound, self->webSocket->messageBuffer); + csound->Free(csound, self->webSocket); + } if (self->inputArgumentCount > 0) { csound->Free(csound, self->inputArguments); @@ -219,7 +236,7 @@ void WebSocketOpcode_allocateStringArgument(cs_float *argument, } else { - if (UNLIKELY(string->size != 0)) { + if (UNLIKELY(string->data != NULL && string->data[0] != '\0')) { csound->Die(csound, Str("websocket: error output string variable %s must not " @@ -229,8 +246,17 @@ void WebSocketOpcode_allocateStringArgument(cs_float *argument, else { argumentArrayItem->itemsCount = stringVarMaximumBytesCount; - string->data = csound->ReAlloc(csound, string->data, - stringVarMaximumBytesCount); + if (string->data == NULL) { + + string->data = csound->Calloc(csound, stringVarMaximumBytesCount); + } + else { + + string->data = csound->ReAlloc(csound, string->data, + stringVarMaximumBytesCount); + } + string->size = stringVarMaximumBytesCount; + string->refcount = 0; memset(string->data, 0, stringVarMaximumBytesCount); } } @@ -431,7 +457,7 @@ void WebSocketOpcode_handleServerWritable(struct lws *websocket, return; } - int32_t inputIndex = 0; + int32_t inputIndex = protocol->id - INPUT_OFFSET; OpcodeArgument *argument = &self->inputArguments[inputIndex]; @@ -491,20 +517,32 @@ void WebSocketOpcode_handleReceive(struct lws *websocket, WebSocketOpcode *self, return; } - if (UNLIKELY(argument->argumentType == STRING_VAR - && - argument->bytesCount > stringVarMaximumBytesCount)) { + int32_t writtenItems; - csound->Message(csound, Str("websocket: received string message from " - "%s is too large, message dumped"), - protocol->name); + if (argument->argumentType == STRING_VAR) { - return; + if (UNLIKELY(inputDataSize >= stringVarMaximumBytesCount)) { + + csound->Message(csound, Str("websocket: received string message from " + "%s is too large, message dumped"), + protocol->name); + + return; + } + + char *stagingBuffer = (char *)argument->readBuffer; + memset(stagingBuffer, 0, stringVarMaximumBytesCount); + memcpy(stagingBuffer, inputData, inputDataSize); + writtenItems = + csound->WriteCircularBuffer(csound, argument->circularBuffer, + stagingBuffer, argument->itemsCount); } + else { - int32_t writtenItems = - csound->WriteCircularBuffer(csound, argument->circularBuffer, - inputData, argument->itemsCount); + writtenItems = + csound->WriteCircularBuffer(csound, argument->circularBuffer, + inputData, argument->itemsCount); + } argument->receivedData = true; if (UNLIKELY(writtenItems == 0)) { @@ -578,14 +616,19 @@ static int32_t Websocket_callback(struct lws *websocket, uintptr_t WebSocketOpcode_processThread(void *opaquePointer) { + int32_t i; WebSocketOpcode *self = opaquePointer; while (self->isRunning == 1) { lws_service(self->webSocket->context, 10); - lws_callback_on_writable_all_protocol(self->webSocket->context, - &self->webSocket->protocols[0]); + + for (i = 0; i < self->inputArgumentCount; ++i) { + + lws_callback_on_writable_all_protocol(self->webSocket->context, + &self->webSocket->protocols[i]); + } } return 0; @@ -628,7 +671,7 @@ void WebSocketOpcode_initialiseWebSocket(WebSocketOpcode *self, CSOUND *csound) self->webSocket->info.gid = -1; self->webSocket->info.uid = -1; - lws_set_log_level(LLL_DEBUG, NULL); + lws_set_log_level(LLL_ERR | LLL_WARN, NULL); self->webSocket->context = lws_create_context(&self->webSocket->info); self->webSocket->messageBuffer = csound->Calloc(csound, LWS_PRE + (sizeof(char) * writeBufferBytesCount)); @@ -696,7 +739,7 @@ static OENTRY localops[] = { sizeof(WebSocketOpcode), 0, (char *)"*", - (char *)"i.", + (char *)"i*", (SUBR)WebSocketOpcode_initialise, (SUBR)WebSocketOpcode_process, (SUBR)WebSocketOpcode_finish, From 4e7e33c191ee3377450f856fb03a32fc8984aae3 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 12:19:33 +0100 Subject: [PATCH 18/72] Port hdf5 read/write opcodes to Csound 7 plugins - Port HDF5IO.c/h from 6.x to the Csound 7 module API: cs_float, positional OENTRY with deinit slot, GetLocalKsmps, GetInputArgName, GetTypeForArg and GetOParms; allocate array outputs via csound_array_ensure_capacity. - Drop the redundant control-counter guard in HDF5Read_readData. The per-dataset offset checks already bound every read, and the guard compared the engine/local kcounter against the dataset length, truncating reads in any instrument not starting at beat 0. - Add 7.x/src/hdf5/CMakeLists.txt and wire the subdirectory, vcpkg dependency, CI staging and README entry. --- .github/workflows/plugins_build_7.yml | 4 +- 7.x/CMakeLists.txt | 1 + 7.x/README.md | 6 +- 7.x/src/hdf5/CMakeLists.txt | 35 + 7.x/src/hdf5/HDF5IO.c | 1401 +++++++++++++++++++++++++ 7.x/src/hdf5/HDF5IO.h | 144 +++ 7.x/vcpkg.json | 1 + 7 files changed, 1590 insertions(+), 2 deletions(-) create mode 100644 7.x/src/hdf5/CMakeLists.txt create mode 100644 7.x/src/hdf5/HDF5IO.c create mode 100644 7.x/src/hdf5/HDF5IO.h diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index ccb06a2..2f2828c 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -70,7 +70,7 @@ jobs: build-essential cmake pkg-config \ libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ libeigen3-dev libfluidsynth-dev \ - libwebsockets-dev libuv1-dev \ + libwebsockets-dev libuv1-dev libhdf5-dev \ flex bison - name: Cache Csound install @@ -112,6 +112,7 @@ jobs: build/src/linear_algebra/*.so \ build/src/fluidOpcodes/*.so \ build/src/websockets/*.so \ + build/src/hdf5/*.so \ build/src/py/*.so package/ - name: Upload plugins @@ -212,6 +213,7 @@ jobs: build/src/linear_algebra/*.dylib \ build/src/fluidOpcodes/*.dylib \ build/src/websockets/*.dylib \ + build/src/hdf5/*.dylib \ build/src/py/*.dylib package/ - name: Upload plugins diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 37c3b23..b7a8439 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -306,4 +306,5 @@ add_subdirectory(./src/chua) add_subdirectory(./src/linear_algebra) add_subdirectory(./src/fluidOpcodes) add_subdirectory(./src/websockets) +add_subdirectory(./src/hdf5) add_subdirectory(./src/py) diff --git a/7.x/README.md b/7.x/README.md index 7d0046f..ea7ba12 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -9,6 +9,9 @@ Currently, the plugins available in this tree are - fluidOpcodes (requires fluidsynth) **fluidEngine fluidLoad fluidNote fluidCCi fluidCCk fluidControl fluidProgramSelect fluidAllOut fluidOut fluidInfo fluidSetInterpMethod** +- hdf5 (requires the HDF5 library) +**hdf5read hdf5write** + - linear_algebra (requires the gmm++ library, header-only; vendored under this directory) **A large family of `la_*` opcodes, with i-rate and k-rate variants, for vector, matrix and tensor operations** @@ -78,7 +81,8 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_FLUID_OPCODES`, -`BUILD_LINEAR_ALGEBRA_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and +`BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, +`BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to exclude the chua plugin, the `cmake` command would be: diff --git a/7.x/src/hdf5/CMakeLists.txt b/7.x/src/hdf5/CMakeLists.txt new file mode 100644 index 0000000..48d5f38 --- /dev/null +++ b/7.x/src/hdf5/CMakeLists.txt @@ -0,0 +1,35 @@ +option(BUILD_HDF5_OPCODES "Build the hdf5 read/write opcodes" ON) + +if(USE_VCPKG) + find_package(HDF5 CONFIG) +else() + find_package(HDF5) +endif() +check_deps(BUILD_HDF5_OPCODES HDF5_FOUND) + +if(BUILD_HDF5_OPCODES AND HDF5_FOUND) + # split version string, as cmake doesn't do this automatically + string(REPLACE "." ";" VERSION_LIST ${HDF5_VERSION}) + list(GET VERSION_LIST 0 HDF5_VERSION_MAJOR) + list(GET VERSION_LIST 1 HDF5_VERSION_MINOR) + list(GET VERSION_LIST 2 HDF5_VERSION_PATCH) + + make_plugin(hdf5ops HDF5IO.c) + + target_include_directories(hdf5ops PRIVATE ${HDF5_INCLUDE_DIRS} ${CSOUND_INCLUDE_DIRS}) + + target_compile_definitions(hdf5ops PRIVATE + -DHDF5_VERSION_MAJOR=${HDF5_VERSION_MAJOR} + -DHDF5_VERSION_MINOR=${HDF5_VERSION_MINOR} + -DHDF5_VERSION_PATCH=${HDF5_VERSION_PATCH} + ) + + if(USE_VCPKG) + target_link_libraries(hdf5ops PRIVATE hdf5::hdf5-static hdf5::hdf5_hl-static) + else() + message(STATUS "HDF5_INCLUDE_DIRS: ${HDF5_INCLUDE_DIRS}") + message(STATUS "HDF5_LIBRARIES: ${HDF5_LIBRARIES}") + + target_link_libraries(hdf5ops ${HDF5_LIBRARIES}) + endif() +endif() diff --git a/7.x/src/hdf5/HDF5IO.c b/7.x/src/hdf5/HDF5IO.c new file mode 100644 index 0000000..8bc3af7 --- /dev/null +++ b/7.x/src/hdf5/HDF5IO.c @@ -0,0 +1,1401 @@ +/* + * Copyright (C) 2014 Edward Costello + * + * This software is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "HDF5IO.h" +#include "arrays.h" +#include +#ifdef _MSC_VER +#include +#else +#include +#endif + +#define HDF5ERROR(x) if (UNLIKELY((x) == -1)) \ + {csound->Die(csound, #x" error\nExiting\n");} + +// Type strings to match the enum types +static const char typeStrings[8][12] = { + "STRING_VAR", + "ARATE_VAR", + "KRATE_VAR", + "IRATE_VAR", + "ARATE_ARRAY", + "KRATE_ARRAY", + "IRATE_ARRAY", + "UNKNOWN" +}; + +// Get the argument enum type from the opcode argument pointer +// +// Get the csound type from the argument +// Get the variable type name +// Do a string comparison and match the type to the enum type + +ArgumentType HDF5IO_getArgumentTypeFromArgument(CSOUND *csound, cs_float *argument) +{ + IGN(csound); + const CS_TYPE *csoundType = GetTypeForArg((void *)argument); + const char *type = csoundType->varTypeName; + ArgumentType argumentType = UNKNOWN; + + if (strcmp("S", type) == 0) { + + argumentType = STRING_VAR; + } + else if (strcmp("a", type) == 0) { + + argumentType = ARATE_VAR; + } + else if (strcmp("k", type) == 0) { + + argumentType = KRATE_VAR; + } + else if (strcmp("i", type) == 0) { + + argumentType = IRATE_VAR; + } + else if (strcmp("[", type) == 0) { + + ARRAYDAT *array = (ARRAYDAT *)argument; + + if (strcmp("k", array->arrayType->varTypeName) == 0) { + + argumentType = KRATE_ARRAY; + } + else if (strcmp("a", array->arrayType->varTypeName) == 0) { + + argumentType = ARATE_ARRAY; + } + else if (strcmp("i", array->arrayType->varTypeName) == 0) { + + argumentType = IRATE_ARRAY; + } + } + + return argumentType; +} + +// Get the matching argument enum type from a string +// +// Do a string comparison and assign the corresponding enum type to the string + +ArgumentType HDF5IO_getArgumentTypeFromString(CSOUND *csound, const char *string) +{ + IGN(csound); + ArgumentType type = UNKNOWN; + + if (strcmp("STRING_VAR", string) == 0) { + + type = STRING_VAR; + } + else if (strcmp("ARATE_VAR", string) == 0) { + + type = ARATE_VAR; + } + else if (strcmp("KRATE_VAR", string) == 0) { + + type = KRATE_VAR; + } + else if (strcmp("IRATE_VAR", string) == 0) { + + type = IRATE_VAR; + } + else if (strcmp("ARATE_ARRAY", string) == 0) { + + type = ARATE_ARRAY; + } + else if (strcmp("KRATE_ARRAY", string) == 0) { + + type = KRATE_ARRAY; + } + else if (strcmp("IRATE_ARRAY", string) == 0) { + + type = IRATE_ARRAY; + } + + return type; +} + +// Create or open a hdf5 file +// +// Allocate the memory for a hdf5 file struct +// Assign the path string to the file name in the struct +// Check if the file exists +// If it doesn't and this function is being called by the hdf5 write function, +// create the file +// If it exists, open the file for appending +// Find out what size the cs_float floating point type is and assign the correct +// hdf5 type to it +// Return the pointer to the hdf5 file struct + +HDF5File *HDF5IO_newHDF5File(CSOUND *csound, AUXCH *hdf5FileMemory, + STRINGDAT *path, bool openForWriting) +{ + csound->AuxAlloc(csound, sizeof(HDF5File), hdf5FileMemory); + HDF5File *hdf5File = hdf5FileMemory->auxp; + + hdf5File->fileName = path->data; + + int32_t fileExists = access(hdf5File->fileName, 0); + + if (UNLIKELY(fileExists == -1)) { + + if (LIKELY(openForWriting == true)) { + + hdf5File->fileHandle = H5Fcreate(hdf5File->fileName, H5F_ACC_TRUNC, + H5P_DEFAULT, H5P_DEFAULT); + HDF5ERROR(hdf5File->fileHandle); + } + else { + + csound->Die(csound, "hdf5read: Error, file does not exist"); + } + } + else { + + hdf5File->fileHandle = H5Fopen(hdf5File->fileName, H5F_ACC_RDWR, H5P_DEFAULT); + HDF5ERROR(hdf5File->fileHandle); + } + +#ifdef USE_DOUBLE + hdf5File->floatSize = H5T_NATIVE_DOUBLE; +#else + hdf5File->floatSize = H5T_NATIVE_FLOAT; +#endif + //else { + + //csound->Die(csound,"HDF5IO: Illegal size for floating point type, exiting"); + //} + + return hdf5File; +} + +// Write a string attribute to a hdf5 file dataset +// +// Create a new attribute of type C string +// Set the size of the string to 11 characters, this is the longest string +// length of the argument type strings +// Set the string to be null terminated +// Create the attribute in the hdf5 file +// Write the string to the attribute +// Close the open handles + +void HDF5IO_writeStringAttribute(CSOUND *csound, HDF5File *self, + HDF5Dataset *dataset, + const char *attributeName, + const char *attributeString) +{ + IGN(self); + hid_t attributeID = H5Screate(H5S_SCALAR); + HDF5ERROR(attributeID); + hid_t attributeType = H5Tcopy(H5T_C_S1); + HDF5ERROR(attributeType); + HDF5ERROR(H5Tset_size(attributeType, 11)); + HDF5ERROR(H5Tset_strpad(attributeType,H5T_STR_NULLTERM)); + hid_t attributeHandle = H5Acreate2(dataset->datasetID, + attributeName, attributeType, attributeID, + H5P_DEFAULT, H5P_DEFAULT); + HDF5ERROR(attributeHandle); + HDF5ERROR(H5Awrite(attributeHandle, attributeType, attributeString)); + HDF5ERROR(H5Sclose(attributeID)); + HDF5ERROR(H5Tclose(attributeType)); + HDF5ERROR(H5Aclose(attributeHandle)); +} + +// Read a string attribute from the hdf5 file +// +// Open the data set and get the info structure +// Get the attribute at index 0, this should probably be more general, needs +// more work +// Get the type of the attribute +// Read the attribute into memory and close all the handles + +void HDF5IO_readStringAttribute(CSOUND *csound, HDF5File *self, + char *datasetName, char *attributeString) +{ + hid_t dataSetID = H5Dopen2(self->fileHandle, datasetName, H5P_DEFAULT); + H5O_info_t oinfo; +#if HDF5_VERSION_MAJOR == 1 && HDF5_VERSION_MINOR >= 12 + HDF5ERROR(H5Oget_info1(dataSetID, &oinfo)); +#else + HDF5ERROR(H5Oget_info(dataSetID, &oinfo)); +#endif + hid_t attributeID = H5Aopen_by_idx(dataSetID, ".", H5_INDEX_CRT_ORDER, + H5_ITER_INC, 0, H5P_DEFAULT, H5P_DEFAULT); + HDF5ERROR(attributeID); + hid_t attributeType = H5Aget_type(attributeID); + HDF5ERROR(attributeType); + hid_t attributeTypeMemory = H5Tget_native_type(attributeType, H5T_DIR_ASCEND); + HDF5ERROR(attributeTypeMemory); + HDF5ERROR(H5Aread(attributeID, attributeTypeMemory, attributeString)); + HDF5ERROR(H5Aclose(attributeID)); + HDF5ERROR(H5Tclose(attributeType)); + HDF5ERROR(H5Tclose(attributeTypeMemory)); + HDF5ERROR(H5Dclose(dataSetID)); +} + +// Find if csound is running in sample accurate mode +// +// Get the argument parameters passed to run csound +// Find the sample accurate parameter and return it + +bool HDF5IO_getSampleAccurate(CSOUND *csound) +{ + const OPARMS *parameters = csound->GetOParms(csound); + return parameters->sampleAccurate; +} + + +// Set everything up so datasets can be written from the opcodes input variables, +// i-rate datasets are written at initialisation all others are written on the +// performance pass. +// +// Get the amount of samples in a control pass +// Get the amount of arguments to the opcode, this doesn't include the first +// argument which is for the filename. +// Check that the first argument is a string for the filename, check others +// are not strings +// Get the path argument and open a hdf5 file, if it doesn't exist create it +// Create the datasets in the file so they can be written + +int32_t HDF5Write_initialise(CSOUND *csound, HDF5Write *self) +{ + self->ksmps = GetLocalKsmps(&self->h); + self->inputArgumentCount = self->INOCOUNT - 1; + HDF5Write_checkArgumentSanity(csound, self); + + STRINGDAT *path = (STRINGDAT *)self->arguments[0]; + self->hdf5File = HDF5IO_newHDF5File(csound, &self->hdf5FileMemory, path, true); + HDF5Write_createDatasets(csound, self); + + return OK; +} + +// Write the input data to the associated dataset +// +// Enlarge the dataset first then get the file space +// Select a hyperslab with the necessary offset and size +// Create a memory space where the data is written to +// Write the data to the memory space +// Close the file space + +void HDF5Write_writeData(CSOUND *csound, HDF5Write *self, + HDF5Dataset *dataset, cs_float *data) +{ + HDF5ERROR(H5Dset_extent(dataset->datasetID, dataset->datasetSize)); + hid_t filespace = H5Dget_space(dataset->datasetID); + HDF5ERROR(filespace); + HDF5ERROR(H5Sselect_hyperslab(filespace, H5S_SELECT_SET, dataset->offset, + NULL, dataset->chunkDimensions, NULL)); + hid_t memspace = H5Screate_simple(dataset->rank, dataset->chunkDimensions, + NULL); + HDF5ERROR(memspace); + HDF5ERROR(H5Dwrite(dataset->datasetID, self->hdf5File->floatSize, memspace, + filespace, H5P_DEFAULT, data)); + HDF5ERROR(H5Sclose(filespace)); +} + +// Write a-rate variables and arrays to the specified data set +// +// For sample accurate mode, get the offset and early variables +// Calculate the size of the incoming vector +// If the vector is 0 return, no more data to write +// Expand the dataset size by ksmps, because data is written in chunks +// For sample accurate mode the exact dataset size is set when writing is finished +// Write the data to the dataset +// Increment the offset by the size of the vector that was just written + +void HDF5Write_writeAudioData(CSOUND *csound, HDF5Write *self, + HDF5Dataset *dataset, cs_float *dataPointer) +{ + size_t offset = self->h.insdshead->ksmps_offset; + size_t early = self->h.insdshead->ksmps_no_end; + + int32_t vectorSize = (int32_t)(self->ksmps - offset - early); + + if (UNLIKELY(vectorSize == 0)) { + return; + } + + dataset->datasetSize[0] += self->ksmps; + + HDF5Write_writeData(csound, self, dataset, &dataPointer[offset]); + + dataset->offset[0] += vectorSize; +} + +// Write k-rate variables and arrays to the specified data set +// +// Increment the data set size by 1 +// Write the data to the dataset +// Increment the offset by 1 + +void HDF5Write_writeControlData(CSOUND *csound, HDF5Write *self, + HDF5Dataset *dataset, cs_float *dataPointer) +{ + dataset->datasetSize[0]++; + + HDF5Write_writeData(csound, self, dataset, dataPointer); + + dataset->offset[0]++; +} + +// Send each input argument to the necessary writing function +// +// Iterate through the dataset array, select the current +// Depending on the dataset type send to the necessary write function + +int32_t HDF5Write_process(CSOUND *csound, HDF5Write *self) +{ + int32_t i; + for (i = 0; i < self->inputArgumentCount; ++i) { + + HDF5Dataset *currentDataset = &self->datasets[i]; + + switch (currentDataset->writeType) { + + case ARATE_ARRAY: { + + HDF5Write_writeAudioData(csound, self, currentDataset, + ((ARRAYDAT *)currentDataset->argumentPointer)->data); + break; + } + case KRATE_ARRAY: { + + HDF5Write_writeControlData(csound, self, currentDataset, + ((ARRAYDAT *)currentDataset->argumentPointer)->data); + break; + } + case ARATE_VAR: { + + HDF5Write_writeAudioData(csound, self, currentDataset, + currentDataset->argumentPointer); + break; + } + case KRATE_VAR: { + + HDF5Write_writeControlData(csound, self, currentDataset, + currentDataset->argumentPointer); + break; + } + default: { + + break; + } + } + } + return OK; +} + +// Close the hdf5 file and set the a-rate dataset extents for sample accurate mode +// +// Check that the datasets exist +// Iterate through the datasets, if a-rate, set the size to be the same as +// current offset +// Set the set extent of the dataset to the size +// Close the datasets, then close the file + +int32_t HDF5Write_finish(CSOUND *csound, void *inReference) +{ + HDF5Write *self = inReference; + + if (LIKELY(self->datasets != NULL)) { + int32_t i; + for (i = 0; i < self->inputArgumentCount; ++i) { + + HDF5Dataset *dataset = &self->datasets[i]; + + switch (dataset->writeType) { + + case ARATE_ARRAY: { + + dataset->datasetSize[0] = + dataset->offset[0]; + HDF5ERROR(H5Dset_extent(dataset->datasetID, dataset->datasetSize)); + break; + } + case ARATE_VAR: { + + dataset->datasetSize[0] = + dataset->offset[0]; + HDF5ERROR(H5Dset_extent(dataset->datasetID, dataset->datasetSize)); + break; + } + default: { + + break; + } + } + + HDF5ERROR(H5Dclose(dataset->datasetID)); + } + } + + HDF5ERROR(H5Fclose(self->hdf5File->fileHandle)); + + return OK; +} + +// Check that the correct types of inputs have been used in the opcode +// +// Get the argument type for the first input +// If it is not a string stop csound +// Iterate over the rest of the input arguments, if any are strings stop csound + +void HDF5Write_checkArgumentSanity(CSOUND *csound, const HDF5Write *self) +{ + int32_t i; + ArgumentType type = HDF5IO_getArgumentTypeFromArgument(csound, + self->arguments[0]); + + if (UNLIKELY(type != STRING_VAR)) { + + csound->Die(csound, "%s", Str("hdf5write: Error, first argument does not " + "appear to be a string, exiting")); + } + + for (i = 0; i < self->inputArgumentCount; ++i) { + + type = HDF5IO_getArgumentTypeFromArgument(csound, self->arguments[i + 1]); + + if (UNLIKELY(type == STRING_VAR + || + type == UNKNOWN)) { + + csound->Die(csound, Str("hdf5write: Error, unable to identify type " + "of argument %d"), i); + } + } +} + +// Create, or delete and create again a dataset in an hdf5 file +// +// Check to see if the dataset exists +// If it exists delete it +// Create the data space, set the writing chunk size and the empty space fill value +// Create the data set in the data space and write the argument type as a string +// attribute + +void HDF5Write_initialiseHDF5Dataset(CSOUND *csound, HDF5Write *self, + HDF5Dataset *dataset) +{ + htri_t result = H5Lexists(self->hdf5File->fileHandle, + dataset->datasetName, H5P_DEFAULT); + + if (result == 1) { + + HDF5ERROR(H5Ldelete(self->hdf5File->fileHandle, + dataset->datasetName, H5P_DEFAULT)); + } + + hid_t dataspaceID = H5Screate_simple(dataset->rank, dataset->chunkDimensions, + dataset->maxDimensions); + HDF5ERROR(dataspaceID); + hid_t cparams = H5Pcreate(H5P_DATASET_CREATE); + HDF5ERROR(cparams); + + HDF5ERROR(H5Pset_chunk(cparams, dataset->rank, dataset->chunkDimensions)); + + cs_float zero = 0; + + HDF5ERROR(H5Pset_fill_value(cparams, self->hdf5File->floatSize, &zero)); + + dataset->datasetID = H5Dcreate2(self->hdf5File->fileHandle, + dataset->datasetName, + self->hdf5File->floatSize, + dataspaceID, H5P_DEFAULT, cparams, H5P_DEFAULT); + HDF5ERROR(dataset->datasetID); + HDF5IO_writeStringAttribute(csound, self->hdf5File, dataset, + "Variable Type", typeStrings[dataset->writeType]); + +} + +// Set up the variables for writing an array dataset +// +// Get the array from the argument pointer +// If its an i-rate array the rank is copied, if not we add a dimension +// Allocate arrays for the chunk sizes, maximum sizes, data set sizes and +// offset sizes +// Copy the sizes from the input array variables to the allocated size arrays +// If it's an a-rate array set the last chunk dimension to ksmps, last max +// dimension to unlimited and dataset size to 0 +// If it's a k-rate array set the last chunk dimension to 1 and last max +// dimension to unlimited +// If it's an i-rate array just return + +void HDF5Write_newArrayDataset(CSOUND *csound, HDF5Write *self, + HDF5Dataset *dataset) +{ + ARRAYDAT *array = (ARRAYDAT *)dataset->argumentPointer; + int32_t i; + if (dataset->writeType == IRATE_ARRAY) { + + dataset->rank = array->dimensions; + } + else { + + dataset->rank = array->dimensions + 1; + } + + csound->AuxAlloc(csound, dataset->rank * sizeof(hsize_t), + &dataset->chunkDimensionsMemory); + dataset->chunkDimensions = dataset->chunkDimensionsMemory.auxp; + + csound->AuxAlloc(csound, dataset->rank * sizeof(hsize_t), + &dataset->maxDimensionsMemory); + dataset->maxDimensions = dataset->maxDimensionsMemory.auxp; + + csound->AuxAlloc(csound, dataset->rank * sizeof(hsize_t), + &dataset->datasetSizeMemory); + dataset->datasetSize = dataset->datasetSizeMemory.auxp; + + csound->AuxAlloc(csound, dataset->rank * sizeof(hsize_t), + &dataset->offsetMemory); + dataset->offset = dataset->offsetMemory.auxp; + + int32_t dimensionOffset = dataset->writeType == IRATE_ARRAY ? 0 : 1; + + for (i = 0; i < array->dimensions; ++i) { + + dataset->chunkDimensions[i + dimensionOffset] = array->sizes[i]; + dataset->maxDimensions[i + dimensionOffset] = array->sizes[i]; + dataset->datasetSize[i + dimensionOffset] = array->sizes[i]; + } + + switch (dataset->writeType) { + + case ARATE_ARRAY: { + + dataset->chunkDimensions[0] = self->ksmps; + dataset->maxDimensions[0] = H5S_UNLIMITED; + dataset->datasetSize[0] = 0; + + break; + } + case KRATE_ARRAY: { + + dataset->chunkDimensions[0] = 1; + dataset->maxDimensions[0] = H5S_UNLIMITED; + break; + } + case IRATE_ARRAY: { + + return; + } + default: { + + csound->Die(csound, "%s", Str("This should not happen, exiting")); + break; + } + } +} + +// Set up variables for writing a scalar dataset +// +// Set the rank to 1 +// Allocate memory for chunk sizes, maximum sizes, dataset sizes and offsets +// If the argument is not an i-rate variable: +// Set the chunk dimensions to ksmps if a-rate, 1 if k-rate +// Set maximum dimensions to unlimited +// Set the data size to 0 +// If it is an i-rate variable: +// Set the data set size to 1 +// Set the chunk dimensions to 1 +// Set the maximum dimensions to 1 +// Set the offset to 0 + +void HDF5Write_newScalarDataset(CSOUND *csound, HDF5Write *self, + HDF5Dataset *dataset) +{ + dataset->rank = 1; + csound->AuxAlloc(csound, sizeof(hsize_t), &dataset->chunkDimensionsMemory); + dataset->chunkDimensions = dataset->chunkDimensionsMemory.auxp; + + csound->AuxAlloc(csound, sizeof(hsize_t), &dataset->maxDimensionsMemory); + dataset->maxDimensions = dataset->maxDimensionsMemory.auxp; + + csound->AuxAlloc(csound, sizeof(hsize_t), &dataset->datasetSizeMemory); + dataset->datasetSize = dataset->datasetSizeMemory.auxp; + + csound->AuxAlloc(csound, sizeof(hsize_t), &dataset->offsetMemory); + dataset->offset = dataset->offsetMemory.auxp; + + if (dataset->writeType != IRATE_VAR) { + + dataset->chunkDimensions[0] = + dataset->writeType == ARATE_VAR ? self->ksmps : 1; + dataset->maxDimensions[0] = H5S_UNLIMITED; + dataset->datasetSize[0] = 0; + } + else { + dataset->datasetSize[0] = 1; + dataset->chunkDimensions[0] = 1; + dataset->maxDimensions[0] = 1; + } + + dataset->offset[0] = 0; +} + +// Create the datasets for each argument to be written +// +// Allocate the memory for the datasets array +// Get the current empty dataset from the array +// Set it's dataset name as the input arguments name + 1 which is after the +// file path string +// Get the argument pointer from the arguments + 1 after the file path string +// Get the enum write type from the argument pointer +// Depending on the write type set up the variables in the correct way for +// writing during performance +// If the variables are i-rate set up the variables and write them + +void HDF5Write_createDatasets(CSOUND *csound, HDF5Write *self) +{ + int32_t i; + csound->AuxAlloc(csound, sizeof(HDF5Dataset) * self->inputArgumentCount, + &self->datasetsMemory); + self->datasets = self->datasetsMemory.auxp; + + for (i = 0; i < self->inputArgumentCount; ++i) { + + HDF5Dataset *currentDataset = &self->datasets[i]; + currentDataset->datasetName = GetInputArgName(&self->h, (uint32_t)i + 1); + currentDataset->argumentPointer = self->arguments[i + 1]; + currentDataset->writeType = + HDF5IO_getArgumentTypeFromArgument(csound, currentDataset->argumentPointer); + + switch (currentDataset->writeType) { + + case ARATE_ARRAY: { + + HDF5Write_newArrayDataset(csound, self, currentDataset); + HDF5Write_initialiseHDF5Dataset(csound, self, currentDataset); + break; + } + case KRATE_ARRAY: { + + HDF5Write_newArrayDataset(csound, self, currentDataset); + HDF5Write_initialiseHDF5Dataset(csound, self, currentDataset); + break; + } + case IRATE_ARRAY: { + + HDF5Write_newArrayDataset(csound, self, currentDataset); + HDF5Write_initialiseHDF5Dataset(csound, self, currentDataset); + HDF5Write_writeData(csound, self, currentDataset, + ((ARRAYDAT *)currentDataset->argumentPointer)->data); + break; + } + case ARATE_VAR: { + + HDF5Write_newScalarDataset(csound, self, currentDataset); + HDF5Write_initialiseHDF5Dataset(csound, self, currentDataset); + break; + } + case KRATE_VAR: { + + HDF5Write_newScalarDataset(csound, self, currentDataset); + HDF5Write_initialiseHDF5Dataset(csound, self, currentDataset); + break; + } + case IRATE_VAR: { + + HDF5Write_newScalarDataset(csound, self, currentDataset); + HDF5Write_initialiseHDF5Dataset(csound, self, currentDataset); + HDF5Write_writeData(csound, self, currentDataset, + currentDataset->argumentPointer); + break; + } + default: { + + break; + } + } + } +} + +// Open datasets in a hdf5 file so they can be read by the opcode +// +// Get the amount of samples in a control pass +// Get the amount of input arguments minus the file path argument +// Get the amount of output arguments +// Check that input == output arguments and input arguments are strings, +// output not strings +// Check csound is running in sample accurate mode +// Get the path string from the first argument +// Open the hdf5 file then open the hdf5 datasets + +int32_t HDF5Read_initialise(CSOUND *csound, HDF5Read *self) +{ + self->ksmps = GetLocalKsmps(&self->h); + self->inputArgumentCount = self->INOCOUNT - 1; + self->outputArgumentCount = self->OUTOCOUNT; + HDF5Read_checkArgumentSanity(csound, self); + self->isSampleAccurate = HDF5IO_getSampleAccurate(csound); + self->hdf5File = HDF5IO_newHDF5File(csound, &self->hdf5FileMemory, self->path, false); + HDF5Read_openDatasets(csound, self); + + return OK; +} + +// Copy data from the a-rate variable read sample buffer to the output array data +// +// This function is used to copy data from a sample buffer each hdf5 +// struct to an array data member, this is because in sample accurate +// mode the stride of the data read from the hdf5 file isn't correct +// and must be offset properly before it is written to the array data + +void HDF5Read_copySampleBufferToArray(size_t channelCount, cs_float *sampleBuffer, + cs_float *arrayData, size_t vectorSize, + size_t offset, size_t ksmps) +{ + size_t channel; + for (channel = 0; channel < channelCount; ++channel) { + + memcpy(&arrayData[ksmps * channel + offset], + &sampleBuffer[vectorSize * channel], + sizeof(cs_float) * vectorSize); + } +} + +// Read data from an hdf5 file dataset +// +// Get the specified file space +// Select the hyperslab at the specified offset and chunk dimension +// Create a memory space from where the data is read +// Read the data from the memory space +// Close the open file and memory spaces + +void HDF5Read_readData(CSOUND *csound, HDF5Read *self, HDF5Dataset *dataset, + hsize_t *offset, hsize_t *chunkDimensions, + cs_float *dataPointer) +{ + hid_t filespace = H5Dget_space(dataset->datasetID); + HDF5ERROR(filespace); + HDF5ERROR(H5Sselect_hyperslab(filespace, H5S_SELECT_SET, offset, + NULL, chunkDimensions, NULL)); + hid_t memspace = H5Screate_simple(dataset->rank, chunkDimensions, NULL); + HDF5ERROR(memspace); + HDF5ERROR(H5Dread(dataset->datasetID, self->hdf5File->floatSize, + memspace, filespace, H5P_DEFAULT, dataPointer)); + HDF5ERROR(H5Sclose(filespace)); + HDF5ERROR(H5Sclose(memspace)); + + +} + +// Read data at audio rate from a hdf5 file dataset +// +// If the offset is larger than the size of the dataset there is no more +// data to read so return +// Get the offset and early variables and work out the size of data to read +// If the read vector size plus the offset is larger than the dataset size +// reduce the vector size accordingly +// If the vector size is less than the ksmps value, use the sample +// buffer to store read data so the stride can be corrected before +// writing it to the array data, if not just point directly to array +// data +// Create the chunk dimensions variable, set the required size +// Read data from the hdf5 file +// If the vector size is not equal to ksmps correct the stride of data +// Increment the offset by the vector size + +void HDF5Read_readAudioData(CSOUND *csound, HDF5Read *self, + HDF5Dataset *dataset, cs_float *inputDataPointer) +{ + if (dataset->offset[0] >= + dataset->datasetSize[0]) { + return; + } + + size_t offset = self->h.insdshead->ksmps_offset; + size_t early = self->h.insdshead->ksmps_no_end; + + size_t vectorSize = (int32_t)(self->ksmps - offset - early); + + if (vectorSize + dataset->offset[0] > + dataset->datasetSize[0]) { + + vectorSize = (int32_t)(dataset->datasetSize[0] - + dataset->offset[0]); + } + cs_float *dataPointer = + vectorSize != self->ksmps ? dataset->sampleBuffer : inputDataPointer; + // FIXME if this is called frequently or on the audio thread then this won't + // work and will need a different solution +#ifdef _MSC_VER + //hsize_t* chunkDimensions = malloc (dataset->rank * sizeof (hsize_t)); + hsize_t chunkDimensions[16]; +#else + hsize_t chunkDimensions[dataset->rank]; +#endif + memcpy(&chunkDimensions[1], &dataset->datasetSize[1], + sizeof(hsize_t) * (dataset->rank-1)); // Reads too much + chunkDimensions[0] = vectorSize; + + // memcpy (chunkDimensions, dataset->datasetSize, + // sizeof (hsize_t)/* * dataset->rank */ + // ); + //chunkDimensions[dataset->rank - 1] = vectorSize; + + HDF5Read_readData (csound, self, dataset, dataset->offset, + chunkDimensions, dataPointer); + + if (vectorSize != self->ksmps) { + + HDF5Read_copySampleBufferToArray(dataset->elementCount, + dataset->sampleBuffer, inputDataPointer, + vectorSize, offset, self->ksmps); + } + + dataset->offset[0] += vectorSize; + +#ifdef _MSC_VER + //free (chunkDimensions); +#endif + +} + +// Read data at control rate from a hdf5 dataset +// +// If the offset of the dataset is larger than the data set size, no +// more data to read to return +// Create chunk dimension variable and set the appropriate size +// Read the data from the dataset +// Increment the offset variable + +void HDF5Read_readControlData(CSOUND *csound, HDF5Read *self, + HDF5Dataset *dataset, cs_float *dataPointer) +{ + if (dataset->offset[0] >= + dataset->datasetSize[0]) { + + return; + } + + // FIXME if this is called frequently or on the audio thread then this won't + // work and will need a different solution +#ifndef _MSC_VER + hsize_t chunkDimensions[dataset->rank]; +#else + hsize_t* chunkDimensions = malloc (dataset->rank * sizeof (hsize_t)); +#endif + memcpy(&chunkDimensions[1], &dataset->datasetSize[1], + sizeof(hsize_t) * (dataset->rank - 1)); + chunkDimensions[0] = 1; + + HDF5Read_readData(csound, self, dataset, dataset->offset, + chunkDimensions, dataPointer); + dataset->offset[0]++; +#ifdef _MSC_VER + free (chunkDimensions); +#endif + +} + +// Read dataset variables during performance time +// +// Iterate through each of the opened datasets, +// Depending on the dataset read type use the appropriate read function +// to read the data + +int32_t HDF5Read_process(CSOUND *csound, HDF5Read *self) +{ + int32_t i; + for (i = 0; i < self->inputArgumentCount; ++i) { + + HDF5Dataset *dataset = &self->datasets[i]; + + if (dataset->readAll == true) { + + continue; + } + + switch (dataset->readType) { + + case ARATE_ARRAY: { + + HDF5Read_readAudioData(csound, self, dataset, + ((ARRAYDAT *)dataset->argumentPointer)->data); + break; + } + case KRATE_ARRAY: { + + HDF5Read_readControlData(csound, self, dataset, + ((ARRAYDAT *)dataset->argumentPointer)->data); + break; + } + case ARATE_VAR: { + + HDF5Read_readAudioData(csound, self, dataset, dataset->argumentPointer); + break; + } + case KRATE_VAR: { + + HDF5Read_readControlData(csound, self, dataset, dataset->argumentPointer); + break; + } + + default: { + + break; + } + } + } + return OK; +} + +// Close the necessary variables when reading has finished +// +// Iterate through open datasets closing them in the hdf5 file +// Close the hdf5 file + +int32_t HDF5Read_finish(CSOUND *csound, void *inReference) +{ + HDF5Read *self = inReference; + int32_t i; + for (i = 0; i < self->inputArgumentCount; ++i) { + + HDF5Dataset *dataset = &self->datasets[i]; + + HDF5ERROR(H5Dclose(dataset->datasetID)); + } + + HDF5ERROR(H5Fclose(self->hdf5File->fileHandle)); + + return OK; +} + +// Check the input and output arguments for validity +// +// Check to see that if the amount of input arguments matches output arguments +// Check that the input arguments are strings, and the output arguments are +// not strings + +void HDF5Read_checkArgumentSanity(CSOUND *csound, const HDF5Read *self) +{ + int32_t i; + if (UNLIKELY(self->inputArgumentCount != self->outputArgumentCount)) { + + if (self->inputArgumentCount > self->outputArgumentCount) { + + csound->Die(csound, "%s", Str("hdf5read: Error, more input arguments than " + "output arguments, exiting")); + } + else { + + csound->Die(csound, "%s", Str("hdf5read: Error, more output arguments than " + "input arguments, exiting")); + } + } + + for (i = 0; i < self->inputArgumentCount; ++i) { + + ArgumentType outputType = + HDF5IO_getArgumentTypeFromArgument(csound, self->arguments[i]); + + if (UNLIKELY(outputType == STRING_VAR)) { + + csound->Die(csound, Str("hdf5read: Error, output argument %d appears " + "to be a string, exiting"), i + 1); + } + else if (UNLIKELY(outputType == UNKNOWN)) { + + csound->Die(csound, Str("hdf5read: Error, output argument %d type " + "is unknown, exiting"), i + 1); + } + } +} + +// Open the specified dataset in the hdf5 file +// +// Check that the hdf5 dataset exists in the file, if it doesn't stop csound +// If it does then open it + +void HDF5Read_initialiseHDF5Dataset(CSOUND *csound, HDF5Read *self, + HDF5Dataset *dataset) +{ + htri_t result = H5Lexists(self->hdf5File->fileHandle, + dataset->datasetName, H5P_DEFAULT); + + if (UNLIKELY(result <= 0)) { + + csound->Die(csound, "%s", Str("hdf5read: Error, dataset does not exist or " + "cannot be found in file")); + } + + dataset->datasetID = H5Dopen2(self->hdf5File->fileHandle, + dataset->datasetName, H5P_DEFAULT); + HDF5ERROR(dataset->datasetID); +} + +// Check opcode read types are compatible with the types written to the hdf5 dataset +// +// Get the written type from the hdf5 file +// If the opcode read type for the dataset is an array and the write type is +// an array or a-rate or k-rate variable return +// If the opcode read type is an a-rate or k-rate variable and the write type +// is an a-rate or k-rate vairable return +// If the opcode read type is an i-reate variable and the write type is an +// i-rate variable return +// Otherwise stop csound + +void HDF5Read_checkReadTypeSanity(CSOUND *csound, HDF5Read *self, + HDF5Dataset *dataset) +{ + char attributeString[12] = {"UNKNOWN\0"}; + HDF5IO_readStringAttribute(csound, self->hdf5File, + dataset->datasetName, attributeString); + dataset->writeType = HDF5IO_getArgumentTypeFromString(csound, attributeString); + + if (dataset->readType == ARATE_ARRAY + || + dataset->readType == KRATE_ARRAY + || + dataset->readType == IRATE_ARRAY) { + + if (dataset->writeType == ARATE_ARRAY + || + dataset->writeType == KRATE_ARRAY + || + dataset->writeType == IRATE_ARRAY + || + dataset->writeType == ARATE_VAR + || + dataset->writeType == KRATE_VAR) { + + return; + } + } + else if (dataset->readType == ARATE_VAR + || + dataset->readType == KRATE_VAR) { + + if (dataset->writeType == ARATE_VAR + || + dataset->writeType == KRATE_VAR) { + + return; + } + } + else if (dataset->readType == IRATE_VAR) { + + if (dataset->writeType == IRATE_VAR) { + + return; + } + } + else { + + csound->Die(csound, "%s", Str("hdf5read: Unable to read saved type of " + "dataset, exiting")); + } +} + +// Allocate the memory for an output array from the opcode +// +// Get the pointer to the output argument and cast to array +// Get the rank and allocate the dimension sizes memory +// Assign first dimension size to array sizes and dataset element count +// If the rank is greater than 1, multiply dimensions to get element count +// Let the engine allocate data space for the array using the element count + +void HDF5Read_allocateArray(CSOUND *csound, HDF5Read *self, + HDF5Dataset *dataset, + hsize_t rank, hsize_t *dimensions) +{ + ARRAYDAT *array = dataset->argumentPointer; + array->dimensions = (int32_t)rank; + array->sizes = csound->Calloc(csound, sizeof(int32_t) * rank); + + array->sizes[0] = (int32_t)dimensions[0]; + dataset->elementCount = dimensions[0]; + + if (rank > 1) { + size_t i; + for (i = 1; i < rank; ++i) { + + array->sizes[i] = (int32_t)dimensions[i]; + dataset->elementCount *= array->sizes[i]; + + } + } + + if (UNLIKELY(csound_array_ensure_capacity(csound, array, + dataset->elementCount, + self->h.insdshead) != OK)) { + csound->Die(csound, "%s", Str("hdf5read: Error, could not allocate " + "output array")); + } +} + + +// Initialise the dataset and prepare for reading an a-rate, k-rate or i-rate +// array during performance time +// +// Get the data space from the dataset in the hdf5 file +// Get the rank from the data space +// Allocate the size array for specified rank +// Get the dimensions of the dataset and copy to dataset size array +// If requested output type for dataset is not an i-rate array: +// Create the dimensions variable and copy the dataset size minus the last +// dimension to the array +// Then allocate the array data for the output argument +// Allocate the memory for the offset variable +// If it's an a-rate array and sample accurate allocate data for the sample buffer +// Else if it's an i-rate array copy the array dimensions including the last one +// Then allocate the array data for the output argument +// Cast the argument pointer to an array, then read the data into the array from +// the hdf5 file + +void HDF5Read_initialiseArrayOutput(CSOUND *csound, HDF5Read *self, + HDF5Dataset *dataset) +{ + + hid_t dataspaceID = H5Dget_space(dataset->datasetID); + HDF5ERROR(dataspaceID); + dataset->rank = H5Sget_simple_extent_ndims(dataspaceID); + + csound->AuxAlloc(csound, sizeof(hsize_t) * dataset->rank, + &dataset->datasetSizeMemory); + dataset->datasetSize = dataset->datasetSizeMemory.auxp; + + H5Sget_simple_extent_dims(dataspaceID, dataset->datasetSize, NULL); + HDF5ERROR(H5Sclose(dataspaceID)); + + if (dataset->readType != IRATE_ARRAY && dataset->readAll == false) { + // FIXME if this is called frequently or on the audio thread then this won't + // work and will need a different solution +#ifdef _MSC_VER + hsize_t* arrayDimensions = malloc ((dataset->rank - 1) * sizeof (hsize_t)); +#else + hsize_t arrayDimensions[dataset->rank - 1]; +#endif + memcpy(arrayDimensions, &dataset->datasetSize[1], + (dataset->rank - 1) * sizeof(hsize_t)); + + HDF5Read_allocateArray(csound, self, dataset, (dataset->rank - 1), + arrayDimensions); + + csound->AuxAlloc(csound, sizeof(hsize_t) * dataset->rank, + &dataset->offsetMemory); + dataset->offset = dataset->offsetMemory.auxp; + + if (dataset->readType == ARATE_ARRAY + || + self->isSampleAccurate == true) { + + csound->AuxAlloc(csound, + dataset->elementCount * self->ksmps * sizeof(cs_float), + &dataset->sampleBufferMemory); + dataset->sampleBuffer = dataset->sampleBufferMemory.auxp; + } +#ifdef _MSC_VER + free (arrayDimensions); +#endif + } + else { +#ifdef _MSC_VER + hsize_t* arrayDimensions = malloc ((dataset->rank) * sizeof (hsize_t)); +#else + hsize_t arrayDimensions[dataset->rank]; +#endif + memcpy(arrayDimensions, dataset->datasetSize, + dataset->rank * sizeof(hsize_t)); + HDF5Read_allocateArray(csound, self, dataset, dataset->rank, arrayDimensions); + ARRAYDAT *array = dataset->argumentPointer; +#ifdef _MSC_VER + hsize_t* offset = malloc ((dataset->rank) * sizeof (hsize_t)); +#else + hsize_t offset[dataset->rank]; +#endif + memset(offset, 0, sizeof(hsize_t) * dataset->rank); + HDF5Read_readData(csound, self, dataset, offset, + arrayDimensions, array->data); +#ifdef _MSC_VER + free (offset); +#endif + } +} + +// Initialise the dataset and prepare for reading an a-rate, k-rate or i-rate +// variable during performance time +// +// Get the data space from the dataset in the hdf5 file +// Set the rank as 1, the variable is a scalar +// If the dataset read type is a-rate or k-rate: +// Allocate the dataset size memory, get the size of the dataset and copy to +// the size memory +// Allocate offset memory and set to 0 +// If the dataset is to be read at a-rate and we are running sample accurate +// allocate the sample buffer +// Otherwise create array dimesions variable, set to 1, create offset variable, +// set to 0 and read the i-rate variable + +void HDF5Read_initialiseScalarOutput(CSOUND *csound, HDF5Read *self, + HDF5Dataset *dataset) +{ + hid_t dataspaceID = H5Dget_space(dataset->datasetID); + HDF5ERROR(dataspaceID); + dataset->rank = 1; + + if (dataset->readType == ARATE_VAR + || + dataset->readType == KRATE_VAR + || + dataset->readType == IRATE_VAR) { + + csound->AuxAlloc(csound, sizeof(hsize_t) * dataset->rank, + &dataset->datasetSizeMemory); + dataset->datasetSize = dataset->datasetSizeMemory.auxp; + + H5Sget_simple_extent_dims(dataspaceID, dataset->datasetSize, NULL); + HDF5ERROR(H5Sclose(dataspaceID)); + + csound->AuxAlloc(csound, sizeof(hsize_t), &dataset->offsetMemory); + dataset->offset = dataset->offsetMemory.auxp; + memset(dataset->offset, 0, sizeof(hsize_t)); + + if (dataset->readType == ARATE_VAR + && + self->isSampleAccurate == true) { + + csound->AuxAlloc(csound, self->ksmps * sizeof(cs_float), + &dataset->sampleBufferMemory); + dataset->sampleBuffer = dataset->sampleBufferMemory.auxp; + dataset->elementCount = 1; + } + + if (dataset->readType == IRATE_VAR) { + + hsize_t arrayDimensions[1] = {1}; + hsize_t offset[1] = {0}; + HDF5Read_readData(csound, self, dataset, offset, arrayDimensions, + dataset->argumentPointer); + } + } + +} + +// Open the datasets in an hdf5 file for reading +// +// Allocate memory for the datasets array +// Iterate through the datasets in the array +// Assign the input argument name to the dataset name +// Get the read type from the arguments +// Assign the argument data pointer +// Check that the read type and write type are compatible +// Initialise the data set using the corresponding function for read type specified + +void HDF5Read_openDatasets(CSOUND *csound, HDF5Read *self) +{ + int32_t i; + csound->AuxAlloc(csound, sizeof(HDF5Dataset) * self->inputArgumentCount, + &self->datasetsMemory); + self->datasets = self->datasetsMemory.auxp; + + for (i = 0; i < self->inputArgumentCount; ++i) { + + HDF5Dataset *currentDataset = &self->datasets[i]; + STRINGDAT *inputArgument = (STRINGDAT *)self->names[i]; + + csound->AuxAlloc(csound, sizeof(char) * strlen(inputArgument->data)+1, + ¤tDataset->datasetNameMemory); + currentDataset->datasetName = currentDataset->datasetNameMemory.auxp; + strcpy(currentDataset->datasetName, inputArgument->data); + + if (currentDataset->datasetName[strlen(inputArgument->data) - 1] == '*') { + + currentDataset->readAll = true; + currentDataset->datasetName[strlen(inputArgument->data) - 1] = '\0'; + } + currentDataset->readType = + HDF5IO_getArgumentTypeFromArgument(csound, self->arguments[i]); + currentDataset->argumentPointer = self->arguments[i]; + HDF5Read_checkReadTypeSanity(csound, self, currentDataset); + HDF5Read_initialiseHDF5Dataset(csound, self, currentDataset); + + switch (currentDataset->readType) { + case ARATE_ARRAY: { + + HDF5Read_initialiseArrayOutput(csound, self, currentDataset); + break; + } + case KRATE_ARRAY: { + + HDF5Read_initialiseArrayOutput(csound, self, currentDataset); + break; + } + case IRATE_ARRAY: { + + HDF5Read_initialiseArrayOutput(csound, self, currentDataset); + break; + } + case ARATE_VAR: { + + HDF5Read_initialiseScalarOutput(csound, self, currentDataset); + break; + } + case KRATE_VAR: { + + HDF5Read_initialiseScalarOutput(csound, self, currentDataset); + break; + } + case IRATE_VAR: { + + HDF5Read_initialiseScalarOutput(csound, self, currentDataset); + break; + } + default: + break; + + } + } + +} + + +static OENTRY localops[] = { + + { + (char *)"hdf5write", + sizeof(HDF5Write), + 0, + (char *)"", + (char *)"*", + (SUBR)HDF5Write_initialise, + (SUBR)HDF5Write_process, + (SUBR)HDF5Write_finish, + NULL, + 0 + }, + { + (char *)"hdf5read", + sizeof(HDF5Read), + 0, + (char *)"********************", + (char *)"SW", + (SUBR)HDF5Read_initialise, + (SUBR)HDF5Read_process, + (SUBR)HDF5Read_finish, + NULL, + 0 + } +}; + +LINKAGE diff --git a/7.x/src/hdf5/HDF5IO.h b/7.x/src/hdf5/HDF5IO.h new file mode 100644 index 0000000..df243cf --- /dev/null +++ b/7.x/src/hdf5/HDF5IO.h @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2014 Edward Costello + * + * This software is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "csdl.h" +#include "hdf5.h" +#include + +typedef enum ArgumentType +{ + STRING_VAR, + ARATE_VAR, + KRATE_VAR, + IRATE_VAR, + ARATE_ARRAY, + KRATE_ARRAY, + IRATE_ARRAY, + UNKNOWN +} ArgumentType; + +typedef struct _fft { + OPDS h; + ARRAYDAT *out; + ARRAYDAT *in, *in2; + cs_float *f; + cs_float b; + int32_t n; + void *setup; + AUXCH mem; +} nFFT; + + + +typedef struct HDF5Dataset +{ + char *datasetName; + AUXCH datasetNameMemory; + void *argumentPointer; + ArgumentType writeType; + ArgumentType readType; + int32_t rank; + hsize_t *chunkDimensions; + AUXCH chunkDimensionsMemory; + hsize_t *maxDimensions; + AUXCH maxDimensionsMemory; + hsize_t *offset; + AUXCH offsetMemory; + hsize_t *datasetSize; + AUXCH datasetSizeMemory; + + hid_t datasetID; + + size_t elementCount; + cs_float *sampleBuffer; + AUXCH sampleBufferMemory; + + bool readAll; + +} HDF5Dataset; + +typedef struct HDF5File +{ + hid_t fileHandle; + char *fileName; + hid_t floatSize; + +} HDF5File; + + +HDF5File *HDF5IO_newHDF5File(CSOUND *csound, AUXCH *hdf5FileMemory, + STRINGDAT *path, bool openForWriting); + +void HDF5IO_deleteHDF5File(CSOUND *csound, HDF5File *hdf5File); + +typedef struct HDF5Write +{ + OPDS h; + cs_float *arguments[20]; + int32_t inputArgumentCount; + size_t ksmps; + HDF5File *hdf5File; + AUXCH hdf5FileMemory; + HDF5Dataset *datasets; + AUXCH datasetsMemory; + +} HDF5Write; + +int32_t HDF5Write_initialise(CSOUND *csound, HDF5Write *self); + +int32_t HDF5Write_process(CSOUND *csound, HDF5Write *self); + +int32_t HDF5Write_finish(CSOUND *csound, void *inReference); + +void HDF5Write_checkArgumentSanity(CSOUND *csound, const HDF5Write *self); + +void HDF5Write_createDatasets(CSOUND *csound, HDF5Write *self); + +void HDF5Write_newArrayDataset(CSOUND *csound, HDF5Write *self, + HDF5Dataset *dataset); + +void HDF5Write_deleteArrayDataset(CSOUND *csound, HDF5Dataset *dataset); + + +typedef struct HDF5Read +{ + OPDS h; + cs_float *arguments[20]; + STRINGDAT *path; + STRINGDAT *names[20]; + int32_t inputArgumentCount; + int32_t outputArgumentCount; + size_t ksmps; + HDF5File *hdf5File; + AUXCH hdf5FileMemory; + HDF5Dataset *datasets; + AUXCH datasetsMemory; + bool isSampleAccurate; + +} HDF5Read; + +int32_t HDF5Read_initialise(CSOUND *csound, HDF5Read *self); + +int32_t HDF5Read_process(CSOUND *csound, HDF5Read *self); + +int32_t HDF5Read_finish(CSOUND *csound, void *inReference); + +void HDF5Read_checkArgumentSanity(CSOUND *csound, const HDF5Read *self); + +void HDF5Read_openDatasets(CSOUND *csound, HDF5Read *self); diff --git a/7.x/vcpkg.json b/7.x/vcpkg.json index 2ddf2db..2ecfcd7 100644 --- a/7.x/vcpkg.json +++ b/7.x/vcpkg.json @@ -6,6 +6,7 @@ "dependencies": [ "eigen3", "fluidsynth", + "hdf5", "libuv", "libwebsockets" ] From 86231aa6e84bd1fba3b2706bbd6a812e38506d5b Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 12:26:47 +0100 Subject: [PATCH 19/72] Fix hdf5 build on vcpkg and newer HDF5 - Link only hdf5::hdf5-static under vcpkg; the config package does not provide an hdf5_hl target and the opcodes do not use the HL API. - Remove the unused H5Oget_info query in HDF5IO_readStringAttribute. Its result was never used, and the H5Oget_info/H5Oget_info1 signature changed in HDF5 1.12/2.x (H5Oget_info now needs a fields argument), breaking the build against HDF5 2.1 on Windows. --- 7.x/src/hdf5/CMakeLists.txt | 14 +------------- 7.x/src/hdf5/HDF5IO.c | 6 ------ 2 files changed, 1 insertion(+), 19 deletions(-) diff --git a/7.x/src/hdf5/CMakeLists.txt b/7.x/src/hdf5/CMakeLists.txt index 48d5f38..41566da 100644 --- a/7.x/src/hdf5/CMakeLists.txt +++ b/7.x/src/hdf5/CMakeLists.txt @@ -8,24 +8,12 @@ endif() check_deps(BUILD_HDF5_OPCODES HDF5_FOUND) if(BUILD_HDF5_OPCODES AND HDF5_FOUND) - # split version string, as cmake doesn't do this automatically - string(REPLACE "." ";" VERSION_LIST ${HDF5_VERSION}) - list(GET VERSION_LIST 0 HDF5_VERSION_MAJOR) - list(GET VERSION_LIST 1 HDF5_VERSION_MINOR) - list(GET VERSION_LIST 2 HDF5_VERSION_PATCH) - make_plugin(hdf5ops HDF5IO.c) target_include_directories(hdf5ops PRIVATE ${HDF5_INCLUDE_DIRS} ${CSOUND_INCLUDE_DIRS}) - target_compile_definitions(hdf5ops PRIVATE - -DHDF5_VERSION_MAJOR=${HDF5_VERSION_MAJOR} - -DHDF5_VERSION_MINOR=${HDF5_VERSION_MINOR} - -DHDF5_VERSION_PATCH=${HDF5_VERSION_PATCH} - ) - if(USE_VCPKG) - target_link_libraries(hdf5ops PRIVATE hdf5::hdf5-static hdf5::hdf5_hl-static) + target_link_libraries(hdf5ops PRIVATE hdf5::hdf5-static) else() message(STATUS "HDF5_INCLUDE_DIRS: ${HDF5_INCLUDE_DIRS}") message(STATUS "HDF5_LIBRARIES: ${HDF5_LIBRARIES}") diff --git a/7.x/src/hdf5/HDF5IO.c b/7.x/src/hdf5/HDF5IO.c index 8bc3af7..ad39157 100644 --- a/7.x/src/hdf5/HDF5IO.c +++ b/7.x/src/hdf5/HDF5IO.c @@ -230,12 +230,6 @@ void HDF5IO_readStringAttribute(CSOUND *csound, HDF5File *self, char *datasetName, char *attributeString) { hid_t dataSetID = H5Dopen2(self->fileHandle, datasetName, H5P_DEFAULT); - H5O_info_t oinfo; -#if HDF5_VERSION_MAJOR == 1 && HDF5_VERSION_MINOR >= 12 - HDF5ERROR(H5Oget_info1(dataSetID, &oinfo)); -#else - HDF5ERROR(H5Oget_info(dataSetID, &oinfo)); -#endif hid_t attributeID = H5Aopen_by_idx(dataSetID, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, 0, H5P_DEFAULT, H5P_DEFAULT); HDF5ERROR(attributeID); From 6e063c76f5586730c6d3bb2d2a26dac5cbac83c2 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 12:38:19 +0100 Subject: [PATCH 20/72] Address CodeRabbit review of hdf5 port --- 7.x/src/hdf5/HDF5IO.c | 60 ++++++++++++++++++++++++++++++------------- 1 file changed, 42 insertions(+), 18 deletions(-) diff --git a/7.x/src/hdf5/HDF5IO.c b/7.x/src/hdf5/HDF5IO.c index ad39157..a433629 100644 --- a/7.x/src/hdf5/HDF5IO.c +++ b/7.x/src/hdf5/HDF5IO.c @@ -169,7 +169,10 @@ HDF5File *HDF5IO_newHDF5File(CSOUND *csound, AUXCH *hdf5FileMemory, } else { - hdf5File->fileHandle = H5Fopen(hdf5File->fileName, H5F_ACC_RDWR, H5P_DEFAULT); + hdf5File->fileHandle = H5Fopen(hdf5File->fileName, + openForWriting ? H5F_ACC_RDWR + : H5F_ACC_RDONLY, + H5P_DEFAULT); HDF5ERROR(hdf5File->fileHandle); } @@ -230,6 +233,7 @@ void HDF5IO_readStringAttribute(CSOUND *csound, HDF5File *self, char *datasetName, char *attributeString) { hid_t dataSetID = H5Dopen2(self->fileHandle, datasetName, H5P_DEFAULT); + HDF5ERROR(dataSetID); hid_t attributeID = H5Aopen_by_idx(dataSetID, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, 0, H5P_DEFAULT, H5P_DEFAULT); HDF5ERROR(attributeID); @@ -303,6 +307,7 @@ void HDF5Write_writeData(CSOUND *csound, HDF5Write *self, HDF5ERROR(H5Dwrite(dataset->datasetID, self->hdf5File->floatSize, memspace, filespace, H5P_DEFAULT, data)); HDF5ERROR(H5Sclose(filespace)); + HDF5ERROR(H5Sclose(memspace)); } // Write a-rate variables and arrays to the specified data set @@ -1094,11 +1099,11 @@ void HDF5Read_checkReadTypeSanity(CSOUND *csound, HDF5Read *self, return; } } - else { - csound->Die(csound, "%s", Str("hdf5read: Unable to read saved type of " - "dataset, exiting")); - } + csound->Die(csound, Str("hdf5read: Error, dataset \"%s\" saved type %s " + "is incompatible with output type %s, exiting"), + dataset->datasetName, typeStrings[dataset->writeType], + typeStrings[dataset->readType]); } // Allocate the memory for an output array from the opcode @@ -1175,16 +1180,29 @@ void HDF5Read_initialiseArrayOutput(CSOUND *csound, HDF5Read *self, if (dataset->readType != IRATE_ARRAY && dataset->readAll == false) { // FIXME if this is called frequently or on the audio thread then this won't // work and will need a different solution + hsize_t elementRank = (hsize_t)(dataset->rank - 1); + hsize_t scalarDimension[1] = {1}; #ifdef _MSC_VER - hsize_t* arrayDimensions = malloc ((dataset->rank - 1) * sizeof (hsize_t)); + hsize_t* arrayDimensions = malloc ((elementRank > 0 ? elementRank : 1) + * sizeof (hsize_t)); #else - hsize_t arrayDimensions[dataset->rank - 1]; + hsize_t arrayDimensions[elementRank > 0 ? elementRank : 1]; #endif - memcpy(arrayDimensions, &dataset->datasetSize[1], - (dataset->rank - 1) * sizeof(hsize_t)); + hsize_t *elementDimensions = arrayDimensions; + + if (elementRank == 0) { + + elementRank = 1; + elementDimensions = scalarDimension; + } + else { - HDF5Read_allocateArray(csound, self, dataset, (dataset->rank - 1), - arrayDimensions); + memcpy(arrayDimensions, &dataset->datasetSize[1], + elementRank * sizeof(hsize_t)); + } + + HDF5Read_allocateArray(csound, self, dataset, elementRank, + elementDimensions); csound->AuxAlloc(csound, sizeof(hsize_t) * dataset->rank, &dataset->offsetMemory); @@ -1265,9 +1283,7 @@ void HDF5Read_initialiseScalarOutput(CSOUND *csound, HDF5Read *self, dataset->offset = dataset->offsetMemory.auxp; memset(dataset->offset, 0, sizeof(hsize_t)); - if (dataset->readType == ARATE_VAR - && - self->isSampleAccurate == true) { + if (dataset->readType == ARATE_VAR) { csound->AuxAlloc(csound, self->ksmps * sizeof(cs_float), &dataset->sampleBufferMemory); @@ -1308,15 +1324,23 @@ void HDF5Read_openDatasets(CSOUND *csound, HDF5Read *self) HDF5Dataset *currentDataset = &self->datasets[i]; STRINGDAT *inputArgument = (STRINGDAT *)self->names[i]; - csound->AuxAlloc(csound, sizeof(char) * strlen(inputArgument->data)+1, + size_t nameLength = strlen(inputArgument->data); + + if (UNLIKELY(nameLength == 0)) { + + csound->Die(csound, Str("hdf5read: Error, dataset name %d is empty"), + i + 1); + } + + csound->AuxAlloc(csound, sizeof(char) * nameLength + 1, ¤tDataset->datasetNameMemory); currentDataset->datasetName = currentDataset->datasetNameMemory.auxp; - strcpy(currentDataset->datasetName, inputArgument->data); + memcpy(currentDataset->datasetName, inputArgument->data, nameLength + 1); - if (currentDataset->datasetName[strlen(inputArgument->data) - 1] == '*') { + if (currentDataset->datasetName[nameLength - 1] == '*') { currentDataset->readAll = true; - currentDataset->datasetName[strlen(inputArgument->data) - 1] = '\0'; + currentDataset->datasetName[nameLength - 1] = '\0'; } currentDataset->readType = HDF5IO_getArgumentTypeFromArgument(csound, self->arguments[i]); From a58e5ad0fa35b185d7e68376a3f4f9c3a791799c Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 12:50:45 +0100 Subject: [PATCH 21/72] Support gmm++ 5.4.3 in linear algebra opcodes --- 7.x/src/linear_algebra/CMakeLists.txt | 19 ++++++++++++++++++- 7.x/src/linear_algebra/linear_algebra.cpp | 16 ++++++++-------- 2 files changed, 26 insertions(+), 9 deletions(-) diff --git a/7.x/src/linear_algebra/CMakeLists.txt b/7.x/src/linear_algebra/CMakeLists.txt index e564934..5d33e5b 100644 --- a/7.x/src/linear_algebra/CMakeLists.txt +++ b/7.x/src/linear_algebra/CMakeLists.txt @@ -10,9 +10,26 @@ check_deps(BUILD_LINEAR_ALGEBRA_OPCODES GMM_FOUND) if(BUILD_LINEAR_ALGEBRA_OPCODES AND GMM_FOUND) make_plugin(linear_algebra linear_algebra.cpp) target_include_directories(linear_algebra PRIVATE ${GMM_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) - target_compile_options(linear_algebra PRIVATE "-DGMM_VERSION") target_compile_definitions(linear_algebra PRIVATE BUILD_PLUGINS) + # gmm++ 5.4.3 made gmm::lapack_ipvt a typedef of std::vector and dropped its + # get() accessor (elements are now accessed with operator[]). There is no + # preprocessor macro to detect this, so probe the headers that were found. + include(CheckCXXSourceCompiles) + set(CMAKE_REQUIRED_INCLUDES ${GMM_INCLUDE_DIR}) + check_cxx_source_compiles(" + #include + int main() { + gmm::lapack_ipvt pivot(1); + return (int)pivot.get(0); + } + " GMM_LAPACK_IPVT_GET) + unset(CMAKE_REQUIRED_INCLUDES) + + if(GMM_LAPACK_IPVT_GET) + target_compile_definitions(linear_algebra PRIVATE HAVE_LAPACK_IPVT_GET=1) + endif() + if (MSVC) target_compile_options(linear_algebra PRIVATE "/D_SCL_SECURE_NO_DEPRECATE") endif() diff --git a/7.x/src/linear_algebra/linear_algebra.cpp b/7.x/src/linear_algebra/linear_algebra.cpp index 60e9ca1..f82714e 100644 --- a/7.x/src/linear_algebra/linear_algebra.cpp +++ b/7.x/src/linear_algebra/linear_algebra.cpp @@ -3504,7 +3504,7 @@ class la_i_lu_factor_mr_t : public OpcodeBase { la_i_mr_create_t *lhs; la_i_vr_create_t *pivot; la_i_mr_create_t *rhs; -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; #else std::vector pivot__; @@ -3519,7 +3519,7 @@ class la_i_lu_factor_mr_t : public OpcodeBase { gmm::copy(rhs->mr, lhs->mr); *isize = gmm::lu_factor(lhs->mr, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) pivot->vr[i] = pivot__.get(i); #else pivot->vr[i] = pivot__[i]; @@ -3538,7 +3538,7 @@ class la_k_lu_factor_mr_t : public OpcodeBase { la_i_mr_create_t *lhs; la_i_vr_create_t *pivot; la_i_mr_create_t *rhs; -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; #else std::vector pivot__; @@ -3556,7 +3556,7 @@ class la_k_lu_factor_mr_t : public OpcodeBase { gmm::copy(rhs->mr, lhs->mr); *ksize = gmm::lu_factor(lhs->mr, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) pivot->vr[i] = pivot__.get(i); #else pivot->vr[i] = pivot__[i]; @@ -3575,7 +3575,7 @@ class la_i_lu_factor_mc_t : public OpcodeBase { la_i_mc_create_t *lhs; la_i_vr_create_t *pivot; la_i_mc_create_t *rhs; -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; #else std::vector pivot__; @@ -3590,7 +3590,7 @@ class la_i_lu_factor_mc_t : public OpcodeBase { gmm::copy(rhs->mc, lhs->mc); *isize = gmm::lu_factor(lhs->mc, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) pivot->vr[i] = pivot__.get(i); #else pivot->vr[i] = pivot__[i]; @@ -3609,7 +3609,7 @@ class la_k_lu_factor_mc_t : public OpcodeBase { la_i_mc_create_t *lhs; la_i_vr_create_t *pivot; la_i_mc_create_t *rhs; -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; #else std::vector pivot__; @@ -3627,7 +3627,7 @@ class la_k_lu_factor_mc_t : public OpcodeBase { gmm::copy(rhs->mc, lhs->mc); *ksize = gmm::lu_factor(lhs->mc, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(GMM_VERSION) +#if defined(HAVE_LAPACK_IPVT_GET) pivot->vr[i] = pivot__.get(i); #else pivot->vr[i] = pivot__[i]; From c71162b5e22af40f60739c54292d9ed0ce82641c Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 12:56:16 +0100 Subject: [PATCH 22/72] Use an accessor helper for gmm++ lapack_ipvt --- 7.x/src/linear_algebra/CMakeLists.txt | 18 ------- 7.x/src/linear_algebra/linear_algebra.cpp | 59 +++++++++-------------- 2 files changed, 23 insertions(+), 54 deletions(-) diff --git a/7.x/src/linear_algebra/CMakeLists.txt b/7.x/src/linear_algebra/CMakeLists.txt index 5d33e5b..24961c3 100644 --- a/7.x/src/linear_algebra/CMakeLists.txt +++ b/7.x/src/linear_algebra/CMakeLists.txt @@ -12,24 +12,6 @@ if(BUILD_LINEAR_ALGEBRA_OPCODES AND GMM_FOUND) target_include_directories(linear_algebra PRIVATE ${GMM_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) target_compile_definitions(linear_algebra PRIVATE BUILD_PLUGINS) - # gmm++ 5.4.3 made gmm::lapack_ipvt a typedef of std::vector and dropped its - # get() accessor (elements are now accessed with operator[]). There is no - # preprocessor macro to detect this, so probe the headers that were found. - include(CheckCXXSourceCompiles) - set(CMAKE_REQUIRED_INCLUDES ${GMM_INCLUDE_DIR}) - check_cxx_source_compiles(" - #include - int main() { - gmm::lapack_ipvt pivot(1); - return (int)pivot.get(0); - } - " GMM_LAPACK_IPVT_GET) - unset(CMAKE_REQUIRED_INCLUDES) - - if(GMM_LAPACK_IPVT_GET) - target_compile_definitions(linear_algebra PRIVATE HAVE_LAPACK_IPVT_GET=1) - endif() - if (MSVC) target_compile_options(linear_algebra PRIVATE "/D_SCL_SECURE_NO_DEPRECATE") endif() diff --git a/7.x/src/linear_algebra/linear_algebra.cpp b/7.x/src/linear_algebra/linear_algebra.cpp index f82714e..ca9dfa8 100644 --- a/7.x/src/linear_algebra/linear_algebra.cpp +++ b/7.x/src/linear_algebra/linear_algebra.cpp @@ -384,6 +384,25 @@ static std::ostream &operator<<(std::ostream &o, return o; } +// gmm++ 5.4.3 changed gmm::lapack_ipvt into a std::vector typedef and replaced +// its get() accessor with operator[]. These overloads select whichever accessor +// the installed gmm++ provides. +template +static auto la_ipvt_get(const Pivot &pivot, size_t i, int) + -> decltype(pivot.get(i)) { + return pivot.get(i); +} + +template +static size_t la_ipvt_get(const Pivot &pivot, size_t i, long) { + return static_cast(pivot[i]); +} + +template +static size_t la_ipvt_get(const Pivot &pivot, size_t i) { + return la_ipvt_get(pivot, i, 0); +} + /** * Template union for safely and efficiently * typecasting the value of a cs_float variable @@ -3504,11 +3523,7 @@ class la_i_lu_factor_mr_t : public OpcodeBase { la_i_mr_create_t *lhs; la_i_vr_create_t *pivot; la_i_mr_create_t *rhs; -#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; -#else - std::vector pivot__; -#endif size_t pivot_size; int32_t init(CSOUND *) { toa(lhs_, lhs); @@ -3519,11 +3534,7 @@ class la_i_lu_factor_mr_t : public OpcodeBase { gmm::copy(rhs->mr, lhs->mr); *isize = gmm::lu_factor(lhs->mr, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(HAVE_LAPACK_IPVT_GET) - pivot->vr[i] = pivot__.get(i); -#else - pivot->vr[i] = pivot__[i]; -#endif + pivot->vr[i] = la_ipvt_get(pivot__, i); } return OK; } @@ -3538,11 +3549,7 @@ class la_k_lu_factor_mr_t : public OpcodeBase { la_i_mr_create_t *lhs; la_i_vr_create_t *pivot; la_i_mr_create_t *rhs; -#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; -#else - std::vector pivot__; -#endif size_t pivot_size; int32_t init(CSOUND *) { toa(lhs_, lhs); @@ -3556,11 +3563,7 @@ class la_k_lu_factor_mr_t : public OpcodeBase { gmm::copy(rhs->mr, lhs->mr); *ksize = gmm::lu_factor(lhs->mr, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(HAVE_LAPACK_IPVT_GET) - pivot->vr[i] = pivot__.get(i); -#else - pivot->vr[i] = pivot__[i]; -#endif + pivot->vr[i] = la_ipvt_get(pivot__, i); } return OK; } @@ -3575,11 +3578,7 @@ class la_i_lu_factor_mc_t : public OpcodeBase { la_i_mc_create_t *lhs; la_i_vr_create_t *pivot; la_i_mc_create_t *rhs; -#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; -#else - std::vector pivot__; -#endif size_t pivot_size; int32_t init(CSOUND *) { toa(lhs_, lhs); @@ -3590,11 +3589,7 @@ class la_i_lu_factor_mc_t : public OpcodeBase { gmm::copy(rhs->mc, lhs->mc); *isize = gmm::lu_factor(lhs->mc, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(HAVE_LAPACK_IPVT_GET) - pivot->vr[i] = pivot__.get(i); -#else - pivot->vr[i] = pivot__[i]; -#endif + pivot->vr[i] = la_ipvt_get(pivot__, i); } return OK; } @@ -3609,11 +3604,7 @@ class la_k_lu_factor_mc_t : public OpcodeBase { la_i_mc_create_t *lhs; la_i_vr_create_t *pivot; la_i_mc_create_t *rhs; -#if defined(HAVE_LAPACK_IPVT_GET) gmm::lapack_ipvt pivot__; -#else - std::vector pivot__; -#endif size_t pivot_size; int32_t init(CSOUND *) { toa(lhs_, lhs); @@ -3627,11 +3618,7 @@ class la_k_lu_factor_mc_t : public OpcodeBase { gmm::copy(rhs->mc, lhs->mc); *ksize = gmm::lu_factor(lhs->mc, pivot__); for (size_t i = 0; i < pivot_size; ++i) { -#if defined(HAVE_LAPACK_IPVT_GET) - pivot->vr[i] = pivot__.get(i); -#else - pivot->vr[i] = pivot__[i]; -#endif + pivot->vr[i] = la_ipvt_get(pivot__, i); } return OK; } From 8ecea4846f1ac02e4034979b4ccc9b383524de01 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 13:44:23 +0100 Subject: [PATCH 23/72] Port image opcodes to Csound 7 plugins Port the image opcodes (imageload, imagesave, imagecreate, imagesize, imagegetpixel, imagesetpixel, imagefree) from the 6.x tree, updating API usage (FindInputFile/FindOutputFile + fopen, NotifyFileOpened, LINKAGE, cs_float) and the OENTRY layout. Wire the plugin into the 7.x build (CMake, vcpkg, CI, README). --- .github/workflows/plugins_build_7.yml | 4 +- 7.x/CMakeLists.txt | 1 + 7.x/README.md | 6 +- 7.x/src/image/CMakeLists.txt | 12 + 7.x/src/image/README.md | 5 + 7.x/src/image/imageOpcodes.c | 670 ++++++++++++++++++++++++++ 7.x/src/image/imageOpcodes.h | 85 ++++ 7.x/vcpkg.json | 1 + 8 files changed, 782 insertions(+), 2 deletions(-) create mode 100644 7.x/src/image/CMakeLists.txt create mode 100644 7.x/src/image/README.md create mode 100644 7.x/src/image/imageOpcodes.c create mode 100644 7.x/src/image/imageOpcodes.h diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index ccb06a2..78a026c 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -69,7 +69,7 @@ jobs: sudo apt-get install -y \ build-essential cmake pkg-config \ libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ - libeigen3-dev libfluidsynth-dev \ + libeigen3-dev libfluidsynth-dev libpng-dev \ libwebsockets-dev libuv1-dev \ flex bison @@ -111,6 +111,7 @@ jobs: cp build/src/chua/*.so \ build/src/linear_algebra/*.so \ build/src/fluidOpcodes/*.so \ + build/src/image/*.so \ build/src/websockets/*.so \ build/src/py/*.so package/ @@ -211,6 +212,7 @@ jobs: cp build/src/chua/*.dylib \ build/src/linear_algebra/*.dylib \ build/src/fluidOpcodes/*.dylib \ + build/src/image/*.dylib \ build/src/websockets/*.dylib \ build/src/py/*.dylib package/ diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 37c3b23..113d570 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -305,5 +305,6 @@ endif() add_subdirectory(./src/chua) add_subdirectory(./src/linear_algebra) add_subdirectory(./src/fluidOpcodes) +add_subdirectory(./src/image) add_subdirectory(./src/websockets) add_subdirectory(./src/py) diff --git a/7.x/README.md b/7.x/README.md index 7d0046f..c68a23e 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -9,6 +9,9 @@ Currently, the plugins available in this tree are - fluidOpcodes (requires fluidsynth) **fluidEngine fluidLoad fluidNote fluidCCi fluidCCk fluidControl fluidProgramSelect fluidAllOut fluidOut fluidInfo fluidSetInterpMethod** +- image (requires libpng) +**imageload imagesave imagecreate imagesize imagegetpixel imagesetpixel imagefree** + - linear_algebra (requires the gmm++ library, header-only; vendored under this directory) **A large family of `la_*` opcodes, with i-rate and k-rate variants, for vector, matrix and tensor operations** @@ -78,7 +81,8 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_FLUID_OPCODES`, -`BUILD_LINEAR_ALGEBRA_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and +`BUILD_IMAGE_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, +`BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to exclude the chua plugin, the `cmake` command would be: diff --git a/7.x/src/image/CMakeLists.txt b/7.x/src/image/CMakeLists.txt new file mode 100644 index 0000000..223ab9a --- /dev/null +++ b/7.x/src/image/CMakeLists.txt @@ -0,0 +1,12 @@ +# Build image opcodes +option(BUILD_IMAGE_OPCODES "Build the image opcodes" ON) + +find_package(PNG) +check_deps(BUILD_IMAGE_OPCODES PNG_FOUND) + +if(BUILD_IMAGE_OPCODES AND PNG_FOUND) + make_plugin(image imageOpcodes.c) + target_include_directories(image PRIVATE ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(image PRIVATE BUILD_PLUGINS) + target_link_libraries(image PRIVATE PNG::PNG) +endif() diff --git a/7.x/src/image/README.md b/7.x/src/image/README.md new file mode 100644 index 0000000..dbc1c19 --- /dev/null +++ b/7.x/src/image/README.md @@ -0,0 +1,5 @@ +Image opcodes +======= + +To build the image opcodes, you will need the libpng library, which can be easily built +and installed from sources using CMake, see [http://www.libpng.org/pub/png/libpng.html](http://www.libpng.org/pub/png/libpng.html) diff --git a/7.x/src/image/imageOpcodes.c b/7.x/src/image/imageOpcodes.c new file mode 100644 index 0000000..baeced9 --- /dev/null +++ b/7.x/src/image/imageOpcodes.c @@ -0,0 +1,670 @@ + +/** + * IMAGE OPCODES + * + * imageOpcodes.c + * + * Copyright (c) 2007 by Cesare Marilungo. All rights reserved. + * + * L I C E N S E + * + * This software is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * C S O U N D M A N P A G E + * + * imageload - opens an image (in PNG format) + * imagesave - saves an image (in PNG format) + * imagecreate - create an empty image + * imagesize - gets the size of an image + * imagegetpixel - gets the rgb values of a pixel + * imagesetpixel - sets the rgb values of a pixel + * imagefree - free memory from a previously loaded or created image. + * + * SYNTAX + * + * iImageNumber imageload sFilename + * + * imageSave iImageNumber, sFilename + * + * iImageNumber imagecreate iWidth, iHeight + * + * iWidth, iHeight imagesize iImageNumber + * + * kred, kgreen, kblue imagegetpixel iImageNumber, kX, kY + * ared, agreen, ablue imagegetpixel iImageNumber, aX, aY + * + * imagesetpixel iImageNumber, kX, kY, kred, kgreen, kblue + * imagesetpixel iImageNumber, aX, aY, ared, agreen, ablue + * + * imageFree iImageNumber + * + */ + +#define USE_LIBPNG + +#ifdef USE_LIBPNG +#include +#else +#include +#include +#endif + +/* #include */ +/* #include */ + +#include +#include + +#include "csdl.h" +#include "imageOpcodes.h" + +/* + __doOpenImage and __doSaveImage are the only two functions that deal + with the actual image loading saving library. + + imageData stores the image content as an array of RGB bytes for each + row (l->r t->b) so a pixel value in imageData is located at: (w*y+x)*3. +*/ + +/* #undef CS_KSMPS */ +/* #define CS_KSMPS (csound->GetKsmps(csound)) */ + +static Image * __doOpenImage(char * filename, CSOUND *csound) +{ +#ifdef USE_LIBPNG +#define HS (8) + FILE *fp; + char *fullname; + unsigned char header[HS]; + png_structp png_ptr; + png_infop info_ptr; + /* png_infop end_ptr; */ + int32_t is_png; + png_uint_32 width, height, rowbytes; + int32_t bit_depth; + int32_t color_type; + unsigned char *image_data; + png_bytepp row_pointers; + uint32_t i; + + Image *img; + + fullname = csound->FindInputFile(csound, filename, "SFDIR;SSDIR"); + fp = (fullname != NULL) ? fopen(fullname, "rb") : NULL; + if (UNLIKELY(fp == NULL)) { + csound->InitError(csound, + Str("imageload: cannot open image %s.\n"), filename); + return NULL; + } + csound->NotifyFileOpened(csound, fullname, CSFTYPE_IMAGE_PNG, 0, 0); + + if (UNLIKELY(HS!=fread(header, 1, HS, fp))) { + csound->InitError(csound, + Str("imageload: file %s is not in PNG format.\n"), + filename); + fclose(fp); + return NULL; + } + is_png = !png_sig_cmp(header, 0, HS); + + if (UNLIKELY(!is_png)) { + csound->InitError(csound, + Str("imageload: file %s is not in PNG format.\n"), + filename); + fclose(fp); + return NULL; + } + + png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); + if (UNLIKELY(!png_ptr)) { + csound->InitError(csound, "%s", Str("imageload: out of memory.\n")); + fclose(fp); + return NULL; + } + info_ptr = png_create_info_struct(png_ptr); + if (UNLIKELY(!info_ptr)) { + png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL); + csound->InitError(csound, "%s", Str("imageload: out of memory.\n")); + fclose(fp); + return NULL; + } + + /* end_ptr = png_create_info_struct(png_ptr); */ + /* if (UNLIKELY(!end_ptr)) { */ + /* png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL); */ + /* csound->InitError(csound, "%s", Str("imageload: out of memory.\n")); */ + /* fclose(fp); */ + /* return NULL; */ + /* } */ + + png_init_io(png_ptr, fp); + png_set_sig_bytes(png_ptr, HS); + + png_read_info(png_ptr, info_ptr); + { + + png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, + &color_type, NULL, NULL, NULL); + } + if (color_type & PNG_COLOR_MASK_ALPHA) + png_set_strip_alpha(png_ptr); + if (bit_depth == 16) + png_set_strip_16(png_ptr); + if (bit_depth < 8) + png_set_packing(png_ptr); + if (color_type == PNG_COLOR_TYPE_GRAY || + color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + png_set_gray_to_rgb(png_ptr); + if (color_type == PNG_COLOR_TYPE_PALETTE) + png_set_palette_to_rgb(png_ptr); + + png_read_update_info(png_ptr, info_ptr); + rowbytes = png_get_rowbytes(png_ptr, info_ptr); + + if (UNLIKELY((image_data = + (unsigned char *)csound->Malloc(csound,rowbytes*height))==NULL)) { + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + csound->InitError(csound, "%s", Str("imageload: out of memory.\n")); + fclose(fp); + return NULL; + } + + row_pointers = (png_bytepp) csound->Malloc(csound, height*sizeof(png_bytep)); + if (UNLIKELY(row_pointers == NULL)) { + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + csound->Free(csound,image_data); + image_data = NULL; + csound->InitError(csound, "%s", Str("imageload: out of memory.\n")); + fclose(fp); + return NULL; + } + + for (i = 0; i < height; i++) + row_pointers[i] = image_data + i*rowbytes; + + png_read_image(png_ptr, row_pointers); + csound->Free(csound,row_pointers); + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + fclose(fp); + + img = csound->Malloc(csound, sizeof(Image)); + if (UNLIKELY(!img)) { + csound->Free(csound,image_data); + csound->InitError(csound, "%s", Str("imageload: out of memory.\n")); + return NULL; + } + + img->w = width; + img->h = height; + img->imageData = image_data; + + return img; + +#else + + Display *disp; + ImlibData *id; + ImlibImage *im; + Image *img; + size_t datasize; + + disp=XOpenDisplay(NULL); + id=Imlib_init(disp); + im=Imlib_load_image(id, filename); + + img = csound->Malloc(csound, sizeof(Image)); + img->w = im->rgb_width; + img->h = im->rgb_height; + datasize = img->w*img->h*3 * sizeof(unsigned char); + img->imageData = csound->Malloc(csound, datasize); + memcpy(img->imageData, im->rgb_data, datasize); + + return img; +#endif + + /* SDL */ +/* Image *img; + size_t datasize; + SDL_Surface *srfc; + int32_t x,y; + int32_t bpp; + int32_t indcount = 0; + Uint32 *pixel; + Uint8 r, g, b; + + srfc = IMG_Load(filename); + if (srfc) { + SDL_LockSurface(srfc); + img = csound->Malloc(csound, sizeof(Image)); + img->w = srfc->w; + img->h = srfc->h; + bpp = srfc->format->BitsPerPixel; + + datasize = img->w*img->h*3 * sizeof(unsigned char); + img->imageData = csound->Malloc(csound, datasize); + + for(y = 0; y < img->h; y++) { + for(x = 0; x < img->w; x++) { + if (bpp<=8) //need to test on other platforms + pixel = srfc->pixels + y * srfc->pitch + x * bpp; + else + pixel = srfc->pixels + y * srfc->pitch + x * bpp / 8; + SDL_GetRGB(*pixel,srfc->format, &r, &g, &b); + img->imageData[indcount]= r; + img->imageData[indcount+1]= g; + img->imageData[indcount+2]= b; + indcount += 3; + } + } + SDL_UnlockSurface(srfc); + SDL_FreeSurface ( srfc ); + return img; + } + + return NULL; +*/ + +} + + +static int32_t __doSaveImage(Image *image, char *filename, CSOUND *csound) +{ +#ifdef USE_LIBPNG + + png_structp png_ptr; + png_infop info_ptr; + png_bytepp row_pointers; + uint32_t rowbytes; + int32_t i; + + FILE *fp; + char *fullname; + + fullname = csound->FindOutputFile(csound, filename, "SFDIR;SSDIR"); + fp = (fullname != NULL) ? fopen(fullname, "wb") : NULL; + if (UNLIKELY(fp == NULL)) { + return + csound->InitError(csound, + Str("imagesave: cannot open image %s for writing.\n"), + filename); + } + csound->NotifyFileOpened(csound, fullname, CSFTYPE_IMAGE_PNG, 1, 0); + + png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); + + if (UNLIKELY(!png_ptr)){ + fclose(fp); + return csound->InitError(csound, "%s", Str("imagesave: out of memory.\n")); + } + + info_ptr = png_create_info_struct(png_ptr); + if (UNLIKELY(!info_ptr)) { + png_destroy_write_struct(&png_ptr, (png_infopp)NULL); + fclose(fp); + return csound->InitError(csound, "%s", Str("imagesave: out of memory.\n")); + } + + png_init_io(png_ptr, fp); + png_set_IHDR(png_ptr, info_ptr, image->w, image->h, + 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, + PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); + + png_write_info(png_ptr, info_ptr); + + row_pointers = (png_bytepp)csound->Malloc(csound, image->h*sizeof(png_bytep)); + if (UNLIKELY(row_pointers == NULL)) { + png_destroy_write_struct(&png_ptr, &info_ptr); + fclose(fp); + return csound->InitError(csound, "%s", Str("imagesave: out of memory.\n")); + } + + rowbytes = png_get_rowbytes(png_ptr, info_ptr); + + for (i = 0; i < image->h; i++) + row_pointers[i] = image->imageData + i*rowbytes; + + png_write_image(png_ptr, row_pointers); + png_write_end(png_ptr, info_ptr); + + csound->Free(csound,row_pointers); + png_destroy_write_struct(&png_ptr, &info_ptr); + fclose(fp); + + return OK; +#else + Display *disp; + ImlibData *id; + ImlibImage *im; + + disp=XOpenDisplay(NULL); + id=Imlib_init(disp); + + im = Imlib_create_image_from_data(id, image->imageData, + NULL, image->w, image->h); + Imlib_save_image(id, im, filename, NULL); + Imlib_kill_image(id, im); + + return OK; +#endif +} + + +static Image * createImage(CSOUND *csound, int32_t w, int32_t h) +{ + Image *img; + size_t datasize; + + img = csound->Malloc(csound, sizeof(Image)); + img->w = w; + img->h = h; + + datasize = img->w*img->h*3 * sizeof(unsigned char); + img->imageData = csound->Malloc(csound, datasize); + + return img; +} + + +static Images * getImages(CSOUND *csound) +{ + Images *pimages; + pimages = (Images*)csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + if (pimages==NULL) { /* first call */ + csound->CreateGlobalVariable(csound, "imageOpcodes.images", + sizeof(Images)); + pimages = (Images*)csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + pimages->images = (Image **) NULL; + pimages->cnt = (size_t) 0; + } + return pimages; +} + +static int32_t imagecreate (CSOUND *csound, IMGCREATE * p) +{ + Images *pimages; + Image *img; + + pimages = getImages(csound); + + pimages->cnt++; + pimages->images = + (Image **) csound->ReAlloc(csound, pimages->images, + sizeof(Image *) * pimages->cnt); + + img = createImage(csound, *p->kw, *p->kh); + + if (UNLIKELY(img==NULL)) { + return csound->InitError(csound, "%s", Str("Cannot allocate memory.\n")); + } + else { + pimages->images[pimages->cnt-1] = img; + *(p->kn) = (cs_float) pimages->cnt; + return OK; + } +} + +static int32_t imageload (CSOUND *csound, IMGLOAD * p) +{ + char filename[256]; + Images *pimages; + Image *img; + + pimages = getImages(csound); + + pimages->cnt++; + pimages->images = + (Image **) csound->ReAlloc(csound, pimages->images, + sizeof(Image *) * pimages->cnt); + + strncpy(filename, (char*) (p->ifilnam->data), 255); filename[255]='\0'; + + img = __doOpenImage(filename, csound); + + if (LIKELY(img)) { + pimages->images[pimages->cnt-1] = img; + *(p->kn) = (cs_float) pimages->cnt; + return OK; + } + else { + return csound->InitError(csound, + Str("imageload: cannot open image %s.\n"), + filename); + } +} + + +static int32_t imagesize (CSOUND *csound, IMGSIZE * p) +{ + Images *pimages; + Image *img; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + img = pimages->images[(int32_t)(*p->kn)-1]; + + *(p->kw) = (cs_float) img->w; + *(p->kh) = (cs_float) img->h; + return OK; +} + + +static int32_t imagegetpixel (CSOUND *csound, IMGGETPIXEL * p) +{ + Images *pimages; + Image *img; + int32_t w, h, x, y; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + img = pimages->images[(int32_t)(*p->kn)-1]; + + w = img->w; + h = img->h; + + x = *p->kx*w; + y = *p->ky*h; + + if (x >= 0 && x < w && y >= 0 && y < h ) { + int32_t pixel = (w*y+x)*3; + *p->kr = img->imageData[pixel]/FL(255.0); + *p->kg = img->imageData[pixel+1]/FL(255.0); + *p->kb = img->imageData[pixel+2]/FL(255.0); + } + else { + *p->kr = FL(0.0); + *p->kg = FL(0.0); + *p->kb = FL(0.0); + } + + return OK; +} + +static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) +{ + Images *pimages; + Image *img; + + cs_float *r = p->kr; + cs_float *g = p->kg; + cs_float *b = p->kb; + + cs_float *tx = p->kx; + cs_float *ty = p->ky; + + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t i, nsmps = CS_KSMPS; + int32_t w, h, x, y, pixel; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + img = pimages->images[(int32_t)(*p->kn)-1]; + w = img->w; + h = img->h; + + + if (UNLIKELY(offset)) { + memset(r, '\0', offset*sizeof(cs_float)); + memset(g, '\0', offset*sizeof(cs_float)); + memset(b, '\0', offset*sizeof(cs_float)); + } + if (UNLIKELY(early)) { + nsmps -= early; + memset(&r[nsmps], '\0', early*sizeof(cs_float)); + memset(&g[nsmps], '\0', early*sizeof(cs_float)); + memset(&b[nsmps], '\0', early*sizeof(cs_float)); + } + for (i = 0; i < nsmps; i++) { + + x = tx[i]*w; + y = ty[i]*h; + + if ( x >= 0 && x < w && y >= 0 && y < h ) { + pixel = (w*y+x)*3; + r[i] = img->imageData[pixel]/FL(255.0); + g[i] = img->imageData[pixel+1]/FL(255.0); + b[i] = img->imageData[pixel+2]/FL(255.0); + } + else { + r[i] = FL(0.0); + g[i] = FL(0.0); + b[i] = FL(0.0); + } + } + + return OK; +} + +static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) +{ + Images *pimages; + Image *img; + + cs_float *r = p->kr; + cs_float *g = p->kg; + cs_float *b = p->kb; + + cs_float *tx = p->kx; + cs_float *ty = p->ky; + + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t i, nsmps = CS_KSMPS; + int32_t h,w,x, y, pixel; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + img = pimages->images[(int32_t)(*p->kn)-1]; + + w = img->w; + h = img->h; + + if (UNLIKELY(early)) nsmps -= early; + for (i = offset; i < nsmps; i++) { + + x = tx[i]*w; + y = ty[i]*h; + + if (x >= 0 && x < w && y >= 0 && y < h ) { + pixel = (w*y+x)*3; + img->imageData[pixel] = (unsigned char)(r[i]*255) % 256; + img->imageData[pixel+1] = (unsigned char)(g[i]*255) % 256; + img->imageData[pixel+2] = (unsigned char)(b[i]*255) % 256; + } + + } + + return OK; +} + +static int32_t imagesetpixel (CSOUND *csound, IMGSETPIXEL * p) +{ + Images *pimages; + Image *img; + int32_t w, h, x, y, pixel; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + img = pimages->images[(int32_t)(*p->kn)-1]; + + w = img->w; + h = img->h; + + x = *p->kx*w; + y = *p->ky*h; + + if (x >= 0 && x < w && y >= 0 && y < h ) { + pixel = (w*y+x)*3; + img->imageData[pixel] = (unsigned char)((*p->kr)*255) % 256; + img->imageData[pixel+1] = (unsigned char)((*p->kg)*255) % 256; + img->imageData[pixel+2] = (unsigned char)((*p->kb)*255) % 256; + } + return OK; +} + +static int32_t imagesave (CSOUND *csound, IMGSAVE * p) +{ + Images *pimages; + Image *img; + char filename[256]; + + strncpy(filename, (char*) (p->ifilnam->data), 254); filename[255]='\0'; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + img = pimages->images[(int32_t)(*p->kn)-1]; + + return __doSaveImage(img, filename, csound); +} + +static int32_t imagefree (CSOUND *csound, IMGSAVE * p) +{ + Images *pimages; + Image *img; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + img = pimages->images[(int32_t + )(*p->kn)-1]; + csound->Free(csound,img->imageData); + csound->Free(csound,img); + + return OK; +} + +static OENTRY localops[] = { + { "imageload", sizeof(IMGLOAD), 0, "i", "S", + (SUBR)imageload, NULL, NULL, NULL, 0 }, + { "imagecreate", sizeof(IMGCREATE),0, "i", "ii", + (SUBR)imagecreate, NULL, NULL, NULL, 0 }, + { "imagesize", sizeof(IMGSIZE), 0, "ii", "i", + (SUBR)imagesize, NULL, NULL, NULL, 0 }, + { "imagegetpixel", sizeof(IMGGETPIXEL), 0, "kkk", "ixx", + (SUBR)imagegetpixel, (SUBR)imagegetpixel, NULL, NULL, 0 }, + { "imagegetpixel", sizeof(IMGGETPIXEL), 0, "aaa", "ixx", + (SUBR)imagegetpixel, (SUBR)imagegetpixel_a, NULL, NULL, 0 }, + { "imagesetpixel", sizeof(IMGSETPIXEL), 0, "", "ikkkkk", + (SUBR)imagesetpixel, (SUBR)imagesetpixel, NULL, NULL, 0 }, + { "imagesetpixel", sizeof(IMGSETPIXEL), 0, "", "iaaaaa", + (SUBR)imagesetpixel, (SUBR)imagesetpixel_a, NULL, NULL, 0 }, + { "imagesave", sizeof(IMGSAVE), 0, "", "iS", + (SUBR)imagesave, NULL, NULL, NULL, 0 }, + { "imagefree", sizeof(IMGFREE), 0, "", "i", + (SUBR)imagefree, NULL, NULL, NULL, 0 }, +}; + +LINKAGE diff --git a/7.x/src/image/imageOpcodes.h b/7.x/src/image/imageOpcodes.h new file mode 100644 index 0000000..f6889a9 --- /dev/null +++ b/7.x/src/image/imageOpcodes.h @@ -0,0 +1,85 @@ +/** + * IMAGE OPCODES + * + * imageOpcodes.h + * + * Copyright (c) 2007 by Cesare Marilungo. All rights reserved. + * + * L I C E N S E + * + * This software is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef IMAGE_OPCODES_H +#define IMAGE_OPCODES_H + +typedef struct +{ + unsigned char *imageData; + int32_t + w,h; +} Image; + +typedef struct +{ + Image **images; + size_t cnt; +} Images; + +typedef struct +{ + OPDS h; + cs_float *kn; + STRINGDAT *ifilnam ; +} IMGLOAD; + +typedef struct +{ + OPDS h; + cs_float *kn, *kw, *kh ; +} IMGCREATE; + +typedef struct +{ + OPDS h; + cs_float *kw, *kh, *kn; +} IMGSIZE; + +typedef struct +{ + OPDS h; + cs_float *kr,*kg,*kb, *kn, *kx,*ky; +} IMGGETPIXEL; + +typedef struct +{ + OPDS h; + cs_float *kn,*kx,*ky,*kr,*kg,*kb; +} IMGSETPIXEL; +typedef struct +{ + OPDS h; + cs_float *kn; + STRINGDAT *ifilnam; +} IMGSAVE; + +typedef struct +{ + OPDS h; + cs_float *kn; +} IMGFREE; + +#endif /* IMAGE_OPCODES_H */ diff --git a/7.x/vcpkg.json b/7.x/vcpkg.json index 2ddf2db..f76c29c 100644 --- a/7.x/vcpkg.json +++ b/7.x/vcpkg.json @@ -6,6 +6,7 @@ "dependencies": [ "eigen3", "fluidsynth", + "libpng", "libuv", "libwebsockets" ] From d8f8b83bc04db67318afd0ecd809cf131edd7de2 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 13:54:13 +0100 Subject: [PATCH 24/72] Select available HDF5 target for vcpkg triplets hdf5::hdf5-static is not exported when the vcpkg triplet builds HDF5 as a shared library. Choose hdf5::hdf5-static, hdf5::hdf5-shared or hdf5::hdf5 depending on which target the package provides. --- 7.x/src/hdf5/CMakeLists.txt | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/7.x/src/hdf5/CMakeLists.txt b/7.x/src/hdf5/CMakeLists.txt index 41566da..18e3362 100644 --- a/7.x/src/hdf5/CMakeLists.txt +++ b/7.x/src/hdf5/CMakeLists.txt @@ -13,7 +13,13 @@ if(BUILD_HDF5_OPCODES AND HDF5_FOUND) target_include_directories(hdf5ops PRIVATE ${HDF5_INCLUDE_DIRS} ${CSOUND_INCLUDE_DIRS}) if(USE_VCPKG) - target_link_libraries(hdf5ops PRIVATE hdf5::hdf5-static) + if(TARGET hdf5::hdf5-static) + target_link_libraries(hdf5ops PRIVATE hdf5::hdf5-static) + elseif(TARGET hdf5::hdf5-shared) + target_link_libraries(hdf5ops PRIVATE hdf5::hdf5-shared) + else() + target_link_libraries(hdf5ops PRIVATE hdf5::hdf5) + endif() else() message(STATUS "HDF5_INCLUDE_DIRS: ${HDF5_INCLUDE_DIRS}") message(STATUS "HDF5_LIBRARIES: ${HDF5_LIBRARIES}") From 554616fe886c17558ebcfb5d993edd77800ea455 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 14:31:51 +0100 Subject: [PATCH 25/72] Harden image opcodes error handling and image handle checks --- 7.x/src/image/imageOpcodes.c | 117 ++++++++++++++++++++++++----------- 1 file changed, 82 insertions(+), 35 deletions(-) diff --git a/7.x/src/image/imageOpcodes.c b/7.x/src/image/imageOpcodes.c index baeced9..fcbab41 100644 --- a/7.x/src/image/imageOpcodes.c +++ b/7.x/src/image/imageOpcodes.c @@ -95,8 +95,8 @@ static Image * __doOpenImage(char * filename, CSOUND *csound) png_uint_32 width, height, rowbytes; int32_t bit_depth; int32_t color_type; - unsigned char *image_data; - png_bytepp row_pointers; + unsigned char * volatile image_data = NULL; + png_bytepp volatile row_pointers = NULL; uint32_t i; Image *img; @@ -149,6 +149,18 @@ static Image * __doOpenImage(char * filename, CSOUND *csound) /* return NULL; */ /* } */ + if (setjmp(png_jmpbuf(png_ptr))) { + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + if (image_data != NULL) + csound->Free(csound, image_data); + if (row_pointers != NULL) + csound->Free(csound, row_pointers); + fclose(fp); + csound->InitError(csound, Str("imageload: error reading image %s.\n"), + filename); + return NULL; + } + png_init_io(png_ptr, fp); png_set_sig_bytes(png_ptr, HS); @@ -285,7 +297,7 @@ static int32_t __doSaveImage(Image *image, char *filename, CSOUND *csound) png_structp png_ptr; png_infop info_ptr; - png_bytepp row_pointers; + png_bytepp volatile row_pointers = NULL; uint32_t rowbytes; int32_t i; @@ -316,6 +328,16 @@ static int32_t __doSaveImage(Image *image, char *filename, CSOUND *csound) return csound->InitError(csound, "%s", Str("imagesave: out of memory.\n")); } + if (setjmp(png_jmpbuf(png_ptr))) { + png_destroy_write_struct(&png_ptr, &info_ptr); + if (row_pointers != NULL) + csound->Free(csound, row_pointers); + fclose(fp); + return csound->InitError(csound, + Str("imagesave: error writing image %s.\n"), + filename); + } + png_init_io(png_ptr, fp); png_set_IHDR(png_ptr, info_ptr, image->w, image->h, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, @@ -371,7 +393,7 @@ static Image * createImage(CSOUND *csound, int32_t w, int32_t h) img->h = h; datasize = img->w*img->h*3 * sizeof(unsigned char); - img->imageData = csound->Malloc(csound, datasize); + img->imageData = csound->Calloc(csound, datasize); return img; } @@ -393,6 +415,21 @@ static Images * getImages(CSOUND *csound) return pimages; } +static Image * getImage(CSOUND *csound, cs_float kn) +{ + Images *pimages; + int32_t n; + + pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + if (UNLIKELY(pimages == NULL)) + return (Image *) NULL; + n = (int32_t) kn; + if (UNLIKELY(n < 1 || (size_t) n > pimages->cnt)) + return (Image *) NULL; + return pimages->images[n-1]; +} + static int32_t imagecreate (CSOUND *csound, IMGCREATE * p) { Images *pimages; @@ -449,12 +486,12 @@ static int32_t imageload (CSOUND *csound, IMGLOAD * p) static int32_t imagesize (CSOUND *csound, IMGSIZE * p) { - Images *pimages; Image *img; - pimages = (Images *) csound->QueryGlobalVariable(csound, - "imageOpcodes.images"); - img = pimages->images[(int32_t)(*p->kn)-1]; + img = getImage(csound, *p->kn); + if (UNLIKELY(img == NULL)) + return csound->InitError(csound, "%s", + Str("imagesize: invalid image handle.\n")); *(p->kw) = (cs_float) img->w; *(p->kh) = (cs_float) img->h; @@ -464,13 +501,13 @@ static int32_t imagesize (CSOUND *csound, IMGSIZE * p) static int32_t imagegetpixel (CSOUND *csound, IMGGETPIXEL * p) { - Images *pimages; Image *img; int32_t w, h, x, y; - pimages = (Images *) csound->QueryGlobalVariable(csound, - "imageOpcodes.images"); - img = pimages->images[(int32_t)(*p->kn)-1]; + img = getImage(csound, *p->kn); + if (UNLIKELY(img == NULL)) + return csound->InitError(csound, "%s", + Str("imagegetpixel: invalid image handle.\n")); w = img->w; h = img->h; @@ -495,7 +532,6 @@ static int32_t imagegetpixel (CSOUND *csound, IMGGETPIXEL * p) static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) { - Images *pimages; Image *img; cs_float *r = p->kr; @@ -510,9 +546,13 @@ static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) uint32_t i, nsmps = CS_KSMPS; int32_t w, h, x, y, pixel; - pimages = (Images *) csound->QueryGlobalVariable(csound, - "imageOpcodes.images"); - img = pimages->images[(int32_t)(*p->kn)-1]; + img = getImage(csound, *p->kn); + if (UNLIKELY(img == NULL)) { + memset(r, '\0', nsmps*sizeof(cs_float)); + memset(g, '\0', nsmps*sizeof(cs_float)); + memset(b, '\0', nsmps*sizeof(cs_float)); + return OK; + } w = img->w; h = img->h; @@ -528,7 +568,7 @@ static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) memset(&g[nsmps], '\0', early*sizeof(cs_float)); memset(&b[nsmps], '\0', early*sizeof(cs_float)); } - for (i = 0; i < nsmps; i++) { + for (i = offset; i < nsmps; i++) { x = tx[i]*w; y = ty[i]*h; @@ -551,7 +591,6 @@ static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) { - Images *pimages; Image *img; cs_float *r = p->kr; @@ -566,9 +605,9 @@ static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) uint32_t i, nsmps = CS_KSMPS; int32_t h,w,x, y, pixel; - pimages = (Images *) csound->QueryGlobalVariable(csound, - "imageOpcodes.images"); - img = pimages->images[(int32_t)(*p->kn)-1]; + img = getImage(csound, *p->kn); + if (UNLIKELY(img == NULL)) + return OK; w = img->w; h = img->h; @@ -593,13 +632,13 @@ static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) static int32_t imagesetpixel (CSOUND *csound, IMGSETPIXEL * p) { - Images *pimages; Image *img; int32_t w, h, x, y, pixel; - pimages = (Images *) csound->QueryGlobalVariable(csound, - "imageOpcodes.images"); - img = pimages->images[(int32_t)(*p->kn)-1]; + img = getImage(csound, *p->kn); + if (UNLIKELY(img == NULL)) + return csound->InitError(csound, "%s", + Str("imagesetpixel: invalid image handle.\n")); w = img->w; h = img->h; @@ -618,30 +657,38 @@ static int32_t imagesetpixel (CSOUND *csound, IMGSETPIXEL * p) static int32_t imagesave (CSOUND *csound, IMGSAVE * p) { - Images *pimages; Image *img; char filename[256]; - strncpy(filename, (char*) (p->ifilnam->data), 254); filename[255]='\0'; + strncpy(filename, (char*) (p->ifilnam->data), 255); filename[255]='\0'; - pimages = (Images *) csound->QueryGlobalVariable(csound, - "imageOpcodes.images"); - img = pimages->images[(int32_t)(*p->kn)-1]; + img = getImage(csound, *p->kn); + if (UNLIKELY(img == NULL)) + return csound->InitError(csound, "%s", + Str("imagesave: invalid image handle.\n")); return __doSaveImage(img, filename, csound); } -static int32_t imagefree (CSOUND *csound, IMGSAVE * p) +static int32_t imagefree (CSOUND *csound, IMGFREE * p) { Images *pimages; Image *img; + int32_t n; pimages = (Images *) csound->QueryGlobalVariable(csound, "imageOpcodes.images"); - img = pimages->images[(int32_t - )(*p->kn)-1]; - csound->Free(csound,img->imageData); - csound->Free(csound,img); + n = (int32_t) (*p->kn); + if (UNLIKELY(pimages == NULL || n < 1 || (size_t) n > pimages->cnt)) + return csound->InitError(csound, "%s", + Str("imagefree: invalid image handle.\n")); + + img = pimages->images[n-1]; + if (img != NULL) { + csound->Free(csound,img->imageData); + csound->Free(csound,img); + pimages->images[n-1] = (Image *) NULL; + } return OK; } From f183c089ab984c97147c7e985f3aa5a6a9614c91 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Sun, 11 Oct 2026 14:42:13 +0100 Subject: [PATCH 26/72] Address image opcode review: allocation, registry, path and init fixes --- 7.x/src/image/imageOpcodes.c | 102 ++++++++++++++++++++++------------- 1 file changed, 64 insertions(+), 38 deletions(-) diff --git a/7.x/src/image/imageOpcodes.c b/7.x/src/image/imageOpcodes.c index fcbab41..ae99f83 100644 --- a/7.x/src/image/imageOpcodes.c +++ b/7.x/src/image/imageOpcodes.c @@ -81,7 +81,7 @@ /* #undef CS_KSMPS */ /* #define CS_KSMPS (csound->GetKsmps(csound)) */ -static Image * __doOpenImage(char * filename, CSOUND *csound) +static Image * __doOpenImage(const char * filename, CSOUND *csound) { #ifdef USE_LIBPNG #define HS (8) @@ -174,8 +174,13 @@ static Image * __doOpenImage(char * filename, CSOUND *csound) png_set_strip_alpha(png_ptr); if (bit_depth == 16) png_set_strip_16(png_ptr); - if (bit_depth < 8) - png_set_packing(png_ptr); + if (bit_depth < 8) { + if (color_type == PNG_COLOR_TYPE_GRAY || + color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + png_set_expand_gray_1_2_4_to_8(png_ptr); + else + png_set_packing(png_ptr); + } if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr); @@ -291,7 +296,7 @@ static Image * __doOpenImage(char * filename, CSOUND *csound) } -static int32_t __doSaveImage(Image *image, char *filename, CSOUND *csound) +static int32_t __doSaveImage(Image *image, const char *filename, CSOUND *csound) { #ifdef USE_LIBPNG @@ -388,12 +393,24 @@ static Image * createImage(CSOUND *csound, int32_t w, int32_t h) Image *img; size_t datasize; + if (UNLIKELY(w < 1 || h < 1)) + return (Image *) NULL; + if (UNLIKELY((size_t) w > ((size_t) -1) / 3 / (size_t) h)) + return (Image *) NULL; + img = csound->Malloc(csound, sizeof(Image)); + if (UNLIKELY(img == NULL)) + return (Image *) NULL; + img->w = w; img->h = h; - datasize = img->w*img->h*3 * sizeof(unsigned char); + datasize = (size_t) w * (size_t) h * 3; img->imageData = csound->Calloc(csound, datasize); + if (UNLIKELY(img->imageData == NULL)) { + csound->Free(csound, img); + return (Image *) NULL; + } return img; } @@ -434,53 +451,57 @@ static int32_t imagecreate (CSOUND *csound, IMGCREATE * p) { Images *pimages; Image *img; + Image **newImages; pimages = getImages(csound); - pimages->cnt++; - pimages->images = - (Image **) csound->ReAlloc(csound, pimages->images, - sizeof(Image *) * pimages->cnt); - img = createImage(csound, *p->kw, *p->kh); - - if (UNLIKELY(img==NULL)) { + if (UNLIKELY(img == NULL)) { return csound->InitError(csound, "%s", Str("Cannot allocate memory.\n")); } - else { - pimages->images[pimages->cnt-1] = img; - *(p->kn) = (cs_float) pimages->cnt; - return OK; + + newImages = (Image **) csound->ReAlloc(csound, pimages->images, + sizeof(Image *) * (pimages->cnt + 1)); + if (UNLIKELY(newImages == NULL)) { + csound->Free(csound, img->imageData); + csound->Free(csound, img); + return csound->InitError(csound, "%s", Str("Cannot allocate memory.\n")); } + + pimages->images = newImages; + pimages->images[pimages->cnt] = img; + pimages->cnt++; + *(p->kn) = (cs_float) pimages->cnt; + return OK; } static int32_t imageload (CSOUND *csound, IMGLOAD * p) { - char filename[256]; Images *pimages; Image *img; + Image **newImages; pimages = getImages(csound); - pimages->cnt++; - pimages->images = - (Image **) csound->ReAlloc(csound, pimages->images, - sizeof(Image *) * pimages->cnt); - - strncpy(filename, (char*) (p->ifilnam->data), 255); filename[255]='\0'; - - img = __doOpenImage(filename, csound); - - if (LIKELY(img)) { - pimages->images[pimages->cnt-1] = img; - *(p->kn) = (cs_float) pimages->cnt; - return OK; - } - else { + img = __doOpenImage((const char*) (p->ifilnam->data), csound); + if (UNLIKELY(img == NULL)) return csound->InitError(csound, Str("imageload: cannot open image %s.\n"), - filename); + (const char*) (p->ifilnam->data)); + + newImages = (Image **) csound->ReAlloc(csound, pimages->images, + sizeof(Image *) * (pimages->cnt + 1)); + if (UNLIKELY(newImages == NULL)) { + csound->Free(csound, img->imageData); + csound->Free(csound, img); + return csound->InitError(csound, "%s", Str("Cannot allocate memory.\n")); } + + pimages->images = newImages; + pimages->images[pimages->cnt] = img; + pimages->cnt++; + *(p->kn) = (cs_float) pimages->cnt; + return OK; } @@ -589,6 +610,14 @@ static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) return OK; } +static int32_t imagesetpixel_a_init (CSOUND *csound, IMGSETPIXEL * p) +{ + if (UNLIKELY(getImage(csound, *p->kn) == NULL)) + return csound->InitError(csound, "%s", + Str("imagesetpixel: invalid image handle.\n")); + return OK; +} + static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) { Image *img; @@ -658,16 +687,13 @@ static int32_t imagesetpixel (CSOUND *csound, IMGSETPIXEL * p) static int32_t imagesave (CSOUND *csound, IMGSAVE * p) { Image *img; - char filename[256]; - - strncpy(filename, (char*) (p->ifilnam->data), 255); filename[255]='\0'; img = getImage(csound, *p->kn); if (UNLIKELY(img == NULL)) return csound->InitError(csound, "%s", Str("imagesave: invalid image handle.\n")); - return __doSaveImage(img, filename, csound); + return __doSaveImage(img, (const char*) (p->ifilnam->data), csound); } static int32_t imagefree (CSOUND *csound, IMGFREE * p) @@ -707,7 +733,7 @@ static OENTRY localops[] = { { "imagesetpixel", sizeof(IMGSETPIXEL), 0, "", "ikkkkk", (SUBR)imagesetpixel, (SUBR)imagesetpixel, NULL, NULL, 0 }, { "imagesetpixel", sizeof(IMGSETPIXEL), 0, "", "iaaaaa", - (SUBR)imagesetpixel, (SUBR)imagesetpixel_a, NULL, NULL, 0 }, + (SUBR)imagesetpixel_a_init, (SUBR)imagesetpixel_a, NULL, NULL, 0 }, { "imagesave", sizeof(IMGSAVE), 0, "", "iS", (SUBR)imagesave, NULL, NULL, NULL, 0 }, { "imagefree", sizeof(IMGFREE), 0, "", "i", From 9650adc86d676b69735165d126f971c9d67a45cb Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 01:02:25 +0100 Subject: [PATCH 27/72] Reject hdf5write calls exceeding the 20-argument limit --- 7.x/src/hdf5/HDF5IO.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/7.x/src/hdf5/HDF5IO.c b/7.x/src/hdf5/HDF5IO.c index a433629..b068a9b 100644 --- a/7.x/src/hdf5/HDF5IO.c +++ b/7.x/src/hdf5/HDF5IO.c @@ -274,6 +274,13 @@ bool HDF5IO_getSampleAccurate(CSOUND *csound) int32_t HDF5Write_initialise(CSOUND *csound, HDF5Write *self) { + if (UNLIKELY(self->INOCOUNT + self->OUTOCOUNT > 20)) { + + return csound->InitError(csound, + Str("hdf5write: too many arguments " + "(maximum of 20 outputs and inputs)")); + } + self->ksmps = GetLocalKsmps(&self->h); self->inputArgumentCount = self->INOCOUNT - 1; HDF5Write_checkArgumentSanity(csound, self); From 6dc2020e25e4c6debd7c5fb325f174938efc0567 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 01:55:59 +0100 Subject: [PATCH 28/72] Fix image opcode size arithmetic and path leaks --- 7.x/src/image/imageOpcodes.c | 35 ++++++++++++++++++++++++++--------- 1 file changed, 26 insertions(+), 9 deletions(-) diff --git a/7.x/src/image/imageOpcodes.c b/7.x/src/image/imageOpcodes.c index ae99f83..051f1f4 100644 --- a/7.x/src/image/imageOpcodes.c +++ b/7.x/src/image/imageOpcodes.c @@ -96,6 +96,7 @@ static Image * __doOpenImage(const char * filename, CSOUND *csound) int32_t bit_depth; int32_t color_type; unsigned char * volatile image_data = NULL; + size_t datasize; png_bytepp volatile row_pointers = NULL; uint32_t i; @@ -104,11 +105,14 @@ static Image * __doOpenImage(const char * filename, CSOUND *csound) fullname = csound->FindInputFile(csound, filename, "SFDIR;SSDIR"); fp = (fullname != NULL) ? fopen(fullname, "rb") : NULL; if (UNLIKELY(fp == NULL)) { + if (fullname != NULL) + csound->Free(csound, fullname); csound->InitError(csound, Str("imageload: cannot open image %s.\n"), filename); return NULL; } csound->NotifyFileOpened(csound, fullname, CSFTYPE_IMAGE_PNG, 0, 0); + csound->Free(csound, fullname); if (UNLIKELY(HS!=fread(header, 1, HS, fp))) { csound->InitError(csound, @@ -190,8 +194,15 @@ static Image * __doOpenImage(const char * filename, CSOUND *csound) png_read_update_info(png_ptr, info_ptr); rowbytes = png_get_rowbytes(png_ptr, info_ptr); + if (UNLIKELY((size_t) rowbytes > ((size_t) -1) / (size_t) height)) { + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + csound->InitError(csound, "%s", Str("imageload: image too large.\n")); + fclose(fp); + return NULL; + } + datasize = (size_t) rowbytes * (size_t) height; if (UNLIKELY((image_data = - (unsigned char *)csound->Malloc(csound,rowbytes*height))==NULL)) { + (unsigned char *)csound->Malloc(csound,datasize))==NULL)) { png_destroy_read_struct(&png_ptr, &info_ptr, NULL); csound->InitError(csound, "%s", Str("imageload: out of memory.\n")); fclose(fp); @@ -209,7 +220,7 @@ static Image * __doOpenImage(const char * filename, CSOUND *csound) } for (i = 0; i < height; i++) - row_pointers[i] = image_data + i*rowbytes; + row_pointers[i] = image_data + (size_t) i * (size_t) rowbytes; png_read_image(png_ptr, row_pointers); csound->Free(csound,row_pointers); @@ -312,12 +323,15 @@ static int32_t __doSaveImage(Image *image, const char *filename, CSOUND *csound) fullname = csound->FindOutputFile(csound, filename, "SFDIR;SSDIR"); fp = (fullname != NULL) ? fopen(fullname, "wb") : NULL; if (UNLIKELY(fp == NULL)) { + if (fullname != NULL) + csound->Free(csound, fullname); return csound->InitError(csound, Str("imagesave: cannot open image %s for writing.\n"), filename); } csound->NotifyFileOpened(csound, fullname, CSFTYPE_IMAGE_PNG, 1, 0); + csound->Free(csound, fullname); png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); @@ -537,7 +551,7 @@ static int32_t imagegetpixel (CSOUND *csound, IMGGETPIXEL * p) y = *p->ky*h; if (x >= 0 && x < w && y >= 0 && y < h ) { - int32_t pixel = (w*y+x)*3; + size_t pixel = ((size_t) w * (size_t) y + (size_t) x) * 3; *p->kr = img->imageData[pixel]/FL(255.0); *p->kg = img->imageData[pixel+1]/FL(255.0); *p->kb = img->imageData[pixel+2]/FL(255.0); @@ -565,7 +579,8 @@ static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) uint32_t offset = p->h.insdshead->ksmps_offset; uint32_t early = p->h.insdshead->ksmps_no_end; uint32_t i, nsmps = CS_KSMPS; - int32_t w, h, x, y, pixel; + int32_t w, h, x, y; + size_t pixel; img = getImage(csound, *p->kn); if (UNLIKELY(img == NULL)) { @@ -595,7 +610,7 @@ static int32_t imagegetpixel_a (CSOUND *csound, IMGGETPIXEL * p) y = ty[i]*h; if ( x >= 0 && x < w && y >= 0 && y < h ) { - pixel = (w*y+x)*3; + pixel = ((size_t) w * (size_t) y + (size_t) x) * 3; r[i] = img->imageData[pixel]/FL(255.0); g[i] = img->imageData[pixel+1]/FL(255.0); b[i] = img->imageData[pixel+2]/FL(255.0); @@ -632,7 +647,8 @@ static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) uint32_t offset = p->h.insdshead->ksmps_offset; uint32_t early = p->h.insdshead->ksmps_no_end; uint32_t i, nsmps = CS_KSMPS; - int32_t h,w,x, y, pixel; + int32_t h,w,x, y; + size_t pixel; img = getImage(csound, *p->kn); if (UNLIKELY(img == NULL)) @@ -648,7 +664,7 @@ static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) y = ty[i]*h; if (x >= 0 && x < w && y >= 0 && y < h ) { - pixel = (w*y+x)*3; + pixel = ((size_t) w * (size_t) y + (size_t) x) * 3; img->imageData[pixel] = (unsigned char)(r[i]*255) % 256; img->imageData[pixel+1] = (unsigned char)(g[i]*255) % 256; img->imageData[pixel+2] = (unsigned char)(b[i]*255) % 256; @@ -662,7 +678,8 @@ static int32_t imagesetpixel_a (CSOUND *csound, IMGSETPIXEL * p) static int32_t imagesetpixel (CSOUND *csound, IMGSETPIXEL * p) { Image *img; - int32_t w, h, x, y, pixel; + int32_t w, h, x, y; + size_t pixel; img = getImage(csound, *p->kn); if (UNLIKELY(img == NULL)) @@ -676,7 +693,7 @@ static int32_t imagesetpixel (CSOUND *csound, IMGSETPIXEL * p) y = *p->ky*h; if (x >= 0 && x < w && y >= 0 && y < h ) { - pixel = (w*y+x)*3; + pixel = ((size_t) w * (size_t) y + (size_t) x) * 3; img->imageData[pixel] = (unsigned char)((*p->kr)*255) % 256; img->imageData[pixel+1] = (unsigned char)((*p->kg)*255) % 256; img->imageData[pixel+2] = (unsigned char)((*p->kb)*255) % 256; From 58cf05b102bde4dc3f17c63bbf2db1f29cb4d14b Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 02:01:42 +0100 Subject: [PATCH 29/72] Fix HDF5 partial-block transfers, array layout, and resource leaks --- 7.x/src/hdf5/HDF5IO.c | 97 ++++++++++++++++++++++++++++++------------- 1 file changed, 68 insertions(+), 29 deletions(-) diff --git a/7.x/src/hdf5/HDF5IO.c b/7.x/src/hdf5/HDF5IO.c index b068a9b..eabca64 100644 --- a/7.x/src/hdf5/HDF5IO.c +++ b/7.x/src/hdf5/HDF5IO.c @@ -333,15 +333,42 @@ void HDF5Write_writeAudioData(CSOUND *csound, HDF5Write *self, size_t offset = self->h.insdshead->ksmps_offset; size_t early = self->h.insdshead->ksmps_no_end; - int32_t vectorSize = (int32_t)(self->ksmps - offset - early); + size_t vectorSize = self->ksmps - offset - early; if (UNLIKELY(vectorSize == 0)) { return; } - dataset->datasetSize[0] += self->ksmps; + dataset->datasetSize[0] += vectorSize; + dataset->chunkDimensions[0] = vectorSize; - HDF5Write_writeData(csound, self, dataset, &dataPointer[offset]); + if (dataset->writeType == ARATE_ARRAY) { + + hsize_t i; + size_t memberCount = 1; + size_t t, member; + cs_float *staging; + + for (i = 1; i < dataset->rank; ++i) + memberCount *= (size_t)dataset->chunkDimensions[i]; + + staging = (cs_float *)csound->Malloc(csound, + vectorSize * memberCount * sizeof(cs_float)); + + for (t = 0; t < vectorSize; ++t) { + + for (member = 0; member < memberCount; ++member) + staging[t * memberCount + member] = + dataPointer[member * self->ksmps + offset + t]; + } + + HDF5Write_writeData(csound, self, dataset, staging); + csound->Free(csound, staging); + } + else { + + HDF5Write_writeData(csound, self, dataset, &dataPointer[offset]); + } dataset->offset[0] += vectorSize; } @@ -527,6 +554,8 @@ void HDF5Write_initialiseHDF5Dataset(CSOUND *csound, HDF5Write *self, self->hdf5File->floatSize, dataspaceID, H5P_DEFAULT, cparams, H5P_DEFAULT); HDF5ERROR(dataset->datasetID); + HDF5ERROR(H5Sclose(dataspaceID)); + HDF5ERROR(H5Pclose(cparams)); HDF5IO_writeStringAttribute(csound, self->hdf5File, dataset, "Variable Type", typeStrings[dataset->writeType]); @@ -770,12 +799,12 @@ void HDF5Read_copySampleBufferToArray(size_t channelCount, cs_float *sampleBuffe cs_float *arrayData, size_t vectorSize, size_t offset, size_t ksmps) { - size_t channel; + size_t channel, t; for (channel = 0; channel < channelCount; ++channel) { - memcpy(&arrayData[ksmps * channel + offset], - &sampleBuffer[vectorSize * channel], - sizeof(cs_float) * vectorSize); + for (t = 0; t < vectorSize; ++t) + arrayData[ksmps * channel + offset + t] = + sampleBuffer[t * channelCount + channel]; } } @@ -832,18 +861,18 @@ void HDF5Read_readAudioData(CSOUND *csound, HDF5Read *self, size_t offset = self->h.insdshead->ksmps_offset; size_t early = self->h.insdshead->ksmps_no_end; - size_t vectorSize = (int32_t)(self->ksmps - offset - early); + size_t vectorSize = self->ksmps - offset - early; if (vectorSize + dataset->offset[0] > dataset->datasetSize[0]) { - vectorSize = (int32_t)(dataset->datasetSize[0] - - dataset->offset[0]); + vectorSize = dataset->datasetSize[0] - dataset->offset[0]; } - cs_float *dataPointer = - vectorSize != self->ksmps ? dataset->sampleBuffer : inputDataPointer; - // FIXME if this is called frequently or on the audio thread then this won't - // work and will need a different solution + + if (UNLIKELY(vectorSize == 0)) { + return; + } + #ifdef _MSC_VER //hsize_t* chunkDimensions = malloc (dataset->rank * sizeof (hsize_t)); hsize_t chunkDimensions[16]; @@ -859,15 +888,19 @@ void HDF5Read_readAudioData(CSOUND *csound, HDF5Read *self, // ); //chunkDimensions[dataset->rank - 1] = vectorSize; - HDF5Read_readData (csound, self, dataset, dataset->offset, - chunkDimensions, dataPointer); - - if (vectorSize != self->ksmps) { + if (dataset->readType == ARATE_ARRAY || vectorSize != self->ksmps) { + HDF5Read_readData(csound, self, dataset, dataset->offset, + chunkDimensions, dataset->sampleBuffer); HDF5Read_copySampleBufferToArray(dataset->elementCount, dataset->sampleBuffer, inputDataPointer, vectorSize, offset, self->ksmps); } + else { + + HDF5Read_readData(csound, self, dataset, dataset->offset, + chunkDimensions, inputDataPointer); + } dataset->offset[0] += vectorSize; @@ -1126,22 +1159,28 @@ void HDF5Read_allocateArray(CSOUND *csound, HDF5Read *self, hsize_t rank, hsize_t *dimensions) { ARRAYDAT *array = dataset->argumentPointer; + size_t elementCount = 1; + size_t i; + array->dimensions = (int32_t)rank; array->sizes = csound->Calloc(csound, sizeof(int32_t) * rank); - array->sizes[0] = (int32_t)dimensions[0]; - dataset->elementCount = dimensions[0]; - - if (rank > 1) { - size_t i; - for (i = 1; i < rank; ++i) { - - array->sizes[i] = (int32_t)dimensions[i]; - dataset->elementCount *= array->sizes[i]; - - } + for (i = 0; i < rank; ++i) { + if (UNLIKELY(dimensions[i] > (hsize_t) INT32_MAX)) + csound->Die(csound, "%s", Str("hdf5read: Error, dataset dimension too " + "large for an array output")); + array->sizes[i] = (int32_t)dimensions[i]; + if (UNLIKELY(dimensions[i] != 0 && + elementCount > ((size_t) -1) / (size_t)dimensions[i])) + csound->Die(csound, "%s", Str("hdf5read: Error, dataset too large to " + "allocate")); + elementCount *= (size_t)dimensions[i]; } + if (UNLIKELY(elementCount < 1)) + elementCount = 1; + dataset->elementCount = elementCount; + if (UNLIKELY(csound_array_ensure_capacity(csound, array, dataset->elementCount, self->h.insdshead) != OK)) { From b978366bf0a64cbb681506a9cbda16513812d7fc Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 02:11:23 +0100 Subject: [PATCH 30/72] Harden HDF5 attribute reads, output clearing, and buffers --- 7.x/src/hdf5/HDF5IO.c | 31 ++++++++++++++++++++----------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/7.x/src/hdf5/HDF5IO.c b/7.x/src/hdf5/HDF5IO.c index eabca64..945acf4 100644 --- a/7.x/src/hdf5/HDF5IO.c +++ b/7.x/src/hdf5/HDF5IO.c @@ -26,7 +26,7 @@ #include #endif -#define HDF5ERROR(x) if (UNLIKELY((x) == -1)) \ +#define HDF5ERROR(x) if (UNLIKELY((x) < 0)) \ {csound->Die(csound, #x" error\nExiting\n");} // Type strings to match the enum types @@ -223,24 +223,24 @@ void HDF5IO_writeStringAttribute(CSOUND *csound, HDF5File *self, // Read a string attribute from the hdf5 file // -// Open the data set and get the info structure -// Get the attribute at index 0, this should probably be more general, needs -// more work -// Get the type of the attribute +// Open the data set then open the attribute by name +// Build a fixed size memory datatype bounded to the supplied buffer size // Read the attribute into memory and close all the handles void HDF5IO_readStringAttribute(CSOUND *csound, HDF5File *self, - char *datasetName, char *attributeString) + char *datasetName, char *attributeString, + size_t attributeStringSize) { hid_t dataSetID = H5Dopen2(self->fileHandle, datasetName, H5P_DEFAULT); HDF5ERROR(dataSetID); - hid_t attributeID = H5Aopen_by_idx(dataSetID, ".", H5_INDEX_CRT_ORDER, - H5_ITER_INC, 0, H5P_DEFAULT, H5P_DEFAULT); + hid_t attributeID = H5Aopen(dataSetID, "Variable Type", H5P_DEFAULT); HDF5ERROR(attributeID); hid_t attributeType = H5Aget_type(attributeID); HDF5ERROR(attributeType); - hid_t attributeTypeMemory = H5Tget_native_type(attributeType, H5T_DIR_ASCEND); + hid_t attributeTypeMemory = H5Tcopy(H5T_C_S1); HDF5ERROR(attributeTypeMemory); + HDF5ERROR(H5Tset_size(attributeTypeMemory, attributeStringSize)); + HDF5ERROR(H5Tset_strpad(attributeTypeMemory, H5T_STR_NULLTERM)); HDF5ERROR(H5Aread(attributeID, attributeTypeMemory, attributeString)); HDF5ERROR(H5Aclose(attributeID)); HDF5ERROR(H5Tclose(attributeType)); @@ -853,6 +853,13 @@ void HDF5Read_readData(CSOUND *csound, HDF5Read *self, HDF5Dataset *dataset, void HDF5Read_readAudioData(CSOUND *csound, HDF5Read *self, HDF5Dataset *dataset, cs_float *inputDataPointer) { + { + size_t memberCount = dataset->readType == ARATE_ARRAY + ? dataset->elementCount : 1; + memset(inputDataPointer, 0, + self->ksmps * memberCount * sizeof(cs_float)); + } + if (dataset->offset[0] >= dataset->datasetSize[0]) { return; @@ -875,7 +882,7 @@ void HDF5Read_readAudioData(CSOUND *csound, HDF5Read *self, #ifdef _MSC_VER //hsize_t* chunkDimensions = malloc (dataset->rank * sizeof (hsize_t)); - hsize_t chunkDimensions[16]; + hsize_t chunkDimensions[H5S_MAX_RANK]; #else hsize_t chunkDimensions[dataset->rank]; #endif @@ -1099,7 +1106,8 @@ void HDF5Read_checkReadTypeSanity(CSOUND *csound, HDF5Read *self, { char attributeString[12] = {"UNKNOWN\0"}; HDF5IO_readStringAttribute(csound, self->hdf5File, - dataset->datasetName, attributeString); + dataset->datasetName, attributeString, + sizeof(attributeString)); dataset->writeType = HDF5IO_getArgumentTypeFromString(csound, attributeString); if (dataset->readType == ARATE_ARRAY @@ -1287,6 +1295,7 @@ void HDF5Read_initialiseArrayOutput(CSOUND *csound, HDF5Read *self, arrayDimensions, array->data); #ifdef _MSC_VER free (offset); + free (arrayDimensions); #endif } } From 671c149b6a7870e466cf6b68e1455ac0508a26b6 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 02:13:14 +0100 Subject: [PATCH 31/72] Address image opcode overloads, cleanup, and diagnostics --- 7.x/src/image/imageOpcodes.c | 28 +++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/7.x/src/image/imageOpcodes.c b/7.x/src/image/imageOpcodes.c index 051f1f4..37c3f9a 100644 --- a/7.x/src/image/imageOpcodes.c +++ b/7.x/src/image/imageOpcodes.c @@ -499,9 +499,7 @@ static int32_t imageload (CSOUND *csound, IMGLOAD * p) img = __doOpenImage((const char*) (p->ifilnam->data), csound); if (UNLIKELY(img == NULL)) - return csound->InitError(csound, - Str("imageload: cannot open image %s.\n"), - (const char*) (p->ifilnam->data)); + return NOTOK; newImages = (Image **) csound->ReAlloc(csound, pimages->images, sizeof(Image *) * (pimages->cnt + 1)); @@ -736,6 +734,26 @@ static int32_t imagefree (CSOUND *csound, IMGFREE * p) return OK; } +PUBLIC int32_t csoundModuleDestroy(CSOUND *csound) +{ + Images *pimages = (Images *) csound->QueryGlobalVariable(csound, + "imageOpcodes.images"); + if (pimages != NULL && pimages->images != NULL) { + size_t i; + for (i = 0; i < pimages->cnt; ++i) { + Image *img = pimages->images[i]; + if (img != NULL) { + csound->Free(csound, img->imageData); + csound->Free(csound, img); + } + } + csound->Free(csound, pimages->images); + pimages->images = (Image **) NULL; + pimages->cnt = (size_t) 0; + } + return OK; +} + static OENTRY localops[] = { { "imageload", sizeof(IMGLOAD), 0, "i", "S", (SUBR)imageload, NULL, NULL, NULL, 0 }, @@ -743,9 +761,9 @@ static OENTRY localops[] = { (SUBR)imagecreate, NULL, NULL, NULL, 0 }, { "imagesize", sizeof(IMGSIZE), 0, "ii", "i", (SUBR)imagesize, NULL, NULL, NULL, 0 }, - { "imagegetpixel", sizeof(IMGGETPIXEL), 0, "kkk", "ixx", + { "imagegetpixel", sizeof(IMGGETPIXEL), 0, "kkk", "ikk", (SUBR)imagegetpixel, (SUBR)imagegetpixel, NULL, NULL, 0 }, - { "imagegetpixel", sizeof(IMGGETPIXEL), 0, "aaa", "ixx", + { "imagegetpixel", sizeof(IMGGETPIXEL), 0, "aaa", "iaa", (SUBR)imagegetpixel, (SUBR)imagegetpixel_a, NULL, NULL, 0 }, { "imagesetpixel", sizeof(IMGSETPIXEL), 0, "", "ikkkkk", (SUBR)imagesetpixel, (SUBR)imagesetpixel, NULL, NULL, 0 }, From 8b0f8502005c6a1bef91c022406c56632526c905 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 09:27:34 +0100 Subject: [PATCH 32/72] Port wiimote opcodes to Csound 7 plugins Port the Csound 6.x wiimote opcodes (wiiconnect, wiidata, wiisend, wiirange) to the 7.x tree. The source is adapted to the Csound 7 API and types: MYFLT becomes cs_float, the OENTRY table uses the 7.x ten-field layout, and the plugin uses the LINKAGE macro. This is a CMake-only port: the wiiuse dependency is not available as a standard distribution package, so the plugin is not built by the CI nor included in the release packages. Where wiiuse is found, CMake builds and installs it; otherwise BUILD_WIIMOTE_OPCODES is silently disabled. --- 7.x/CMakeLists.txt | 1 + 7.x/README.md | 21 +- 7.x/src/wiimote/CMakeLists.txt | 12 + 7.x/src/wiimote/wii_mac.h | 58 +++++ 7.x/src/wiimote/wiimote.c | 430 +++++++++++++++++++++++++++++++++ 5 files changed, 521 insertions(+), 1 deletion(-) create mode 100644 7.x/src/wiimote/CMakeLists.txt create mode 100644 7.x/src/wiimote/wii_mac.h create mode 100644 7.x/src/wiimote/wiimote.c diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index e5b936a..7de35a0 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -309,3 +309,4 @@ add_subdirectory(./src/image) add_subdirectory(./src/websockets) add_subdirectory(./src/hdf5) add_subdirectory(./src/py) +add_subdirectory(./src/wiimote) diff --git a/7.x/README.md b/7.x/README.md index bc925a0..aa26475 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -24,6 +24,9 @@ Currently, the plugins available in this tree are - websockets (requires libwebsockets) **websocket** +- wiimote (requires the wiiuse library; CMake-only, see note below) +**wiiconnect wiidata wiisend wiirange** + Fluid settings opcodes --- @@ -44,6 +47,22 @@ The setters fail at init if the setting name is unknown or of the wrong type; the getters report a message and return 0 (or an empty string) instead. +Wiimote opcodes +--- + +The `wiimote` opcodes (`wiiconnect`, `wiidata`, `wiisend`, `wiirange`) are a +CMake-only port of the Csound 6.x plugin. They are **not** built by the CI and +are **not** included in the release packages, because the required `wiiuse` +library is not available as a standard distribution package: it is not in the +Ubuntu repositories, and the vcpkg `wiiuse` port ships only pkg-config +metadata, so it cannot be wired into the automated builds. + +When `wiiuse` (headers and library) is found by CMake, the plugin is built and +installed like any other; otherwise `BUILD_WIIMOTE_OPCODES` is silently +disabled. To build it locally, install `wiiuse` and configure with +`-DBUILD_WIIMOTE_OPCODES=ON`. + + Install location -------------- The CMake scripts in this repository use the default CS_USER_PLUGIN @@ -85,7 +104,7 @@ By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_FLUID_OPCODES`, `BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, -`BUILD_WEBSOCKET_OPCODE` and +`BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to exclude the chua plugin, the `cmake` command would be: diff --git a/7.x/src/wiimote/CMakeLists.txt b/7.x/src/wiimote/CMakeLists.txt new file mode 100644 index 0000000..4a9b138 --- /dev/null +++ b/7.x/src/wiimote/CMakeLists.txt @@ -0,0 +1,12 @@ +# Build the wiimote opcodes (requires the wiiuse library) +option(BUILD_WIIMOTE_OPCODES "Build the Wiimote opcodes" ON) + +find_path(WIIUSE_INCLUDE_DIR wiiuse.h /usr/local/include /usr/include) +find_library(WIIUSE_LIB wiiuse) +check_deps(BUILD_WIIMOTE_OPCODES WIIUSE_INCLUDE_DIR WIIUSE_LIB) + +if(BUILD_WIIMOTE_OPCODES) + make_plugin(wiimote wiimote.c ${WIIUSE_LIB}) + target_include_directories(wiimote PRIVATE ${WIIUSE_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(wiimote PRIVATE BUILD_PLUGINS) +endif() diff --git a/7.x/src/wiimote/wii_mac.h b/7.x/src/wiimote/wii_mac.h new file mode 100644 index 0000000..12e8963 --- /dev/null +++ b/7.x/src/wiimote/wii_mac.h @@ -0,0 +1,58 @@ +/* wii_mac.h: Names for WiiMote opcodes in Csound. + Copyright 2009 John ffitch + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + +#define WII_BUTTONS (0) +#define WII_TWO (1) +#define WII_ONE (2) +#define WII_B (3) +#define WII_A (4) +#define WII_MINUS (5) +#define WII_HOME (8) +#define WII_LEFT (9) +#define WII_RIGHT (10) +#define WII_DOWN (11) +#define WII_UP (12) +#define WII_PLUS (13) + +#define WII_AXIS_X (17) +#define WII_AXIS_Y (18) +#define WII_AXIS_Z (19) +#define WII_PITCH (20) +#define WII_ROLL (21) +#define WII_YAW (22) +#define WII_FORCE_X (23) +#define WII_FORCE_Y (24) +#define WII_FORCE_Z (25) +#define WII_FORCE_TOTAL (26) +#define WII_BATTERY (27) +#define WII_NUNCHUK_ANG (28) +#define WII_NUNCHUK_MAG (29) +#define WII_NUNCHUK_PITCH (30) +#define WII_NUNCHUK_ROLL (31) +#define WII_NUNCHUK_YAW (32) +#define WII_NUNCHUK_Z (33) +#define WII_NUNCHUK_C (34) +#define WII_IR1_X (35) +#define WII_IR1_Y (36) +#define WII_IR1_Z (37) + +#define WII_RUMBLE (3) +#define WII_SET_LEDS (4) diff --git a/7.x/src/wiimote/wiimote.c b/7.x/src/wiimote/wiimote.c new file mode 100644 index 0000000..7a1348f --- /dev/null +++ b/7.x/src/wiimote/wiimote.c @@ -0,0 +1,430 @@ +/* + wiimote.c: + + Copyright (C) 2009 by John ffitch, + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + + /* wiimote.c */ +#include + +#include "csdl.h" +#include "wiiuse.h" /* Uses WIIUSE library which is LGPL */ +#define MAX_WIIMOTES 4 +#include "wii_mac.h" + +typedef struct { + cs_float axis_x_min; /* 0 -> 255 */ + cs_float axis_x_scale; /* 1 */ + cs_float axis_y_min; + cs_float axis_y_scale; + cs_float axis_z_min; + cs_float axis_z_scale; + cs_float pitch_min; /* -90 -> +90 */ + cs_float pitch_scale; /* 1 */ + cs_float roll_min; + cs_float roll_scale; + /* cs_float tilt_z_min; */ + /* cs_float tilt_z_scale; */ + cs_float joy_min; + cs_float joy_scale; + cs_float nunchuk_pitch_min; + cs_float nunchuk_pitch_scale; + cs_float nunchuk_roll_min; + cs_float nunchuk_roll_scale; + /* cs_float naxis_z_min; */ + /* cs_float naxis_z_max; */ +} wiirange_t; + + +typedef struct { + OPDS h; + cs_float *res; + cs_float *kControl; + cs_float *num; + /* ------------------------------------- */ + wiimote **wii; + wiirange_t *wiir; + int32_t max_wiimotes; +} WIIMOTE; + +typedef struct { + OPDS h; + cs_float *kControl; + cs_float *kValue; + cs_float *num; + /* ------------------------------------- */ + wiimote **wii; + wiirange_t *wiir; +} WIIMOTES; + +typedef struct { + OPDS h; + cs_float *iControl; + cs_float *iMin; + cs_float *iMax; + cs_float *num; + } WIIRANGE; + +#ifndef WIIMOTE_STATE_CONNECTED +# if defined(WIIUSE_0_13) +# define WIIMOTE_STATE_CONNECTED (0x0010) +# else +# define WIIMOTE_STATE_CONNECTED (0x0008) +# endif +#endif + +int32_t wiimote_find(CSOUND *csound, WIIMOTE *p) +{ + int32_t n, i; + wiimote **wiimotes; + wiirange_t *wiirange; + int32_t max_wiimotes; + + wiimotes = (wiimote**)csound->QueryGlobalVariable(csound, "wiiMote"); + if (wiimotes == NULL) { + csound->CreateGlobalVariable(csound, "wiiMote", + MAX_WIIMOTES*sizeof(wiimote*)); + wiimotes = (wiimote**)csound->QueryGlobalVariable(csound, "wiiMote"); + } + wiirange = (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); + if (wiirange == NULL) { + csound->CreateGlobalVariable(csound, "wiiRange", + MAX_WIIMOTES*sizeof(wiirange_t)); + wiirange = (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); + } + { /* Use our copy not his */ + wiimote** ww = wiiuse_init(MAX_WIIMOTES); + memcpy(wiimotes, ww, MAX_WIIMOTES*sizeof(wiimote*)); + free(ww); + } + i = (int32_t)*p->kControl; + if (i<=0) i = 10; /* default timeout */ + max_wiimotes = (int32_t)*p->num; + if (max_wiimotes<=0 || max_wiimotes>MAX_WIIMOTES) max_wiimotes = MAX_WIIMOTES; + n = wiiuse_find(wiimotes, max_wiimotes, i); + if (LIKELY(n!=0)) n = wiiuse_connect(wiimotes, max_wiimotes); + if (UNLIKELY(n==0)) { + return csound->InitError(csound, "%s", Str("unable to open wiimote\n")); + } + /* Initialise ranges */ + for (i=0; iwii = wiimotes; + p->max_wiimotes = n; + *p->res = FL(1.0); + return OK; +} + +int32_t wiimote_poll(CSOUND *csound, WIIMOTE *p) +{ + wiimote **wiimotes = p->wii; + int32_t i; + int32_t max_wiimotes = p->max_wiimotes; + + wiiuse_poll(wiimotes, max_wiimotes); + for (i=0; i < max_wiimotes; ++i) { + switch (wiimotes[i]->event) { + case WIIUSE_EVENT: + case WIIUSE_STATUS: + case WIIUSE_READ_DATA: + break; + case WIIUSE_DISCONNECT: + case WIIUSE_UNEXPECTED_DISCONNECT: + /* the wiimote disconnected */ + csound->Warning(csound, + Str("wiimote %i disconnected\n"), wiimotes[i]->unid); + *p->res = FL(0.0); + return OK; + case WIIUSE_NUNCHUK_INSERTED: + /* + * This is a good place to set any nunchuk specific + * threshold values. By default they are the same + * as the wiimote. + */ + /* wiiuse_set_nunchuk_orient_threshold((struct nunchuk_t*)&wiimotes[i]-> */ + /* exp.nunchuk, 90.0f); */ + /* wiiuse_set_nunchuk_accel_threshold((struct nunchuk_t*)&wiimotes[i]-> */ + /* exp.nunchuk, 100); */ + csound->Warning(csound, "%s", Str("Nunchuk inserted.\n")); + break; + case WIIUSE_NUNCHUK_REMOVED: + /* some expansion was removed */ + csound->Warning(csound, Str("Nunchuk for wiimote %i was removed.\n"), i); + break; + default: + break; + } + } + *p->res = FL(1.0); + return OK; +} + + +int32_t wii_data_init(CSOUND *csound, WIIMOTE *p) +{ + wiimote **wiimotes; + wiirange_t *wiirange; + wiimotes = (wiimote**)csound->QueryGlobalVariable(csound, "wiiMote"); + if (UNLIKELY(wiimotes==NULL)) + return csound->InitError(csound, "%s", Str("No wii open")); + wiirange = (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); + if (UNLIKELY(wiirange==NULL)) + return csound->InitError(csound, "%s", Str("No wii open")); + p->wii = wiimotes; + p->wiir = wiirange; + return OK; +} + +int32_t wii_data(CSOUND *csound, WIIMOTE *p) +{ + wiimote **wii = p->wii; + wiirange_t *wiir = p->wiir; + int32_t n = (int32_t)*p->num; + int32_t kontrol = (int32_t)(*p->kControl+FL(0.5)); + if (UNLIKELY(n>=MAX_WIIMOTES || !(wii[n]->state & WIIMOTE_STATE_CONNECTED))) { + printf("state of wii %d is %x\n", n, wii[n]->state); + return csound->PerfError(csound, &(p->h), + Str("wiimote %d does not exist"), n); + } + if (kontrol<0) { + printf("%f -- %.4x: " + "tilt=[%f %f];\nforce=(%f %f %f)\n", + 100.0*wii[n]->battery_level, wii[n]->btns, + wiir[n].pitch_min+wiir[n].pitch_scale*(FL(90.0)+ + (cs_float)wii[n]->orient.pitch), + wiir[n].roll_min+wiir[n].roll_scale*(FL(90.0)- + (cs_float)wii[n]->orient.roll), + wii[n]->gforce.x, wii[n]->gforce.y, wii[n]->gforce.z); + *p->res = FL(0.0); + return OK; + } + if (kontrol>0 && kontrol<17) { + *p->res = (cs_float)IS_JUST_PRESSED(wii[n], 1<<(kontrol-1)); + } + if (kontrol>100 && kontrol<117) { + *p->res = (cs_float)IS_PRESSED(wii[n], 1<<(kontrol-101)); + return OK; + } + if (kontrol>200 && kontrol<217) { + *p->res = (cs_float)IS_HELD(wii[n], 1<<(kontrol-201)); + return OK; + } + if (kontrol>300 && kontrol<317) { + *p->res = (cs_float)IS_RELEASED(wii[n], 1<<(kontrol-301)); + return OK; + } + else switch (kontrol) { + case WII_BUTTONS: + *p->res = (cs_float)(wii[n]->btns&WIIMOTE_BUTTON_ALL); + return OK; + /* case 17: */ + /* *p->res = wiir[n].axis_x_min+wiir[n].axis_x_scale*(cs_float)wii[n]->axis.x; */ + /* return OK; */ + /* case 18: */ + /* *p->res = wiir[n].axis_y_min+wiir[n].axis_y_scale*(cs_float)wii[n]->axis.y; */ + /* return OK; */ + /* case 19: */ + /* *p->res = wiir[n].axis_z_min+wiir[n].axis_z_scale*(cs_float)wii[n]->axis.z; */ + /* return OK; */ + case WII_PITCH: + /* I think the sign is wrong so negated; inplies negative is down */ + *p->res = wiir[n].pitch_min+ + wiir[n].pitch_scale*(FL(90.0)-(cs_float)wii[n]->orient.pitch); + return OK; + case WII_ROLL: + *p->res = wiir[n].roll_min+ + wiir[n].roll_scale*(FL(90.0)+(cs_float)wii[n]->orient.roll); + return OK; + /* case 22: */ + /* *p->res = wiir[n].tilt_z_min+ + wiir[n].tilt_z_scale*(FL(90.0)-(cs_float)wii[n]->tilt.z); */ + /* return OK; */ + case WII_FORCE_X: + *p->res = (cs_float)wii[n]->gforce.x; + return OK; + case WII_FORCE_Y: + *p->res = (cs_float)wii[n]->gforce.y; + return OK; + case WII_FORCE_Z: + *p->res = (cs_float)wii[n]->gforce.z; + return OK; + case WII_FORCE_TOTAL: + *p->res = SQRT(wii[n]->gforce.x*wii[n]->gforce.x+ + wii[n]->gforce.y*wii[n]->gforce.y+ + wii[n]->gforce.z*wii[n]->gforce.z); + return OK; + case WII_BATTERY: + *p->res = FL(100.0)*(cs_float)wii[n]->battery_level; + return OK; + case WII_NUNCHUK_ANG: + *p->res = (cs_float)wii[n]->exp.nunchuk.js.ang; + return OK; + case WII_NUNCHUK_MAG: + *p->res = (cs_float)wii[n]->exp.nunchuk.js.mag; + return OK; + case WII_NUNCHUK_PITCH: + *p->res = wiir[n].nunchuk_pitch_min+ + wiir[n].nunchuk_pitch_scale*(FL(90.0)- + (cs_float)wii[n]->exp.nunchuk.orient.pitch); + return OK; + case WII_NUNCHUK_ROLL: + *p->res = wiir[n].nunchuk_roll_min+ + wiir[n].nunchuk_roll_scale*(FL(90.0)- + (cs_float)wii[n]->exp.nunchuk.orient.roll); + return OK; + /* case 32: */ + /* *p->res = (cs_float)wii[n]->exp.nunchuk.axis.z; */ + /* return OK; */ + case WII_NUNCHUK_Z: + *p->res = (cs_float)((wii[n]->exp.nunchuk.btns & NUNCHUK_BUTTON_Z)== + NUNCHUK_BUTTON_Z); + return OK; + case WII_NUNCHUK_C: + *p->res = (cs_float)((wii[n]->exp.nunchuk.btns & NUNCHUK_BUTTON_C)== + NUNCHUK_BUTTON_C); + return OK; + case WII_IR1_X: + *p->res = (cs_float)wii[n]->ir.x; + return OK; + case WII_IR1_Y: + *p->res = (cs_float)wii[n]->ir.y; + return OK; + case WII_IR1_Z: + *p->res = (cs_float)wii[n]->ir.z; + return OK; + } + return NOTOK; +} + +int32_t wii_data_inits(CSOUND *csound, WIIMOTES *p) +{ + wiimote **wiimotes; + wiirange_t *wiirange; + wiimotes = (wiimote**)csound->QueryGlobalVariable(csound, "wiiMote"); + if (UNLIKELY(wiimotes==NULL)) + return csound->InitError(csound, "%s", Str("No wii open")); + wiirange = (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); + if (UNLIKELY(wiirange==NULL)) + return csound->InitError(csound, "%s", Str("No wii open")); + p->wii = wiimotes; + p->wiir = wiirange; + return OK; +} + +int32_t wii_send(CSOUND *csound, WIIMOTES *p) +{ + wiimote **wii = p->wii; + int32_t num = (int32_t)*p->num; + if (UNLIKELY(!(wii[num]->state & WIIMOTE_STATE_CONNECTED))) + return csound->PerfError(csound, &(p->h), "%s", Str("Not open")); + switch ((int32_t)(*p->kControl+FL(0.5))) { + /* case 1: */ + /* wii->mode.acc = (int32_t)*p->kValue; */ + /* break; */ + /* case 2: */ + /* wii->mode.ir = (int32_t)*p->kValue; */ + /* break; */ + case WII_RUMBLE: + wiiuse_rumble(wii[num], (int32_t)*p->kValue); + break; + case WII_SET_LEDS: + wiiuse_set_leds(wii[num], ((uint16)*p->kValue)<<4); + break; + } + return OK; +} + +int32_t wiimote_range(CSOUND *csound, WIIRANGE *p) +{ + wiirange_t *wiirange = + (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); + if (UNLIKELY(wiirange==NULL)) + return csound->InitError(csound, "%s", Str("No wii range")); + switch ((int32_t)(*p->iControl+FL(0.5))) { + /* case 17: */ + /* wiirange->axis_x_min = *p->iMin; */ + /* wiirange->axis_x_scale = (*p->iMax-*p->iMin)/FL(255.0); */ + /* return OK; */ + /* case 18: */ + /* wiirange->axis_y_min = *p->iMin; */ + /* wiirange->axis_y_scale = (*p->iMax-*p->iMin)/FL(255.0); */ + /* return OK; */ + /* case 19: */ + /* wiirange->axis_z_min = *p->iMin; */ + /* wiirange->axis_z_scale = (*p->iMax-*p->iMin)/FL(255.0); */ + /* return OK; */ + case WII_PITCH: + wiirange->pitch_min = *p->iMin; + wiirange->pitch_scale = (*p->iMax-*p->iMin)/FL(180.0); + return OK; + case WII_ROLL: + wiirange->roll_min = *p->iMin; + wiirange->roll_scale = (*p->iMax-*p->iMin)/FL(180.0); + return OK; + /* case 22: */ + /* wiirange->tilt_z_min = *p->iMin; */ + /* wiirange->tilt_z_scale = (*p->iMax-*p->iMin)/FL(180.0); */ + /* return OK; */ + case WII_NUNCHUK_PITCH: + wiirange->nunchuk_pitch_min = *p->iMin; + wiirange->nunchuk_pitch_scale = (*p->iMax-*p->iMin)/FL(180.0); + return OK; + case WII_NUNCHUK_ROLL: + wiirange->nunchuk_roll_min = *p->iMin; + wiirange->nunchuk_roll_scale = (*p->iMax-*p->iMin)/FL(180.0); + return OK; + default: + return NOTOK; + } +} + + + +#define S(x) sizeof(x) + +static OENTRY localops[] = { + {"wiiconnect", S(WIIMOTE), 0, "i", "oo", (SUBR)wiimote_find, + (SUBR)wiimote_poll, NULL, NULL, 0 }, + {"wiidata", S(WIIMOTE), 0, "k", "ko", (SUBR)wii_data_init, + (SUBR)wii_data, NULL, NULL, 0 }, + {"wiisend", S(WIIMOTES), 0, "", "kko", (SUBR)wii_data_inits, + (SUBR)wii_send, NULL, NULL, 0 }, + {"wiirange", S(WIIRANGE), 0, "", "iiio", (SUBR)wiimote_range, + NULL, NULL, NULL, 0 } +}; + +LINKAGE From 41dcf22e14d69d4264a9d0589c931baf710c745c Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 09:39:33 +0100 Subject: [PATCH 33/72] Address wiimote review: bounds checks, poll state, button return - Validate num before indexing the wiimote array in wii_data, wii_send and wiirange (reject negative and out-of-range indices, guard NULL). - Make wiirange index the requested remote instead of always slot 0. - Keep wiiconnect's result at 0 while a remote is disconnected. - Return OK from the just-pressed button branch so it does not fall through to the switch and report NOTOK. - Check the global-variable and wiiuse_init allocations in wiimote_find. - Drop the per-call debug printf in the wii_data guard. --- 7.x/src/wiimote/wiimote.c | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/7.x/src/wiimote/wiimote.c b/7.x/src/wiimote/wiimote.c index 7a1348f..df2ac5e 100644 --- a/7.x/src/wiimote/wiimote.c +++ b/7.x/src/wiimote/wiimote.c @@ -102,15 +102,24 @@ int32_t wiimote_find(CSOUND *csound, WIIMOTE *p) csound->CreateGlobalVariable(csound, "wiiMote", MAX_WIIMOTES*sizeof(wiimote*)); wiimotes = (wiimote**)csound->QueryGlobalVariable(csound, "wiiMote"); + if (UNLIKELY(wiimotes == NULL)) + return csound->InitError(csound, "%s", + Str("wiiconnect: cannot allocate wiimote state")); } wiirange = (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); if (wiirange == NULL) { csound->CreateGlobalVariable(csound, "wiiRange", MAX_WIIMOTES*sizeof(wiirange_t)); wiirange = (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); + if (UNLIKELY(wiirange == NULL)) + return csound->InitError(csound, "%s", + Str("wiiconnect: cannot allocate wii range state")); } { /* Use our copy not his */ wiimote** ww = wiiuse_init(MAX_WIIMOTES); + if (UNLIKELY(ww == NULL)) + return csound->InitError(csound, "%s", + Str("wiiconnect: cannot initialise wiimotes")); memcpy(wiimotes, ww, MAX_WIIMOTES*sizeof(wiimote*)); free(ww); } @@ -188,6 +197,10 @@ int32_t wiimote_poll(CSOUND *csound, WIIMOTE *p) default: break; } + if (UNLIKELY(!(wiimotes[i]->state & WIIMOTE_STATE_CONNECTED))) { + *p->res = FL(0.0); + return OK; + } } *p->res = FL(1.0); return OK; @@ -215,8 +228,8 @@ int32_t wii_data(CSOUND *csound, WIIMOTE *p) wiirange_t *wiir = p->wiir; int32_t n = (int32_t)*p->num; int32_t kontrol = (int32_t)(*p->kControl+FL(0.5)); - if (UNLIKELY(n>=MAX_WIIMOTES || !(wii[n]->state & WIIMOTE_STATE_CONNECTED))) { - printf("state of wii %d is %x\n", n, wii[n]->state); + if (UNLIKELY(n<0 || n>=MAX_WIIMOTES || wii[n]==NULL || + !(wii[n]->state & WIIMOTE_STATE_CONNECTED))) { return csound->PerfError(csound, &(p->h), Str("wiimote %d does not exist"), n); } @@ -234,6 +247,7 @@ int32_t wii_data(CSOUND *csound, WIIMOTE *p) } if (kontrol>0 && kontrol<17) { *p->res = (cs_float)IS_JUST_PRESSED(wii[n], 1<<(kontrol-1)); + return OK; } if (kontrol>100 && kontrol<117) { *p->res = (cs_float)IS_PRESSED(wii[n], 1<<(kontrol-101)); @@ -349,7 +363,8 @@ int32_t wii_send(CSOUND *csound, WIIMOTES *p) { wiimote **wii = p->wii; int32_t num = (int32_t)*p->num; - if (UNLIKELY(!(wii[num]->state & WIIMOTE_STATE_CONNECTED))) + if (UNLIKELY(num < 0 || num >= MAX_WIIMOTES || wii[num]==NULL || + !(wii[num]->state & WIIMOTE_STATE_CONNECTED))) return csound->PerfError(csound, &(p->h), "%s", Str("Not open")); switch ((int32_t)(*p->kControl+FL(0.5))) { /* case 1: */ @@ -370,10 +385,15 @@ int32_t wii_send(CSOUND *csound, WIIMOTES *p) int32_t wiimote_range(CSOUND *csound, WIIRANGE *p) { - wiirange_t *wiirange = + int32_t n = (int32_t)*p->num; + wiirange_t *wiiranges = (wiirange_t *)csound->QueryGlobalVariable(csound, "wiiRange"); - if (UNLIKELY(wiirange==NULL)) + wiirange_t *wiirange; + if (UNLIKELY(wiiranges==NULL)) return csound->InitError(csound, "%s", Str("No wii range")); + if (UNLIKELY(n<0 || n>=MAX_WIIMOTES)) + return csound->InitError(csound, Str("wiirange: invalid wiimote %d"), n); + wiirange = &wiiranges[n]; switch ((int32_t)(*p->iControl+FL(0.5))) { /* case 17: */ /* wiirange->axis_x_min = *p->iMin; */ From 81e853f88cca3a56bf388b548b2977a8fdd3492d Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 10:10:13 +0100 Subject: [PATCH 34/72] Port p5glove opcodes to Csound 7 plugins Port p5gconnect and p5gdata from the Csound 6.x tree, updating them to the Csound 7 plugin API: cs_float samples, the 10-field OENTRY, the LINKAGE macro, and the OENTRY deinit slot in place of the removed RegisterDeinitCallback. The reader thread is stopped by clearing the glove handle and joining it, since pthread_cancel is not used. The vendored libp5glove sources (used by the macOS build) are carried over from 6.x. The opcode file now validates the global-variable and thread allocations, uses a bitwise complement for the just-pressed/ released masks, and returns from the missing-glove error path. The plugin is not available as a distribution package (there is no vcpkg port), so it is disabled in the CI/release builds: it is built only when an external libp5glove is found, or on macOS with P5GLOVE_USE_BUNDLED=ON. --- 7.x/CMakeLists.txt | 1 + 7.x/README.md | 22 +- 7.x/src/p5glove/CMakeLists.txt | 30 + 7.x/src/p5glove/libp5glove/macosx_usb_hid.h | 54 ++ 7.x/src/p5glove/libp5glove/p5glove.c | 690 ++++++++++++++++++++ 7.x/src/p5glove/libp5glove/p5glove.h | 226 +++++++ 7.x/src/p5glove/libp5glove/usb_hid.h | 77 +++ 7.x/src/p5glove/libp5glove/usb_hid_libusb.c | 162 +++++ 7.x/src/p5glove/libp5glove/usb_hid_macosx.c | 365 +++++++++++ 7.x/src/p5glove/libp5glove/usb_hid_win32.c | 346 ++++++++++ 7.x/src/p5glove/p5glove.c | 260 ++++++++ 11 files changed, 2232 insertions(+), 1 deletion(-) create mode 100644 7.x/src/p5glove/CMakeLists.txt create mode 100644 7.x/src/p5glove/libp5glove/macosx_usb_hid.h create mode 100644 7.x/src/p5glove/libp5glove/p5glove.c create mode 100644 7.x/src/p5glove/libp5glove/p5glove.h create mode 100644 7.x/src/p5glove/libp5glove/usb_hid.h create mode 100644 7.x/src/p5glove/libp5glove/usb_hid_libusb.c create mode 100644 7.x/src/p5glove/libp5glove/usb_hid_macosx.c create mode 100644 7.x/src/p5glove/libp5glove/usb_hid_win32.c create mode 100644 7.x/src/p5glove/p5glove.c diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 7de35a0..a492bea 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -310,3 +310,4 @@ add_subdirectory(./src/websockets) add_subdirectory(./src/hdf5) add_subdirectory(./src/py) add_subdirectory(./src/wiimote) +add_subdirectory(./src/p5glove) diff --git a/7.x/README.md b/7.x/README.md index aa26475..4c8b015 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -27,6 +27,9 @@ Currently, the plugins available in this tree are - wiimote (requires the wiiuse library; CMake-only, see note below) **wiiconnect wiidata wiisend wiirange** +- p5glove (requires the p5glove driver; CMake-only, see note below) +**p5gconnect p5gdata** + Fluid settings opcodes --- @@ -63,6 +66,23 @@ disabled. To build it locally, install `wiiuse` and configure with `-DBUILD_WIIMOTE_OPCODES=ON`. +P5Glove opcodes +--- + +The `p5glove` opcodes (`p5gconnect`, `p5gdata`) are a CMake-only port of the +Csound 6.x plugin. They are **not** built by the CI and are **not** included in +the release packages, because the required P5Glove driver is not widely +packaged: there is no vcpkg port for `libp5glove`, and its Linux backend needs +the legacy libusb-0.1 API (not present in vcpkg). + +When an external `libp5glove` (headers and library) is found by CMake, the +plugin is built and installed like any other; otherwise +`BUILD_P5GLOVE_OPCODES` is silently disabled. On macOS the driver can +additionally be built from the sources bundled under `src/p5glove/libp5glove` +by configuring with `-DP5GLOVE_USE_BUNDLED=ON` (in addition to +`-DBUILD_P5GLOVE_OPCODES=ON`). + + Install location -------------- The CMake scripts in this repository use the default CS_USER_PLUGIN @@ -104,7 +124,7 @@ By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_FLUID_OPCODES`, `BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, -`BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and +`BUILD_P5GLOVE_OPCODES`, `BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to exclude the chua plugin, the `cmake` command would be: diff --git a/7.x/src/p5glove/CMakeLists.txt b/7.x/src/p5glove/CMakeLists.txt new file mode 100644 index 0000000..591a72b --- /dev/null +++ b/7.x/src/p5glove/CMakeLists.txt @@ -0,0 +1,30 @@ +# Build the P5Glove opcodes. +# +# The P5Glove driver is not available as a standard distribution package, and +# the vcpkg registry has neither libp5glove nor the libusb-0.1 compatibility +# layer its Linux backend needs, so this plugin is disabled in the automated +# CI/release builds (see the README for details). +# +# On macOS the driver can additionally be built from the bundled sources under +# ./libp5glove by setting P5GLOVE_USE_BUNDLED=ON. +option(BUILD_P5GLOVE_OPCODES "Build the P5Glove opcodes" ON) +option(P5GLOVE_USE_BUNDLED "Build p5glove from the bundled libp5glove sources (macOS)" OFF) + +if(APPLE AND P5GLOVE_USE_BUNDLED) + if(BUILD_P5GLOVE_OPCODES) + make_plugin(p5g "p5glove.c;libp5glove/p5glove.c;libp5glove/usb_hid_macosx.c") + target_link_libraries(p5g PRIVATE "-framework IOKit" "-framework CoreFoundation") + target_include_directories(p5g PRIVATE ./libp5glove ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(p5g PRIVATE BUILD_PLUGINS) + endif() +else() + find_path(P5GLOVE_INCLUDE_DIR p5glove.h /usr/local/include /usr/include) + find_library(P5GLOVE_LIB p5glove) + check_deps(BUILD_P5GLOVE_OPCODES P5GLOVE_INCLUDE_DIR P5GLOVE_LIB) + + if(BUILD_P5GLOVE_OPCODES) + make_plugin(p5g p5glove.c ${P5GLOVE_LIB}) + target_include_directories(p5g PRIVATE ${P5GLOVE_INCLUDE_DIR} ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(p5g PRIVATE BUILD_PLUGINS) + endif() +endif() diff --git a/7.x/src/p5glove/libp5glove/macosx_usb_hid.h b/7.x/src/p5glove/libp5glove/macosx_usb_hid.h new file mode 100644 index 0000000..10abb24 --- /dev/null +++ b/7.x/src/p5glove/libp5glove/macosx_usb_hid.h @@ -0,0 +1,54 @@ +/* + Copyright (c) 2004 Tim Kreger + + Macintosh OS X USB HID I/O routines + + Created by Tim Kreger on Wed Mar 17 2004. +*/ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef INCLUDED_WIN32_USB_HID_H +#define INCLUDED_WIN32_USB_HID_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + these calls are roughly equivalent to those defined in win32_usb_hid.h +*/ + +typedef void* USBHIDHandle; + +#define INVALID_USBHIDHANDLE_VALUE (0) + + +USBHIDHandle OpenUSBHID( int index, int idVendor, int idProduct, int versionNumber, int flags ); + + +void CloseUSBHID( USBHIDHandle usbHidHandle ); + + +int ReadUSBHID( USBHIDHandle usbHidHandle, void *data, int count ); + + +#ifdef __cplusplus +} +#endif + +#endif /* INCLUDED_WIN32_USB_HID_H */ \ No newline at end of file diff --git a/7.x/src/p5glove/libp5glove/p5glove.c b/7.x/src/p5glove/libp5glove/p5glove.c new file mode 100644 index 0000000..5abc311 --- /dev/null +++ b/7.x/src/p5glove/libp5glove/p5glove.c @@ -0,0 +1,690 @@ +/* + * $Id$ + * + * Copyright (c) 2003 Jason McMullan + * Windows patch (c) 2004 Ross Bencina + * MacOSX patch (c) 2004 Tim Kreger + * + * USB P5 Data Glove support + */ + +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include /* for calloc */ +#include +#include /* for memcpy */ +#include + +#include "usb_hid.h" +#include +#include "p5glove.h" + +#define DEBUG +#ifdef DEBUG +#define DPRINTF(fmt,args...) fprintf(stderr,"p5: " fmt , ##args ) +#else +#define DPRINTF(fmt,args...) do { } while (0) +#endif + +struct p5glove { + USBHID usb; + + char name[128]; + + /* Calibration data from Report 12 & 6 */ + struct p5glove_cal { + int id; /* Device id */ + struct { + double v; /* in Radians */ + double h; /* in Radians */ + } head[2]; + double head_dist; /* in Meters */ + double led[10][3]; + } cal; + + struct p5glove_data { + struct timeval sampled; /* Time sampled at */ + uint32_t valid; /* Which data items are valid (mask) */ + + int buttons; /* Button bitmask */ + int finger[5]; /* Finger clench values (0-63) */ + + /* Raw glove data */ + struct p5glove_ir { + int visible; /* Was the sensor visible? */ + int v1,v2,h; + } ir[8]; /* IR Sensors values. (-511 - 511) */ + + /* Computed from p5g_process_sample + */ + double position[3]; /* Position */ + + /* Rotation information */ + struct { + double axis[3]; /* Rotation axis (normalized) */ + double angle; /* In degrees */ + } rotation; + } data,prev; +}; + +static uint32_t get_bits(uint8_t *data,int pos,int len) +{ + int index = (pos>>3); + uint32_t value = 0; + + pos &= 0x7; + if (pos != 0) { + value |= (data[index] & (0xff >> pos)) << (len-(8-pos)); + len -= (8-pos); + index++; + } + + for (; len >= 8; len-=8) { + value |= data[index] << (len-8); + index++; + } + + if (len > 0) + value |= (data[index] & (0xff << (8-len))) >> (8-len); + + return value; +} + +static int32_t get_bits_signed(uint8_t *data,int pos,int len) +{ + uint32_t value,mask=0; + + value = get_bits(data,pos,len); + if (value & (1 << (len-1))) + mask = 0xffffffff << (len - 32); + return value | mask; +} + +static void p5g_unpack_sample(struct p5glove *p5, uint8_t data[24]) +{ + unsigned char tmp[24]; + int visible=1; + int i; + + /* Decode data. + * Format (nibbles from LSB to MSB) + * 11111111111111112222222222222222 + * 0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF + * 01ddddddddBCCCCVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVxxx + * 0 1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 + * 1 1 1 1 1 1 1 1 + * (bytes from LSB to MSB) + * + * d - Packed 6-bit bend sensor data (Index, Middle, Ring, Pinky, Thumb) + * B - Button data. A=1, B=2, C=4 + * C - IR sensor report index + * V - Packed 30 bit signed IR info (10 bits X, 10 bits Y, 10 bits Z), x4 + */ + + if (data[0] != 1) { +printf("Odd. Sample [0]=%d\n",data[0]); + return; + } + + for (i=0; i < 5; i++) { + int value; + + switch (i) { + case 0: value = data[1] >> 2; break; + case 1: value = ((data[1] & 0x3) << 4) | (data[2] >> 4); break; + case 2: value = ((data[2] & 0xF) << 2) | (data[3] >> 6); break; + case 3: value = (data[3] & 0x3F); break; + case 4: value = data[4] >> 2; break; + default: value = 0; break; + } + + p5->data.finger[i]=get_bits(data,8+6*i,6); + } + + p5->data.buttons=get_bits(data,40,4); + + /* Clear visibility */ + for (i=0 ; i <8; i++) + p5->data.ir[i].visible=0; + + for (i=0; i < 4; i++) { + int axis; + int value; + + axis = get_bits(data,44+4*i,4); + if (axis & 0x8) + continue; + + p5->data.ir[axis].v2=get_bits_signed(data,60+(i*30),10); + p5->data.ir[axis].v1=get_bits_signed(data,60+(i*30)+10,10); + p5->data.ir[axis].h=get_bits_signed(data,60+(i*30)+20,10); + p5->data.ir[axis].visible=visible++; + } +} + +void p5g_process_led(P5Glove p5,int led,double pos[3]) +{ + double v1,v2,h,d,zprime; + + v1 = atan(p5->data.ir[led].v1/512.0)+p5->cal.head[0].v; + v2 = atan(p5->data.ir[led].v2/512.0)+p5->cal.head[1].v; + h = atan(p5->data.ir[led].h/512.0); + d = p5->cal.head_dist; + + zprime = d/(tan(v1)-tan(v2)); + + pos[0]=-sin(h)*zprime; + pos[1]=tan(v1)*zprime-d/2.0; /* Places 0 in the center */ + pos[2]=cos(h)*zprime-d*2.0; /* A reasonable Z center */ +} + +int p5glove_reference_led(P5Glove p5, int led, double pos[3]) +{ + if (led < 0 || led > 7) + return -EINVAL; + + memcpy(pos,p5->cal.led[led],sizeof(double)*3); + return 0; +} + +#ifdef CHECK_ACUTE_TRIANGLES +static int p5glove_check_triangle(P5Glove p5,int led1,int led2,int led3) +{ + double c; + int led[3]; + int i; + + led[0]=led1; + led[1]=led2; + led[2]=led3; + + for (i=0; i < 3; i++) { + c=p5glove_angle(p5->cal.led[led[i]], + p5->cal.led[led[(i+1)%3]], + p5->cal.led[led[(i+2)%3]])*180.0/M_PI; + + /* At too acute/obtune an angle? */ + DPRINTF("Angle %d-%d-%d is %.4lf\n",led[i],led[(i+1)%3],led[(i+2)%3],c); + if (c < 7.0) + return -EINVAL; + } + + return 0; +} +#endif + +/* Determine the 'best' leds to use form the data. + * Return the # of good leds + */ +static int p5g_best_leds(P5Glove p5,int led[4],double pos[4][3]) +{ + int leds; + int i,j; + int error[4]={0,0,0,0}; + + for (i=0; i < 4; i++) + led[i]=-1; + + /* Get the position from the 'best led' */ + for (i = 0 ; i < 8; i++) + if (p5->data.ir[i].visible) + led[p5->data.ir[i].visible-1]=i; + + /* Hmm. No 'best' led. + */ + if (led[0] < 0) + return -ENOENT; + p5g_process_led(p5,led[0],pos[0]); + + if (led[1] < 0) + return 1; + p5g_process_led(p5,led[1],pos[1]); + + if (led[2] < 0) + return 2; + + p5g_process_led(p5,led[2],pos[2]); + + /* If we have more than 2, we need to verify the data */ + if (led[3] < 0) + leds=3; + else { + p5g_process_led(p5,led[3],pos[3]); + leds=4; + } + + /* For each led-led pair, determine the error % versus the + * reference distances + */ + DPRINTF("Distances: %d - %d - %d - %d\n",led[0],led[1],led[2],led[3]); + for (i=0; i < leds; i++) { + for (j=i+1 ;j < leds; j++) { + double ref_dist = p5glove_dist(p5->cal.led[led[i]],p5->cal.led[led[j]]); + double dist = p5glove_dist(pos[i],pos[j]); + double err = fabs(dist-ref_dist)/ref_dist; + + DPRINTF("%d - %d: %.4lf ",led[i],led[j],ref_dist); + DPRINTF("(%.4lf) [%.4lf]\n",led[i],led[j],dist,err); + + /* Max 9% error margin on distance */ + if (err > 0.20) { + error[i]++; + error[j]++; + } + } + } + + /* Mark as dead anything with an error index of leds-1 */ + j=leds-1; + for (i=0; i < leds; i++) { + if (error[i] != j) + continue; + + DPRINTF("Dead: Led %d\n",led[i]); + leds--; + if (i != leds) { + memcpy(&error[i],&error[i+1],sizeof(int)*(leds-i)); + memcpy(&led[i],&led[i+1],sizeof(double)*(leds-i)); + memcpy(pos[i],pos[i+1],sizeof(double)*3*(leds-i)); + } + i--; + if (leds == 1) + return leds; + } + +#ifdef CHECK_ACUTE_TRIANGLES + /* Not enough left for rotation. Darn. */ + if (leds < 3) + return leds; + + /* Check all triangles for obtusity */ + if (leds == 3) { + int err; + err=p5glove_check_triangle(p5,led[0],led[1],led[2]); + if (err < 0) + return 1; + return 3; + } + + /* Leds == 4 */ + for (i=0; i < leds; i++) + error[i]=0; + + for (i=0; i < leds; i++) { + int err; + int l[3]; + + err = p5glove_check_triangle(p5,led[i],led[(i+1)%4],led[(i+2)%4]); + if (err < 0) { + error[i]++; + error[(i+1)%4]++; + error[(i+2)%4]++; + } + } + + for (i=0; i < leds; i++) + DPRINTF("%d: error=%d\n",led[i],error[i]); + + + /* Mark as dead anything with an error index of leds-1 */ + j=leds-1; + for (i=0; i < leds; i++) { + if (error[i] != j) + continue; + + DPRINTF("Dead: Led %d\n",led[i]); + leds--; + if (i != leds) { + memcpy(&error[i],&error[i+1],sizeof(int)*(leds-i)); + memcpy(&led[i],&led[i+1],sizeof(double)*(leds-i)); + memcpy(pos[i],pos[i+1],sizeof(double)*3*(leds-i)); + } + i--; + if (leds == 1) + return leds; + } +#endif /* CHECK_ACUTE_TRIANGES */ + + return leds; +} + +/* Calculate delta, then store in 'prev' + */ +static int p5g_delta(P5Glove p5,int have_pos, int have_rot) +{ + int mask=0; + int i; + + if (p5->prev.buttons != p5->data.buttons) + mask |= P5GLOVE_DELTA_BUTTONS; + + for (i=0; i < 5; i++) + if (p5->prev.finger[i] != p5->data.finger[i]) { + mask |= P5GLOVE_DELTA_FINGERS; + break; + } + + if (have_pos && (! memcmp(p5->data.position,p5->prev.position,sizeof(double)*3))) + have_pos=0; + + if (have_rot && (! memcmp(&p5->data.rotation,&p5->prev.rotation,sizeof(p5->data.rotation)))) + have_rot=0; + + memcpy(&p5->prev,&p5->data,sizeof(p5->data)); + return mask | + (have_pos ? P5GLOVE_DELTA_POSITION : 0) | + (have_rot ? P5GLOVE_DELTA_ROTATION : 0); +} + + +static int p5g_process_sample(P5Glove p5) +{ + int i,j,leds; + int led[4] = {-1,-1,-1,-1}; + double pos[4][3]; + double pos_plane[3],ref_plane[3]; + double rot_matrix[4][4]; + double c,s,t; + double x,y,z; + const double zero[3]={0.0,0.0,0.0}; + const double y_up[3]={0.0,1.0,0.0}; + + /* Get the best leds from the data */ + leds=p5g_best_leds(p5,led,pos); + if (leds < 1) + return p5g_delta(p5,0,0); + + p5g_process_led(p5,led[0],pos[0]); + + /* Less than 3 leds. Can't calculate rotation info. + */ + if (leds < 3) + return p5g_delta(p5,1,0); + + /* Calculate reference normal of the leds */ + p5glove_plane(p5->cal.led[led[0]], + p5->cal.led[led[1]], + p5->cal.led[led[2]],ref_plane); + + /* Calculate actual normal of the leds */ + p5glove_plane(pos[0],pos[1],pos[2],pos_plane); + + /* Calculate cos(theta) from the dot product of the ref and actual */ + c=p5glove_dot(ref_plane,pos_plane); + p5->data.rotation.angle=acos(c)*180.0/M_PI; + /* Calculate the rotation axis normal */ + p5glove_plane(ref_plane,zero,pos_plane,p5->data.rotation.axis); + +DPRINTF("Position: %d - %d - %d\n",led[0],led[1],led[2]); +DPRINTF("Position: [%.4lf, %.4lf,%.4lf]\n",pos[0][0],pos[0][1],pos[0][2]); +DPRINTF("Reference normal: [%.4lf, %.4lf, %.4lf]\n",ref_plane[0],ref_plane[1],ref_plane[2]); +DPRINTF("Position normal: [%.4lf, %.4lf, %.4lf]\n",pos_plane[0],pos_plane[1],pos_plane[2]); +DPRINTF("Reference angle: %.4lf\n",p5glove_dot(ref_plane,y_up)*180.0/M_PI); +DPRINTF("Normal up angle: %.4lf\n",p5glove_dot(pos_plane,y_up)*180.0/M_PI); +DPRINTF("Rotation angle: %.4lf\n",p5->data.rotation.angle); +DPRINTF("Rotation axis : [%.4lf, %.4lf, %.4lf]\n",p5->data.rotation.axis[0],p5->data.rotation.axis[1],p5->data.rotation.axis[2]); + + c=cos(p5->data.rotation.angle*M_PI/180.0); + s=sin(p5->data.rotation.angle*M_PI/180.0); + t=1.0-c; + + /* Calculate transformation matrix, in column major order */ + x=p5->data.rotation.axis[0]; + y=p5->data.rotation.axis[1]; + z=p5->data.rotation.axis[2]; + + /* Column 0 */ + rot_matrix[0][0]=t*x*x+c; + rot_matrix[0][1]=t*x*y-s*z; + rot_matrix[0][2]=t*x*z+s*y; + rot_matrix[0][3]=0; + + /* Column 1 */ + rot_matrix[1][0]=t*x*y+s*z; + rot_matrix[1][1]=t*y*y+c; + rot_matrix[1][2]=t*y*z-s*x; + rot_matrix[1][3]=0; + + /* Column 2 */ + rot_matrix[2][0]=t*x*z-s*y; + rot_matrix[2][1]=t*y*z+s*x; + rot_matrix[2][2]=t*z*z+c; + rot_matrix[2][3]=0; + + /* Column 3 */ + rot_matrix[3][0]=0; + rot_matrix[3][1]=0; + rot_matrix[3][2]=0; + rot_matrix[3][3]=1; + + /* Now, apply the rotation angle to the position */ + p5glove_vec_mat(p5->cal.led[led[0]],rot_matrix,pos[1]); + + /* Then simply subtract the difference from the + * reference position to get the *real* point */ + for (i=0; i<3; i++) + p5->data.position[i] = pos[0][i] - pos[1][i]; + + /* There! The position is corrected, the rotation matrix is complete - we're done! */ + return p5g_delta(p5,1,1); +} + +static int p5g_parse_report6(struct p5glove *p5,int8_t *buff) +{ + /* We are given 32nds of a degree, so: */ +#define REPORT6_TO_RAD(x) ((x)/32.0*M_PI/180.0) + p5->cal.head[0].v += REPORT6_TO_RAD(buff[1]); + p5->cal.head[0].h += REPORT6_TO_RAD(buff[2]); + p5->cal.head[1].v += REPORT6_TO_RAD(buff[3]); + p5->cal.head[1].h += REPORT6_TO_RAD(buff[4]); + + /* The following is in 10ths of an inch. Convert to meters */ +#define REPORT6_TO_METERS(x) ((x)/393.70039) + p5->cal.head_dist = REPORT6_TO_METERS(buff[5]); + + return 0; +} + +static int p5g_parse_report12(struct p5glove *p5,uint8_t *buff) +{ + int led,axis; + + p5->cal.id = get_bits(buff,8,8); + switch (p5->cal.id) { + case 0: + p5->cal.head[0].v += 17.0 * (M_PI/180.0); + p5->cal.head[1].v += -10.0 * (M_PI/180.0); + break; + default: fprintf(stderr,"libp5glove: unknown glove type %d\n",p5->cal.id); + return -EINVAL; + } + /* The following is in 100ths of an inch. Convert to meters */ +#define REPORT12_TO_METERS(x) ((x)/3937.0039) + for (led = 0; led < 10; led++) { + for (axis = 0; axis < 3; axis++) { + int16_t val; + val = get_bits(buff,16+(48*led)+(16*axis),16); + p5->cal.led[led][axis]=REPORT12_TO_METERS(val); + if (axis == 0) + p5->cal.led[led][axis] *= -1.0; + } + } + +#ifdef DEBUG_CAL +for (led=0; led < 12; led++) { + DPRINTF("%d %.4lf %.4lf %.4lf\n",led, + p5->cal.led[led][0], + p5->cal.led[led][1], + p5->cal.led[led][2]); +} +#endif + + return 0; +} + +static int p5glove_calibrate(struct p5glove *p5) +{ + int8_t report6_buff[6]; + int8_t report12_buff[255]; + int err; + + memset(&p5->cal,0,sizeof(p5->cal)); + report12_buff[0]=12; + err=GetUSBHIDFeature(p5->usb,report12_buff,sizeof(report12_buff)); + if (err < 0) goto end; + + err=p5g_parse_report12(p5,report12_buff); + if (err < 0) goto end; + + report6_buff[0]=6; + err=GetUSBHIDFeature(p5->usb,report6_buff,sizeof(report6_buff)); + if (err < 0) goto end; + + err=p5g_parse_report6(p5,report6_buff); + +#ifdef DEBUG_CALIB +DPRINTF("Cal results:\n"); +{ int i; for (i=0;i<2;i++) { +DPRINTF("\tHead %d.v = %.2f deg\n",i,p5->cal.head[i].v * 180.0/M_PI); +DPRINTF("\tHead %d.h = %.2f deg\n",i,p5->cal.head[i].h * 180.0/M_PI);} } +DPRINTF("\tHead Distance = %.2f meters\n",p5->cal.head_dist); +#endif + +end: + return err; +} + +/*********** Public API **************/ + +P5Glove p5glove_open(int glove_number) +{ + struct p5glove *p5 = NULL; + USBHID usb; + int err; + + usb = OpenUSBHID ( + glove_number, /* nth matching device */ + 0x0d7f, /* vendor id */ + 0x0100, /* product id */ + 0, /* version number (not used) */ + SELECT_VENDOR_ID_FLAG | SELECT_PRODUCT_ID_FLAG ); /* selection flags */ + if ( usb == INVALID_USBHID_VALUE ) + return NULL; + + p5=calloc(1,sizeof(*p5)); + p5->usb=usb; + err = p5glove_calibrate(p5); + if (err < 0) { + if (err == -EBUSY) { + fprintf(stderr,"libp5glove: Can't get feature reports.\n"); + fprintf(stderr,"libp5glove: If you have the 'usbmouse' module loaded, please unload it.\n"); + } + free(p5); + CloseUSBHID(usb); + return NULL; + } + + return p5; +} + +void p5glove_close(P5Glove p5) +{ + if (p5->usb != NULL) { + CloseUSBHID(p5->usb); + } + p5->usb=NULL; + free(p5); +} + +int p5glove_sample(P5Glove p5,int timeout) +{ + int err; + uint8_t data[24]; + + if ( ReadUSBHID( p5->usb, data, 24 ) == 24 && data[0]==1) { + p5g_unpack_sample(p5, data); + err=p5g_process_sample(p5); + } else { + errno = EACCES; + err = -1; + } + + return err; +} + +int p5glove_get_buttons(P5Glove p5,uint32_t *buttons) +{ + *buttons = p5->data.buttons; + return 0; +} + +int p5glove_get_finger(P5Glove p5,int finger,double *clench) +{ + *clench = p5->data.finger[finger]/63.0; + return 0; +} + +int p5glove_get_position(P5Glove p5,double pos[3]) +{ + memcpy(pos,p5->data.position,sizeof(double)*3); + return 0; +} + +int p5glove_get_rotation(P5Glove p5,double *angle,double axis[3]) +{ + memcpy(axis,p5->data.rotation.axis,sizeof(double)*3); + *angle = p5->data.rotation.angle; + return 0; +} + +void p5glove_begin_calibration(P5Glove p5) +{ + char report[2] = { 0x01, 0x01 }; + SetUSBHIDFeature( p5->usb, report, 2 ); +} + +void p5glove_end_calibration(P5Glove p5) +{ + char report[2] = { 0x01, 0x00 }; + SetUSBHIDFeature( p5->usb, report, 2 ); +} + +int p5glove_get_mouse_mode(P5Glove p5) +{ + char report[2] = { 0x05, 0x00 }; + GetUSBHIDFeature( p5->usb, report, 2 ); + + return (report[1] == 0x01)? 1 : 0; +} + +void p5glove_mouse_mode_on(P5Glove p5) +{ + char report[2] = { 0x05, 0x01 }; + SetUSBHIDFeature( p5->usb, report, 2 ); +} + +void p5glove_mouse_mode_off(P5Glove p5) +{ + char report[2] = { 0x05, 0xFF }; + SetUSBHIDFeature( p5->usb, report, 2 ); +} + diff --git a/7.x/src/p5glove/libp5glove/p5glove.h b/7.x/src/p5glove/libp5glove/p5glove.h new file mode 100644 index 0000000..55cd6e2 --- /dev/null +++ b/7.x/src/p5glove/libp5glove/p5glove.h @@ -0,0 +1,226 @@ +/* + * $Id$ + * + * Copyright (c) 2003 Jason McMullan + * + * USB P5 Data Glove support + */ + +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef P5GLOVE_H +#define P5GLOVE_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +typedef struct p5glove *P5Glove; + +/* Button bitmasks */ +#define P5GLOVE_BUTTON_A 1 +#define P5GLOVE_BUTTON_B 2 +#define P5GLOVE_BUTTON_C 4 + +/* IR Sensor Index */ +#define P5GLOVE_IR_WRIST_TOP 0 +#define P5GLOVE_IR_PINKY_R 1 +#define P5GLOVE_IR_PINKY_L 2 +#define P5GLOVE_IR_PALM 3 +#define P5GLOVE_IR_INDEX 4 +#define P5GLOVE_IR_THUMB_TOP 5 +#define P5GLOVE_IR_WRIST_BOT 6 +#define P5GLOVE_IR_THUMB_BOT 7 + +/* Finger Sensor Index */ +#define P5GLOVE_FINGER_INDEX 0 +#define P5GLOVE_FINGER_MIDDLE 1 +#define P5GLOVE_FINGER_RING 2 +#define P5GLOVE_FINGER_PINKY 3 +#define P5GLOVE_FINGER_THUMB 4 + +/* p5glove_open: + * Open a handle to the Nth P5 Glove. Returns NULL on error, + * and sets errno appropriately. + */ +P5Glove p5glove_open(int glove_number); + + +/* p5glove_close: + * Close an open handle to a P5 Glove. + */ +void p5glove_close(P5Glove glove); + +#define P5GLOVE_DELTA_BUTTONS 0x01 +#define P5GLOVE_DELTA_FINGERS 0x02 +#define P5GLOVE_DELTA_POSITION 0x04 +#define P5GLOVE_DELTA_ROTATION 0x08 + +/* p5glove_sample + * Retrieve a sample from the P5, before 'timeout' milliseconds + * (timeout of < 0 means forever) + * Returns the 'delta mask' on success, -1 on error, and sets + * errno to EAGAIN if it is called faster than the refresh frequency. + */ +int p5glove_sample(P5Glove glove, int timeout); + + +/* Get information about the current glove state + */ + +/* Reference LED positions (in meters) + */ +int p5glove_get_led(P5Glove glove,int led,double position[3]); + +/* Button states + */ +int p5glove_get_buttons(P5Glove glove,uint32_t *button_mask); + +/* Finger flex + * (0.0 - unclenched, 1.0 - clenched) + */ +int p5glove_get_finger(P5Glove glove,int finger,double *clench); + +/* Current glove position (in meters) + */ +int p5glove_get_position(P5Glove glove,double position[3]); + +/* Get Axis/Angle rotation information (angle is in degrees) + */ +int p5glove_get_rotation(P5Glove glove,double *angle,double axis[3]); + + +void p5glove_begin_calibration(P5Glove glove); +void p5glove_end_calibration(P5Glove glove); + +int p5glove_get_mouse_mode(P5Glove glove); +void p5glove_mouse_mode_on(P5Glove glove); +void p5glove_mouse_mode_off(P5Glove glove); + +/* Inline helpers */ + +/* Distance between two points */ +static inline double p5glove_dist(const double a[3],const double b[3]) +{ + double w = 0.0; + int i; + + for (i = 0; i < 3; i++) + w += (a[i]-b[i])*(a[i]-b[i]); + + return sqrt(w); +} + +/* Cross product of two vectors */ +static inline void p5glove_cross(const double v1[3],const double v2[3],double res[3]) +{ + res[0]=v1[1]*v2[2]-v1[2]*v2[1]; + res[1]=v1[2]*v2[0]-v1[0]*v2[2]; + res[2]=v1[0]*v2[1]-v1[1]*v2[0]; +} + +/* Optimized for our use. We know the last row and last column are all zeros, + * except for [3][3]=1. + */ +static inline void p5glove_vec_mat(const double vec[3],double mat[4][4],double res[3]) +{ + int r,c; + + for (r=0; r < 3; r++) { + res[r]=0.0; + for (c=0; c < 3; c++) + res[r] += vec[c]*mat[c][r]; + } +} + +static inline double p5glove_dot(const double a[3],const double b[3]) +{ + double res = 0.0; + int i; + + for (i=0;i < 3; i++) + res += a[i]*b[i]; + + return res; +} + +/* This is safe to call with v==res + */ +static inline void p5glove_normal(const double v[3],double res[3]) +{ + double tmp=0.0; + int i; + + for (i=0; i < 3; i++) { + tmp += v[i]*v[i]; + } + + tmp=sqrt(tmp); + + for (i=0; i < 3; i++) + res[i] = v[i] / tmp; +} + +/* Get the plane normal of three points */ +static inline void p5glove_plane(const double p1[3],const double p2[3],const double p3[3],double xyz[3]) +{ + double v1[3],v2[3]; + + v1[0]=p1[0]-p2[0]; + v1[1]=p1[1]-p2[1]; + v1[2]=p1[2]-p2[2]; + + v2[0]=p3[0]-p2[0]; + v2[1]=p3[1]-p2[1]; + v2[2]=p3[2]-p2[2]; + + p5glove_cross(v1,v2,xyz); + + if (xyz[0]==0.0 && xyz[1]==0.0 && xyz[2]==0.0) + xyz[1]=1.0; + + p5glove_normal(xyz,xyz); +} + +/* Angle of three points */ +static inline double p5glove_angle(const double p1[3],const double p2[3],const double p3[3]) +{ + double v1[3],v2[3]; + + v1[0]=p1[0]-p2[0]; + v1[1]=p1[1]-p2[1]; + v1[2]=p1[2]-p2[2]; + + v2[0]=p3[0]-p2[0]; + v2[1]=p3[1]-p2[1]; + v2[2]=p3[2]-p2[2]; + + p5glove_normal(v1,v1); + p5glove_normal(v2,v2); + + return acos(p5glove_dot(v1,v2)); +} + + +#ifdef __cplusplus +} +#endif + +#endif /* P5GLOVE_H */ diff --git a/7.x/src/p5glove/libp5glove/usb_hid.h b/7.x/src/p5glove/libp5glove/usb_hid.h new file mode 100644 index 0000000..1ba2e6d --- /dev/null +++ b/7.x/src/p5glove/libp5glove/usb_hid.h @@ -0,0 +1,77 @@ +/* + Copyright (c) 2004 Ross Bencina + Copyright (c) 2004 Jason McMullan + + USB/HID I/O routines +*/ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef USB_HID_H +#define USB_HID_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct USBHID_struct *USBHID; + +#define INVALID_USBHID_VALUE (0) + + +#define SELECT_VENDOR_ID_FLAG (0x01) +#define SELECT_PRODUCT_ID_FLAG (0x02) +#define SELECT_VERSION_NUMBER_FLAG (0x04) + + +/* + Open the indexth USBHID device which match the delection criteria. The + selection criteria may be any combination of vendor id, product id and + version number as specified by the flags parameter. + + Returns an open handle on success, or INVALID_USBHIDHANDLE if an error + occurred. +*/ +USBHID OpenUSBHID( int index, int vendorId, int productId, int versionNumber, int flags ); + + +/* + Close a USB HID handle previously opened with OpenUSBHID() +*/ +void CloseUSBHID( USBHID handle ); + + +/* + Read count bytes from the USB HID into dest. Returns the number of bytes + read. This routine reads from the Kernel HID ring buffer, if it is no called + frequently enough the data returned may lag behind the latest HID reports + from the device. + + HidD_GetInputReport will read the most recent report, but is only + implemented on Windows XP. +*/ +int ReadUSBHID( USBHID handle, void *dest, int count ); + + +int SetUSBHIDFeature( USBHID handle, char *report, int count ); + +int GetUSBHIDFeature( USBHID handle, char *report, int count ); + + +#ifdef __cplusplus +} +#endif + +#endif /* USB_HID_H */ diff --git a/7.x/src/p5glove/libp5glove/usb_hid_libusb.c b/7.x/src/p5glove/libp5glove/usb_hid_libusb.c new file mode 100644 index 0000000..3f63663 --- /dev/null +++ b/7.x/src/p5glove/libp5glove/usb_hid_libusb.c @@ -0,0 +1,162 @@ +/* + Copyright (c) 2004 Jason McMullan + + USB/HID I/O routines +*/ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include +#include + +#include "config.h" + +#define USBHID_struct usb_dev_handle +#include "usb_hid.h" + +static int timeout = 1000; + +/* + Open the indexth USBHID device which match the delection criteria. The + selection criteria may be any combination of vendor id, product id and + version number as specified by the flags parameter. + + Returns an open handle on success, or INVALID_USBHIDHANDLE if an error + occurred. +*/ +USBHID OpenUSBHID( int index, int vendorId, int productId, int versionNumber, int flags ) +{ + struct usb_bus *bus; + struct usb_device *dev; + struct usb_dev_handle *usb = NULL; + int err,i=0; + + usb_init(); + + usb_find_busses(); + usb_find_devices(); + + for (bus = usb_get_busses(); bus != NULL; bus = bus->next) { + for (dev = bus->devices; dev != NULL; dev = dev->next) { + if (dev->descriptor.idVendor != vendorId || + dev->descriptor.idProduct != productId) + continue; + + if (i < index) + continue; + + usb = usb_open(dev); + if (usb == NULL) + continue; + + err=usb_claim_interface(usb,1); + if (err < 0) { + fprintf(stderr,"Can't claim P5 glove interface: %s\n",strerror(errno)); + usb_close(usb); + return NULL; + } + + break; + } + if (usb != NULL) + break; + } + + return usb; +} + + +/* + Close a USB HID handle previously opened with OpenUSBHID() +*/ +void CloseUSBHID( USBHID usb ) +{ + usb_release_interface(usb,1); + usb_close(usb); +} + + +/* + Read count bytes from the USB HID into dest. Returns the number of bytes + read. This routine reads from the Kernel HID ring buffer, if it is no called + frequently enough the data returned may lag behind the latest HID reports + from the device. + + HidD_GetInputReport will read the most recent report, but is only + implemented on Windows XP. +*/ +#ifndef HAVE_USB_INTERRUPT_READ +# define usb_read(usb,ep,data,len,tm) usb_bulk_read(usb,ep,data,len,tm) +# define usb_clear_halt(usb,ep) usb_resetep(usb,ep) +#else +//# define usb_read(usb,ep,data,len,tm) usb_get_input(usb,1,data,len) +# define usb_read(usb,ep,data,len,tm) usb_interrupt_read(usb,ep,data,len,tm) +#endif + +int ReadUSBHID( USBHID usb, void *dest, int count ) +{ + return usb_read(usb, 0x81, dest, count, timeout); +} + + +int usb_get_input(USBHID udev, unsigned char *report, int ReportSize) +{ + int err; +retry: + err=usb_control_msg(udev, + USB_ENDPOINT_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE, + 0x01, /* HID_REPORT_GET */ + (report[0]&0xf) | (0x01<<8), /* HID_REPORT_TYPE_INPUT */ + 1, report, ReportSize, timeout); + if (err == -EPIPE) + goto retry; + return err; +} + + +int usb_set_output(USBHID udev, unsigned char *report, int ReportSize ) +{ + return usb_control_msg(udev, + USB_ENDPOINT_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE, + 0x09, /* HID_REPORT_SET = 0x09*/ + (report[0]&0xf) | (0x02<<8), /* HID_REPORT_TYPE_OUPUT */ + 1, report, ReportSize, timeout); +} + +int GetUSBHIDFeature( USBHID udev, char *report, int count ) +{ + int err; +retry: + err=usb_control_msg(udev, + USB_ENDPOINT_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE, + 0x01, /* HID_REPORT_GET */ + (report[0]&0xf) | (0x03<<8), /* HID_REPORT_TYPE_FEATURE */ + 1, report, count, timeout); + if (err == -EPIPE) + goto retry; + return err; +} + + +int SetUSBHIDFeature( USBHID udev, char *report, int count ) +{ + return usb_control_msg(udev, + USB_ENDPOINT_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE, + 0x09, /* HID_REPORT_SET = 0x09*/ + (report[0]&0xf) | (0x03<<8), /* HID_REPORT_TYPE_FEATURE */ + 1, report, count, timeout); +} diff --git a/7.x/src/p5glove/libp5glove/usb_hid_macosx.c b/7.x/src/p5glove/libp5glove/usb_hid_macosx.c new file mode 100644 index 0000000..6359fd6 --- /dev/null +++ b/7.x/src/p5glove/libp5glove/usb_hid_macosx.c @@ -0,0 +1,365 @@ +/* + Copyright (c) 2004 Tim Kreger + + Macintosh OS X USB HID I/O routines + + Created by Tim Kreger on Wed Mar 17 2004. +*/ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + + +#include +#include +#include + + +// Mac Headers + +#include +#include +#include +#include +#include + + +#include "macosx_usb_hid.h" + + + +USBHIDHandle OpenUSBHID( int index, int idVendor, int idProduct, int versionNumber, int flags ) +{ + // todo: index and flags are currently ignored, see win32 for example implementation. + + IOUSBDeviceInterface **dev; + IOCFPlugInInterface **iodev; + kern_return_t err; + CFMutableDictionaryRef matchingDictionary = 0; // requires + CFNumberRef numberRef; + UInt8 inPipeRef; + io_service_t usbDeviceRef; + io_iterator_t iterator = 0; + + SInt32 score; + + UInt8 numConf; + IOUSBConfigurationDescriptorPtr confDesc; + io_service_t usbInterfaceRef; + IOUSBFindInterfaceRequest interfaceRequest; + IOUSBInterfaceInterface183 **intf = 0; + UInt8 numPipes; + UInt8 direction, number, transferType, interval; + int i; + UInt16 maxPacketSize; + + mach_port_t masterPort; // requires + + + err = IOMasterPort(MACH_PORT_NULL, &masterPort); + if (err) + { + fprintf( stderr, "USBSimpleExample: could not create master port, err = %08x\n", err); + return 0; + } + + // configure matching dictionary + + matchingDictionary = IOServiceMatching(kIOUSBDeviceClassName); // requires + if (!matchingDictionary) + { + fprintf( stderr, "USBSimpleExample: could not create matching dictionary\n"); + return 0; + } + + if( 1 ){ //todo: use flag to decide whether to add vendor id + + numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &idVendor); + if (!numberRef) + { + fprintf( stderr, "USBSimpleExample: could not create CFNumberRef for vendor\n"); + return 0; + } + + CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBVendorID), numberRef); + CFRelease(numberRef); + numberRef = 0; + } + + if( 1 ){ // todo: use flag to decide whether to add product id + numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &idProduct); + if (!numberRef) + { + fprintf( stderr, "USBSimpleExample: could not create CFNumberRef for product\n"); + return 0; + } + + CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBProductID), numberRef); + CFRelease(numberRef); + numberRef = 0; + } + + // get iterator to matching devices + + err = IOServiceGetMatchingServices(masterPort, matchingDictionary, &iterator); + matchingDictionary = 0; + + // get first matching device + + if((usbDeviceRef = IOIteratorNext(iterator))) + { + // open device + + err = IOCreatePlugInInterfaceForService(usbDeviceRef, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score); + if (err || !iodev) + { + fprintf( stderr, "dealWithDevice: unable to create plugin. ret = %08x, iodev = %p\n", err, iodev); + return 0; + } + + err = (*iodev)->QueryInterface(iodev, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (LPVOID)&dev); + (*iodev)->Release(iodev); // done with this + if (err || !dev) + { + fprintf( stderr, "dealWithDevice: unable to create a device interface. ret = %08x, dev = %p\n", err, dev); + return 0; + } + + err = (*dev)->USBDeviceOpen(dev); + if (err) + { + fprintf( stderr, "dealWithDevice: unable to open device. ret = %08x\n", err); + return 0; + } + + err = (*dev)->GetNumberOfConfigurations(dev, &numConf); + if (err || !numConf) + { + fprintf( stderr, "dealWithDevice: unable to obtain the number of configurations. ret = %08x\n", err); + (*dev)->USBDeviceClose(dev); + (*dev)->Release(dev); + return 0; + } + + fprintf( stderr, "dealWithDevice: found %d configurations\n", numConf); + + err = (*dev)->GetConfigurationDescriptorPtr(dev, 0, &confDesc); // get the first config desc (index 0) + if (err) + { + fprintf( stderr, "dealWithDevice:unable to get config descriptor for index 0\n"); + (*dev)->USBDeviceClose(dev); + (*dev)->Release(dev); + return 0; + } + + err = (*dev)->SetConfiguration(dev, confDesc->bConfigurationValue); + if (err) + { + fprintf( stderr, "dealWithDevice: unable to set the configuration\n"); + (*dev)->USBDeviceClose(dev); + (*dev)->Release(dev); + return 0; + } + + }else{ + return intf; + } + + // set criteria for interface iterator + + interfaceRequest.bInterfaceClass = 3; // requested class (3==hid class) + interfaceRequest.bInterfaceSubClass = 0; // requested subclass + interfaceRequest.bInterfaceProtocol = kIOUSBFindInterfaceDontCare; // requested protocol + interfaceRequest.bAlternateSetting = kIOUSBFindInterfaceDontCare; // requested alt setting + + err = (*dev)->CreateInterfaceIterator(dev, &interfaceRequest, &iterator); + if (err) + { + fprintf( stderr, "dealWithDevice: unable to create interface iterator\n"); + (*dev)->USBDeviceClose(dev); + (*dev)->Release(dev); + return 0; + } + + // get first interface matching criteria + + if( (usbInterfaceRef = IOIteratorNext(iterator)) ) + { + // open interface + + fprintf( stderr, "found interface: %u\n", usbInterfaceRef); + + err = IOCreatePlugInInterfaceForService(usbInterfaceRef, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score); + if (err || !iodev) + { + fprintf( stderr, "dealWithInterface: unable to create plugin. ret = %08x, iodev = %p\n", err, iodev); + return 0; + } + + err = (*iodev)->QueryInterface(iodev, CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID183), (LPVOID)&intf); + (*iodev)->Release(iodev); // done with this + if (err || !intf) + { + fprintf( stderr, "dealWithInterface: unable to create a device interface. ret = %08x, intf = %p\n", err, intf); + return 0; + } + + err = (*intf)->USBInterfaceOpenSeize(intf); + if (err) + { + (*intf)->Release( intf ); + fprintf( stderr, "dealWithInterface: unable to open interface. ret = %08x, score = %d \n", err, (int)score); + return 0; + } + + }else{ + return 0; + } + + + err = (*intf)->GetNumEndpoints(intf, &numPipes); + if (err) + { + fprintf( stderr, "dealWithInterface: unable to get number of endpoints. ret = %08x\n", err); + (*intf)->USBInterfaceClose(intf); + (*intf)->Release(intf); + return 0; + } + + fprintf( stderr, "dealWithInterface: found %d pipes\n", numPipes); + + // find pipe with transfer type kUSBInterrupt and direction kUSBIn + // store pipe number in inPipeRef + + for (i=1; i <= numPipes; i++) + { + err = (*intf)->GetPipeProperties(intf, i, &direction, &number, &transferType, &maxPacketSize, &interval); + if (err) + { + (*intf)->USBInterfaceClose(intf); + (*intf)->Release(intf); + fprintf( stderr, "dealWithPipes: unable to get pipe properties for pipe %d, err = %08x\n", i, err); + return 0; + } + + if (transferType != kUSBInterrupt) + { + fprintf( stderr, "dealWithPipes: skipping pipe %d because it is not an interupt pipe\n", i); + fprintf( stderr, "Pipe is type %d\n", transferType); + + continue; + } + + if (direction == kUSBIn) + { + fprintf( stderr, "dealWithPipes: grabbing BULK IN pipe index %d, number %d, inteveral %d \n",i, number, interval); + inPipeRef = i; + } + } + + return intf; +} + + + + +void CloseUSBHID( USBHIDHandle usbHidHandle ) +{ + IOUSBInterfaceInterface183 **intf = usbHidHandle; + + (*intf)->USBInterfaceClose(intf); + (*intf)->Release(intf); +} + + + +int ReadUSBHID( USBHIDHandle usbHidHandle, void *data, int count ) +{ + IOUSBInterfaceInterface183 **intf = usbHidHandle; + UInt32 readSize = count; + + (*intf)->ReadPipe(intf, 1, data, &readSize ); // 1 should be inPipeRef + + return readSize; +} + + +int HIrequest(void *usbHidHandle, UInt8 RequestType, UInt16 Request, UInt16 ReportId, int index, unsigned char *raw_buf, int ReportSize ) +{ + IOUSBDevRequest request; + IOUSBInterfaceInterface183 **intf = usbHidHandle; + IOUSBDeviceInterface **device; + io_service_t usbDeviceRef; + IOReturn success = 0 ; + char test[2]; + + // 0x21 for set, 0xA1for get + request.bmRequestType = RequestType; + request.bRequest = Request; + request.wValue = ReportId; + request.wIndex = index; + request.wLength = ReportSize; + request.pData = raw_buf; + + // (*theDev)->DeviceRequest(theDev, &request); + success = (*intf)->ControlRequest(intf, 0, &request); + + if(success != kIOReturnSuccess) + printf("Hi Request Failed \n"); + return success; + +} + + +int usb_get_report(void *usbHidHandle,int ReportId, unsigned char *raw_buf, int ReportSize ) +{ + int err; + + err = HIrequest(usbHidHandle, + 0xA1, /* Request Type */ + 0x01, /* HID_REPORT_GET */ + ReportId+(0x03<<8), /* HID_REPORT_TYPE_FEATURE */ + 1, /* Index */ + raw_buf, ReportSize); +// if (err == -EPIPE) +// goto retry; + return err; +} + + +int usb_set_report(void *usbHidHandle,int ReportId, unsigned char *raw_buf, int ReportSize ) +{ + return HIrequest(usbHidHandle, + 0x21, /* Request Type */ + 0x09, /* HID_REPORT_SET */ + ReportId+(0x03<<8), /* HID_REPORT_TYPE_FEATURE */ + 1, /* Index */ + raw_buf, ReportSize); + +} + +int SetUSBHIDFeature( USBHIDHandle handle, char *report, int count ) +{ + return usb_set_report(handle, report[0]&0xf, (unsigned char*) report, count ); + +} + +int GetUSBHIDFeature( USBHIDHandle handle, char *report, int count ) +{ + return usb_get_report(handle, report[0]&0xf, (unsigned char*) report, count ); + +} + diff --git a/7.x/src/p5glove/libp5glove/usb_hid_win32.c b/7.x/src/p5glove/libp5glove/usb_hid_win32.c new file mode 100644 index 0000000..6987acf --- /dev/null +++ b/7.x/src/p5glove/libp5glove/usb_hid_win32.c @@ -0,0 +1,346 @@ +/* + Copyright (c) 2003 Alan Macek + (c) 2004 Ross Bencina + + Win32 USB HID I/O routines + + Based on usb.c code be Alan Macek +*/ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "usb_hid.h" +#include +#include +#include + +#ifdef HAVE_HIDSDI_DDK_HEADERS + +/* + hidsdi.h and the files it includes are part of the Windows DDK. If you + don't have the DDK header files, define HAVE_HIDSDI_DDK_HEADERS, otherwise + the definitions in the #else block will be used. +*/ + +# include + +#else + +#include + +void __stdcall +HidD_GetHidGuid ( + OUT LPGUID HidGuid + ); + +typedef struct _HIDD_ATTRIBUTES { + ULONG Size; // = sizeof (struct _HIDD_ATTRIBUTES) + + // + // Vendor ids of this hid device + // + USHORT VendorID; + USHORT ProductID; + USHORT VersionNumber; + + // + // Additional fields will be added to the end of this structure. + // +} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES; + +BOOLEAN __stdcall +HidD_GetAttributes ( + IN HANDLE HidDeviceObject, + OUT PHIDD_ATTRIBUTES Attributes + ); + +BOOLEAN __stdcall +HidD_GetSerialNumberString ( + IN HANDLE HidDeviceObject, + OUT PVOID Buffer, + IN ULONG BufferLength + ); + + +BOOLEAN __stdcall +HidD_SetFeature( + IN HANDLE HidDeviceObject, + IN PVOID ReportBuffer, + IN ULONG ReportBufferLength + ); + +BOOLEAN __stdcall +HidD_GetFeature( + IN HANDLE HidDeviceObject, + OUT PVOID ReportBuffer, + IN ULONG ReportBufferLength + ); + +#include + +#endif + +/* + typedef for enumeration function called by EnumHidDevices for every + USB HID device. Return non-zero to continue enumeration +*/ +typedef BOOL HidEnumProc( PSP_DEVICE_INTERFACE_DATA deviceInterfaceData, + PSP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData, + void *userData ); + + +/* + call enumProc with enumProcData for every UDB HID device until enumProc + returns zero or all devices have been enumerated. +*/ +void EnumHidDevices( HidEnumProc* enumProc, void *enumProcData ) +{ + GUID hidGUID; + HDEVINFO hardwareDeviceInfoSet; + SP_DEVICE_INTERFACE_DATA deviceInterfaceData; + PSP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData; + ULONG requiredSize; + DWORD index; + DWORD result; + BOOL enumOk; + BOOL continueEnumerating = TRUE; + + /* Get the HID GUID value - used as mask to get list of devices */ + HidD_GetHidGuid( &hidGUID ); + + /* Get a list of devices matching the criteria (hid interface, present) */ + hardwareDeviceInfoSet = SetupDiGetClassDevs( &hidGUID, + NULL, /* no enumerator (global) */ + NULL, /* no top level window */ + (DIGCF_PRESENT | /* Only Devices present */ + DIGCF_DEVICEINTERFACE) ); /* Function class devices. */ + + if( hardwareDeviceInfoSet != INVALID_HANDLE_VALUE ){ + + deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); + + index = 0; + do{ + // enumerate the list and get the interface data + enumOk = SetupDiEnumDeviceInterfaces( hardwareDeviceInfoSet, + NULL, /* infoData */ + &hidGUID, /* interfaceClassGuid */ + index, + &deviceInterfaceData ); + + /* + regarding SetupDiEnumDeviceInterfaces msdn says: + You should first call this function with the MemberIndex parameter set + to zero to obtain the first interface. Then, repeatedly increment + MemberIndex and retrieve an interface until this function fails and + GetLastError returns ERROR_NO_MORE_ITEMS. + + Rather than checking for ERROR_NO_MORE_ITEMS we halt on any error. + */ + + if( enumOk ){ + + /* Get the details with null values to get the required size of the buffer */ + requiredSize = 0; + SetupDiGetDeviceInterfaceDetail( hardwareDeviceInfoSet, + &deviceInterfaceData, + NULL, /* interfaceDetail */ + 0, /* interfaceDetailSize */ + &requiredSize, + 0 ); /* infoData */ + if( requiredSize != 0 ){ + /* Allocate the buffer */ + deviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(requiredSize); + + if( deviceInterfaceDetailData != NULL ){ + deviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); + + /* Fill the buffer with the device details */ + result = SetupDiGetDeviceInterfaceDetail( hardwareDeviceInfoSet, + &deviceInterfaceData, + deviceInterfaceDetailData, + requiredSize, + &requiredSize, + NULL ); + if( result != 0 ){ + + /* call the enumProc */ + continueEnumerating = enumProc( &deviceInterfaceData, deviceInterfaceDetailData, enumProcData ); + + } + + free (deviceInterfaceDetailData); + } + } + + ++index; + } + + }while( enumOk && continueEnumerating ); + + SetupDiDestroyDeviceInfoList (hardwareDeviceInfoSet); + } +} + + +typedef struct{ + DWORD currentIndex; + DWORD deviceIndex; + USHORT vendorId, productId, versionNumber; + int flags; + HANDLE deviceHandle; +} FindHidDeviceEnumData; + + +BOOL FindHidDeviceEnumProc( PSP_DEVICE_INTERFACE_DATA deviceInterfaceData, + PSP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData, + void *userData ) +{ + HANDLE deviceHandle; + HIDD_ATTRIBUTES deviceAttributes; + FindHidDeviceEnumData *data = (FindHidDeviceEnumData*)userData; + + (void) deviceInterfaceData; /* unused parameter */ + + /* Open file on the device */ + deviceHandle = CreateFile( deviceInterfaceDetailData->DevicePath, + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, /* no SECURITY_ATTRIBUTES structure */ + OPEN_EXISTING, /* No special create flags */ + 0, + NULL ); /* No template file */ + + if( deviceHandle != INVALID_HANDLE_VALUE ){ + + deviceAttributes.Size = sizeof(HIDD_ATTRIBUTES); + if( HidD_GetAttributes( deviceHandle, &deviceAttributes ) == TRUE + && ( !(data->flags & SELECT_VENDOR_ID_FLAG) || deviceAttributes.VendorID == data->vendorId ) + && ( !(data->flags & SELECT_PRODUCT_ID_FLAG) || deviceAttributes.ProductID == data->productId ) + && ( !(data->flags & SELECT_VERSION_NUMBER_FLAG) || deviceAttributes.VersionNumber == data->versionNumber ) ){ + + /* found a device which matches the selection criteria */ + + if( data->currentIndex == data->deviceIndex ){ + + /* found the requested device */ + + data->deviceHandle = deviceHandle; + return FALSE; /* stop enumerating */ + + }else{ + CloseHandle( deviceHandle ); + } + + ++data->currentIndex; + + }else{ + CloseHandle( deviceHandle ); + } + } + + return TRUE; /* continue enumerating */ +} + + +USBHID OpenUSBHID( int index, int vendorId, int productId, int versionNumber, int flags ) +{ + FindHidDeviceEnumData data; + + data.currentIndex = 0; + data.deviceIndex = index; + data.vendorId = (USHORT)vendorId; + data.productId = (USHORT)productId; + data.versionNumber = (USHORT)versionNumber; + data.flags = flags; + data.deviceHandle = INVALID_HANDLE_VALUE; + + EnumHidDevices( FindHidDeviceEnumProc, &data ); + + if( data.deviceHandle == INVALID_HANDLE_VALUE ) + return INVALID_USBHID_VALUE; + else + return (USBHID)data.deviceHandle; +} + + +BOOL DumpHidDeviceInfoEnumProc( PSP_DEVICE_INTERFACE_DATA deviceInterfaceData, + PSP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData, + void *userData ) +{ + HANDLE deviceHandle; + HIDD_ATTRIBUTES deviceAttributes; + wchar_t s[128]; + + (void) deviceInterfaceData; /* unused parameter */ + (void) userData; + + printf( "Device Path: %s\n", deviceInterfaceDetailData->DevicePath ); + + deviceHandle = CreateFile( deviceInterfaceDetailData->DevicePath, + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, /* no SECURITY_ATTRIBUTES structure */ + OPEN_EXISTING, /* No special create flags */ + 0, + NULL ); /* No template file */ + + if( deviceHandle != INVALID_HANDLE_VALUE ){ + + deviceAttributes.Size = sizeof(HIDD_ATTRIBUTES); + if( HidD_GetAttributes( deviceHandle, &deviceAttributes ) ){ + + printf( "Vendor ID: %d\n", deviceAttributes.VendorID ); + printf( "Product ID: %d\n", deviceAttributes.ProductID ); + printf( "Version Number: %d\n", deviceAttributes.VersionNumber ); + } + + if( HidD_GetSerialNumberString( deviceHandle, s, 128 ) ) + printf( "Serial Number: `%ls' (len:%d, 1st char:%d)\n", s, wcslen(s), s[0] ); + + + CloseHandle( deviceHandle ); + } + + printf( "\n" ); + + return TRUE; /* continue enumerating */ +} + + +void CloseUSBHID( USBHID handle ) +{ + CloseHandle( (HANDLE)handle ); +} + +int ReadUSBHID( USBHID handle, void *dest, int count ) +{ + DWORD bytesRead; + + ReadFile( (HANDLE)handle, dest, count, &bytesRead, 0 ); + + return bytesRead; +} + +int SetUSBHIDFeature( USBHID handle, char *report, int count ) +{ + return HidD_SetFeature( handle, report, count ) == TRUE ? 0 : -EINVAL; +} + +void GetUSBHIDFeature( USBHID handle, char *report, int count ) +{ + return HidD_GetFeature( handle, report, count ) == TRUE ? 0 : -EINVAL; +} diff --git a/7.x/src/p5glove/p5glove.c b/7.x/src/p5glove/p5glove.c new file mode 100644 index 0000000..aa93712 --- /dev/null +++ b/7.x/src/p5glove/p5glove.c @@ -0,0 +1,260 @@ +/* + p5glove.c: + + Copyright (C) 2009 by John ffitch, + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + + /* p5glove.c */ +#include "csdl.h" +#include +#include + +typedef struct { + OPDS h; + /* ------------------------------------- */ + void *thread; +} P5GLOVEINIT; + +typedef struct { + OPDS h; + cs_float *res; + cs_float *kControl; + cs_float *num; + /* ------------------------------------- */ + uint32_t last; +} P5GLOVE; + +#define P5G_BUTTONS 0 +#define P5G_BUTTON_A 1 +#define P5G_BUTTON_B 2 +#define P5G_BUTTON_C 4 +#define P5G_JUSTPUSH 8 +#define P5G_JUSTPU_A 9 +#define P5G_JUSTPU_B 10 +#define P5G_JUSTPU_C 12 +#define P5G_RELEASED 16 +#define P5G_RELSED_A 17 +#define P5G_RELSED_B 18 +#define P5G_RELSED_C 20 +#define P5G_FINGER_INDEX 32 +#define P5G_FINGER_MIDDLE 33 +#define P5G_FINGER_RING 34 +#define P5G_FINGER_PINKY 35 +#define P5G_FINGER_THUMB 36 +#define P5G_DELTA_X 37 +#define P5G_DELTA_Y 38 +#define P5G_DELTA_Z 39 +#define P5G_DELTA_XR 40 +#define P5G_DELTA_YR 41 +#define P5G_DELTA_ZR 42 +#define P5G_ANGLES 43 + +static uintptr_t runp5thread(void *g) +{ + P5Glove *glove = (P5Glove *)g; + while (*glove) { + p5glove_sample(*glove, 0); + } + return 0; +} + +int32_t p5g_deinit(CSOUND *csound, P5GLOVEINIT *p) +{ + P5Glove *glove = (P5Glove*)csound->QueryGlobalVariable(csound, "p5glove"); + P5Glove handle = NULL; + if (glove != NULL) { + handle = *glove; + *glove = NULL; /* ask the reader thread to stop */ + } + if (p->thread != NULL) { + csound->JoinThread(p->thread); + p->thread = NULL; + } + if (handle != NULL) { + p5glove_close(handle); + } + if (glove != NULL) { + csound->DestroyGlobalVariable(csound, "p5glove"); + } + return OK; +} + +int32_t p5glove_find(CSOUND *csound, P5GLOVEINIT *p) +{ + P5Glove *glove = (P5Glove*)csound->QueryGlobalVariable(csound, "p5glove"); + if (glove == NULL) { + csound->CreateGlobalVariable(csound, "p5glove", sizeof(P5Glove)); + glove = (P5Glove*)csound->QueryGlobalVariable(csound, "p5glove"); + if (UNLIKELY(glove == NULL)) { + return csound->InitError(csound, "%s", + Str("cannot allocate p5glove state")); + } + } + *glove = p5glove_open(0); + if (UNLIKELY(*glove==NULL)) { + return csound->InitError(csound, "%s", Str("unable to open p5glove\n")); + } + p->thread = csound->CreateThread(runp5thread, glove); + if (UNLIKELY(p->thread == NULL)) { + p5glove_close(*glove); + *glove = NULL; + return csound->InitError(csound, "%s", Str("unable to start p5glove thread\n")); + } + return OK; +} + +int32_t p5glove_poll(CSOUND *csound, P5GLOVE *p) +{ + /* P5Glove *glove = (P5Glove*)csound->QueryGlobalVariable(csound,"p5glove"); */ + /* int32_t res; */ + /* if (glove == NULL) */ + /* return csound->PerfError(csound, &p->h, */ + /* Str("No glove open")); */ + /* res = p5glove_sample(*glove, -1); */ + /* if (res < 0 && errno == EAGAIN) return OK; */ + /* //res = p5glove_sample(*glove, -1); */ + /* if (UNLIKELY(res < 0)) */ + /* return csound->PerfError(csound, &p->h, */ + /* Str("P5Glove failure")); */ + return OK; +} + +int32_t p5g_data_init(CSOUND *csound, P5GLOVE *p) +{ + /* P5Glove p5g; */ + /* p5g = (P5Glove)csound->QueryGlobalVariable(csound, "p5glove"); */ + /* if (UNLIKELY(p5g==NULL)) */ + /* return csound->InitError(csound, Str("No p5glove open")); */ + p->last = 0; + return OK; +} + +int32_t p5g_data(CSOUND *csound, P5GLOVE *p) +{ + P5Glove *glove = (P5Glove*)csound->QueryGlobalVariable(csound, "p5glove"); + int32_t kontrol = (int32_t)(*p->kControl+FL(0.5)); + uint32_t buttons, just, rels; + if (UNLIKELY(glove==NULL)) + return csound->PerfError(csound, &(p->h), "%s", Str("No open glove")); + p5glove_get_buttons(*glove,&buttons); + just = ((~p->last) & buttons); + rels = (p->last & ~buttons); + p->last = buttons; + if (kontrol<0) { + *p->res = FL(0.0); + return OK; + } + else if (kontrolres = (cs_float)(buttons); + return OK; + case P5G_BUTTON_A: + *p->res = (cs_float)(buttons & P5GLOVE_BUTTON_A); + return OK; + case P5G_BUTTON_B: + *p->res = (cs_float)(buttons & P5GLOVE_BUTTON_B); + return OK; + case P5G_BUTTON_C: + *p->res = (cs_float)(buttons & P5GLOVE_BUTTON_C); + return OK; + case P5G_JUSTPUSH: + *p->res = (cs_float)just; + return OK; + case P5G_JUSTPU_A: + *p->res = (cs_float)(just & P5GLOVE_BUTTON_A); + return OK; + case P5G_JUSTPU_B: + *p->res = (cs_float)(just & P5GLOVE_BUTTON_B); + return OK; + case P5G_JUSTPU_C: + *p->res = (cs_float)(just & P5GLOVE_BUTTON_C); + return OK; + case P5G_RELEASED: + *p->res = (cs_float)rels; + return OK; + case P5G_RELSED_A: + *p->res = (cs_float)(rels & P5GLOVE_BUTTON_A); + return OK; + case P5G_RELSED_B: + *p->res = (cs_float)(rels & P5GLOVE_BUTTON_B); + return OK; + case P5G_RELSED_C: + *p->res = (cs_float)(rels & P5GLOVE_BUTTON_C); + return OK; + default: + *p->res = FL(0.0); + return NOTOK; + } + } + else if (kontrol<=P5G_FINGER_THUMB) { + double clench; + p5glove_get_finger(*glove,kontrol-P5G_FINGER_INDEX,&clench); + *p->res = (cs_float)clench; + /* *p->res = (cs_float)(p5->data.finger[finger]/63.0); */ + return OK; + } + else { + double pos[3], axis[3], angle; + p5glove_get_position(*glove, pos); + p5glove_get_rotation(*glove, &angle, axis); + /* printf("pos: %f %f %f\n", pos[0], pos[1], pos[2]); */ + /* printf("axis: %f %f %f\n", axis[0], axis[1], axis[2]); */ + /* printf("angle: %f\n", angle); */ + switch (kontrol) { + case P5G_DELTA_X: + *p->res = (cs_float)pos[0]; + return OK; + case P5G_DELTA_Y: + *p->res = (cs_float)pos[1]; + return OK; + case P5G_DELTA_Z: + *p->res = (cs_float)pos[2]; + return OK; + case P5G_DELTA_XR: + *p->res = (cs_float)axis[0]; + return OK; + case P5G_DELTA_YR: + *p->res = (cs_float)axis[1]; + return OK; + case P5G_DELTA_ZR: + *p->res = (cs_float)axis[2]; + return OK; + case P5G_ANGLES: + *p->res = (cs_float)angle; + return OK; + default: + break; + } + } + return NOTOK; +} + +#define S(x) sizeof(x) + +static OENTRY localops[] = { + {"p5gconnect", S(P5GLOVEINIT), 0, "", "", + (SUBR)p5glove_find, (SUBR)p5glove_poll, (SUBR)p5g_deinit, NULL, 0 }, + {"p5gdata", S(P5GLOVE), 0, "k", "k", + (SUBR)p5g_data_init, (SUBR)p5g_data, NULL, NULL, 0 } +}; + +LINKAGE From 158f9300aedaf759297c043ad99663a84d5baff7 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 10:49:40 +0100 Subject: [PATCH 35/72] Address p5glove review: input guards and vendored driver fixes Plugin (p5glove.c): - Reject a second p5gconnect while a glove is already open (the shared handle would otherwise be overwritten and closed twice). - Guard p5gdata against a registered global that holds a NULL handle. Vendored libp5glove: - Fix negative-shift UB in the signed IR sign extension (shift by len, not len-32). - Fix the dead-LED stack overflow: size each compaction move by its element type and use memmove for the overlapping regions (both the main and CHECK_ACUTE_TRIANGLES blocks). - Check the calloc result and set errno on failure. - Make DEBUG an opt-in compile definition and correct a DPRINTF call. - usb_hid_macosx: release the device on failure paths, drop it once the interface is open, release both iterators, and check the ReadPipe result before returning a byte count. - usb_hid_win32: return int from GetUSBHIDFeature to match its declaration and include errno.h for EINVAL. --- 7.x/src/p5glove/libp5glove/p5glove.c | 24 ++++++++++++--------- 7.x/src/p5glove/libp5glove/usb_hid_macosx.c | 13 ++++++++++- 7.x/src/p5glove/libp5glove/usb_hid_win32.c | 3 ++- 7.x/src/p5glove/p5glove.c | 6 +++++- 4 files changed, 33 insertions(+), 13 deletions(-) diff --git a/7.x/src/p5glove/libp5glove/p5glove.c b/7.x/src/p5glove/libp5glove/p5glove.c index 5abc311..8d46932 100644 --- a/7.x/src/p5glove/libp5glove/p5glove.c +++ b/7.x/src/p5glove/libp5glove/p5glove.c @@ -38,7 +38,6 @@ #include #include "p5glove.h" -#define DEBUG #ifdef DEBUG #define DPRINTF(fmt,args...) fprintf(stderr,"p5: " fmt , ##args ) #else @@ -114,8 +113,8 @@ static int32_t get_bits_signed(uint8_t *data,int pos,int len) uint32_t value,mask=0; value = get_bits(data,pos,len); - if (value & (1 << (len-1))) - mask = 0xffffffff << (len - 32); + if (len < 32 && (value & (1u << (len-1)))) + mask = 0xffffffffu << len; return value | mask; } @@ -283,7 +282,7 @@ static int p5g_best_leds(P5Glove p5,int led[4],double pos[4][3]) double err = fabs(dist-ref_dist)/ref_dist; DPRINTF("%d - %d: %.4lf ",led[i],led[j],ref_dist); - DPRINTF("(%.4lf) [%.4lf]\n",led[i],led[j],dist,err); + DPRINTF("(%.4lf) [%.4lf]\n",dist,err); /* Max 9% error margin on distance */ if (err > 0.20) { @@ -302,9 +301,9 @@ static int p5g_best_leds(P5Glove p5,int led[4],double pos[4][3]) DPRINTF("Dead: Led %d\n",led[i]); leds--; if (i != leds) { - memcpy(&error[i],&error[i+1],sizeof(int)*(leds-i)); - memcpy(&led[i],&led[i+1],sizeof(double)*(leds-i)); - memcpy(pos[i],pos[i+1],sizeof(double)*3*(leds-i)); + memmove(&error[i],&error[i+1],sizeof(error[0])*(leds-i)); + memmove(&led[i],&led[i+1],sizeof(led[0])*(leds-i)); + memmove(pos[i],pos[i+1],sizeof(pos[0])*(leds-i)); } i--; if (leds == 1) @@ -354,9 +353,9 @@ static int p5g_best_leds(P5Glove p5,int led[4],double pos[4][3]) DPRINTF("Dead: Led %d\n",led[i]); leds--; if (i != leds) { - memcpy(&error[i],&error[i+1],sizeof(int)*(leds-i)); - memcpy(&led[i],&led[i+1],sizeof(double)*(leds-i)); - memcpy(pos[i],pos[i+1],sizeof(double)*3*(leds-i)); + memmove(&error[i],&error[i+1],sizeof(error[0])*(leds-i)); + memmove(&led[i],&led[i+1],sizeof(led[0])*(leds-i)); + memmove(pos[i],pos[i+1],sizeof(pos[0])*(leds-i)); } i--; if (leds == 1) @@ -591,6 +590,11 @@ P5Glove p5glove_open(int glove_number) return NULL; p5=calloc(1,sizeof(*p5)); + if (p5 == NULL) { + CloseUSBHID(usb); + errno = ENOMEM; + return NULL; + } p5->usb=usb; err = p5glove_calibrate(p5); if (err < 0) { diff --git a/7.x/src/p5glove/libp5glove/usb_hid_macosx.c b/7.x/src/p5glove/libp5glove/usb_hid_macosx.c index 6359fd6..c82ddfb 100644 --- a/7.x/src/p5glove/libp5glove/usb_hid_macosx.c +++ b/7.x/src/p5glove/libp5glove/usb_hid_macosx.c @@ -142,6 +142,7 @@ USBHIDHandle OpenUSBHID( int index, int idVendor, int idProduct, int versionNumb if (err) { fprintf( stderr, "dealWithDevice: unable to open device. ret = %08x\n", err); + (*dev)->Release(dev); return 0; } @@ -185,6 +186,7 @@ USBHIDHandle OpenUSBHID( int index, int idVendor, int idProduct, int versionNumb interfaceRequest.bInterfaceProtocol = kIOUSBFindInterfaceDontCare; // requested protocol interfaceRequest.bAlternateSetting = kIOUSBFindInterfaceDontCare; // requested alt setting + IOObjectRelease(iterator); // done with the device iterator err = (*dev)->CreateInterfaceIterator(dev, &interfaceRequest, &iterator); if (err) { @@ -221,15 +223,21 @@ USBHIDHandle OpenUSBHID( int index, int idVendor, int idProduct, int versionNumb if (err) { (*intf)->Release( intf ); + (*dev)->USBDeviceClose(dev); + (*dev)->Release(dev); fprintf( stderr, "dealWithInterface: unable to open interface. ret = %08x, score = %d \n", err, (int)score); return 0; } + /* the interface stays usable; drop the device reference */ + (*dev)->USBDeviceClose(dev); + (*dev)->Release(dev); }else{ return 0; } + IOObjectRelease(iterator); // done with the interface iterator err = (*intf)->GetNumEndpoints(intf, &numPipes); if (err) { @@ -290,8 +298,11 @@ int ReadUSBHID( USBHIDHandle usbHidHandle, void *data, int count ) { IOUSBInterfaceInterface183 **intf = usbHidHandle; UInt32 readSize = count; + IOReturn ret; - (*intf)->ReadPipe(intf, 1, data, &readSize ); // 1 should be inPipeRef + ret = (*intf)->ReadPipe(intf, 1, data, &readSize ); // 1 should be inPipeRef + if (ret != kIOReturnSuccess) + return -1; return readSize; } diff --git a/7.x/src/p5glove/libp5glove/usb_hid_win32.c b/7.x/src/p5glove/libp5glove/usb_hid_win32.c index 6987acf..3b597bc 100644 --- a/7.x/src/p5glove/libp5glove/usb_hid_win32.c +++ b/7.x/src/p5glove/libp5glove/usb_hid_win32.c @@ -26,6 +26,7 @@ #include #include #include +#include #ifdef HAVE_HIDSDI_DDK_HEADERS @@ -340,7 +341,7 @@ int SetUSBHIDFeature( USBHID handle, char *report, int count ) return HidD_SetFeature( handle, report, count ) == TRUE ? 0 : -EINVAL; } -void GetUSBHIDFeature( USBHID handle, char *report, int count ) +int GetUSBHIDFeature( USBHID handle, char *report, int count ) { return HidD_GetFeature( handle, report, count ) == TRUE ? 0 : -EINVAL; } diff --git a/7.x/src/p5glove/p5glove.c b/7.x/src/p5glove/p5glove.c index aa93712..cf6ab2c 100644 --- a/7.x/src/p5glove/p5glove.c +++ b/7.x/src/p5glove/p5glove.c @@ -107,6 +107,10 @@ int32_t p5glove_find(CSOUND *csound, P5GLOVEINIT *p) Str("cannot allocate p5glove state")); } } + if (UNLIKELY(*glove != NULL)) { + return csound->InitError(csound, "%s", + Str("p5glove is already connected")); + } *glove = p5glove_open(0); if (UNLIKELY(*glove==NULL)) { return csound->InitError(csound, "%s", Str("unable to open p5glove\n")); @@ -151,7 +155,7 @@ int32_t p5g_data(CSOUND *csound, P5GLOVE *p) P5Glove *glove = (P5Glove*)csound->QueryGlobalVariable(csound, "p5glove"); int32_t kontrol = (int32_t)(*p->kControl+FL(0.5)); uint32_t buttons, just, rels; - if (UNLIKELY(glove==NULL)) + if (UNLIKELY(glove==NULL || *glove==NULL)) return csound->PerfError(csound, &(p->h), "%s", Str("No open glove")); p5glove_get_buttons(*glove,&buttons); just = ((~p->last) & buttons); From 3a03c4c6e702a20bc0ef3337bf744217452aa892 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 11:18:54 +0100 Subject: [PATCH 36/72] Port CUDA opcodes to Csound 7 plugins Port the five canonical CUDA opcode plugins (cudaop1-cudaop5: cudasynth, cudanal, cudasliding, cudaconv, cudapconv) from 6.x to the Csound 7 plugin API. CMake: add src/CUDA with BUILD_CUDA_OPCODES (off by default, non-Apple only), using enable_language(CUDA)/find_package(CUDAToolkit) instead of the deprecated FindCUDA. Add a compile-only Linux CUDA CI job and merge the plugins into the Linux release package. --- .github/workflows/plugins_build_7.yml | 72 ++- 7.x/CMakeLists.txt | 1 + 7.x/README.md | 25 +- 7.x/src/CUDA/CMakeLists.txt | 60 +++ 7.x/src/CUDA/adsyn.cu | 188 ++++++++ 7.x/src/CUDA/conv.cu | 152 ++++++ 7.x/src/CUDA/pconv.cu | 261 +++++++++++ 7.x/src/CUDA/pvsops.cu | 446 ++++++++++++++++++ 7.x/src/CUDA/slidingm.cu | 641 ++++++++++++++++++++++++++ 9 files changed, 1844 insertions(+), 2 deletions(-) create mode 100644 7.x/src/CUDA/CMakeLists.txt create mode 100644 7.x/src/CUDA/adsyn.cu create mode 100644 7.x/src/CUDA/conv.cu create mode 100644 7.x/src/CUDA/pconv.cu create mode 100644 7.x/src/CUDA/pvsops.cu create mode 100644 7.x/src/CUDA/slidingm.cu diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 421a400..ace0e95 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -324,10 +324,74 @@ jobs: path: package/ if-no-files-found: error + linux_cuda: + name: Linux CUDA (ubuntu-latest) + needs: update_version + runs-on: ubuntu-latest + container: + image: nvidia/cuda:12.4.1-devel-ubuntu22.04 + steps: + - name: Checkout source + uses: actions/checkout@v4 + + - name: Install build dependencies + run: | + apt-get update + apt-get install -y --no-install-recommends \ + build-essential cmake git ca-certificates \ + libsndfile1-dev flex bison + + - name: Show CUDA toolchain + run: | + nvcc --version + nvidia-smi || true + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v4 + with: + path: /csound-install + key: csound-cuda-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} + + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + git clone --depth 1 --branch "$CSOUND_VERSION" \ + https://github.com/csound/csound.git /tmp/csound + cmake -S /tmp/csound -B /tmp/csound-build \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/csound-install \ + -DBUILD_TESTS=OFF \ + -DINSTALL_PYTHON_INTERFACE=OFF + cmake --build /tmp/csound-build --parallel "$(nproc)" + cmake --install /tmp/csound-build + + - name: Build CUDA plugins + run: | + cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ + -DBUILD_CUDA_OPCODES=ON \ + -DCMAKE_CUDA_ARCHITECTURES="50;60;70;75;80;86" \ + -DCSOUND_INCLUDE_DIR_HINT=/csound-install/include/csound \ + -DCSOUND_LIBRARY_DIR_HINT=/csound-install/lib + cmake --build build --parallel "$(nproc)" \ + --target cudaop1 cudaop2 cudaop3 cudaop4 cudaop5 + + - name: Stage plugins + run: | + mkdir -p package + cp build/src/CUDA/*.so package/ + + - name: Upload plugins + uses: actions/upload-artifact@v4 + with: + name: csound7-plugins-linux-cuda + path: package/ + if-no-files-found: error + publish_release: name: Publish release if: ${{ (github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main') && needs.update_version.outputs.release == 'true' }} - needs: [update_version, linux, macos, windows] + needs: [update_version, linux, linux_cuda, macos, windows] runs-on: ubuntu-latest permissions: contents: write @@ -338,6 +402,12 @@ jobs: name: csound7-plugins-linux path: release/linux + - name: Download Linux CUDA plugins + uses: actions/download-artifact@v4 + with: + name: csound7-plugins-linux-cuda + path: release/linux + - name: Download macOS plugins uses: actions/download-artifact@v4 with: diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index a492bea..a3bea3e 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -311,3 +311,4 @@ add_subdirectory(./src/hdf5) add_subdirectory(./src/py) add_subdirectory(./src/wiimote) add_subdirectory(./src/p5glove) +add_subdirectory(./src/CUDA) diff --git a/7.x/README.md b/7.x/README.md index 4c8b015..88b9bc5 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -30,6 +30,9 @@ Currently, the plugins available in this tree are - p5glove (requires the p5glove driver; CMake-only, see note below) **p5gconnect p5gdata** +- CUDA (requires the CUDA toolkit; Linux/Windows only, disabled by default, see note below) +**cudasynth cudanal cudasliding cudaconv cudapconv** + Fluid settings opcodes --- @@ -83,6 +86,25 @@ by configuring with `-DP5GLOVE_USE_BUNDLED=ON` (in addition to `-DBUILD_P5GLOVE_OPCODES=ON`). +CUDA opcodes +--- + +The `CUDA` opcodes (`cudasynth`, `cudanal`, `cudasliding`, `cudaconv`, +`cudapconv`) are a port of the Csound 6.x plugin to the Csound 7 plugin API. +They run their DSP kernels on an NVIDIA GPU; `cudanal` and `cudapconv` also +rely on cuFFT. + +They are **disabled by default** and only built when the CUDA toolkit is +found: configure with `-DBUILD_CUDA_OPCODES=ON`. CUDA is **not available on +macOS** (NVIDIA dropped macOS support after 10.13), so on macOS the option is +ignored. The Linux CI builds them compile-only (the hosted runners have no +GPU) and they are included in the Linux release package; they cannot be built +or tested on macOS. + +The compute capabilities default to `75 80 86 89`; override with +`-DCMAKE_CUDA_ARCHITECTURES="..."` (for example `native` for the local GPU). + + Install location -------------- The CMake scripts in this repository use the default CS_USER_PLUGIN @@ -122,7 +144,8 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. -The options are `BUILD_CHUA_OPCODES`, `BUILD_FLUID_OPCODES`, +The options are `BUILD_CHUA_OPCODES`, `BUILD_CUDA_OPCODES`, +`BUILD_FLUID_OPCODES`, `BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, `BUILD_P5GLOVE_OPCODES`, `BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to diff --git a/7.x/src/CUDA/CMakeLists.txt b/7.x/src/CUDA/CMakeLists.txt new file mode 100644 index 0000000..60156c9 --- /dev/null +++ b/7.x/src/CUDA/CMakeLists.txt @@ -0,0 +1,60 @@ +# Build the CUDA GPU opcodes (requires the CUDA toolkit). +# Not available on macOS: NVIDIA dropped CUDA support after macOS 10.13. + +option(BUILD_CUDA_OPCODES "Build the CUDA GPU opcodes" OFF) + +if(BUILD_CUDA_OPCODES) + if(APPLE) + message(STATUS "CUDA is not supported on macOS; disabling BUILD_CUDA_OPCODES") + set(BUILD_CUDA_OPCODES OFF) + else() + include(CheckLanguage) + check_language(CUDA) + if(CMAKE_CUDA_COMPILER) + enable_language(CUDA) + find_package(CUDAToolkit) + endif() + check_deps(BUILD_CUDA_OPCODES CMAKE_CUDA_COMPILER CUDAToolkit_FOUND) + endif() +endif() + +if(BUILD_CUDA_OPCODES) + message(STATUS "Building the CUDA opcodes") + + # A broad set of compute capabilities; override with + # -DCMAKE_CUDA_ARCHITECTURES="..." (e.g. "native"). + if(NOT CMAKE_CUDA_ARCHITECTURES) + set(CMAKE_CUDA_ARCHITECTURES 75 80 86 89) + endif() + set(CMAKE_CUDA_STANDARD 14) + set(CMAKE_CUDA_STANDARD_REQUIRED ON) + + function(make_cuda_plugin libname srcs) + make_plugin(${libname} ${srcs}) + target_include_directories(${libname} PRIVATE ${CSOUND_INCLUDE_DIRS}) + target_compile_options(${libname} PRIVATE + "$<$:-use_fast_math>") + endfunction() + + # cudaop1: cudasynth (additive synthesis driven by a PVS signal) + make_cuda_plugin(cudaop1 adsyn.cu) + target_link_libraries(cudaop1 PRIVATE CUDA::cudart) + + # cudaop2: cudasynth, cudanal (PVS analysis/synthesis) + make_cuda_plugin(cudaop2 pvsops.cu) + target_link_libraries(cudaop2 PRIVATE CUDA::cudart CUDA::cufft) + + # cudaop3: cudasliding (sliding DFT) + make_cuda_plugin(cudaop3 slidingm.cu) + target_link_libraries(cudaop3 PRIVATE CUDA::cudart) + + # cudaop4: cudaconv (direct convolution) + make_cuda_plugin(cudaop4 conv.cu) + target_link_libraries(cudaop4 PRIVATE CUDA::cudart) + + # cudaop5: cudapconv (partitioned convolution) + make_cuda_plugin(cudaop5 pconv.cu) + target_link_libraries(cudaop5 PRIVATE CUDA::cudart CUDA::cufft) +else() + message(STATUS "Not building the CUDA opcodes") +endif() diff --git a/7.x/src/CUDA/adsyn.cu b/7.x/src/CUDA/adsyn.cu new file mode 100644 index 0000000..bcd5993 --- /dev/null +++ b/7.x/src/CUDA/adsyn.cu @@ -0,0 +1,188 @@ +// -*- c++ -*- +/* adsyn.cu + experimental cuda opcodes + + (c) Victor Lazzarini, 2013 + + based on M Puckette's pitch tracking algorithm. + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + +#include +#include + +#define S(x) sizeof(x) + +typedef struct cudadsyn_ { + OPDS h; + cs_float *asig; + PVSDAT *fsig; + cs_float *kamp, *kfreq; + cs_float *inum; + float *out; + float *frame; + int64_t *ndx; + float *fp, *previous; + AUXCH out_; + int bins, blocks, threads; + int count; + int vsamps, mblocks, mthreads; + int framecount; +} CUDADSYN; + +static int destroy_cudadsyn(CSOUND *csound, void *pp); + +static int init_cudadsyn(CSOUND *csound, CUDADSYN *p){ + + int asize, ipsize, fpsize, blockspt; + if(p->fsig->overlap > 1024) + return csound->InitError(csound, "overlap is too large\n"); + cudaDeviceProp deviceProp; + cudaGetDeviceProperties(&deviceProp, 0); + blockspt = deviceProp.maxThreadsPerBlock; + if(deviceProp.major < 2) + return csound->InitError(csound, + "this opcode requires device capability 2.0 minimum. Device is %d.%d\n", + deviceProp.major, deviceProp.minor ); + + p->bins = (p->fsig->N)/2; + + if(*p->inum > 0 && *p->inum < p->bins) p->bins = *p->inum; + + p->vsamps = p->fsig->overlap; + p->threads = p->bins*p->vsamps; + p->blocks = p->threads > blockspt ? p->threads/blockspt : 1; + p->mthreads = p->bins; + p->mblocks = p->mthreads > blockspt ? p->mthreads/blockspt : 1; + + p->threads /= p->blocks; + p->mthreads /= p->mblocks; + + asize = p->vsamps*sizeof(float); + ipsize = p->fsig->N*sizeof(int64_t)/2; + fpsize = p->fsig->N*sizeof(float); + + cudaMalloc(&p->out, asize); + cudaMalloc(&p->ndx, ipsize); + cudaMalloc(&p->frame, fpsize); + cudaMalloc(&p->previous, fpsize/2); + cudaMemset(p->previous, 0, fpsize/2); + cudaMemset(p->ndx, 0, ipsize); + cudaMemset(p->out, 0, sizeof(float)*p->vsamps); + + asize = p->vsamps*sizeof(float); + if(p->out_.auxp == NULL || + p->out_.size < asize) + csound->AuxAlloc(csound, asize , &p->out_); + + p->count = 0; + return OK; +} + +__global__ void sample(float *out, float *frame, float pitch, int64_t *ph, + float *amps, int vsize, float sr) { + + int t = (threadIdx.x + blockIdx.x*blockDim.x); + int n = t%vsize; /* sample index */ + int h = t/vsize; /* bin index */ + //if(amps[h] < 0.001) return; + int k = h<<1; + int64_t lph; + float a = amps[h], ascl = ((float)n)/vsize; + int64_t d = (int64_t) round(frame[k+1]*pitch*FMAXLEN/sr); + lph = ph[h] + n*d; + a += ascl*(frame[k] - a); + atomicAdd(&out[n], a*sinf((2*PI*lph)/FMAXLEN)); + // if(n) return; + // ph[h] = (ph[h] + vsize*d) & PHMASK; + // amps[h] = frame[k]; +} + +__global__ void update(float *frame, float *amps, + int64_t *ph,float pitch, int vsize, float sr){ + + int h = threadIdx.x + blockIdx.x*blockDim.x; + int k = h << 1; + /* update phases and amps */ + ph[h] = (ph[h] + (int64_t)(vsize*round(pitch*frame[k+1]*FMAXLEN/sr))) & PHMASK; + amps[h] = frame[k]; +} + +static int perf_cudadsyn(CSOUND *csound, CUDADSYN *p){ + + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + float *out_ = (float *) p->out_.auxp; + cs_float *asig = p->asig; + int count = p->count, vsamps = p->vsamps; + p->fp = (float *) (p->fsig->frame.auxp); + + if (UNLIKELY(offset)) memset(asig, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&asig[nsmps], '\0', early*sizeof(cs_float)); + } + + for(n=offset; n < nsmps; n++){ + if(count == 0) { + cudaMemcpy(out_,p->out,vsamps*sizeof(float),cudaMemcpyDeviceToHost); + update<<mblocks,p->mthreads>>>(p->frame, + p->previous, + p->ndx, + *p->kfreq, + vsamps, + CS_ESR); + cudaMemset(p->out, 0, sizeof(float)*vsamps); + cudaMemcpy(p->frame,p->fp,sizeof(float)*p->bins*2,cudaMemcpyHostToDevice); + sample<<blocks,p->threads>>>(p->out,p->frame, + *p->kfreq, + p->ndx, + p->previous, + vsamps, + CS_ESR); + + count = vsamps; + } + asig[n] = (cs_float) out_[vsamps - count]; + count--; + } + p->count = count; + return OK; +} + +static int destroy_cudadsyn(CSOUND *csound, void *pp){ + CUDADSYN *p = (CUDADSYN *) pp; + cudaFree(p->out); + cudaFree(p->ndx); + cudaFree(p->previous); + cudaFree(p->frame); + return OK; +} + + +static OENTRY localops[] = { + {"cudasynth", S(CUDADSYN), 0, "a", "fkko", (SUBR) init_cudadsyn, + (SUBR) perf_cudadsyn, (SUBR) destroy_cudadsyn, NULL, 0} +}; + +extern "C" { + LINKAGE +} + diff --git a/7.x/src/CUDA/conv.cu b/7.x/src/CUDA/conv.cu new file mode 100644 index 0000000..a00b949 --- /dev/null +++ b/7.x/src/CUDA/conv.cu @@ -0,0 +1,152 @@ +// -*- c++ -*- +/* conv.cu + + (c) Victor Lazzarini, 2013 + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + +#include + +#define S(x) sizeof(x) + +__global__ void convol(cs_float *out, cs_float *del, cs_float *coefs, int irsize, int rp, int vsize) { + int t = (threadIdx.x + blockIdx.x*blockDim.x); + if(t >= irsize*vsize) return; + int n = t%vsize; /* sample index */ + int h = t/vsize; /* coeff index */ + int end = irsize+vsize; + rp += n + h; /* read point, oldest -> newest */ + out[t] = del[rp < end ? rp : rp%end]*coefs[irsize-1-h]; /* single tap */ + if(t >= vsize) return; + __syncthreads(); + cs_float a = 0.0; + for(int i=1, j=vsize; i < irsize; i++, j+=vsize) + a += out[n + j]; /* mix all taps */ + out[n] += a; +} + +// __device__ double atomicAdd(double* address, double val) +// { +// unsigned long long int* address_as_ull = +// (unsigned long long int*)address; +// unsigned long long int old = *address_as_ull, assumed; +// do { +// assumed = old; +// old = atomicCAS(address_as_ull, assumed, +// __double_as_longlong(val + +// __longlong_as_double(assumed))); +// } while (assumed != old); +// return __longlong_as_double(old); +// } + +// __global__ void convol2(cs_float *out, cs_float *del, cs_float *coefs, int irsize, int rp, int vsize) { +// int t = (threadIdx.x + blockIdx.x*blockDim.x); +// if(t >= irsize*vsize) return; +// int n = t%vsize; /* sample index */ +// int h = t/vsize; /* coeff index */ +// int end = irsize+vsize; +// rp += n + h; /* read point, oldest -> newest */ +// cs_float s = del[rp < end ? rp : rp%end]*coefs[irsize-1-h]; /* single tap */ +// t == n ? out[n] = s : atomicAdd(&out[n], s); +// } + +typedef struct _CONV { + OPDS h; + cs_float *aout, *asig, *ifn; + cs_float *coeffs, *out, *del; + int wp, irsize; + int blocks, threads; +} CONV; + + +static int destroy_conv(CSOUND *csound, void *pp){ + CONV *p = (CONV *) pp; + cudaFree(p->coeffs); + cudaFree(p->del); + cudaFree(p->out); + return OK; +} + +static int conv_init(CSOUND *csound, CONV *p){ + + FUNC *ftab = csound->FTFind(csound, p->ifn); + int irsize = ftab->flen; + int nsmps = CS_KSMPS; + int threads = irsize*nsmps; + + cudaMalloc(&p->coeffs, sizeof(cs_float)*irsize); + cudaMemcpy(p->coeffs, ftab->ftable, sizeof(cs_float)*irsize, + cudaMemcpyHostToDevice); + + cudaMalloc(&p->del, sizeof(cs_float)*(irsize+nsmps)); + cudaMalloc(&p->out, sizeof(cs_float)*threads); + cudaMemset(p->del,0,sizeof(cs_float)*(irsize+nsmps)); + cudaMemset(p->out, 0, sizeof(cs_float)*threads); + + p->wp = 0; + p->irsize = irsize; + + cudaDeviceProp deviceProp; + cudaGetDeviceProperties(&deviceProp, 0); + int blockspt = deviceProp.maxThreadsPerBlock; + csound->Message(csound, "CUDAconv: using device %s (capability %d.%d)\n", + deviceProp.name,deviceProp.major, deviceProp.minor); + + p->blocks = threads > blockspt ? ceil(threads/blockspt) : 1; + p->threads = threads > blockspt ? blockspt : threads; + + if(csound->GetDebug(csound)) + csound->Message(csound, "blocks %d, threads %d - %d\n", p->blocks, p->threads, threads); + + return OK; + +} +/* the delay size is irsize + vsize so that + we can shift in a whole block of samples */ +int conv_perf(CSOUND *csound, CONV *p){ + + int nsmps = CS_KSMPS; + cs_float *sig = p->asig, *aout = p->aout; + cs_float *del = p->del, *out = p->out, *coefs = p->coeffs; + int irsize = p->irsize; + int wp = p->wp; + + if(wp > irsize) { + int front = wp - irsize; + cudaMemcpy(&del[wp], sig, sizeof(cs_float)*(nsmps-front), cudaMemcpyHostToDevice); + cudaMemcpy(del, &sig[nsmps-front], sizeof(cs_float)*front, cudaMemcpyHostToDevice); + } + else cudaMemcpy(&del[wp], sig, sizeof(cs_float)*nsmps, cudaMemcpyHostToDevice); + + wp = (wp+nsmps)%(irsize+nsmps); /* wp is now the oldest sample in the delay */ + convol<<blocks,p->threads>>>(out, del, coefs, irsize, wp, nsmps); + + cudaMemcpy(aout, out, sizeof(cs_float)*nsmps, cudaMemcpyDeviceToHost); + p->wp = wp; + return OK; +} + +static OENTRY localops[] = { + {"cudaconv", S(CONV), 0, "a", "ai", (SUBR) conv_init, + (SUBR) conv_perf, (SUBR) destroy_conv, NULL, 0}, +}; + +extern "C" { + LINKAGE +} diff --git a/7.x/src/CUDA/pconv.cu b/7.x/src/CUDA/pconv.cu new file mode 100644 index 0000000..1383f26 --- /dev/null +++ b/7.x/src/CUDA/pconv.cu @@ -0,0 +1,261 @@ +// -*- c++ -*- +/* pconv.cu + (c) Victor Lazzarini, 2013 + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ +#include +#include + +#define S(x) sizeof(x) + +/* + each kernel processes one bin +*/ +__global__ void pconvol(float *out,float *in, + float *coef,int rp, int dftsize, + int nparts, int end) { + float re,im,re2,im2; + + /* thread count */ + int t = (threadIdx.x + blockIdx.x*blockDim.x); + + int k = t<<1; /* coef pos */ + int n = k%(dftsize+2); /* inframe pos */ + + /* if beyond the buffer end, exit */ + if(k >= end) return; + rp += k/(dftsize+2); /* rp pos */ + + /* select correct input buffer */ + in += (rp < nparts ? rp : rp%nparts)*(dftsize+2); + + re = coef[k]; im = coef[k+1]; + re2 = in[n]; im2 = in[n+1]; + + /* complex multiplication + sums */ + atomicAdd(&out[n], re*re2 - im*im2); + (n || n != dftsize) ? atomicAdd(&out[n+1], re*im2 + re2*im) : im; + +} + +/* sample-by-sample overlap-add operation */ +__global__ void olapadd(float *buf, float *in, int parts){ + int n = (threadIdx.x + blockIdx.x*blockDim.x); + buf[n] = in[n] + buf[parts+n]; + buf[parts+n] = in[parts+n]; +} + + + +typedef struct _pconv{ + OPDS h; + cs_float *aout, *asig, *ifn, *parts; + float *out, *coef, *in, *buf; + AUXCH bufin, bufout; + int wp, nparts, dftsize, cnt; + cufftHandle plan, iplan; + int threads, blocks, othreads, oblocks; +} PCONV; + + +int isPowerOfTwo (unsigned int x) +{ + return ((x != 0) && !(x & (x - 1))); +} + + +static int destroy_pconv(CSOUND *csound, void *pp){ + PCONV *p = (PCONV *) pp; + cufftDestroy(p->plan); + cufftDestroy(p->iplan); + cudaFree(p->coef); + cudaFree(p->in); + cudaFree(p->out); + cudaFree(p->buf); + return OK; +} + + +int pconv_init(CSOUND *csound, PCONV *p){ + + FUNC *ftab = csound->FTFind(csound, p->ifn); + float *tmp; + int tlen = ftab->flen; + int end, i, j, k, parts = *p->parts, dftsize, nparts; + cs_float *tab = ftab->ftable; + + if(!isPowerOfTwo(parts)) + return csound->InitError(csound, "partition size needs to be power of two\n"); + + if(parts > tlen) + return csound->InitError(csound, "partition size too big \n"); + + end = tlen + parts - 1; + + nparts = end / parts; + dftsize = parts << 1; + end = nparts*(dftsize+2); + + cudaMalloc(&p->coef, sizeof(float)*end); + cudaMalloc(&p->in, sizeof(float)*end); + cudaMalloc(&p->out, sizeof(float)*(dftsize+2)); + cudaMalloc(&p->buf, sizeof(float)*(dftsize)); + cudaMemset(p->in,0,sizeof(float)*end); + cudaMemset(p->out, 0, sizeof(float)*(dftsize+2)); + cudaMemset(p->buf, 0, sizeof(float)*(dftsize)); + cudaMemset(p->coef, 0, sizeof(float)*end); + + p->wp = 0; + + if(!p->bufin.auxp || p->bufin.size < sizeof(float)*dftsize) + csound->AuxAlloc(csound, sizeof(float)*dftsize, &p->bufin); + if(!p->bufout.auxp || p->bufout.size < sizeof(float)*parts) + csound->AuxAlloc(csound, sizeof(float)*parts, &p->bufout); + + memset(p->bufout.auxp, 0, sizeof(float)*parts); + + tmp = (float *) p->bufin.auxp; + cufftPlan1d(&p->plan, dftsize, CUFFT_R2C, 1); +#if __CUDACC_VER_MAJOR__ < 8 + cufftSetCompatibilityMode(p->plan, CUFFT_COMPATIBILITY_NATIVE); +#endif + cufftPlan1d(&p->iplan, dftsize, CUFFT_C2R, 1); +#if __CUDACC_VER_MAJOR__ < 8 + cufftSetCompatibilityMode(p->iplan, CUFFT_COMPATIBILITY_NATIVE); +#endif + + for(i =0, k=0; i < nparts; i++){ + for(j=0; j < dftsize; j++) + tmp[j] = j < parts && k < tlen ? tab[k++] : 0.f; + float *pp = p->coef + (nparts - 1 - i)*(dftsize+2); + cudaMemcpy(pp, tmp, sizeof(float)*dftsize, + cudaMemcpyHostToDevice); + // csound->Message(csound,"CUDA init: copy buffer %d to device\n",i); + cufftExecR2C(p->plan,pp,(cufftComplex*)pp); + //csound->Message(csound,"CUDA init: done transform %d\n",i); + } + + cudaDeviceSynchronize(); + cudaDeviceProp deviceProp; + cudaGetDeviceProperties(&deviceProp, 0); + int blockspt = deviceProp.maxThreadsPerBlock; + csound->Message(csound, "CUDApconv: using device %s (capability %d.%d)\n", + deviceProp.name,deviceProp.major, deviceProp.minor); + + + end >>= 1; + + p->blocks = end > blockspt ? ceil(end/blockspt) : 1; + p->threads = end > blockspt ? blockspt : end; + p->oblocks = parts > blockspt ? ceil(parts/blockspt) : 1; + p->othreads = parts > blockspt ? blockspt : parts; + + if(csound->GetDebug(csound)) + csound->Message(csound, + "blocks %d - threads/block %d - threads %d - dftsize %d - parts %d\n", + p->blocks, p->threads, end, dftsize, nparts); + + p->nparts = nparts; + p->dftsize = dftsize; + p->cnt = 0; + + return OK; +} + +int pconv_perf(CSOUND *csound, PCONV *p){ + + int dftsize = p->dftsize, cnt = p->cnt, wp = p->wp, nparts = p->nparts; + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + float *bufin = (float *) p->bufin.auxp, *bufout = (float *) p->bufout.auxp; + cs_float *asig = p->asig, *aout = p->aout; + float *in = p->in, *out = p->out, *coef = p->coef, *buf = p->buf; + int end = nparts*(dftsize+2); + int parts = *p->parts; + + if (UNLIKELY(offset)) memset(asig, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&asig[nsmps], '\0', early*sizeof(cs_float)); + } + + //csound->Message(csound,"pconv perf count: %d\n", cnt); + for(n = offset; n < nsmps; n++){ + bufin[cnt] = (float) asig[n]; + aout[n] = (cs_float) bufout[cnt]/dftsize; + + if(++cnt == parts){ + //csound->Message(csound,"CUDA execution:\n"); + /* in buffer pos */ + int pos = wp*(dftsize+2); + + /* increment delay line pos + so that it points to the oldest partition + */ + wp += 1; + if(wp == nparts) wp = 0; + + /* copy current buffer into newest partition */ + cudaMemset(out, 0, sizeof(float)*(dftsize+2)); + cudaMemcpy(&in[pos],bufin,sizeof(float)*dftsize,cudaMemcpyHostToDevice); + //csound->Message(csound,"done copy to device\n"); + + /* apply transform */ + if(cufftExecR2C(p->plan,&in[pos],(cufftComplex*)&in[pos]) + != CUFFT_SUCCESS) csound->Message(csound, "cuda fft error\n"); + if (cudaDeviceSynchronize() != cudaSuccess) + csound->Message(csound,"Cuda error: Failed to synchronize\n"); + //csound->Message(csound,"done transform\n"); + + /* convolution */ + pconvol<<blocks,p->threads>>>(out, in, coef, wp, dftsize, nparts, end); + if (cudaDeviceSynchronize() != cudaSuccess) + csound->Message(csound,"Cuda error: Failed to synchronize\n"); + //csound->Message(csound,"done convolution\n"); + + /* transform output */ + if(cufftExecC2R(p->iplan,(cufftComplex*)out,out) + != CUFFT_SUCCESS) csound->Message(csound, "cuda fft error\n"); + //csound->Message(csound,"done inverse transform\n"); + + /* overlap-add */ + olapadd<<oblocks,p->othreads>>>(buf,out,parts); + //csound->Message(csound,"done overlap-add\n"); + + /* copy buffer out */ + cudaMemcpy(bufout,buf, sizeof(float)*parts,cudaMemcpyDeviceToHost); + //csound->Message(csound,"done copy from device\n"); + + cnt = 0; + } + } + p->cnt = cnt; + p->wp = wp; + return OK; +} + +static OENTRY localops[] = { + {"cudapconv", S(PCONV), 0, "a", "aii", (SUBR) pconv_init, + (SUBR) pconv_perf, (SUBR) destroy_pconv, NULL, 0}, +}; + +extern "C" { + LINKAGE +} diff --git a/7.x/src/CUDA/pvsops.cu b/7.x/src/CUDA/pvsops.cu new file mode 100644 index 0000000..e233648 --- /dev/null +++ b/7.x/src/CUDA/pvsops.cu @@ -0,0 +1,446 @@ +// -*- c++ -*- +/* pvsops.cu + experimental cuda opcodes + + (c) Victor Lazzarini, 2013 + + based on M Puckette's pitch tracking algorithm. + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + +#include +#include + +#include + +#define S(x) sizeof(x) + +/* kernel to convert from pvs to rectangular frame */ +__global__ void frompvs(float* inframe, double* lastph, + double scal, double fac) { + + int k = threadIdx.x + blockIdx.x*blockDim.x + 1; + int i = k << 1; + float mag = inframe[i]; + double delta = (inframe[i+1] - k*scal)*fac; + double phi = fmod(lastph[k-1] + delta, TWOPI); + lastph[k-1] = phi; + inframe[i] = (float) (mag*cos(phi)); + inframe[i+1] = (float) (mag*sin(phi)); +} + +__global__ void winrotate(float* inframe2, float* inframe, float *win, + int N, int offset){ + int k = (threadIdx.x + blockIdx.x*blockDim.x); + inframe2[k] = win[k]*inframe[(k+offset)%N]; +} + +typedef struct _pvsyn{ + OPDS h; + cs_float *asig; + PVSDAT *fsig; + float *inframe; /* N */ + float *inframe2; + double *lastph; /* N/2 */ + float *win; /* N */ + int framecount; + int curframe; + AUXCH frames; + AUXCH count; + cufftHandle plan; + double scal, fac; + int bblocks, nblocks; + int bthreads, nthreads; +} PVSYN; + +static int destroy_pvsyn(CSOUND *csound, void *pp); + +static int pvsynset(CSOUND *csound, PVSYN *p){ + + int N = p->fsig->N; + + if((N != 0) && !(N & (N - 1))) { + int hsize = p->fsig->overlap; + int size, numframes, i, blockspt; + cs_float sum = 0.0, bins = N/2; + float *win; + cudaDeviceProp deviceProp; + cudaGetDeviceProperties(&deviceProp, 0); + blockspt = deviceProp.maxThreadsPerBlock; + csound->Message(csound, "CUDAsynth: using device %s (capability %d.%d)\n", + deviceProp.name,deviceProp.major, deviceProp.minor); + + if(p->fsig->wintype != 1) + return csound->InitError(csound, + "window type not implemented yet\n"); + numframes = N/hsize; + size = N*sizeof(float)*numframes; + if(p->frames.auxp == NULL || + p->frames.size < size) + csound->AuxAlloc(csound, size, &p->frames); + memset(p->frames.auxp, 0, size); + + size = sizeof(int)*numframes; + if(p->count.auxp == NULL || + p->count.size < size) + csound->AuxAlloc(csound, size, &p->count); + *((int *)(p->count.auxp)) = 0; + for(i=1; i < numframes; i++) + ((int *)(p->count.auxp))[i] = + (i + (1.f - (float)i/numframes))*N; + + size = (N+2)*sizeof(float); + cudaMalloc(&p->inframe, size); + cudaMemset(p->inframe, 0, size); + size = (N+2)*sizeof(float); + cudaMalloc(&p->inframe2, size); + size = (N+2)*sizeof(float); + cudaMalloc(&p->lastph, size); + cudaMemset(p->lastph, 0, size); + size = N*sizeof(float); + cudaMalloc(&p->win, size); + + win = (float *) malloc(sizeof(float)*(N+1)); + for(i=0; i <= N; i++) + win[i] = (float) (0.5 - 0.5*cos(i*TWOPI/N)); + + for(i = 0; i < N; i++) sum += win[i]; + sum = FL(2.0) / sum; + for(i = 0; i < N; i++) win[i] *= sum; + sum = FL(0.0); + for(i = 0; i <= N; i+=hsize) + sum += win[i] * win[i]; + sum = (1.0/N)/(sum); + for(i = 0; i < N; i++) win[i] *= 3*sum/sqrt(numframes); + cudaMemcpy(p->win,win,N*sizeof(float), + cudaMemcpyHostToDevice); + free(win); + + p->framecount = 0; + p->curframe = 0; + + p->fac = TWOPI*hsize/CS_ESR; + p->scal =CS_ESR/N; + cufftPlan1d(&p->plan, N, CUFFT_C2R, 1); +#if __CUDACC_VER_MAJOR__ < 8 + cufftSetCompatibilityMode(p->plan, CUFFT_COMPATIBILITY_NATIVE); +#endif + p->bblocks = bins > blockspt? bins/blockspt : 1; + p->nblocks = N > blockspt ? N/blockspt : 1; + p->bthreads = bins/p->bblocks; + p->nthreads = N/p->nblocks; + if(csound->GetDebug(csound)) + csound->Message(csound, "%d (%d each), %d (%d each)\n", + p->nblocks, p->nthreads, p->bblocks, p->bthreads); + return OK; + } + return csound->InitError(csound, "fftsize not power-of-two \n"); + +} + +static int pvsynperf(CSOUND *csound, PVSYN *p){ + + int N = p->fsig->N, i; + int hsize = p->fsig->overlap; + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + cs_float *asig = p->asig; + float *frames = (float *) p->frames.auxp; + int framecount = p->framecount; + int numframes = N/hsize; + int *count = (int *) p->count.auxp; + + if (UNLIKELY(offset)) memset(asig, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&asig[nsmps], '\0', early*sizeof(cs_float)); + } + + for(n=offset; n < nsmps; n++) { + + if(framecount == 0) { + int curframe = p->curframe; + /* start offset for current frame */ + int start = N*curframe; + float *cur = &(frames[start]); + float *win = (float *) p->win; + float *inframe = p->inframe; + float *inframe2 = p->inframe2; + float *fsig = (float *) p->fsig->frame.auxp; + /* copy fsig data to device */ + fsig[N+1] = fsig[1] = 0.f; + cudaMemcpy(inframe,fsig,(N+2)*sizeof(float), + cudaMemcpyHostToDevice); + /* perf pvs to rect conversion */ + frompvs<<bblocks,p->bthreads-1>>>(inframe,p->lastph,p->scal,p->fac); + /* execute inverse real FFT */ + if(cufftExecC2R(p->plan,(cufftComplex*)inframe,inframe) + != CUFFT_SUCCESS) csound->Message(csound, "cuda fft error\n"); + if (cudaDeviceSynchronize() != cudaSuccess) + csound->Message(csound,"Cuda error: Failed to synchronize\n"); + /* window and rotate data on device */ + winrotate<<nblocks,p->nthreads>>>(inframe2,inframe,win,N,hsize*curframe); + /* copy data to current out frame */ + cudaMemcpy(cur,inframe2,N*sizeof(float),cudaMemcpyDeviceToHost); + /* reset counter for this frame to the start */ + count[curframe] = start; + /* move current to next frame circularly */ + p->curframe = ++(curframe) == numframes ? 0 : curframe; + framecount = hsize; + } + asig[n] = FL(0.0); + for(i=0; i < numframes; i++){ + /* overlap-add */ + asig[n] += frames[count[i]]; + count[i]++; + } + framecount--; + } + p->framecount = framecount; + return OK; +} + +static int destroy_pvsyn(CSOUND *csound, void *pp){ + PVSYN *p = (PVSYN *) pp; + cufftDestroy(p->plan); + cudaFree(p->inframe); + cudaFree(p->inframe2); + cudaFree(p->lastph); + cudaFree(p->win); + return OK; +} + +__device__ double modTwoPi(double x) +{ + x = fmod(x,TWOPI); + return x <= -PI ? x + TWOPI : + (x > PI ? x - TWOPI : x); +} + +/* kernel to convert from rectangular to pvs frame */ +__global__ void topvs(float* aframe, double* oldph, + double scal, double fac) { + int k = threadIdx.x + blockIdx.x*blockDim.x + 1; + int i = k << 1; + + float re = aframe[i], im = aframe[i+1]; + float mag = sqrtf(re*re + im*im); + double phi = atan2f(im,re); + double delta = phi - oldph[k-1]; + oldph[k-1] = phi; + aframe[i] = mag; + aframe[i+1] = (float) ((modTwoPi(delta) + k*scal)*fac); +} + +__global__ void rotatewin(float* aframe2, float *aframe, float *win, + int N, int offset){ + int k = threadIdx.x + blockIdx.x*blockDim.x; + aframe2[(k+offset)%N] = win[k]*aframe[k]; +} + +typedef struct _pvan { + OPDS h; + PVSDAT *fsig; + cs_float *asig,*fftsize,*hsize,*winsize,*wintype; + + float *aframe; /* N */ + float *aframe2; + double *oldph; /* N/2 */ + float *win; /* N */ + + int framecount; + int curframe; + AUXCH frames; + AUXCH count; + cufftHandle plan; + double scal, fac; + int bblocks, nblocks; + int bthreads, nthreads; +} PVAN; + +static int destroy_pvanal(CSOUND *csound, void *pp); + +static int pvanalset(CSOUND *csound, PVAN *p){ + + int N = *p->fftsize; + if((N != 0) && !(N & (N - 1))) { + int size, numframes, i, bins = N/2; + int hsize = *p->hsize, blockspt; + float *win; + cudaDeviceProp deviceProp; + cudaGetDeviceProperties(&deviceProp, 0); + blockspt = deviceProp.maxThreadsPerBlock; + csound->Message(csound, "CUDAnal: using device %s (capability %d.%d)\n", + deviceProp.name,deviceProp.major, deviceProp.minor); + + p->fsig->N = N; + p->fsig->overlap = hsize; + /* ignore winsize & wintype */ + p->fsig->winsize = N; + p->fsig->wintype = 1; + p->fsig->framecount = 0; + + numframes = N/hsize; + size = N*sizeof(float)*numframes; + if(p->frames.auxp == NULL || + p->frames.size < size) + csound->AuxAlloc(csound, size, &p->frames); + memset(p->frames.auxp, 0, size); + + size = (N+2)*sizeof(float); + if(p->fsig->frame.auxp == NULL || + p->fsig->frame.size < size) + csound->AuxAlloc(csound, size, &p->fsig->frame); + memset(p->fsig->frame.auxp, 0, size); + + size = sizeof(int)*numframes; + if(p->count.auxp == NULL || + p->count.size < size) + csound->AuxAlloc(csound, size, &p->count); + *((int *)(p->count.auxp)) = 0; + for(i=1; i < numframes; i++) + ((int *)(p->count.auxp))[i] = + (i + (float)i/numframes)*N; + + size = (N+2)*sizeof(float); + cudaMalloc(&p->aframe, size); + size = (N+2)*sizeof(float); + cudaMalloc(&p->aframe2, size); + size = (N/2-1)*sizeof(double); + cudaMalloc(&p->oldph, size); + cudaMemset(p->oldph, 0, size); + size = N*sizeof(float); + cudaMalloc(&p->win, size); + + win = (float *) malloc(sizeof(float)*N); + for(i=0; i < N; i++) + win[i] = (float) (0.5 - 0.5*cos(i*TWOPI/N)); + float sum = 0.0; + for(i = 0; i < N; i++) sum += win[i]; + sum = FL(2.0) / sum; + for(i = 0; i < N; i++) win[i] *= sum; + + cudaMemcpy(p->win,win,N*sizeof(float), + cudaMemcpyHostToDevice); + free(win); + + p->framecount = 1; + p->curframe = numframes-1; + p->fac = CS_ESR/(TWOPI*hsize); + p->scal = (TWOPI*hsize)/N; + cufftPlan1d(&p->plan, N, CUFFT_R2C, 1); +#if __CUDACC_VER_MAJOR__ < 8 + cufftSetCompatibilityMode(p->plan, CUFFT_COMPATIBILITY_NATIVE); +#endif + p->bblocks = bins > blockspt? bins/blockspt : 1; + p->nblocks = N > blockspt ? N/blockspt : 1; + p->bthreads = bins/p->bblocks; + p->nthreads = N/p->nblocks; + if(csound->GetDebug(csound)) + csound->Message(csound, "%d (%d each), %d (%d each)\n", + p->nblocks, p->nthreads, p->bblocks, p->bthreads); + return OK; + } + return csound->InitError(csound, "fftsize not power-of-two \n"); +} + +static int pvanalperf(CSOUND *csound, PVAN *p){ + + int N = p->fsig->N, i; + int hsize = p->fsig->overlap; + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + cs_float *asig = p->asig; + float *frames = (float *) p->frames.auxp; + int framecount = p->framecount; + int numframes = N/hsize; + int *count = (int *) p->count.auxp; + + if (UNLIKELY(offset)) memset(asig, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&asig[nsmps], '\0', early*sizeof(cs_float)); + } + + for(n=offset; n < nsmps; n++) { + for(i=0; i < numframes; i++){ + frames[count[i]] = asig[n]; + count[i]++; + } + framecount++; + + if(framecount == hsize) { + int curframe = p->curframe; + /* start offset for current frame */ + int start = N*curframe; + float *cur = &(frames[start]); + float *win = (float *) p->win; + float *aframe = p->aframe; + float *aframe2 = p->aframe2; + float *fsig = (float *) p->fsig->frame.auxp; + /* copy fsig data to device */ + cudaMemcpy(aframe,cur,N*sizeof(float), + cudaMemcpyHostToDevice); + /* window and rotate data on device */ + rotatewin<<nblocks,p->nthreads>>>(aframe2,aframe,win,N, + hsize*(numframes-curframe)); + /* execute inverse real FFT */ + if(cufftExecR2C(p->plan,aframe2,(cufftComplex*)aframe2) + != CUFFT_SUCCESS) csound->Message(csound, "cuda fft error\n"); + if (cudaDeviceSynchronize() != cudaSuccess) + csound->Message(csound,"Cuda error: Failed to synchronize\n"); + /* perf rect to pvs conversion */ + topvs<<bblocks,p->bthreads-1>>>(aframe2,p->oldph,p->scal,p->fac); + /* copy data to current out frame */ + cudaMemcpy(fsig,aframe2,(N+2)*sizeof(float),cudaMemcpyDeviceToHost); + /* reset counter for this frame to the start */ + fsig[N+1] = fsig[1] = 0.f; + count[curframe] = start; + /* move current to next frame circularly */ + p->curframe = --(curframe) < 0 ? numframes-1 : curframe; + framecount = 0; + p->fsig->framecount++; + } + } + p->framecount = framecount; + return OK; +} + +static int destroy_pvanal(CSOUND *csound, void *pp){ + PVAN *p = (PVAN *) pp; + cufftDestroy(p->plan); + cudaFree(p->aframe); + cudaFree(p->aframe2); + cudaFree(p->oldph); + cudaFree(p->win); + return OK; +} + +static OENTRY localops[] = { + {"cudasynth", S(PVSYN), 0, "a", "f", (SUBR) pvsynset, + (SUBR) pvsynperf, (SUBR) destroy_pvsyn, NULL, 0}, + {"cudanal", S(PVAN), 0, "f", "aiiii", (SUBR) pvanalset, + (SUBR) pvanalperf, (SUBR) destroy_pvanal, NULL, 0} +}; + +extern "C" { + LINKAGE +} diff --git a/7.x/src/CUDA/slidingm.cu b/7.x/src/CUDA/slidingm.cu new file mode 100644 index 0000000..b95ecdb --- /dev/null +++ b/7.x/src/CUDA/slidingm.cu @@ -0,0 +1,641 @@ +// -*- c++ -*- +/* + slindingm.cu: + + Copyright (C) 2014 Russell Bradford, Victor Lazzarini, John ffitch + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ +// slindingm.cu +// experimental cuda opcodes +// using the sliding DFT +// adapted from Russell Bradford & John ffitch +// + +#include +#if defined(WIN32) +# include +#else +# include +#endif +#include +#include +#include +#include +// #include +#include + +#define S(x) sizeof(x) + +//#define RB + +#ifndef RB +typedef float real; +#else +typedef double real; +#endif + +#define real(x) x +#define M_PI 3.14159265358979323846 +#define TWO_PI (2.0*M_PI) +#define NBATCH (256) + +#define Re(z) ((z).x) +#define Im(z) ((z).y) +#define R(p) ((p).x) +#define Theta(p) ((p).y) + +#define RectA (real(1.0)) +#define RectB (real(0.0)) +#define HannA (real(0.5)) +#define HannB (real(-0.5)) +#define A HannA +#define B2 (HannB/real(2.0)) +#define WINDOW + + +typedef double2 complex; +typedef double2 phasor; + +// Put a few things into constant memory to free up a couple of registers +//__constant__ int N, N2; +__constant__ real binbandwidth, nyquist; +// array alignment +__constant__ int offset; +// process in batches of this size +__constant__ int nbatch; + + +#define CUDA(name, args ...) { name(args); checkcuda(csound, #name, __LINE__); } +#define CHK(name) checkcuda(csound, #name, __LINE__) +#define NEXT(p) p += offset + +void checkcuda(CSOUND *csound, char* name, int line) +{ + cudaError_t err = cudaGetLastError(); + + if (err) { + csound->Message(csound, "%s: %s\nLine: %d\n", name, cudaGetErrorString(err), line); + exit(1); + } +} + +#if !defined(__CUDA_ARCH__) || __CUDA_ARCH__ >= 600 + +#else +__device__ double atomicAdd(double* address, double val) { + unsigned long long int* address_as_ull = (unsigned long long int*)address; + unsigned long long int old = *address_as_ull, assumed; + do { assumed = old; + old = atomicCAS(address_as_ull, + assumed, __double_as_longlong(val + __longlong_as_double(assumed))); + } while (assumed != old); + return __longlong_as_double(old); +} +#endif + +__device__ complex conjugate(complex z) +{ + return (complex){ Re(z), -Im(z) }; +} + +// round up to multiple of 256 +__host__ __device__ int roundup(int n) +{ + return 1 + ((n - 1) | 0xff); +} + +// Fin/Fout +// thread k does bin k; parallel across bins in a batch item.. +__global__ void slide(real deltas[/*nbatch*/], complex Fin[/*N*/], + complex Fout[/*N*nbatch*/], + real *sine, real *cosine, int N) +{ + int k = blockIdx.x * blockDim.x + threadIdx.x; + int b, N2 = N/2; + complex f; + real Fr, Fi, c, s; + + if (k > N2) return; + f = Fin[k]; + + // in constant memory + s = sine[k]; + c = cosine[k]; + + for (b = 0; b < nbatch; b++) { + Fr = Re(f) + deltas[b]; + Fi = Im(f); + f = (complex){ Fr*c - Fi*s, Fi*c + Fr*s }; + Fout[k] = f; + NEXT(Fout); + } + Fin[k] = f; +} + +__device__ real mod2Pi(real x) +{ + x = fmod(x, (real)TWO_PI); + if (x > PI) return x - TWO_PI; + if (x <= -PI) return x + TWO_PI; + return x; +} + +#ifdef RB +// below is one thread per bin, as per other kernels +// data is spread across blocks, but there is no sync across blocks +// thus cannot do in-place window +// parallel across bins in a batch item +// could do bins*batches +__global__ void window(complex Foutw[/*N*nbatch*/], + complex Fout[/*N*nbatch*/], int N) +{ + int k = blockIdx.x * blockDim.x + threadIdx.x; + int b, N2 = N/2; + complex F, Fm1, Fp1, f; + real Fr, Fi; + + // in the last block + if (k > N2) return; + + for (b = 0; b < nbatch; b++) { + F = Foutw[k]; + // conjugate reflection at edges + Fp1 = k < N2 ? Foutw[k + 1] : conjugate(Foutw[N2-1]); + Fm1 = k > 0 ? Foutw[k - 1] : conjugate(Foutw[1]); + Fr = A*Re(F) + B2*(Re(Fm1) + Re(Fp1)); + Fi = A*Im(F) + B2*(Im(Fm1) + Im(Fp1)); + + Re(f) = Fr; + Im(f) = Fi; + Fout[k] = f; + + NEXT(Fout); + NEXT(Foutw); + } +} + +// parallel across batches +// <<>> +// what is memory access pattern? +// small array sum, so not worth a tree reduction? +// middle sample only, so +- on real parts +__global__ void reconstruct(complex f[/*nbatch*N*/], real s[/*nbatch*/], int N) +{ + int k = blockIdx.x * blockDim.x + threadIdx.x; + complex *F = f + offset*k; + real sum = real(0.0); + int bin, N2 = N/2; + + if (k >= nbatch) return; + for (bin = 0; bin < N; bin += 2) { + real v0 = bin <= N2 ? Re(F[bin]) : Re(F[N - bin]); + real v1 = bin < N2 ? Re(F[bin + 1]) : Re(F[N - bin - 1]); + sum += v0 - v1; + } + s[k] = sum/N; +} + +#else +// the code below depends on fast single-precision +// atomic addition + +// this parallelises across N*nbatch +__global__ void window(complex Foutw[/*N*nbatch*/], + complex Fout[/*N*nbatch*/], int N) +{ + int n = blockIdx.x * blockDim.x + threadIdx.x; + int N2 = N/2; + int s = n/N; + int k = n%N; + complex F, Fm1, Fp1, f; + real Fr, Fi; + Foutw += s*offset; + Fout += s*offset; + + // in the last block + if (n > N*nbatch) return; + + F = Foutw[k]; + Fp1 = k < N2 ? Foutw[k + 1] : conjugate(Foutw[N2-1]); + Fm1 = k > 0 ? Foutw[k - 1] : conjugate(Foutw[1]); + + Fr = A*Re(F) + B2*(Re(Fm1) + Re(Fp1)); + Fi = A*Im(F) + B2*(Im(Fm1) + Im(Fp1)); + + Re(f) = Fr; + Im(f) = Fi; + Fout[k] = f; +} + +// this parallelises across N2*nbatch +__global__ void reconstruct(complex f[/*nbatch*N*/], real s[/*nbatch*/], int N) +{ + int n = blockIdx.x * blockDim.x + threadIdx.x, N2 = N/2; + int k = n/N2; + int bin = (n%N2)*2; + complex *F = &f[offset*k]; + + if (n >= nbatch*N2) return; + + real v0 = bin <= N2 ? Re(F[bin]) : Re(F[N - bin]); + real v1 = bin < N2 ? Re(F[bin + 1]) : Re(F[N - bin - 1]); + atomicAdd(&s[k],v0-v1); +} +#endif + + +__device__ phasor convert(complex f, real &oldiphase, int bin, int N) +{ + real Fr, Fi; + real phase, deltaphase; + phasor pha; + + Fr = Re(f); + Fi = Im(f); + + // magnitude is easy + R(pha) = hypot(Fi, Fr); + + phase = atan2(Fi, Fr); + deltaphase = phase - oldiphase; + oldiphase = phase; + + // subtract expected phase diff + deltaphase = mod2Pi(deltaphase - bin*TWO_PI/N); + + // find actual freq + // scale by bin width to give freq + Theta(pha) = binbandwidth * (bin + deltaphase*N/TWO_PI); + + return pha; +} + +__device__ phasor harmonic_shift(phasor pha, real fm) +{ + real sfreq; + + // tweak the freq using fm + // same across all channels + sfreq = Theta(pha)*fm; + + if (sfreq >= nyquist || sfreq <= -nyquist) R(pha) = real(0.0); + Theta(pha) = sfreq; + + return pha; +} + +__device__ real unconvert(phasor pha, real &oldophase, int N) +{ + real bin, phase; + + bin = Theta(pha)/binbandwidth; + phase = bin*TWO_PI/N; + phase = mod2Pi(oldophase + phase); + oldophase = phase; + + return R(pha)*cos(phase); +} + +// parallelism across bins*channels +__global__ void fmsyn(real inphase[/*N*/], complex F[/*nbatch*N*/], + real fm[/*nbatch*/], real outphase[/*N*/], int N) +{ + int k = blockIdx.x * blockDim.x + threadIdx.x; + int b, N2 = N/2; + real oldiphase, oldophase, val; + phasor pha; + + if (k > N2) return; + + oldiphase = inphase[k]; + oldophase = outphase[k]; + + for (b = 0; b < nbatch; b++) { + pha = convert(F[k], oldiphase, k, N); // updates oldiphase + pha = harmonic_shift(pha, fm[b]); + + // ignore imag part + val = unconvert(pha, oldophase, N); // updates oldophase + Re(F[k]) = val; + NEXT(F); + } + + inphase[k] = oldiphase; + outphase[k] = oldophase; +} + + +// blocks a multiple of 32 threads +// more blocks than multiprocessors +// perhaps 128 threads per block, as long as you have more blocks than +// multiprocessors +void threadblock(int device, int n, int *nblocks, int *nthreads) +{ + int nt, nb, nproc; + cudaDeviceProp deviceProp; + + //printf("%d threads needed\n", n); + + cudaGetDeviceProperties(&deviceProp, device); + nt = deviceProp.warpSize; // usually 32 threads + nproc = deviceProp.multiProcessorCount; + + nb = 1 + (n - 1)/nt; + + + //more blocks than procs + if (nb >= 2*nproc) { + nt *= 2; // 64 threads + nb = 1 + (n - 1)/nt; + } + + // // still more blocks than procs + if (nb >= 2*nproc) { + nt *= 2; // 128 threads + nb = 1 + (n - 1)/nt; + } + + if (nblocks) *nblocks = nb; + if (nthreads) *nthreads = nt; +} + +typedef struct _SPV { + OPDS h; + cs_float *out, *in, *shift, *iN; + int nbins, ptr, nbtch, nblocks, nblocks1, nthreads, nthreads1, rblocks, rthreads; + real *deltas, *ddeltas, *dinphase, *doutphase, *dfm; + real *sine, *cosine; + complex *dFin, *dFout, *dFoutw; + real *samples, srate; + real *framesin, *framesout, *fm; + AUXCH aframesfm, aframesout, aframesin; + uint32_t count; +} SPV; + + +void init_tables(CSOUND *csound, SPV *p, int nbins) +{ + int k; + real s[nbins], c[nbins]; + + for (k = 0; k < nbins; k++) { + sincos(TWO_PI*k/nbins, &s[k], &c[k]); + } + + CUDA(cudaMemcpy, p->sine, s, nbins*sizeof(real), cudaMemcpyHostToDevice); + CUDA(cudaMemcpy, p->cosine, c, nbins*sizeof(real), cudaMemcpyHostToDevice); +} + +void cuinit(CSOUND *csound, + SPV *p, uint32_t nframes, + int nbins, int device) +{ + int csize, rsize, off, nbins2; + real binbw, nyq; + cudaDeviceProp deviceProp; + + if(!p->aframesin.auxp || p->aframesin.size < sizeof(real)*NBATCH) + csound->AuxAlloc(csound, sizeof(real)*NBATCH, &p->aframesin); + if(!p->aframesout.auxp || p->aframesout.size < sizeof(real)*NBATCH) + csound->AuxAlloc(csound, sizeof(real)*NBATCH, &p->aframesout); + if(!p->aframesfm.auxp || p->aframesfm.size < sizeof(real)*NBATCH) + csound->AuxAlloc(csound, sizeof(real)*NBATCH, &p->aframesfm); + + p->framesin = (real *) p->aframesin.auxp; + p->framesout = (real *) p->aframesout.auxp; + p->fm = (real *) p->aframesfm.auxp; + + p->nbins = nbins; + nbins2 = nbins/2; + p->nbtch = nframes; + p->srate = (real) CS_ESR; + binbw = p->srate/p->nbins; + nyq = p->srate/real(2.0); + + CUDA(cudaSetDevice, device); + + cudaGetDeviceProperties(&deviceProp, device); + + // allocate contiguous arrays to aid cudaMemcpy; round up to align + // arrays for coalescence + csize = roundup(p->nbins*sizeof(complex)); + rsize = roundup(p->nbins*sizeof(real)); + off = csize/sizeof(complex); + + if (off != rsize/sizeof(real)) { + csound->InitError(csound, "Something weird happening with offsets at line %d\n", + __LINE__); + } + + if (!csound->QueryGlobalVariable(csound, "::cusliding::init")) { + csound->CreateGlobalVariable(csound, "::cusliding::init",1); +#ifndef RB + csound->Message(csound, "Sliding PV: using floats on device %s (capability %d.%d)\n", deviceProp.name, + deviceProp.major, deviceProp.minor); +#else + csound->Message(csound, "Sliding PV: using doubles on device %s (capability %d.%d)\n", deviceProp.name, + deviceProp.major, deviceProp.minor); +#endif + // global constants + CUDA(cudaMemcpyToSymbol, offset, &off, sizeof(int)); + CUDA(cudaMemcpyToSymbol, nbatch, &p->nbtch, sizeof(int)); + CUDA(cudaMemcpyToSymbol, binbandwidth, &binbw, sizeof(real)); + CUDA(cudaMemcpyToSymbol, nyquist, &nyq, sizeof(real)); + + } + // N complexes + CUDA(cudaMalloc, &p->dFin, csize); + CUDA(cudaMemset, p->dFin, 0, csize); + + // N*nbatch complexes + CUDA(cudaMalloc, &p->dFout, p->nbtch*csize); + CUDA(cudaMalloc, &p->dFoutw, p->nbtch*csize); + + // N reals + CUDA(cudaMalloc, &p->dinphase, p->nbins*sizeof(real)); + CUDA(cudaMalloc, &p->doutphase, p->nbins*sizeof(real)); + CUDA(cudaMemset, p->dinphase, 0, p->nbins*sizeof(real)); + CUDA(cudaMemset, p->doutphase, 0, p->nbins*sizeof(real)); + + CUDA(cudaMalloc, &p->sine, p->nbins*sizeof(real)); + CUDA(cudaMalloc, &p->cosine, p->nbins*sizeof(real)); + + // nbatch reals + CUDA(cudaMalloc, &p->ddeltas, p->nbtch*sizeof(real)); + CUDA(cudaMalloc, &p->dfm, p->nbtch*sizeof(real)); + + // circular history of nbins samples + p->samples = (real*) csound->Calloc(csound, p->nbins*sizeof(real)); + if (p->samples == NULL) { + csound->InitError(csound, "calloc failed at line %d\n", __LINE__); + return; + } + + // pinned memory is marginally faster + //CUDA(cudaHostAlloc, &deltas, p->nbtch*sizeof(real), cudaHostAllocDefault); + p->deltas = (real*) csound->Malloc(csound, p->nbtch*sizeof(real)); + if (p->deltas == NULL) { + csound->InitError(csound, "malloc failed at line %d\n", __LINE__); + return; + } + + init_tables(csound, p, p->nbins); + + // index of oldest sample + p->ptr = 0; + +#ifdef RB + threadblock(device, p->nbtch, &p->rblocks, &p->rthreads); +#else + threadblock(device, p->nbtch*(nbins2), &p->rblocks, &p->rthreads); + threadblock(device, p->nbtch*nbins, &p->nblocks1, &p->nthreads1); +#endif + threadblock(device, (nbins2+1), &p->nblocks, &p->nthreads); + + if(csound->GetDebug(csound)) { + csound->Message(csound, "%d bins, %d actual\n", p->nbins, nbins2 + 1); + csound->Message(csound, "csize = %d -> %d bytes, offset %d elements\n", (int) (p->nbins*sizeof(complex)), + csize, off); + csound->Message(csound, "%gHz bin bandwidth, Nyquist %gHz\n", binbw, nyq); + csound->Message(csound, "period %d samples (%g sec)\n", p->nbtch, (real)p->nbtch/p->srate); + csound->Message(csound, "%d multiprocessors\n", deviceProp.multiProcessorCount); + csound->Message(csound, "%d blocks with %d threads = %d\n", p->nblocks, p->nthreads, + p->nblocks1*p->nthreads); + csound->Message(csound, "%d idle threads in last block\n", p->nblocks*p->nthreads - + (nbins2 + 1)); + csound->Message(csound, "%d blocks per SM\n", + (int)ceil((double)p->nblocks/deviceProp.multiProcessorCount)); + csound->Message(csound, "reconstruct using %d blocks of %d threads = %d\n", p->rblocks, p->rthreads, + p->rblocks*p->rthreads); + } +} + +int cushutdown(CSOUND *csound, void *pp) +{ + SPV *p = (SPV *) pp; + csound->Free(csound, p->samples); + + CUDA(cudaFree, p->dinphase); + CUDA(cudaFree, p->doutphase); + CUDA(cudaFree, p->ddeltas); + CUDA(cudaFree, p->dFoutw); + CUDA(cudaFree, p->dFout); + CUDA(cudaFree, p->dFin); + CUDA(cudaFree, p->sine); + CUDA(cudaFree, p->cosine); + + //CUDA(cudaFreeHost, deltas); + csound->Free(csound, p->deltas); + + if(csound->GetDebug(csound)) + csound->Message(csound, "cuda shutdown\n"); + + return OK; +} + +// in samples with channels muxed 0 1 2 0 1 2 ... +void cuprocess(CSOUND *csound, SPV *p, real in[/*nbatch*/], real out[/*nbatch*/], + real fm[/*nbatch*/]) +{ + int b; + + for (b = 0; b < p->nbtch; b++) { + p->deltas[b] = in[b] - p->samples[p->ptr]; + p->samples[p->ptr] = in[b]; + p->ptr = (p->ptr + 1) % (p->nbins); + } + + CUDA(cudaMemcpy, p->ddeltas, p->deltas, p->nbtch*sizeof(real), + cudaMemcpyHostToDevice); + + slide<<nblocks,p->nthreads>>>(p->ddeltas, p->dFin, p->dFoutw, + p->sine, p->cosine, p->nbins); + cudaDeviceSynchronize(); CHK(slide); + + // Foutw and Fout must be separate to avoid data race +#ifdef RB + window<<nblocks,p->nthreads>>>(p->dFoutw, p->dFout, p->nbins); +#else + window<<nblocks1,p->nthreads1>>>(p->dFoutw, p->dFout, p->nbins); +#endif + cudaDeviceSynchronize(); CHK(window); + + CUDA(cudaMemcpy, p->dfm, fm, p->nbtch*sizeof(real), cudaMemcpyHostToDevice); + + fmsyn<<nblocks,p->nthreads>>>(p->dinphase, p->dFout, p->dfm, p->doutphase, p->nbins); + + // reuse ddeltas array + reconstruct<<rblocks,p->rthreads>>>(p->dFout, p->ddeltas, p->nbins); + CHK(reconstruct); + // is is faster to transfer to pinned memory then copy; or just + // transfer directly to out? + CUDA(cudaMemcpy, out, p->ddeltas, p->nbtch*sizeof(real), + cudaMemcpyDeviceToHost); + +#ifndef RB + for(b=0; b < p->nbtch; b++) out[b] /= p->nbins; +#endif + +} + + +int spv_init(CSOUND *csound, SPV *p) { + cuinit(csound,p,NBATCH,*p->iN,0); + return OK; +} + +int spv_perf(CSOUND *csound, SPV *p) { + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + uint32_t count = p->count; + + if (UNLIKELY(offset)) memset(p->out, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->out[nsmps], '\0', early*sizeof(cs_float)); + } + + for(n=offset; n < nsmps; n++) { + p->framesin[count] = p->in[n]; + p->out[n] = p->framesout[count]; + p->fm[count] = p->shift[n]; + count++; + if(count == NBATCH) { + cuprocess(csound, p,p->framesin,p->framesout,p->fm); + count = 0; + } + + } + + p->count = count; + return OK; +} + +static OENTRY localops[] = { + {"cudasliding", S(SPV), 0, "a", "aai", (SUBR) spv_init, + (SUBR) spv_perf, (SUBR) cushutdown, NULL, 0} +}; + +extern "C" { + LINKAGE +} + + + From a84c619e85c2b2b7392a68ccdc697e2b1a2d8c33 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 11:24:44 +0100 Subject: [PATCH 37/72] Note that the CUDA opcodes are Linux-only Windows is not built or tested; clarify the README accordingly. --- 7.x/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/7.x/README.md b/7.x/README.md index 88b9bc5..714bd8e 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -30,7 +30,7 @@ Currently, the plugins available in this tree are - p5glove (requires the p5glove driver; CMake-only, see note below) **p5gconnect p5gdata** -- CUDA (requires the CUDA toolkit; Linux/Windows only, disabled by default, see note below) +- CUDA (requires the CUDA toolkit; Linux only, disabled by default, see note below) **cudasynth cudanal cudasliding cudaconv cudapconv** @@ -98,8 +98,8 @@ They are **disabled by default** and only built when the CUDA toolkit is found: configure with `-DBUILD_CUDA_OPCODES=ON`. CUDA is **not available on macOS** (NVIDIA dropped macOS support after 10.13), so on macOS the option is ignored. The Linux CI builds them compile-only (the hosted runners have no -GPU) and they are included in the Linux release package; they cannot be built -or tested on macOS. +GPU) and they are included in the Linux release package. Windows is not built +or tested, so the CUDA opcodes are currently Linux-only. The compute capabilities default to `75 80 86 89`; override with `-DCMAKE_CUDA_ARCHITECTURES="..."` (for example `native` for the local GPU). From 108114f7459a26eb8b83768b7e4fd62c0a629ea3 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 11:25:23 +0100 Subject: [PATCH 38/72] Fix CUDA CI: install ALSA and pkg-config to build Csound The CUDA container builds Csound for its headers; Csound's CMake requires ALSA on Linux. --- .github/workflows/plugins_build_7.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index ace0e95..6cddbd6 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -338,8 +338,8 @@ jobs: run: | apt-get update apt-get install -y --no-install-recommends \ - build-essential cmake git ca-certificates \ - libsndfile1-dev flex bison + build-essential cmake git ca-certificates pkg-config \ + libsndfile1-dev libasound2-dev flex bison - name: Show CUDA toolchain run: | From 21aa3d6a24b67118b8c558b597fc598fd5ddcd05 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 11:29:49 +0100 Subject: [PATCH 39/72] Build only the CUDA opcodes in the CUDA CI job Disable the other plugins so the job does not need their dependencies. --- .github/workflows/plugins_build_7.yml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 6cddbd6..1c121d8 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -370,6 +370,15 @@ jobs: run: | cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ -DBUILD_CUDA_OPCODES=ON \ + -DBUILD_CHUA_OPCODES=OFF \ + -DBUILD_FLUID_OPCODES=OFF \ + -DBUILD_HDF5_OPCODES=OFF \ + -DBUILD_IMAGE_OPCODES=OFF \ + -DBUILD_LINEAR_ALGEBRA_OPCODES=OFF \ + -DBUILD_PYTHON_OPCODES=OFF \ + -DBUILD_WEBSOCKET_OPCODE=OFF \ + -DBUILD_WIIMOTE_OPCODES=OFF \ + -DBUILD_P5GLOVE_OPCODES=OFF \ -DCMAKE_CUDA_ARCHITECTURES="50;60;70;75;80;86" \ -DCSOUND_INCLUDE_DIR_HINT=/csound-install/include/csound \ -DCSOUND_LIBRARY_DIR_HINT=/csound-install/lib From d0c9578e198e8d3a0db076c398e8d4b6da61cd2d Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 11:56:53 +0100 Subject: [PATCH 40/72] Address CUDA review: bounds checks, launch sizing and cleanup Fixes raised in the pull request review: - validate the hopsize in cudanal and the bin count in cudasliding - guard the launch sizes in cudasynth (round up and add a bins bound) and zero the frame buffer - fix the pconvol output condition and zero aout rather than asig - NULL-check the FTFind() results in cudaconv and cudapconv - use integer ceiling for the block counts in cudaconv/cudapconv - free the cudasliding frequency-modulation buffer and clear the reused overlap buffer before reconstruction - require CMake 3.18 for the CUDA build --- 7.x/README.md | 3 ++- 7.x/src/CUDA/CMakeLists.txt | 3 +++ 7.x/src/CUDA/adsyn.cu | 24 ++++++++++++++---------- 7.x/src/CUDA/conv.cu | 5 ++++- 7.x/src/CUDA/pconv.cu | 14 +++++++++----- 7.x/src/CUDA/pvsops.cu | 2 ++ 7.x/src/CUDA/slidingm.cu | 10 +++++++++- 7 files changed, 43 insertions(+), 18 deletions(-) diff --git a/7.x/README.md b/7.x/README.md index 714bd8e..4d55ec8 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -101,7 +101,8 @@ ignored. The Linux CI builds them compile-only (the hosted runners have no GPU) and they are included in the Linux release package. Windows is not built or tested, so the CUDA opcodes are currently Linux-only. -The compute capabilities default to `75 80 86 89`; override with +Building them requires CMake 3.18 or later; with an older CMake the option +is ignored. The compute capabilities default to `75 80 86 89`; override with `-DCMAKE_CUDA_ARCHITECTURES="..."` (for example `native` for the local GPU). diff --git a/7.x/src/CUDA/CMakeLists.txt b/7.x/src/CUDA/CMakeLists.txt index 60156c9..ad06da7 100644 --- a/7.x/src/CUDA/CMakeLists.txt +++ b/7.x/src/CUDA/CMakeLists.txt @@ -7,6 +7,9 @@ if(BUILD_CUDA_OPCODES) if(APPLE) message(STATUS "CUDA is not supported on macOS; disabling BUILD_CUDA_OPCODES") set(BUILD_CUDA_OPCODES OFF) + elseif(CMAKE_VERSION VERSION_LESS 3.18) + message(STATUS "CUDA requires CMake 3.18 or later; disabling BUILD_CUDA_OPCODES") + set(BUILD_CUDA_OPCODES OFF) else() include(CheckLanguage) check_language(CUDA) diff --git a/7.x/src/CUDA/adsyn.cu b/7.x/src/CUDA/adsyn.cu index bcd5993..8ab3f98 100644 --- a/7.x/src/CUDA/adsyn.cu +++ b/7.x/src/CUDA/adsyn.cu @@ -66,13 +66,12 @@ static int init_cudadsyn(CSOUND *csound, CUDADSYN *p){ if(*p->inum > 0 && *p->inum < p->bins) p->bins = *p->inum; p->vsamps = p->fsig->overlap; + /* per-block/launch sizes, rounded up to cover all work items */ p->threads = p->bins*p->vsamps; - p->blocks = p->threads > blockspt ? p->threads/blockspt : 1; - p->mthreads = p->bins; - p->mblocks = p->mthreads > blockspt ? p->mthreads/blockspt : 1; - - p->threads /= p->blocks; - p->mthreads /= p->mblocks; + p->threads = p->threads < blockspt ? p->threads : blockspt; + p->blocks = (p->bins*p->vsamps + p->threads - 1)/p->threads; + p->mthreads = p->bins < blockspt ? p->bins : blockspt; + p->mblocks = (p->bins + p->mthreads - 1)/p->mthreads; asize = p->vsamps*sizeof(float); ipsize = p->fsig->N*sizeof(int64_t)/2; @@ -81,6 +80,7 @@ static int init_cudadsyn(CSOUND *csound, CUDADSYN *p){ cudaMalloc(&p->out, asize); cudaMalloc(&p->ndx, ipsize); cudaMalloc(&p->frame, fpsize); + cudaMemset(p->frame, 0, fpsize); cudaMalloc(&p->previous, fpsize/2); cudaMemset(p->previous, 0, fpsize/2); cudaMemset(p->ndx, 0, ipsize); @@ -96,11 +96,12 @@ static int init_cudadsyn(CSOUND *csound, CUDADSYN *p){ } __global__ void sample(float *out, float *frame, float pitch, int64_t *ph, - float *amps, int vsize, float sr) { + float *amps, int vsize, float sr, int bins) { int t = (threadIdx.x + blockIdx.x*blockDim.x); int n = t%vsize; /* sample index */ int h = t/vsize; /* bin index */ + if (h >= bins) return; //if(amps[h] < 0.001) return; int k = h<<1; int64_t lph; @@ -115,9 +116,10 @@ __global__ void sample(float *out, float *frame, float pitch, int64_t *ph, } __global__ void update(float *frame, float *amps, - int64_t *ph,float pitch, int vsize, float sr){ + int64_t *ph,float pitch, int vsize, float sr, int bins){ int h = threadIdx.x + blockIdx.x*blockDim.x; + if (h >= bins) return; int k = h << 1; /* update phases and amps */ ph[h] = (ph[h] + (int64_t)(vsize*round(pitch*frame[k+1]*FMAXLEN/sr))) & PHMASK; @@ -148,7 +150,8 @@ static int perf_cudadsyn(CSOUND *csound, CUDADSYN *p){ p->ndx, *p->kfreq, vsamps, - CS_ESR); + CS_ESR, + p->bins); cudaMemset(p->out, 0, sizeof(float)*vsamps); cudaMemcpy(p->frame,p->fp,sizeof(float)*p->bins*2,cudaMemcpyHostToDevice); sample<<blocks,p->threads>>>(p->out,p->frame, @@ -156,7 +159,8 @@ static int perf_cudadsyn(CSOUND *csound, CUDADSYN *p){ p->ndx, p->previous, vsamps, - CS_ESR); + CS_ESR, + p->bins); count = vsamps; } diff --git a/7.x/src/CUDA/conv.cu b/7.x/src/CUDA/conv.cu index a00b949..270f84b 100644 --- a/7.x/src/CUDA/conv.cu +++ b/7.x/src/CUDA/conv.cu @@ -86,6 +86,9 @@ static int destroy_conv(CSOUND *csound, void *pp){ static int conv_init(CSOUND *csound, CONV *p){ FUNC *ftab = csound->FTFind(csound, p->ifn); + if (ftab == NULL) + return csound->InitError(csound, "could not find table %d\n", + (int) *p->ifn); int irsize = ftab->flen; int nsmps = CS_KSMPS; int threads = irsize*nsmps; @@ -108,7 +111,7 @@ static int conv_init(CSOUND *csound, CONV *p){ csound->Message(csound, "CUDAconv: using device %s (capability %d.%d)\n", deviceProp.name,deviceProp.major, deviceProp.minor); - p->blocks = threads > blockspt ? ceil(threads/blockspt) : 1; + p->blocks = (threads + blockspt - 1)/blockspt; p->threads = threads > blockspt ? blockspt : threads; if(csound->GetDebug(csound)) diff --git a/7.x/src/CUDA/pconv.cu b/7.x/src/CUDA/pconv.cu index 1383f26..5c49ba8 100644 --- a/7.x/src/CUDA/pconv.cu +++ b/7.x/src/CUDA/pconv.cu @@ -50,13 +50,14 @@ __global__ void pconvol(float *out,float *in, /* complex multiplication + sums */ atomicAdd(&out[n], re*re2 - im*im2); - (n || n != dftsize) ? atomicAdd(&out[n+1], re*im2 + re2*im) : im; + if (n && n != dftsize) atomicAdd(&out[n+1], re*im2 + re2*im); } /* sample-by-sample overlap-add operation */ __global__ void olapadd(float *buf, float *in, int parts){ int n = (threadIdx.x + blockIdx.x*blockDim.x); + if(n >= parts) return; buf[n] = in[n] + buf[parts+n]; buf[parts+n] = in[parts+n]; } @@ -96,6 +97,9 @@ int pconv_init(CSOUND *csound, PCONV *p){ FUNC *ftab = csound->FTFind(csound, p->ifn); float *tmp; + if (ftab == NULL) + return csound->InitError(csound, "could not find table %d\n", + (int) *p->ifn); int tlen = ftab->flen; int end, i, j, k, parts = *p->parts, dftsize, nparts; cs_float *tab = ftab->ftable; @@ -161,9 +165,9 @@ int pconv_init(CSOUND *csound, PCONV *p){ end >>= 1; - p->blocks = end > blockspt ? ceil(end/blockspt) : 1; + p->blocks = (end + blockspt - 1)/blockspt; p->threads = end > blockspt ? blockspt : end; - p->oblocks = parts > blockspt ? ceil(parts/blockspt) : 1; + p->oblocks = (parts + blockspt - 1)/blockspt; p->othreads = parts > blockspt ? blockspt : parts; if(csound->GetDebug(csound)) @@ -190,10 +194,10 @@ int pconv_perf(CSOUND *csound, PCONV *p){ int end = nparts*(dftsize+2); int parts = *p->parts; - if (UNLIKELY(offset)) memset(asig, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(offset)) memset(aout, '\0', offset*sizeof(cs_float)); if (UNLIKELY(early)) { nsmps -= early; - memset(&asig[nsmps], '\0', early*sizeof(cs_float)); + memset(&aout[nsmps], '\0', early*sizeof(cs_float)); } //csound->Message(csound,"pconv perf count: %d\n", cnt); diff --git a/7.x/src/CUDA/pvsops.cu b/7.x/src/CUDA/pvsops.cu index e233648..53c3b6c 100644 --- a/7.x/src/CUDA/pvsops.cu +++ b/7.x/src/CUDA/pvsops.cu @@ -284,6 +284,8 @@ static int pvanalset(CSOUND *csound, PVAN *p){ int size, numframes, i, bins = N/2; int hsize = *p->hsize, blockspt; float *win; + if(hsize <= 0 || hsize > N || (N % hsize) != 0) + return csound->InitError(csound, "CUDAnal: invalid hopsize\n"); cudaDeviceProp deviceProp; cudaGetDeviceProperties(&deviceProp, 0); blockspt = deviceProp.maxThreadsPerBlock; diff --git a/7.x/src/CUDA/slidingm.cu b/7.x/src/CUDA/slidingm.cu index b95ecdb..08b2f28 100644 --- a/7.x/src/CUDA/slidingm.cu +++ b/7.x/src/CUDA/slidingm.cu @@ -534,6 +534,7 @@ int cushutdown(CSOUND *csound, void *pp) CUDA(cudaFree, p->dinphase); CUDA(cudaFree, p->doutphase); CUDA(cudaFree, p->ddeltas); + CUDA(cudaFree, p->dfm); CUDA(cudaFree, p->dFoutw); CUDA(cudaFree, p->dFout); CUDA(cudaFree, p->dFin); @@ -581,6 +582,9 @@ void cuprocess(CSOUND *csound, SPV *p, real in[/*nbatch*/], real out[/*nbatch*/] fmsyn<<nblocks,p->nthreads>>>(p->dinphase, p->dFout, p->dfm, p->doutphase, p->nbins); // reuse ddeltas array +#ifndef RB + CUDA(cudaMemset, p->ddeltas, 0, p->nbtch*sizeof(real)); +#endif reconstruct<<rblocks,p->rthreads>>>(p->dFout, p->ddeltas, p->nbins); CHK(reconstruct); // is is faster to transfer to pinned memory then copy; or just @@ -596,7 +600,11 @@ void cuprocess(CSOUND *csound, SPV *p, real in[/*nbatch*/], real out[/*nbatch*/] int spv_init(CSOUND *csound, SPV *p) { - cuinit(csound,p,NBATCH,*p->iN,0); + int nbins = (int) *p->iN; + if (nbins < 2) + return csound->InitError(csound, "cudasliding: invalid size %d\n", nbins); + p->count = 0; + cuinit(csound,p,NBATCH,nbins,0); return OK; } From 01b4b042f18fb89add7a6877c82f3f1a44b28f3f Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 12:02:22 +0100 Subject: [PATCH 41/72] Annotate CUDA sources with FIXMEs for deferred review fixes Mark the three review findings that need larger rewrites: the cross-block __syncthreads() in cudaconv, the exit(1) in the cudasliding CUDA error check, and the module-global __constant__ values used by the sliding DFT. --- 7.x/src/CUDA/conv.cu | 4 ++++ 7.x/src/CUDA/slidingm.cu | 9 +++++++++ 2 files changed, 13 insertions(+) diff --git a/7.x/src/CUDA/conv.cu b/7.x/src/CUDA/conv.cu index 270f84b..203dbd3 100644 --- a/7.x/src/CUDA/conv.cu +++ b/7.x/src/CUDA/conv.cu @@ -34,6 +34,10 @@ __global__ void convol(cs_float *out, cs_float *del, cs_float *coefs, int irsize rp += n + h; /* read point, oldest -> newest */ out[t] = del[rp < end ? rp : rp%end]*coefs[irsize-1-h]; /* single tap */ if(t >= vsize) return; + /* FIXME: __syncthreads() only synchronizes threads within a block, but + the taps below are then mixed across blocks, which is incorrect (this + also skips the threads that returned above). Needs a two-stage scheme: + one kernel to compute every tap and a second to reduce them. */ __syncthreads(); cs_float a = 0.0; for(int i=1, j=vsize; i < irsize; i++, j+=vsize) diff --git a/7.x/src/CUDA/slidingm.cu b/7.x/src/CUDA/slidingm.cu index 08b2f28..72961d5 100644 --- a/7.x/src/CUDA/slidingm.cu +++ b/7.x/src/CUDA/slidingm.cu @@ -79,6 +79,10 @@ __constant__ real binbandwidth, nyquist; __constant__ int offset; // process in batches of this size __constant__ int nbatch; +/* FIXME: __constant__ memory is module-global, so these values clash when + more than one instance of the opcode is active, and the symbol copy + fails for some sizes (the declaration can be optimised out when unused). + These per-instance values should be passed as kernel arguments instead. */ #define CUDA(name, args ...) { name(args); checkcuda(csound, #name, __LINE__); } @@ -91,6 +95,9 @@ void checkcuda(CSOUND *csound, char* name, int line) if (err) { csound->Message(csound, "%s: %s\nLine: %d\n", name, cudaGetErrorString(err), line); + /* FIXME: this aborts the whole host process on any CUDA error; it + should propagate the error through the CUDA()/CHK() macros (and out + of init/perf) instead, which touches every call site. */ exit(1); } } @@ -453,6 +460,8 @@ void cuinit(CSOUND *csound, deviceProp.major, deviceProp.minor); #endif // global constants + /* FIXME: see the note on the __constant__ declarations above; these are + module-global and only copied on the first init. */ CUDA(cudaMemcpyToSymbol, offset, &off, sizeof(int)); CUDA(cudaMemcpyToSymbol, nbatch, &p->nbtch, sizeof(int)); CUDA(cudaMemcpyToSymbol, binbandwidth, &binbw, sizeof(real)); From ad9fdaaa7d661051a332de9f5203fc1b213374e5 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 12:24:49 +0100 Subject: [PATCH 42/72] Add OpenCL opcodes (cladsyn) Port the Csound 6.x OpenCL plugin (cladsynth.c) to the Csound 7 plugin API as the cladsyn opcode, plus the CMake plumbing to build it on all platforms: - 7.x/src/OpenCL: source and CMakeLists with a BUILD_OPENCL_OPCODES option, using find_package(OpenCL) (system framework on macOS, ocl-icd on Linux, vcpkg opencl port on Windows). - 7.x/CMakeLists.txt: add the OpenCL subdirectory. - 7.x/vcpkg.json and x64-windows-csound.cmake: add the windows-only opencl dependency with dynamic linkage. - CI: install ocl-icd-opencl-dev on Linux and stage the OpenCL plugins on Linux and macOS. - README: document the opcode, the note and the build option. --- .github/workflows/plugins_build_7.yml | 7 +- 7.x/CMakeLists.txt | 1 + 7.x/README.md | 19 +- 7.x/src/OpenCL/CMakeLists.txt | 24 ++ 7.x/src/OpenCL/cladsynth.c | 393 ++++++++++++++++++++++++++ 7.x/vcpkg.json | 3 +- 7.x/x64-windows-csound.cmake | 2 +- 7 files changed, 444 insertions(+), 5 deletions(-) create mode 100644 7.x/src/OpenCL/CMakeLists.txt create mode 100644 7.x/src/OpenCL/cladsynth.c diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 1c121d8..00bf9d5 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -71,6 +71,7 @@ jobs: libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ libeigen3-dev libfluidsynth-dev libpng-dev \ libwebsockets-dev libuv1-dev libhdf5-dev \ + ocl-icd-opencl-dev \ flex bison - name: Cache Csound install @@ -114,7 +115,8 @@ jobs: build/src/image/*.so \ build/src/websockets/*.so \ build/src/hdf5/*.so \ - build/src/py/*.so package/ + build/src/py/*.so \ + build/src/OpenCL/*.so package/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -216,7 +218,8 @@ jobs: build/src/image/*.dylib \ build/src/websockets/*.dylib \ build/src/hdf5/*.dylib \ - build/src/py/*.dylib package/ + build/src/py/*.dylib \ + build/src/OpenCL/*.dylib package/ - name: Upload plugins uses: actions/upload-artifact@v4 diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index a3bea3e..ff9f79b 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -312,3 +312,4 @@ add_subdirectory(./src/py) add_subdirectory(./src/wiimote) add_subdirectory(./src/p5glove) add_subdirectory(./src/CUDA) +add_subdirectory(./src/OpenCL) diff --git a/7.x/README.md b/7.x/README.md index 4d55ec8..7ccc2ae 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -33,6 +33,9 @@ Currently, the plugins available in this tree are - CUDA (requires the CUDA toolkit; Linux only, disabled by default, see note below) **cudasynth cudanal cudasliding cudaconv cudapconv** +- OpenCL (requires the OpenCL headers/loader; see note below) +**cladsyn** + Fluid settings opcodes --- @@ -106,6 +109,20 @@ is ignored. The compute capabilities default to `75 80 86 89`; override with `-DCMAKE_CUDA_ARCHITECTURES="..."` (for example `native` for the local GPU). +OpenCL opcodes +--- + +The `OpenCL` opcode (`cladsyn`) is a port of the Csound 6.x plugin to the +Csound 7 plugin API. It runs its DSP kernels on any available OpenCL device +(CPU or GPU) through the ICD loader. + +It is built by default when OpenCL is available: the system framework is used +on macOS, `ocl-icd-opencl-dev` on Linux and the vcpkg `opencl` port on Windows. +Configure with `-DBUILD_OPENCL_OPCODES=OFF` to exclude it. The CI builds it +compile-only (the hosted runners have no OpenCL device) and it is included in +the Linux, macOS and Windows release packages. + + Install location -------------- The CMake scripts in this repository use the default CS_USER_PLUGIN @@ -146,7 +163,7 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_CUDA_OPCODES`, -`BUILD_FLUID_OPCODES`, +`BUILD_OPENCL_OPCODES`, `BUILD_FLUID_OPCODES`, `BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, `BUILD_P5GLOVE_OPCODES`, `BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to diff --git a/7.x/src/OpenCL/CMakeLists.txt b/7.x/src/OpenCL/CMakeLists.txt new file mode 100644 index 0000000..1244184 --- /dev/null +++ b/7.x/src/OpenCL/CMakeLists.txt @@ -0,0 +1,24 @@ +# Build the OpenCL opcodes. +# +# The OpenCL headers and ICD loader come from the system framework on macOS, +# from vcpkg on Windows, and from ocl-icd-opencl-dev on Linux. +option(BUILD_OPENCL_OPCODES "Build the OpenCL opcodes" ON) + +if(APPLE OR NOT USE_VCPKG) + find_package(OpenCL) +else() + find_package(OpenCL CONFIG) +endif() + +check_deps(BUILD_OPENCL_OPCODES OpenCL_FOUND) + +if(BUILD_OPENCL_OPCODES AND OpenCL_FOUND) + make_plugin(clop cladsynth.c) + target_include_directories(clop PRIVATE ${CSOUND_INCLUDE_DIRS}) + if(TARGET OpenCL::OpenCL) + target_link_libraries(clop PRIVATE OpenCL::OpenCL) + else() + target_include_directories(clop PRIVATE ${OpenCL_INCLUDE_DIRS}) + target_link_libraries(clop PRIVATE ${OpenCL_LIBRARIES}) + endif() +endif() diff --git a/7.x/src/OpenCL/cladsynth.c b/7.x/src/OpenCL/cladsynth.c new file mode 100644 index 0000000..abc0c0f --- /dev/null +++ b/7.x/src/OpenCL/cladsynth.c @@ -0,0 +1,393 @@ +/* + cladsynth.c + + (c) Victor Lazzarini, 2014 + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ +#include +#include + +#ifdef __MACH__ +#include +#else +#include +#endif + +#define S(x) sizeof(x) + +const char *code = + "#define FMAXLEN ((float)0x40000000) \n" + "#define PHMASK 0x3fffffff \n" + "#define PI 3.1415926f\n" + "inline void AtomicAdd(volatile __global float *source, const float operand) {\n" + " union {\n" + " unsigned int intVal;\n" + " float floatVal;\n" + " } newVal;\n" + " union {\n" + " unsigned int intVal;\n" + " float floatVal;\n" + " } prevVal;\n" + " do {\n" + " prevVal.floatVal = *source;\n" + " newVal.floatVal = prevVal.floatVal + operand;\n" + " } while (atomic_cmpxchg((volatile __global unsigned int *)source, \n" + " prevVal.intVal, newVal.intVal) != prevVal.intVal);\n" + "}\n" + "kernel void sample(global float *out, global float *frame, \n" + " global long *ph,\n" + " global float *amps, float pitch, int bins, \n" + " int vsize, float sr) {\n" + " int t = get_global_id(0);\n" + " int n = t%vsize; /* sample index */\n" + " int h = t/vsize; /* bin index */\n" + " int k = h<<1;\n" + " long lph;\n" + " float a = amps[h], ascl = ((float)n)/vsize;\n" + " float fscal = pitch*FMAXLEN/sr;\n" + " lph = (ph[h] + (long)(n*round(frame[k+1]*fscal))) & PHMASK;\n" + " a += ascl*(frame[k] - a);\n" + " AtomicAdd(&out[n], a*sin((2*PI*lph)/FMAXLEN));\n" + "}\n" + "kernel void update(global float *out, global float *frame,\n" + " global long *ph, global float *amps, float pitch, int bins, \n" + " int vsize, float sr){\n" + " int h = get_global_id(0);\n" + " int k = h << 1,i,j;\n" + " /* update phases and amps */\n" + " ph[h] = (ph[h] + (long)(vsize*round(pitch*frame[k+1]*FMAXLEN/sr))) & PHMASK;\n" + " amps[h] = frame[k];\n" + " if(h >= vsize) return;\n" + " out[h] = 0.f;\n" + "}\n" + " \n"; + +typedef struct cladsyn_ { + OPDS h; + cs_float *asig; + PVSDAT *fsig; + cs_float *kamp, *kfreq; + cs_float *inum, *idev; + cl_mem out; + cl_mem frame; + cl_mem ph; + float *fp; + cl_mem amps; + AUXCH out_; + int bins; + size_t threads; + int count; + int vsamps; + size_t mthreads; + int framecount; + cl_context context; + cl_command_queue commands; + cl_program program; + cl_kernel kernel1, kernel2; + size_t wgs1, wgs2; + float sr; +} CLADSYN; + +char * cl_error_string(int err) { + switch (err) { + case CL_SUCCESS: return "Success!"; + case CL_DEVICE_NOT_FOUND: return "Device not found."; + case CL_DEVICE_NOT_AVAILABLE: return "Device not available"; + case CL_COMPILER_NOT_AVAILABLE: return "Compiler not available"; + case CL_MEM_OBJECT_ALLOCATION_FAILURE: + return "Memory object allocation failure"; + case CL_OUT_OF_RESOURCES: return "Out of resources"; + case CL_OUT_OF_HOST_MEMORY: return "Out of host memory"; + case CL_PROFILING_INFO_NOT_AVAILABLE: + return "Profiling information not available"; + case CL_MEM_COPY_OVERLAP: return "Memory copy overlap"; + case CL_IMAGE_FORMAT_MISMATCH: return "Image format mismatch"; + case CL_IMAGE_FORMAT_NOT_SUPPORTED: return "Image format not supported"; + case CL_BUILD_PROGRAM_FAILURE: return "Program build failure"; + case CL_MAP_FAILURE: return "Map failure"; + case CL_INVALID_VALUE: return "Invalid value"; + case CL_INVALID_DEVICE_TYPE: return "Invalid device type"; + case CL_INVALID_PLATFORM: return "Invalid platform"; + case CL_INVALID_DEVICE: return "Invalid device"; + case CL_INVALID_CONTEXT: return "Invalid context"; + case CL_INVALID_QUEUE_PROPERTIES: return "Invalid queue properties"; + case CL_INVALID_COMMAND_QUEUE: return "Invalid command queue"; + case CL_INVALID_HOST_PTR: return "Invalid host pointer"; + case CL_INVALID_MEM_OBJECT: return "Invalid memory object"; + case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: + return "Invalid image format descriptor"; + case CL_INVALID_IMAGE_SIZE: return "Invalid image size"; + case CL_INVALID_SAMPLER: return "Invalid sampler"; + case CL_INVALID_BINARY: return "Invalid binary"; + case CL_INVALID_BUILD_OPTIONS: return "Invalid build options"; + case CL_INVALID_PROGRAM: return "Invalid program"; + case CL_INVALID_PROGRAM_EXECUTABLE: return "Invalid program executable"; + case CL_INVALID_KERNEL_NAME: return "Invalid kernel name"; + case CL_INVALID_KERNEL_DEFINITION: return "Invalid kernel definition"; + case CL_INVALID_KERNEL: return "Invalid kernel"; + case CL_INVALID_ARG_INDEX: return "Invalid argument index"; + case CL_INVALID_ARG_VALUE: return "Invalid argument value"; + case CL_INVALID_ARG_SIZE: return "Invalid argument size"; + case CL_INVALID_KERNEL_ARGS: return "Invalid kernel arguments"; + case CL_INVALID_WORK_DIMENSION: return "Invalid work dimension"; + case CL_INVALID_WORK_GROUP_SIZE: return "Invalid work group size"; + case CL_INVALID_WORK_ITEM_SIZE: return "Invalid work item size"; + case CL_INVALID_GLOBAL_OFFSET: return "Invalid global offset"; + case CL_INVALID_EVENT_WAIT_LIST: return "Invalid event wait list"; + case CL_INVALID_EVENT: return "Invalid event"; + case CL_INVALID_OPERATION: return "Invalid operation"; + case CL_INVALID_GL_OBJECT: return "Invalid GL object"; + case CL_INVALID_BUFFER_SIZE: return "Invalid buffer size"; + case CL_INVALID_MIP_LEVEL: return "Invalid mip-map level"; + default: return "Unknown error"; + } +} + +static int destroy_cladsyn(CSOUND *csound, void *pp); + +static int init_cladsyn(CSOUND *csound, CLADSYN *p){ + + int asize, ipsize, fpsize, err; + cl_device_id device_ids[32], device_id; + cl_context context; + cl_command_queue commands; + cl_program program; + cl_kernel kernel1, kernel2; + cl_uint num = 0, nump = 0; + cl_platform_id platforms[16]; + uint32_t i; + + if(p->fsig->overlap > 1024) + return csound->InitError(csound, "overlap is too large\n"); + + + + err = clGetDeviceIDs(NULL, CL_DEVICE_TYPE_ALL, 32, device_ids, &num); + if (err != CL_SUCCESS){ + clGetPlatformIDs(16, platforms, &nump); + int devs = 0; + for(i=0; i < nump && devs < 32; i++){ + char name[128]; + clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, 128, name, NULL); + csound->Message(csound, "available platform[%d] %s\n",i, name); + err = clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, + 32-devs, &device_ids[devs], &num); + if (err != CL_SUCCESS) + csound->InitError(csound, "failed to find an OpenCL device! %s \n", + cl_error_string(err)); + } + devs += num; + } + + + for(i=0; i < num; i++){ + char name[128]; + cl_device_type type; + clGetDeviceInfo(device_ids[i], CL_DEVICE_NAME, 128, name, NULL); + clGetDeviceInfo(device_ids[i], CL_DEVICE_TYPE, sizeof(cl_device_type), + &type, NULL); + if(type & CL_DEVICE_TYPE_CPU) + csound->Message(csound, "available CPU[device %d] %s\n",i, name); + else if(type & CL_DEVICE_TYPE_GPU) + csound->Message(csound, "available GPU[device %d] %s\n",i, name); + else if(type & CL_DEVICE_TYPE_ACCELERATOR) + csound->Message(csound, "available ACCELLERATOR[device %d] %s\n",i, name); + else + csound->Message(csound, "available generic [device %d] %s\n",i, name);; + } + + // SELECT THE GPU HERE + if(*p->idev < num) + device_id = device_ids[(int)*p->idev]; + else + device_id = device_ids[num-1]; + + context = clCreateContext(0, 1, &device_id, NULL, NULL, &err); + if (!context) + return csound->InitError(csound, "Failed to create a compute context! %s\n", + cl_error_string(err)); + + // Create a command commands + // + commands = clCreateCommandQueue(context, device_id, 0, &err); + if (!commands) + return csound->InitError(csound, "Failed to create a command commands! %s\n", + cl_error_string(err)); + // Create the compute program from the source buffer + // + program = clCreateProgramWithSource(context, 1, (const char **) &code, + NULL, &err); + if (!program) + return csound->InitError(csound, "Failed to create compute program! %s\n", + cl_error_string(err)); + + err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL); + if (err != CL_SUCCESS) + { + size_t len; + char buffer[2048]; + csound->Message(csound, "Failed to build program executable! %s\n", + cl_error_string(err)); + clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, + sizeof(buffer), buffer, &len); + return csound->InitError(csound, "%s\n", buffer); + } + + kernel1 = clCreateKernel(program, "sample", &err); + if (!kernel1 || err != CL_SUCCESS) + return csound->InitError(csound, + "Failed to create sample compute kernel! %s\n", + cl_error_string(err)); + + kernel2 = clCreateKernel(program, "update", &err); + if (!kernel2 || err != CL_SUCCESS) + return csound->InitError(csound, + "Failed to create update compute kernel! %s\n", + cl_error_string(err)); + + char name[128]; + clGetDeviceInfo(device_id, CL_DEVICE_NAME, 128, name, NULL); + csound->Message(csound, "using device: %s\n",name); + + p->bins = (p->fsig->N)/2; + + if(*p->inum > 0 && *p->inum < p->bins) p->bins = *p->inum; + + p->vsamps = p->fsig->overlap; + p->threads = p->bins*p->vsamps; + p->mthreads = (p->bins > p->vsamps ? p->bins : p->vsamps); + + asize = p->vsamps*sizeof(cl_float); + ipsize = p->mthreads*sizeof(cl_long); + fpsize = p->fsig->N*sizeof(cl_float); + + p->out = clCreateBuffer(context,0, asize, NULL, NULL); + p->frame = clCreateBuffer(context, CL_MEM_READ_ONLY, fpsize, NULL, NULL); + p->ph = clCreateBuffer(context,0, ipsize, NULL, NULL); + p->amps = clCreateBuffer(context,0,p->mthreads*sizeof(cl_float), NULL, NULL); + + // memset needed? + + asize = p->vsamps*sizeof(float); + if(p->out_.auxp == NULL || + p->out_.size < (unsigned long) asize) + csound->AuxAlloc(csound, asize , &p->out_); + + p->count = 0; + p->context = context; + p->program = program; + p->commands = commands; + p->kernel1 = kernel1; + p->kernel2 = kernel2; + + clGetKernelWorkGroupInfo(p->kernel1, + device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(p->wgs1), &p->wgs1, NULL); + clGetKernelWorkGroupInfo(p->kernel2, + device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(p->wgs2), &p->wgs2, NULL); + + p->sr = (float) CS_ESR; + clSetKernelArg(p->kernel1, 0, sizeof(cl_mem), &p->out); + clSetKernelArg(p->kernel1, 1, sizeof(cl_mem), &p->frame); + clSetKernelArg(p->kernel1, 2, sizeof(cl_mem), &p->ph); + clSetKernelArg(p->kernel1, 3, sizeof(cl_mem), &p->amps); + clSetKernelArg(p->kernel1, 5, sizeof(cl_int), &p->bins); + clSetKernelArg(p->kernel1, 6, sizeof(cl_int), &p->vsamps); + clSetKernelArg(p->kernel1, 7, sizeof(cl_float), &p->sr); + + clSetKernelArg(p->kernel2, 0, sizeof(cl_mem), &p->out); + clSetKernelArg(p->kernel2, 1, sizeof(cl_mem), &p->frame); + clSetKernelArg(p->kernel2, 2, sizeof(cl_mem), &p->ph); + clSetKernelArg(p->kernel2, 3, sizeof(cl_mem), &p->amps); + clSetKernelArg(p->kernel2, 5, sizeof(cl_int), &p->bins); + clSetKernelArg(p->kernel2, 6, sizeof(cl_int), &p->vsamps); + clSetKernelArg(p->kernel2, 7, sizeof(cl_float), &p->sr); + + return OK; +} + +static int perf_cladsyn(CSOUND *csound, CLADSYN *p){ + + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + float *out_ = (float *) p->out_.auxp; + cs_float *asig = p->asig; + int count = p->count, vsamps = p->vsamps; + p->fp = (float *) (p->fsig->frame.auxp); + + if (UNLIKELY(offset)) memset(asig, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&asig[nsmps], '\0', early*sizeof(cs_float)); + } + + for(n=offset; n < nsmps; n++){ + if(count == 0) { + int err; + float freq = *p->kfreq; + clSetKernelArg(p->kernel1, 4, sizeof(cl_float), &freq); + clSetKernelArg(p->kernel2, 4, sizeof(cl_float), &freq); + + clEnqueueWriteBuffer(p->commands,p->frame, CL_TRUE, 0, + sizeof(cl_float)*p->bins*2, + p->fp, 0, NULL, NULL); + + err = clEnqueueNDRangeKernel(p->commands,p->kernel1, 1, NULL, &p->threads, + &p->wgs1, 0, NULL, NULL); + if(err) + csound->Message(csound,"Error: Failed to compute sample kernel! %s\n", + cl_error_string(err)); + clFinish(p->commands); + clEnqueueReadBuffer(p->commands,p->out, + CL_TRUE, 0,vsamps*sizeof(cl_float),out_, 0, NULL, NULL); + err = clEnqueueNDRangeKernel(p->commands,p->kernel2, 1, NULL, &p->mthreads, + &p->wgs2, 0, NULL, NULL); + if(err) + csound->Message(csound,"Error: Failed to compute update kernel!%s\n", + cl_error_string(err)); + count = vsamps; + } + asig[n] = (cs_float) out_[vsamps - count]; + count--; + } + p->count = count; + return OK; +} + +static int destroy_cladsyn(CSOUND *csound, void *pp){ + CLADSYN *p = (CLADSYN *) pp; + clReleaseMemObject(p->out); + clReleaseMemObject(p->ph); + clReleaseMemObject(p->frame); + clReleaseMemObject(p->amps); + clReleaseProgram(p->program); + clReleaseKernel(p->kernel1); + clReleaseKernel(p->kernel2); + clReleaseCommandQueue(p->commands); + clReleaseContext(p->context); + + return OK; +} + +static OENTRY localops[] = { + {"cladsyn", S(CLADSYN), 0, "a", "fkkoo", (SUBR) init_cladsyn, + (SUBR) perf_cladsyn, (SUBR) destroy_cladsyn, NULL, 0} +}; + +LINKAGE diff --git a/7.x/vcpkg.json b/7.x/vcpkg.json index ee72144..ed84db3 100644 --- a/7.x/vcpkg.json +++ b/7.x/vcpkg.json @@ -9,6 +9,7 @@ "libpng", "hdf5", "libuv", - "libwebsockets" + "libwebsockets", + { "name": "opencl", "platform": "windows" } ] } diff --git a/7.x/x64-windows-csound.cmake b/7.x/x64-windows-csound.cmake index dc862f9..ad3e391 100644 --- a/7.x/x64-windows-csound.cmake +++ b/7.x/x64-windows-csound.cmake @@ -1,7 +1,7 @@ set(VCPKG_TARGET_ARCHITECTURE x64) set(VCPKG_CRT_LINKAGE dynamic) -if(${PORT} MATCHES "fluidsynth|glib|zlib|pcre|libffi|gettext|libiconv|portmidi|portaudio|liblo") +if(${PORT} MATCHES "fluidsynth|glib|zlib|pcre|libffi|gettext|libiconv|portmidi|portaudio|liblo|opencl") set(VCPKG_LIBRARY_LINKAGE dynamic) else() set(VCPKG_LIBRARY_LINKAGE static) From af5d5a0de5b2f6afa5cde8eeadbd0322752e172d Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 20:51:06 +0100 Subject: [PATCH 43/72] Enforce Csound 7.0 minimum in FindCSOUND --- 7.x/CMakeLists.txt | 6 +++--- 7.x/cmake/Modules/FindCSOUND.cmake | 32 ++++++++++++++++++++++++++++-- 2 files changed, 33 insertions(+), 5 deletions(-) diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index ff9f79b..80b1181 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -45,10 +45,10 @@ set(CMAKE_MACOSX_RPATH 1) set(CMAKE_VERBOSE_MAKEFILE ON) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/") -find_package(CSOUND) +find_package(CSOUND 7.0) -if(NOT CSOUND_INCLUDE_DIRS) - message(FATAL_ERROR "Csound header files are required") +if(NOT CSOUND_FOUND) + message(FATAL_ERROR "Csound 7.0 or newer is required") endif() include(TestBigEndian) diff --git a/7.x/cmake/Modules/FindCSOUND.cmake b/7.x/cmake/Modules/FindCSOUND.cmake index d83c0c0..66232fe 100644 --- a/7.x/cmake/Modules/FindCSOUND.cmake +++ b/7.x/cmake/Modules/FindCSOUND.cmake @@ -51,12 +51,40 @@ else() ) endif() +if(CSOUND_INCLUDE_DIR AND EXISTS "${CSOUND_INCLUDE_DIR}/version.h") + file(STRINGS "${CSOUND_INCLUDE_DIR}/version.h" _csound_major + REGEX "^#define[ \t]+CS_VERSION[ \t]+") + file(STRINGS "${CSOUND_INCLUDE_DIR}/version.h" _csound_minor + REGEX "^#define[ \t]+CS_SUBVER[ \t]+") + file(STRINGS "${CSOUND_INCLUDE_DIR}/version.h" _csound_patch + REGEX "^#define[ \t]+CS_PATCHLEVEL[ \t]+") + + string(REGEX REPLACE "^#define[ \t]+CS_VERSION[ \t]+\\(?([0-9]+)\\)?.*" "\\1" + CSOUND_VERSION_MAJOR "${_csound_major}") + string(REGEX REPLACE "^#define[ \t]+CS_SUBVER[ \t]+\\(?([0-9]+)\\)?.*" "\\1" + CSOUND_VERSION_MINOR "${_csound_minor}") + string(REGEX REPLACE "^#define[ \t]+CS_PATCHLEVEL[ \t]+\\(?([0-9]+)\\)?.*" "\\1" + CSOUND_VERSION_PATCH "${_csound_patch}") + + if(CSOUND_VERSION_MAJOR MATCHES "^[0-9]+$") + if(NOT CSOUND_VERSION_MINOR MATCHES "^[0-9]+$") + set(CSOUND_VERSION_MINOR 0) + endif() + if(NOT CSOUND_VERSION_PATCH MATCHES "^[0-9]+$") + set(CSOUND_VERSION_PATCH 0) + endif() + set(CSOUND_VERSION + "${CSOUND_VERSION_MAJOR}.${CSOUND_VERSION_MINOR}.${CSOUND_VERSION_PATCH}") + endif() +endif() + include(FindPackageHandleStandardArgs) # handle the QUIETLY and REQUIRED arguments and set CSOUND_FOUND to TRUE -# if all listed variables are TRUE +# if all listed variables are TRUE and the version satisfies the request find_package_handle_standard_args(CSOUND - CSOUND_LIBRARY CSOUND_INCLUDE_DIR + REQUIRED_VARS CSOUND_LIBRARY CSOUND_INCLUDE_DIR + VERSION_VAR CSOUND_VERSION ) mark_as_advanced(CSOUND_INCLUDE_DIR CSOUND_LIBRARY) From c1316129c1a07000741f396ffaaff99393375b6b Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Mon, 12 Oct 2026 21:20:51 +0100 Subject: [PATCH 44/72] Document that macOS release plugins are arm64-only The CI builds the macOS plugins on the arm64 macos-latest runner via the arm64-osx vcpkg triplet, without CMAKE_OSX_ARCHITECTURES, so the release binaries are not universal. Note this in the README and point Intel Mac users at a from-source build. --- 7.x/README.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/7.x/README.md b/7.x/README.md index 7ccc2ae..ec3c5d7 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -123,6 +123,23 @@ compile-only (the hosted runners have no OpenCL device) and it is included in the Linux, macOS and Windows release packages. +Release binaries and macOS architecture +-------------- + +The CI builds each plugin on its default hosted runner and packages the +resulting plugin libraries into the GitHub release assets. These binaries are +single-architecture — they are **not** universal fat binaries. + +On macOS the release plugins are built on the Apple Silicon (`arm64`) +`macos-latest` runner with no `CMAKE_OSX_ARCHITECTURES` override, and the +dependencies come from vcpkg using the `arm64-osx` triplet. The +`csound7-plugins-*-macos.zip` release asset therefore contains **arm64-only** +`.dylib` files: they load in the arm64 build of Csound on Apple Silicon, but +not in the x86_64 (Intel) build on Intel Macs. Users on Intel Macs should +build the plugins from source against x86_64 versions of their dependencies +(see the build instructions below). + + Install location -------------- The CMake scripts in this repository use the default CS_USER_PLUGIN From ecc55305849515717d38b48a826251117ecfa415 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Tue, 13 Oct 2026 09:38:02 +0100 Subject: [PATCH 45/72] Add STK opcodes Port the Csound 6.x STK opcode plugin (27 Synthesis ToolKit instruments) to the Csound 7 plugin API, building STK 4.6.2 from sources vendored under 7.x/src/stk so that a patched copy is always used. Patch Sitar::setFrequency to remove the noise modulation of the delay line that could make STKSitar build up clipped samples over time (see csound/plugins#4). Build the stkops plugin by default, install its rawwaves, and add it to the Linux, macOS and Windows release packages. --- .github/workflows/plugins_build_7.yml | 13 +- 7.x/CMakeLists.txt | 1 + 7.x/README.md | 34 +- 7.x/src/stk/CMakeLists.txt | 28 + 7.x/src/stk/LICENSE | 27 + 7.x/src/stk/OpcodeBase.hpp | 499 ++++++++++++++ 7.x/src/stk/include/ADSR.h | 179 +++++ 7.x/src/stk/include/Asymp.h | 146 +++++ 7.x/src/stk/include/BandedWG.h | 153 +++++ 7.x/src/stk/include/BeeThree.h | 127 ++++ 7.x/src/stk/include/BiQuad.h | 186 ++++++ 7.x/src/stk/include/Blit.h | 151 +++++ 7.x/src/stk/include/BlitSaw.h | 148 +++++ 7.x/src/stk/include/BlitSquare.h | 170 +++++ 7.x/src/stk/include/BlowBotl.h | 144 ++++ 7.x/src/stk/include/BlowHole.h | 185 ++++++ 7.x/src/stk/include/BowTable.h | 150 +++++ 7.x/src/stk/include/Bowed.h | 157 +++++ 7.x/src/stk/include/Brass.h | 147 +++++ 7.x/src/stk/include/Chorus.h | 172 +++++ 7.x/src/stk/include/Clarinet.h | 152 +++++ 7.x/src/stk/include/Cubic.h | 138 ++++ 7.x/src/stk/include/Delay.h | 188 ++++++ 7.x/src/stk/include/DelayA.h | 207 ++++++ 7.x/src/stk/include/DelayL.h | 230 +++++++ 7.x/src/stk/include/Drummer.h | 130 ++++ 7.x/src/stk/include/Echo.h | 120 ++++ 7.x/src/stk/include/Effect.h | 79 +++ 7.x/src/stk/include/Envelope.h | 131 ++++ 7.x/src/stk/include/FM.h | 119 ++++ 7.x/src/stk/include/FMVoices.h | 135 ++++ 7.x/src/stk/include/FileLoop.h | 165 +++++ 7.x/src/stk/include/FileRead.h | 141 ++++ 7.x/src/stk/include/FileWrite.h | 116 ++++ 7.x/src/stk/include/FileWvIn.h | 208 ++++++ 7.x/src/stk/include/FileWvOut.h | 102 +++ 7.x/src/stk/include/Filter.h | 124 ++++ 7.x/src/stk/include/Fir.h | 155 +++++ 7.x/src/stk/include/Flute.h | 167 +++++ 7.x/src/stk/include/FormSwep.h | 190 ++++++ 7.x/src/stk/include/FreeVerb.h | 251 +++++++ 7.x/src/stk/include/Function.h | 41 ++ 7.x/src/stk/include/Generator.h | 50 ++ 7.x/src/stk/include/Granulate.h | 209 ++++++ 7.x/src/stk/include/Guitar.h | 202 ++++++ 7.x/src/stk/include/HevyMetl.h | 126 ++++ 7.x/src/stk/include/Iir.h | 204 ++++++ 7.x/src/stk/include/Instrmnt.h | 108 +++ 7.x/src/stk/include/JCRev.h | 166 +++++ 7.x/src/stk/include/JetTable.h | 112 ++++ 7.x/src/stk/include/LentPitShift.h | 263 ++++++++ 7.x/src/stk/include/Mandolin.h | 143 ++++ 7.x/src/stk/include/Mesh2D.h | 144 ++++ 7.x/src/stk/include/MidiFileIn.h | 135 ++++ 7.x/src/stk/include/Modal.h | 154 +++++ 7.x/src/stk/include/ModalBar.h | 65 ++ 7.x/src/stk/include/Modulate.h | 111 ++++ 7.x/src/stk/include/Moog.h | 125 ++++ 7.x/src/stk/include/NRev.h | 160 +++++ 7.x/src/stk/include/Noise.h | 84 +++ 7.x/src/stk/include/OnePole.h | 134 ++++ 7.x/src/stk/include/OneZero.h | 134 ++++ 7.x/src/stk/include/PRCRev.h | 140 ++++ 7.x/src/stk/include/PercFlut.h | 127 ++++ 7.x/src/stk/include/Phonemes.h | 55 ++ 7.x/src/stk/include/PitShift.h | 107 +++ 7.x/src/stk/include/Plucked.h | 117 ++++ 7.x/src/stk/include/PoleZero.h | 113 ++++ 7.x/src/stk/include/Recorder.h | 167 +++++ 7.x/src/stk/include/ReedTable.h | 143 ++++ 7.x/src/stk/include/Resonate.h | 124 ++++ 7.x/src/stk/include/Rhodey.h | 128 ++++ 7.x/src/stk/include/SKINImsg.h | 129 ++++ 7.x/src/stk/include/SKINItbl.h | 135 ++++ 7.x/src/stk/include/Sampler.h | 75 +++ 7.x/src/stk/include/Saxofony.h | 166 +++++ 7.x/src/stk/include/Shakers.h | 332 ++++++++++ 7.x/src/stk/include/Simple.h | 126 ++++ 7.x/src/stk/include/SineWave.h | 159 +++++ 7.x/src/stk/include/SingWave.h | 136 ++++ 7.x/src/stk/include/Sitar.h | 129 ++++ 7.x/src/stk/include/Skini.h | 122 ++++ 7.x/src/stk/include/Sphere.h | 79 +++ 7.x/src/stk/include/StifKarp.h | 153 +++++ 7.x/src/stk/include/Stk.h | 637 ++++++++++++++++++ 7.x/src/stk/include/TapDelay.h | 220 +++++++ 7.x/src/stk/include/TubeBell.h | 125 ++++ 7.x/src/stk/include/Twang.h | 160 +++++ 7.x/src/stk/include/TwoPole.h | 153 +++++ 7.x/src/stk/include/TwoZero.h | 149 +++++ 7.x/src/stk/include/Vector3D.h | 68 ++ 7.x/src/stk/include/VoicForm.h | 161 +++++ 7.x/src/stk/include/Voicer.h | 219 +++++++ 7.x/src/stk/include/Whistle.h | 128 ++++ 7.x/src/stk/include/Wurley.h | 128 ++++ 7.x/src/stk/include/WvIn.h | 46 ++ 7.x/src/stk/include/WvOut.h | 85 +++ 7.x/src/stk/rawwaves/ahh.raw | Bin 0 -> 184 bytes 7.x/src/stk/rawwaves/bassdrum.raw | Bin 0 -> 4288 bytes 7.x/src/stk/rawwaves/britestk.raw | Bin 0 -> 4096 bytes 7.x/src/stk/rawwaves/cowbell1.raw | Bin 0 -> 6438 bytes 7.x/src/stk/rawwaves/crashcym.raw | Bin 0 -> 40776 bytes 7.x/src/stk/rawwaves/dope.raw | Bin 0 -> 20480 bytes 7.x/src/stk/rawwaves/eee.raw | Bin 0 -> 184 bytes 7.x/src/stk/rawwaves/fwavblnk.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/halfwave.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/hihatcym.raw | Bin 0 -> 4976 bytes 7.x/src/stk/rawwaves/impuls10.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/impuls20.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/impuls40.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/makefunc.c | 55 ++ 7.x/src/stk/rawwaves/makemidi.c | 33 + 7.x/src/stk/rawwaves/makewavs.c | 116 ++++ 7.x/src/stk/rawwaves/mand1.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand10.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand11.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand12.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand2.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand3.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand4.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand5.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand6.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand7.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand8.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mand9.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/mandpluk.raw | Bin 0 -> 8900 bytes 7.x/src/stk/rawwaves/marmstk1.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/ooo.raw | Bin 0 -> 184 bytes 7.x/src/stk/rawwaves/peksblnk.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/ppksblnk.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/ridecymb.raw | Bin 0 -> 32394 bytes 7.x/src/stk/rawwaves/silence.raw | Bin 0 -> 448 bytes 7.x/src/stk/rawwaves/sine.c | 22 + 7.x/src/stk/rawwaves/sineblnk.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/sinewave.raw | Bin 0 -> 2048 bytes 7.x/src/stk/rawwaves/snardrum.raw | Bin 0 -> 16660 bytes 7.x/src/stk/rawwaves/snglpeak.raw | Bin 0 -> 512 bytes 7.x/src/stk/rawwaves/tambourn.raw | Bin 0 -> 9240 bytes 7.x/src/stk/rawwaves/tomhidrm.raw | Bin 0 -> 27642 bytes 7.x/src/stk/rawwaves/tomlowdr.raw | Bin 0 -> 39200 bytes 7.x/src/stk/rawwaves/tommiddr.raw | Bin 0 -> 28292 bytes 7.x/src/stk/rawwaves/twopeaks.raw | Bin 0 -> 512 bytes 7.x/src/stk/src/ADSR.cpp | 181 ++++++ 7.x/src/stk/src/Asymp.cpp | 112 ++++ 7.x/src/stk/src/BandedWG.cpp | 364 +++++++++++ 7.x/src/stk/src/BeeThree.cpp | 79 +++ 7.x/src/stk/src/BiQuad.cpp | 103 +++ 7.x/src/stk/src/Blit.cpp | 78 +++ 7.x/src/stk/src/BlitSaw.cpp | 91 +++ 7.x/src/stk/src/BlitSquare.cpp | 95 +++ 7.x/src/stk/src/BlowBotl.cpp | 122 ++++ 7.x/src/stk/src/BlowHole.cpp | 224 +++++++ 7.x/src/stk/src/Bowed.cpp | 180 +++++ 7.x/src/stk/src/Brass.cpp | 158 +++++ 7.x/src/stk/src/Chorus.cpp | 56 ++ 7.x/src/stk/src/Clarinet.cpp | 138 ++++ 7.x/src/stk/src/Delay.cpp | 110 ++++ 7.x/src/stk/src/DelayA.cpp | 117 ++++ 7.x/src/stk/src/DelayL.cpp | 73 +++ 7.x/src/stk/src/Drummer.cpp | 141 ++++ 7.x/src/stk/src/Echo.cpp | 51 ++ 7.x/src/stk/src/Envelope.cpp | 87 +++ 7.x/src/stk/src/FM.cpp | 179 +++++ 7.x/src/stk/src/FMVoices.cpp | 164 +++++ 7.x/src/stk/src/FileLoop.cpp | 237 +++++++ 7.x/src/stk/src/FileRead.cpp | 903 ++++++++++++++++++++++++++ 7.x/src/stk/src/FileWrite.cpp | 799 +++++++++++++++++++++++ 7.x/src/stk/src/FileWvIn.cpp | 267 ++++++++ 7.x/src/stk/src/FileWvOut.cpp | 140 ++++ 7.x/src/stk/src/Fir.cpp | 74 +++ 7.x/src/stk/src/Flute.cpp | 163 +++++ 7.x/src/stk/src/FormSwep.cpp | 136 ++++ 7.x/src/stk/src/FreeVerb.cpp | 227 +++++++ 7.x/src/stk/src/Granulate.cpp | 296 +++++++++ 7.x/src/stk/src/Guitar.cpp | 244 +++++++ 7.x/src/stk/src/HevyMetl.cpp | 75 +++ 7.x/src/stk/src/Iir.cpp | 125 ++++ 7.x/src/stk/src/JCRev.cpp | 136 ++++ 7.x/src/stk/src/LentPitShift.cpp | 52 ++ 7.x/src/stk/src/Mandolin.cpp | 186 ++++++ 7.x/src/stk/src/Mesh2D.cpp | 367 +++++++++++ 7.x/src/stk/src/MidiFileIn.cpp | 353 ++++++++++ 7.x/src/stk/src/Modal.cpp | 169 +++++ 7.x/src/stk/src/ModalBar.cpp | 182 ++++++ 7.x/src/stk/src/Modulate.cpp | 49 ++ 7.x/src/stk/src/Moog.cpp | 111 ++++ 7.x/src/stk/src/NRev.cpp | 119 ++++ 7.x/src/stk/src/Noise.cpp | 34 + 7.x/src/stk/src/OnePole.cpp | 61 ++ 7.x/src/stk/src/OneZero.cpp | 49 ++ 7.x/src/stk/src/PRCRev.cpp | 120 ++++ 7.x/src/stk/src/PercFlut.cpp | 85 +++ 7.x/src/stk/src/Phonemes.cpp | 292 +++++++++ 7.x/src/stk/src/PitShift.cpp | 88 +++ 7.x/src/stk/src/Plucked.cpp | 98 +++ 7.x/src/stk/src/PoleZero.cpp | 73 +++ 7.x/src/stk/src/Recorder.cpp | 345 ++++++++++ 7.x/src/stk/src/Resonate.cpp | 113 ++++ 7.x/src/stk/src/Rhodey.cpp | 92 +++ 7.x/src/stk/src/Sampler.cpp | 53 ++ 7.x/src/stk/src/Saxofony.cpp | 177 +++++ 7.x/src/stk/src/Shakers.cpp | 729 +++++++++++++++++++++ 7.x/src/stk/src/Simple.cpp | 105 +++ 7.x/src/stk/src/SineWave.cpp | 78 +++ 7.x/src/stk/src/SingWave.cpp | 53 ++ 7.x/src/stk/src/Sitar.cpp | 95 +++ 7.x/src/stk/src/Skini.cpp | 228 +++++++ 7.x/src/stk/src/Sphere.cpp | 50 ++ 7.x/src/stk/src/StifKarp.cpp | 181 ++++++ 7.x/src/stk/src/Stk.cpp | 401 ++++++++++++ 7.x/src/stk/src/TapDelay.cpp | 87 +++ 7.x/src/stk/src/TubeBell.cpp | 78 +++ 7.x/src/stk/src/Twang.cpp | 103 +++ 7.x/src/stk/src/TwoPole.cpp | 76 +++ 7.x/src/stk/src/TwoZero.cpp | 74 +++ 7.x/src/stk/src/VoicForm.cpp | 189 ++++++ 7.x/src/stk/src/Voicer.cpp | 224 +++++++ 7.x/src/stk/src/Whistle.cpp | 256 ++++++++ 7.x/src/stk/src/Wurley.cpp | 94 +++ 7.x/src/stk/stkOpcodes.cpp | 610 +++++++++++++++++ 220 files changed, 28103 insertions(+), 3 deletions(-) create mode 100644 7.x/src/stk/CMakeLists.txt create mode 100644 7.x/src/stk/LICENSE create mode 100644 7.x/src/stk/OpcodeBase.hpp create mode 100644 7.x/src/stk/include/ADSR.h create mode 100644 7.x/src/stk/include/Asymp.h create mode 100644 7.x/src/stk/include/BandedWG.h create mode 100644 7.x/src/stk/include/BeeThree.h create mode 100644 7.x/src/stk/include/BiQuad.h create mode 100644 7.x/src/stk/include/Blit.h create mode 100644 7.x/src/stk/include/BlitSaw.h create mode 100644 7.x/src/stk/include/BlitSquare.h create mode 100644 7.x/src/stk/include/BlowBotl.h create mode 100644 7.x/src/stk/include/BlowHole.h create mode 100644 7.x/src/stk/include/BowTable.h create mode 100644 7.x/src/stk/include/Bowed.h create mode 100644 7.x/src/stk/include/Brass.h create mode 100644 7.x/src/stk/include/Chorus.h create mode 100644 7.x/src/stk/include/Clarinet.h create mode 100644 7.x/src/stk/include/Cubic.h create mode 100644 7.x/src/stk/include/Delay.h create mode 100644 7.x/src/stk/include/DelayA.h create mode 100644 7.x/src/stk/include/DelayL.h create mode 100644 7.x/src/stk/include/Drummer.h create mode 100644 7.x/src/stk/include/Echo.h create mode 100644 7.x/src/stk/include/Effect.h create mode 100644 7.x/src/stk/include/Envelope.h create mode 100644 7.x/src/stk/include/FM.h create mode 100644 7.x/src/stk/include/FMVoices.h create mode 100644 7.x/src/stk/include/FileLoop.h create mode 100644 7.x/src/stk/include/FileRead.h create mode 100644 7.x/src/stk/include/FileWrite.h create mode 100644 7.x/src/stk/include/FileWvIn.h create mode 100644 7.x/src/stk/include/FileWvOut.h create mode 100644 7.x/src/stk/include/Filter.h create mode 100644 7.x/src/stk/include/Fir.h create mode 100644 7.x/src/stk/include/Flute.h create mode 100644 7.x/src/stk/include/FormSwep.h create mode 100644 7.x/src/stk/include/FreeVerb.h create mode 100644 7.x/src/stk/include/Function.h create mode 100644 7.x/src/stk/include/Generator.h create mode 100644 7.x/src/stk/include/Granulate.h create mode 100644 7.x/src/stk/include/Guitar.h create mode 100644 7.x/src/stk/include/HevyMetl.h create mode 100644 7.x/src/stk/include/Iir.h create mode 100644 7.x/src/stk/include/Instrmnt.h create mode 100644 7.x/src/stk/include/JCRev.h create mode 100644 7.x/src/stk/include/JetTable.h create mode 100644 7.x/src/stk/include/LentPitShift.h create mode 100644 7.x/src/stk/include/Mandolin.h create mode 100644 7.x/src/stk/include/Mesh2D.h create mode 100644 7.x/src/stk/include/MidiFileIn.h create mode 100644 7.x/src/stk/include/Modal.h create mode 100644 7.x/src/stk/include/ModalBar.h create mode 100644 7.x/src/stk/include/Modulate.h create mode 100644 7.x/src/stk/include/Moog.h create mode 100644 7.x/src/stk/include/NRev.h create mode 100644 7.x/src/stk/include/Noise.h create mode 100644 7.x/src/stk/include/OnePole.h create mode 100644 7.x/src/stk/include/OneZero.h create mode 100644 7.x/src/stk/include/PRCRev.h create mode 100644 7.x/src/stk/include/PercFlut.h create mode 100644 7.x/src/stk/include/Phonemes.h create mode 100644 7.x/src/stk/include/PitShift.h create mode 100644 7.x/src/stk/include/Plucked.h create mode 100644 7.x/src/stk/include/PoleZero.h create mode 100644 7.x/src/stk/include/Recorder.h create mode 100644 7.x/src/stk/include/ReedTable.h create mode 100644 7.x/src/stk/include/Resonate.h create mode 100644 7.x/src/stk/include/Rhodey.h create mode 100644 7.x/src/stk/include/SKINImsg.h create mode 100644 7.x/src/stk/include/SKINItbl.h create mode 100644 7.x/src/stk/include/Sampler.h create mode 100644 7.x/src/stk/include/Saxofony.h create mode 100644 7.x/src/stk/include/Shakers.h create mode 100644 7.x/src/stk/include/Simple.h create mode 100644 7.x/src/stk/include/SineWave.h create mode 100644 7.x/src/stk/include/SingWave.h create mode 100644 7.x/src/stk/include/Sitar.h create mode 100644 7.x/src/stk/include/Skini.h create mode 100644 7.x/src/stk/include/Sphere.h create mode 100644 7.x/src/stk/include/StifKarp.h create mode 100644 7.x/src/stk/include/Stk.h create mode 100644 7.x/src/stk/include/TapDelay.h create mode 100644 7.x/src/stk/include/TubeBell.h create mode 100644 7.x/src/stk/include/Twang.h create mode 100644 7.x/src/stk/include/TwoPole.h create mode 100644 7.x/src/stk/include/TwoZero.h create mode 100644 7.x/src/stk/include/Vector3D.h create mode 100644 7.x/src/stk/include/VoicForm.h create mode 100644 7.x/src/stk/include/Voicer.h create mode 100644 7.x/src/stk/include/Whistle.h create mode 100644 7.x/src/stk/include/Wurley.h create mode 100644 7.x/src/stk/include/WvIn.h create mode 100644 7.x/src/stk/include/WvOut.h create mode 100644 7.x/src/stk/rawwaves/ahh.raw create mode 100644 7.x/src/stk/rawwaves/bassdrum.raw create mode 100644 7.x/src/stk/rawwaves/britestk.raw create mode 100644 7.x/src/stk/rawwaves/cowbell1.raw create mode 100644 7.x/src/stk/rawwaves/crashcym.raw create mode 100644 7.x/src/stk/rawwaves/dope.raw create mode 100644 7.x/src/stk/rawwaves/eee.raw create mode 100644 7.x/src/stk/rawwaves/fwavblnk.raw create mode 100644 7.x/src/stk/rawwaves/halfwave.raw create mode 100644 7.x/src/stk/rawwaves/hihatcym.raw create mode 100644 7.x/src/stk/rawwaves/impuls10.raw create mode 100644 7.x/src/stk/rawwaves/impuls20.raw create mode 100644 7.x/src/stk/rawwaves/impuls40.raw create mode 100644 7.x/src/stk/rawwaves/makefunc.c create mode 100644 7.x/src/stk/rawwaves/makemidi.c create mode 100644 7.x/src/stk/rawwaves/makewavs.c create mode 100644 7.x/src/stk/rawwaves/mand1.raw create mode 100644 7.x/src/stk/rawwaves/mand10.raw create mode 100644 7.x/src/stk/rawwaves/mand11.raw create mode 100644 7.x/src/stk/rawwaves/mand12.raw create mode 100644 7.x/src/stk/rawwaves/mand2.raw create mode 100644 7.x/src/stk/rawwaves/mand3.raw create mode 100644 7.x/src/stk/rawwaves/mand4.raw create mode 100644 7.x/src/stk/rawwaves/mand5.raw create mode 100644 7.x/src/stk/rawwaves/mand6.raw create mode 100644 7.x/src/stk/rawwaves/mand7.raw create mode 100644 7.x/src/stk/rawwaves/mand8.raw create mode 100644 7.x/src/stk/rawwaves/mand9.raw create mode 100644 7.x/src/stk/rawwaves/mandpluk.raw create mode 100644 7.x/src/stk/rawwaves/marmstk1.raw create mode 100644 7.x/src/stk/rawwaves/ooo.raw create mode 100644 7.x/src/stk/rawwaves/peksblnk.raw create mode 100644 7.x/src/stk/rawwaves/ppksblnk.raw create mode 100644 7.x/src/stk/rawwaves/ridecymb.raw create mode 100644 7.x/src/stk/rawwaves/silence.raw create mode 100644 7.x/src/stk/rawwaves/sine.c create mode 100644 7.x/src/stk/rawwaves/sineblnk.raw create mode 100644 7.x/src/stk/rawwaves/sinewave.raw create mode 100644 7.x/src/stk/rawwaves/snardrum.raw create mode 100644 7.x/src/stk/rawwaves/snglpeak.raw create mode 100644 7.x/src/stk/rawwaves/tambourn.raw create mode 100644 7.x/src/stk/rawwaves/tomhidrm.raw create mode 100644 7.x/src/stk/rawwaves/tomlowdr.raw create mode 100644 7.x/src/stk/rawwaves/tommiddr.raw create mode 100644 7.x/src/stk/rawwaves/twopeaks.raw create mode 100644 7.x/src/stk/src/ADSR.cpp create mode 100644 7.x/src/stk/src/Asymp.cpp create mode 100644 7.x/src/stk/src/BandedWG.cpp create mode 100644 7.x/src/stk/src/BeeThree.cpp create mode 100644 7.x/src/stk/src/BiQuad.cpp create mode 100644 7.x/src/stk/src/Blit.cpp create mode 100644 7.x/src/stk/src/BlitSaw.cpp create mode 100644 7.x/src/stk/src/BlitSquare.cpp create mode 100644 7.x/src/stk/src/BlowBotl.cpp create mode 100644 7.x/src/stk/src/BlowHole.cpp create mode 100644 7.x/src/stk/src/Bowed.cpp create mode 100644 7.x/src/stk/src/Brass.cpp create mode 100644 7.x/src/stk/src/Chorus.cpp create mode 100644 7.x/src/stk/src/Clarinet.cpp create mode 100644 7.x/src/stk/src/Delay.cpp create mode 100644 7.x/src/stk/src/DelayA.cpp create mode 100644 7.x/src/stk/src/DelayL.cpp create mode 100644 7.x/src/stk/src/Drummer.cpp create mode 100644 7.x/src/stk/src/Echo.cpp create mode 100644 7.x/src/stk/src/Envelope.cpp create mode 100644 7.x/src/stk/src/FM.cpp create mode 100644 7.x/src/stk/src/FMVoices.cpp create mode 100644 7.x/src/stk/src/FileLoop.cpp create mode 100644 7.x/src/stk/src/FileRead.cpp create mode 100644 7.x/src/stk/src/FileWrite.cpp create mode 100644 7.x/src/stk/src/FileWvIn.cpp create mode 100644 7.x/src/stk/src/FileWvOut.cpp create mode 100644 7.x/src/stk/src/Fir.cpp create mode 100644 7.x/src/stk/src/Flute.cpp create mode 100644 7.x/src/stk/src/FormSwep.cpp create mode 100644 7.x/src/stk/src/FreeVerb.cpp create mode 100644 7.x/src/stk/src/Granulate.cpp create mode 100644 7.x/src/stk/src/Guitar.cpp create mode 100644 7.x/src/stk/src/HevyMetl.cpp create mode 100644 7.x/src/stk/src/Iir.cpp create mode 100644 7.x/src/stk/src/JCRev.cpp create mode 100644 7.x/src/stk/src/LentPitShift.cpp create mode 100644 7.x/src/stk/src/Mandolin.cpp create mode 100644 7.x/src/stk/src/Mesh2D.cpp create mode 100644 7.x/src/stk/src/MidiFileIn.cpp create mode 100644 7.x/src/stk/src/Modal.cpp create mode 100644 7.x/src/stk/src/ModalBar.cpp create mode 100644 7.x/src/stk/src/Modulate.cpp create mode 100644 7.x/src/stk/src/Moog.cpp create mode 100644 7.x/src/stk/src/NRev.cpp create mode 100644 7.x/src/stk/src/Noise.cpp create mode 100644 7.x/src/stk/src/OnePole.cpp create mode 100644 7.x/src/stk/src/OneZero.cpp create mode 100644 7.x/src/stk/src/PRCRev.cpp create mode 100644 7.x/src/stk/src/PercFlut.cpp create mode 100644 7.x/src/stk/src/Phonemes.cpp create mode 100644 7.x/src/stk/src/PitShift.cpp create mode 100644 7.x/src/stk/src/Plucked.cpp create mode 100644 7.x/src/stk/src/PoleZero.cpp create mode 100644 7.x/src/stk/src/Recorder.cpp create mode 100644 7.x/src/stk/src/Resonate.cpp create mode 100644 7.x/src/stk/src/Rhodey.cpp create mode 100644 7.x/src/stk/src/Sampler.cpp create mode 100644 7.x/src/stk/src/Saxofony.cpp create mode 100644 7.x/src/stk/src/Shakers.cpp create mode 100644 7.x/src/stk/src/Simple.cpp create mode 100644 7.x/src/stk/src/SineWave.cpp create mode 100644 7.x/src/stk/src/SingWave.cpp create mode 100644 7.x/src/stk/src/Sitar.cpp create mode 100644 7.x/src/stk/src/Skini.cpp create mode 100644 7.x/src/stk/src/Sphere.cpp create mode 100644 7.x/src/stk/src/StifKarp.cpp create mode 100644 7.x/src/stk/src/Stk.cpp create mode 100644 7.x/src/stk/src/TapDelay.cpp create mode 100644 7.x/src/stk/src/TubeBell.cpp create mode 100644 7.x/src/stk/src/Twang.cpp create mode 100644 7.x/src/stk/src/TwoPole.cpp create mode 100644 7.x/src/stk/src/TwoZero.cpp create mode 100644 7.x/src/stk/src/VoicForm.cpp create mode 100644 7.x/src/stk/src/Voicer.cpp create mode 100644 7.x/src/stk/src/Whistle.cpp create mode 100644 7.x/src/stk/src/Wurley.cpp create mode 100644 7.x/src/stk/stkOpcodes.cpp diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 00bf9d5..5316a50 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -116,7 +116,10 @@ jobs: build/src/websockets/*.so \ build/src/hdf5/*.so \ build/src/py/*.so \ - build/src/OpenCL/*.so package/ + build/src/OpenCL/*.so \ + build/src/stk/*.so package/ + mkdir -p package/rawwaves + cp 7.x/src/stk/rawwaves/*.wav package/rawwaves/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -219,7 +222,10 @@ jobs: build/src/websockets/*.dylib \ build/src/hdf5/*.dylib \ build/src/py/*.dylib \ - build/src/OpenCL/*.dylib package/ + build/src/OpenCL/*.dylib \ + build/src/stk/*.dylib package/ + mkdir -p package/rawwaves + cp 7.x/src/stk/rawwaves/*.wav package/rawwaves/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -319,6 +325,9 @@ jobs: if (Test-Path $vcpkgBin) { Copy-Item (Join-Path $vcpkgBin '*.dll') -Destination $package -ErrorAction SilentlyContinue } + $rawwaves = Join-Path $package 'rawwaves' + New-Item -ItemType Directory -Force -Path $rawwaves | Out-Null + Copy-Item '7.x\src\stk\rawwaves\*.wav' -Destination $rawwaves - name: Upload plugins uses: actions/upload-artifact@v4 diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 80b1181..ed75642 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -313,3 +313,4 @@ add_subdirectory(./src/wiimote) add_subdirectory(./src/p5glove) add_subdirectory(./src/CUDA) add_subdirectory(./src/OpenCL) +add_subdirectory(./src/stk) diff --git a/7.x/README.md b/7.x/README.md index ec3c5d7..f6691d4 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -36,6 +36,9 @@ Currently, the plugins available in this tree are - OpenCL (requires the OpenCL headers/loader; see note below) **cladsyn** +- STK (port of the Synthesis ToolKit instruments; STK 4.6.2 is vendored under this directory, see note below) +**STKBandedWG STKBeeThree STKBlowBotl STKBlowHole STKBowed STKBrass STKClarinet STKDrummer STKFlute STKFMVoices STKHevyMetl STKMandolin STKModalBar STKMoog STKPercFlut STKPlucked STKResonate STKRhodey STKSaxofony STKShakers STKSimple STKSitar STKStifKarp STKTubeBell STKVoicForm STKWhistle STKWurley** + Fluid settings opcodes --- @@ -123,6 +126,34 @@ compile-only (the hosted runners have no OpenCL device) and it is included in the Linux, macOS and Windows release packages. +STK opcodes +--- + +The `STK` opcodes are a port of the Csound 6.x plugin to the Csound 7 plugin +API. They expose the instruments of Perry Cook and Gary Scavone's Synthesis +ToolKit in C++ (STK), each named `STK` followed by the STK class, e.g. +`STKSitar`. All of them share the same signature: + +``` +aout STKName ifrequency igain {kcontroller0, kvalue0, ..., kcontrollerN, kvalueN} +``` + +The STK sources are **vendored under this directory** (`include/`, `src/` and +`rawwaves/`) and built from source, so no external STK installation is needed +and the result is independent of any system or package-manager STK. The +vendored copy carries a fix for the sample buildup reported in +[csound/plugins#4](https://github.com/csound/plugins/issues/4): the noise +modulation of the sitar delay line in `Sitar::setFrequency`, which could make +`STKSitar` build up clipped output over time, has been removed. + +It is built by default; configure with `-DBUILD_STK_OPCODES=OFF` to exclude +it. The wavetables the instruments need are installed alongside the plugin +(under `stk/rawwaves`). At run time the `RAWWAVE_PATH` environment variable, +if set, overrides the built-in default location; otherwise the installed +`rawwaves` directory is used. The plugin is included in the Linux, macOS and +Windows release packages. + + Release binaries and macOS architecture -------------- @@ -182,7 +213,8 @@ plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_CUDA_OPCODES`, `BUILD_OPENCL_OPCODES`, `BUILD_FLUID_OPCODES`, `BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, -`BUILD_P5GLOVE_OPCODES`, `BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and +`BUILD_P5GLOVE_OPCODES`, `BUILD_STK_OPCODES`, `BUILD_WIIMOTE_OPCODES`, +`BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to exclude the chua plugin, the `cmake` command would be: diff --git a/7.x/src/stk/CMakeLists.txt b/7.x/src/stk/CMakeLists.txt new file mode 100644 index 0000000..caa1d4c --- /dev/null +++ b/7.x/src/stk/CMakeLists.txt @@ -0,0 +1,28 @@ +option(BUILD_STK_OPCODES "Build the stk opcodes" ON) + +# The STK sources are bundled under this directory (include/, src/ and +# rawwaves/) so that a patched copy is always built, independent of any system +# or package-manager STK installation. In particular, src/Sitar.cpp carries a +# fix for the sample buildup described in csound/plugins#4. +if(BUILD_STK_OPCODES) + file(GLOB stk_srcs "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp") + list(APPEND stk_srcs "${CMAKE_CURRENT_SOURCE_DIR}/stkOpcodes.cpp") + + make_plugin(stkops "${stk_srcs}") + target_include_directories(stkops PRIVATE + ${CSOUND_INCLUDE_DIRS} + "${CMAKE_CURRENT_SOURCE_DIR}/include" + "${CMAKE_CURRENT_SOURCE_DIR}/src") + target_compile_definitions(stkops PRIVATE BUILD_PLUGINS) + + # Install the rawwaves used by the STK instruments and make them the + # default raw wave path; the RAWWAVE_PATH environment variable overrides it. + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/rawwaves" + DESTINATION "${PLUGIN_INSTALL_DIR}/stk") + if(PLUGIN_INSTALL_DIR) + target_compile_definitions(stkops PRIVATE + DEFAULT_RAWWAVE_PATH="${PLUGIN_INSTALL_DIR}/stk/rawwaves") + endif() + + message(STATUS "Building STK opcodes") +endif() diff --git a/7.x/src/stk/LICENSE b/7.x/src/stk/LICENSE new file mode 100644 index 0000000..c606999 --- /dev/null +++ b/7.x/src/stk/LICENSE @@ -0,0 +1,27 @@ +The Synthesis ToolKit in C++ (STK) + +Copyright (c) 1995-2021 Perry R. Cook and Gary P. Scavone + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +Any person wishing to distribute modifications to the Software is +asked to send the modifications to the original developer so that they +can be incorporated into the canonical version. This is, however, not +a binding provision of this license. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/7.x/src/stk/OpcodeBase.hpp b/7.x/src/stk/OpcodeBase.hpp new file mode 100644 index 0000000..49a724f --- /dev/null +++ b/7.x/src/stk/OpcodeBase.hpp @@ -0,0 +1,499 @@ +/* + OpcodeBase.hpp: + + Copyright (C) 2005, 2009, 2017 by Istva Varga, Victor Lazzarini and + Michael Gogins + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA +*/ +#pragma once + +/** + * There is a conflict between the preprocessor definition "_CR" in the + * standard C++ library and in Csound. To work around this, undefine "_CR" and + * include ALL standard library include files BEFORE including ANY Csound + * include files. + */ +#if defined(_CR) +#undef _CR +#endif + +#include +#include +#include +#if !(defined(__wasi__)) +#include +#endif +#include +#include +#include "interlocks.h" +#ifdef BUILD_PLUGINS +#include "csdl.h" +#else +#include "csoundCore.h" +#endif + +/** + * Template base class, or pseudo-virtual base class, + * for writing Csound opcodes in C++. + * Derive opcode implementation classes like this: + * + * DerivedClass : public OpcodeBase + * { + * public: + * // All output fields must be declared first as cs_float *: + * cs_float *aret1; + * // All input fields must be declared next as cs_float *: + * cs_float *iarg1; + * cs_float *karg2; + * cs_float *aarg3; + * // All internal state variables must be declared after that: + * size_t state1; + * double state2; + * cs_float state3; + * // If the opcode shares data protect it by creating one or more void + * // *mutex member pointers: + * void *mutex1; + * void *mutex2; + * // and create them usind csound->Create_Mutex() in csoundModuleCreate + * // and destroy them using csound->DeleteMutex(mutex) + * // csoundModuleDestroy, and lock them using LockGuard guard(mutex). + * int32_t init(); + * int32_t kontrol(); + * int32_t audio; + * int32_t noteoff(); + * void deinit(); + * }; + */ + +namespace csound { + + static bool diagnostics_enabled = false; + + /** + * Use this to guard against data races in opcode functions. The mutex should + * be created by csound->Create_Mutex() in csoundModuleCreate(), and should + * be destroyed by csound->DeleteMutex() in csoundModuleDestroy(). + * + * If data is shared between opcode instances, the mutex should be global to + * the opcode library; if data is shared between threads for a single instance, + * the mutex should belong to the opcode instance. + */ + struct LockGuard { + LockGuard(CSOUND *csound_, void *mutex_) : csound(csound_), mutex(mutex_) + { + csound->LockMutex(mutex); + } + ~LockGuard() + { + csound->UnlockMutex(mutex); + } + CSOUND *csound; + void *mutex; + }; + + /** + * Use this to store a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + + template int32_t CreateGlobalPointer(CSOUND *csound, const char *name, T *pointer) + { + T **pointer_to_pointer = 0; + int32_t result = csound->CreateGlobalVariable(csound, name, sizeof(pointer_to_pointer)); + pointer_to_pointer = static_cast(csound->QueryGlobalVariable(csound, name)); + *pointer_to_pointer = pointer; + return result; + } + + /** + * Retrieve a pointer to a global heap-allocated object, e.g. one + * used to manage state between opcode instances. + */ + template T *QueryGlobalPointer(CSOUND *csound, const char *name, T*& pointer) + { + T **pointer_to_pointer = static_cast(csound->QueryGlobalVariableNoCheck(csound, name)); + if (pointer_to_pointer != 0) { + pointer = *pointer_to_pointer; + } else { + pointer = 0; + } + return pointer; + } + + template + class OpcodeBase + { + public: + int32_t init(CSOUND *csound) + { + return NOTOK; + } + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + int32_t kontrol(CSOUND *csound) + { + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + OPDS opds; + }; + + template + class OpcodeNoteoffBase + { + public: + int32_t init(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + + static int32_t deinit_(CSOUND *csound, void *opcode) + { + if (!csound->GetReinitFlag(csound) && !csound->GetTieFlag(csound)) { + return noteoff_(csound, opcode); + } + return OK; + } + + static int32_t init_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->init(csound); + } + + int32_t kontrol(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t kontrol_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->kontrol(csound); + } + int32_t audio(CSOUND *csound) + { + IGN(csound); + return NOTOK; + } + static int32_t audio_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->audio(csound); + } + /** + This is how to compute audio signals for normal opcodes: + (1) Zero all frames from 0 up to but not including Offset. + (2) Compute all frames from ksmps_offset up to but not including End. + (3) Zero all frames from End up to but not including ksmps. + Example from a C opcode: + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + uint32_t n, nsmps = CS_KSMPS; + if (UNLIKELY(offset)) memset(p->r, '\0', offset*sizeof(cs_float)); + if (UNLIKELY(early)) { + nsmps -= early; + memset(&p->r[nsmps], '\0', early*sizeof(cs_float)); + } + for (n = offset; n < nsmps; n++) { + input1 = CS_FLOAT2LRND(p->a[n]); + p->r[n] = (cs_float) (input1 >> input2); + } + So in C++ it should look like this (which is much easier to understand): + int32_t frameIndex = 0; + for( ; frameIndex < kperiodOffset(); ++frameIndex) { + asignal[frameIndex] = 0; + } + for( ; frameIndex < kperiodEnd(); ++frameIndex) { + asignal[frameIndex] = compute(); + } + for( ; frameIndex < ksmps(); ++frameIndex) { + asignal[frameIndex] = 0; + } + */ + uint32_t kperiodOffset() const + { + return opds.insdshead->ksmps_offset; + } + uint32_t kperiodEnd() const + { + uint32_t end = opds.insdshead->ksmps_no_end; + if (end) { + return end; + } else { + return ksmps(); + } + } + uint32_t ksmps() const + { + return opds.insdshead->ksmps; + } + uint32_t output_arg_count() + { + return (uint32_t)opds.optext->t.outArgCount; + } + uint32_t input_arg_count() + { + return (uint32_t)opds.optext->t.inArgCount; + } + void log(CSOUND *csound, const char *format,...) + { + va_list args; + va_start(args, format); + if(csound) { + csound->MessageV(csound, 0, format, args); + } else { + vfprintf(stdout, format, args); + } + va_end(args); + } + void warn(CSOUND *csound, const char *format,...) + { + if(csound) { + if(csound->GetMessageLevel(csound) & CS_WARNMSG) { + va_list args; + va_start(args, format); + csound->MessageV(csound, CSOUNDMSG_WARNING, format, args); + va_end(args); + } + } else { + va_list args; + va_start(args, format); + vfprintf(stdout, format, args); + va_end(args); + } + } + int32_t noteoff(CSOUND *csound) + { + return OK; + } + static int32_t noteoff_(CSOUND *csound, void *opcode) + { + return reinterpret_cast(opcode)->noteoff(csound); + } + OPDS opds; + }; + + +#if (__cplusplus >= 201103L) && !(defined(__wasi__)) && !defined(BARE_METAL) + // #pragma message("Defining heap_object_manager_t.") + /** + * The memory of non-POD C++ or C objects allocated on the heap by Csound + * plugins is managed not by Csound, but by the plugin module. This class + * performs that function. + * + * As long as all memory is allocated in or after csoundModuleCreate and + * de-allocated in csoundModuleDestroy, all will be well. The danger however + * is that memory leaks will occur if allocations are not matched with + * de-allocations, or worse, that crashes will occur if any objects are + * deleted twice or de-referenced after deletion. + * + * So, the plugin should manage a collection of all heap-allocated objects, + * keyed first off the Csound instance, and second off an object handle; and + * all such objects must be accessed only by handle, from this collection. + * + * In csoundModuleDestroy, all objects for the calling instance of Csound + * should be de-allocated, and the sub-collection for that instance should + * also be de-allocated. + * + * If then there are no more sub-collections for other instances of Csound, + * the entire contents of the collection should be de-allocated. + * + * This should be done as a singleton, and in a thread-safe way. + * + * There might still be a problem if any of the heap-allocated objects, + * themselves, have global static members, perhaps created by some external + * dependency. + * + * Please note, objects O in the declaration below must not be std::shared_ptr + * objects. Deletion of objects herein must be unconditional. Rather, the + * objects passed are raw pointers to instances of class O. + */ + template class heap_object_manager_t { + private: + std::map> objects_; + std::recursive_mutex mutex; + heap_object_manager_t(){}; + ~heap_object_manager_t(){}; + public: + static heap_object_manager_t &instance() { + static heap_object_manager_t singleton; + return singleton; + } + std::map> &objects() { + std::lock_guard lock(mutex); + return objects_; + } + /** + * Returns a list of pointers to all objects allocated for this + * instance of Csound. + */ + std::vector &objects_for_csound(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects()[csound]; + return objects_for_csound_; + } + /** + * Returns the handle for the object; if the object has not yet been + * stored, inserts it into the list of object pointers for this + * instance of Csound; otherwise, returns the handle of the stored + * object pointer. + */ + int32_t handle_for_object(CSOUND *csound, O *object) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + auto iterator = std::find(objects_for_csound_.begin(), objects_for_csound_.end(), object); + if (iterator == objects_for_csound_.end()) { + int32_t handle = objects_for_csound_.size(); + objects_for_csound_.push_back(object); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object %p: new object handle: %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return handle; + } else { + int32_t handle = static_cast(iterator - objects_for_csound_.begin()); + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::handle_for_object: existing object handle: %d\n", handle); + return handle; + } + } + /** + * Returns the object pointer for the handle; + * if the object pointer has not been stored by + * handle, returns a null pointer. + */ + O *object_for_handle(CSOUND *csound, int32_t handle) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + if (handle >= objects_for_csound_.size()) { + return nullptr; + } + O *object = objects_for_csound_[handle]; + if (diagnostics_enabled) std::fprintf(stderr, "heap_object_manager_t::object_for_handle: %p %d (of %ld)\n", object, handle, objects_for_csound_.size()); + return object; + } + /** + * First destroys all objects created by the calling + * instance of Csound, then destroys the list of + * object pointers for this instance of Csound. + */ + void module_destroy(CSOUND *csound) { + std::lock_guard lock(mutex); + auto &objects_for_csound_ = objects_for_csound(csound); + for (int32_t i = 0, n = objects_for_csound_.size(); i < n; ++i) { + delete objects_for_csound_[i]; + objects_for_csound_[i] = nullptr; + } + objects_for_csound_.clear(); + objects().erase(csound); + } + }; + +#endif + +} diff --git a/7.x/src/stk/include/ADSR.h b/7.x/src/stk/include/ADSR.h new file mode 100644 index 0000000..777778e --- /dev/null +++ b/7.x/src/stk/include/ADSR.h @@ -0,0 +1,179 @@ +#ifndef STK_ADSR_H +#define STK_ADSR_H + +#include "Generator.h" + +namespace stk { + +/***************************************************/ +/*! \class ADSR + \brief STK ADSR envelope class. + + This class implements a traditional ADSR (Attack, Decay, Sustain, + Release) envelope. It responds to simple keyOn and keyOff + messages, keeping track of its state. The \e state = ADSR::IDLE + before being triggered and after the envelope value reaches 0.0 in + the ADSR::RELEASE state. All rate, target and level settings must + be non-negative. All time settings are in seconds and must be + positive. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class ADSR : public Generator +{ + public: + + //! ADSR envelope states. + enum { + ATTACK, /*!< Attack */ + DECAY, /*!< Decay */ + SUSTAIN, /*!< Sustain */ + RELEASE, /*!< Release */ + IDLE /*!< Before attack / after release */ + }; + + //! Default constructor. + ADSR( void ); + + //! Class destructor. + ~ADSR( void ); + + //! Set target = 1, state = \e ADSR::ATTACK. + void keyOn( void ); + + //! Set target = 0, state = \e ADSR::RELEASE. + void keyOff( void ); + + //! Set the attack rate (gain / sample). + void setAttackRate( StkFloat rate ); + + //! Set the target value for the attack (default = 1.0). + void setAttackTarget( StkFloat target ); + + //! Set the decay rate (gain / sample). + void setDecayRate( StkFloat rate ); + + //! Set the sustain level. + void setSustainLevel( StkFloat level ); + + //! Set the release rate (gain / sample). + void setReleaseRate( StkFloat rate ); + + //! Set the attack rate based on a time duration (seconds). + void setAttackTime( StkFloat time ); + + //! Set the decay rate based on a time duration (seconds). + void setDecayTime( StkFloat time ); + + //! Set the release rate based on a time duration (seconds). + void setReleaseTime( StkFloat time ); + + //! Set sustain level and attack, decay, and release time durations (seconds). + void setAllTimes( StkFloat aTime, StkFloat dTime, StkFloat sLevel, StkFloat rTime ); + + //! Set a sustain target value and attack or decay from current value to target. + void setTarget( StkFloat target ); + + //! Return the current envelope \e state (ATTACK, DECAY, SUSTAIN, RELEASE, IDLE). + int getState( void ) const { return state_; }; + + //! Set to state = ADSR::SUSTAIN with current and target values of \e value. + void setValue( StkFloat value ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); + + int state_; + StkFloat value_; + StkFloat target_; + StkFloat attackRate_; + StkFloat decayRate_; + StkFloat releaseRate_; + StkFloat releaseTime_; + StkFloat sustainLevel_; +}; + +inline StkFloat ADSR :: tick( void ) +{ + switch ( state_ ) { + + case ATTACK: + value_ += attackRate_; + if ( value_ >= target_ ) { + value_ = target_; + target_ = sustainLevel_; + state_ = DECAY; + } + lastFrame_[0] = value_; + break; + + case DECAY: + if ( value_ > sustainLevel_ ) { + value_ -= decayRate_; + if ( value_ <= sustainLevel_ ) { + value_ = sustainLevel_; + state_ = SUSTAIN; + } + } + else { + value_ += decayRate_; // attack target < sustain level + if ( value_ >= sustainLevel_ ) { + value_ = sustainLevel_; + state_ = SUSTAIN; + } + } + lastFrame_[0] = value_; + break; + + case RELEASE: + value_ -= releaseRate_; + if ( value_ <= 0.0 ) { + value_ = 0.0; + state_ = IDLE; + } + lastFrame_[0] = value_; + + } + + return value_; +} + +inline StkFrames& ADSR :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "ADSR::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i 0). + /*! + The rate is computed as described above. The value of \e tau + must be greater than zero. Values of \e tau close to zero produce + fast approach rates, while values greater than 1.0 produce rather + slow rates. + */ + void setTau( StkFloat tau ); + + //! Set the asymptotic rate based on a time duration (must be > 0). + void setTime( StkFloat time ); + + //! Set the asymptotic rate such that the target value is perceptually reached (to within -60dB of the target) in \e t60 seconds. + void setT60( StkFloat t60 ); + + //! Set the target value. + void setTarget( StkFloat target ); + + //! Set current and target values to \e value. + void setValue( StkFloat value ); + + //! Return the current envelope \e state (0 = at target, 1 otherwise). + int getState( void ) const { return state_; }; + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); + + StkFloat value_; + StkFloat target_; + StkFloat factor_; + StkFloat constant_; + int state_; +}; + +inline StkFloat Asymp :: tick( void ) +{ + if ( state_ ) { + + value_ = factor_ * value_ + constant_; + + // Check threshold. + if ( target_ > value_ ) { + if ( target_ - value_ <= TARGET_THRESHOLD ) { + value_ = target_; + state_ = 0; + } + } + else { + if ( value_ - target_ <= TARGET_THRESHOLD ) { + value_ = target_; + state_ = 0; + } + } + lastFrame_[0] = value_; + } + + return value_; +} + +inline StkFrames& Asymp :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Asymp::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "BandedWG::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i Out + 3 -/| + 4 -- + \endcode + + Control Change Numbers: + - Operator 4 (feedback) Gain = 2 + - Operator 3 Gain = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class BeeThree : public FM +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + BeeThree( void ); + + //! Class destructor. + ~BeeThree( void ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + +}; + +inline StkFloat BeeThree :: tick( unsigned int ) +{ + StkFloat temp; + + if ( modDepth_ > 0.0 ) { + temp = 1.0 + ( modDepth_ * vibrato_.tick() * 0.1 ); + waves_[0]->setFrequency( baseFrequency_ * temp * ratios_[0] ); + waves_[1]->setFrequency( baseFrequency_ * temp * ratios_[1] ); + waves_[2]->setFrequency( baseFrequency_ * temp * ratios_[2] ); + waves_[3]->setFrequency( baseFrequency_ * temp * ratios_[3] ); + } + + waves_[3]->addPhaseOffset( twozero_.lastOut() ); + temp = control1_ * 2.0 * gains_[3] * adsr_[3]->tick() * waves_[3]->tick(); + twozero_.tick( temp ); + + temp += control2_ * 2.0 * gains_[2] * adsr_[2]->tick() * waves_[2]->tick(); + temp += gains_[1] * adsr_[1]->tick() * waves_[1]->tick(); + temp += gains_[0] * adsr_[0]->tick() * waves_[0]->tick(); + + lastFrame_[0] = temp * 0.125; + return lastFrame_[0]; +} + +inline StkFrames& BeeThree :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "BeeThree::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i= 1.0. The + \e frequency value should be between zero and half the sample rate. + */ + void setResonance( StkFloat frequency, StkFloat radius, bool normalize = false ); + + //! Set the filter coefficients for a notch at \e frequency (in Hz). + /*! + This method determines the filter coefficients corresponding to + two complex-conjugate zeros with the given \e frequency (in Hz) + and \e radius from the z-plane origin. No filter normalization is + attempted. The \e frequency value should be between zero and half + the sample rate. The \e radius value should be positive. + */ + void setNotch( StkFloat frequency, StkFloat radius ); + + //! Sets the filter zeroes for equal resonance gain. + /*! + When using the filter as a resonator, zeroes places at z = 1, z + = -1 will result in a constant gain at resonance of 1 / (1 - R), + where R is the pole radius setting. + + */ + void setEqualGainZeroes( void ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Input one sample to the filter and return a reference to one output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + + protected: + + virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); +}; + +inline StkFloat BiQuad :: tick( StkFloat input ) +{ + inputs_[0] = gain_ * input; + lastFrame_[0] = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2]; + lastFrame_[0] -= a_[2] * outputs_[2] + a_[1] * outputs_[1]; + inputs_[2] = inputs_[1]; + inputs_[1] = inputs_[0]; + outputs_[2] = outputs_[1]; + outputs_[1] = lastFrame_[0]; + + return lastFrame_[0]; +} + +inline StkFrames& BiQuad :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "BiQuad::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "BiQuad::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i +#include + +namespace stk { + +/***************************************************/ +/*! \class Blit + \brief STK band-limited impulse train class. + + This class generates a band-limited impulse train using a + closed-form algorithm reported by Stilson and Smith in "Alias-Free + Digital Synthesis of Classic Analog Waveforms", 1996. The user + can specify both the fundamental frequency of the impulse train + and the number of harmonics contained in the resulting signal. + + The signal is normalized so that the peak value is +/-1.0. + + If nHarmonics is 0, then the signal will contain all harmonics up + to half the sample rate. Note, however, that this setting may + produce aliasing in the signal when the frequency is changing (no + automatic modification of the number of harmonics is performed by + the setFrequency() function). + + Original code by Robin Davies, 2005. + Revisions by Gary Scavone for STK, 2005. +*/ +/***************************************************/ + +class Blit: public Generator +{ + public: + //! Default constructor that initializes BLIT frequency to 220 Hz. + Blit( StkFloat frequency = 220.0 ); + + //! Class destructor. + ~Blit(); + + //! Resets the oscillator state and phase to 0. + void reset(); + + //! Set the phase of the signal. + /*! + Set the phase of the signal, in the range 0 to 1. + */ + void setPhase( StkFloat phase ) { phase_ = PI * phase; }; + + //! Get the current phase of the signal. + /*! + Get the phase of the signal, in the range [0 to 1.0). + */ + StkFloat getPhase() const { return phase_ / PI; }; + + //! Set the impulse train rate in terms of a frequency in Hz. + void setFrequency( StkFloat frequency ); + + //! Set the number of harmonics generated in the signal. + /*! + This function sets the number of harmonics contained in the + resulting signal. It is equivalent to (2 * M) + 1 in the BLIT + algorithm. The default value of 0 sets the algorithm for maximum + harmonic content (harmonics up to half the sample rate). This + parameter is not checked against the current sample rate and + fundamental frequency. Thus, aliasing can result if one or more + harmonics for a given fundamental frequency exceeds fs / 2. This + behavior was chosen over the potentially more problematic solution + of automatically modifying the M parameter, which can produce + audible clicks in the signal. + */ + void setHarmonics( unsigned int nHarmonics = 0 ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + void updateHarmonics( void ); + + unsigned int nHarmonics_; + unsigned int m_; + StkFloat rate_; + StkFloat phase_; + StkFloat p_; + +}; + +inline StkFloat Blit :: tick( void ) +{ + // The code below implements the SincM algorithm of Stilson and + // Smith with an additional scale factor of P / M applied to + // normalize the output. + + // A fully optimized version of this code would replace the two sin + // calls with a pair of fast sin oscillators, for which stable fast + // two-multiply algorithms are well known. In the spirit of STK, + // which favors clarity over performance, the optimization has not + // been made here. + + // Avoid a divide by zero at the sinc peak, which has a limiting + // value of 1.0. + StkFloat tmp, denominator = sin( phase_ ); + if ( denominator <= std::numeric_limits::epsilon() ) + tmp = 1.0; + else { + tmp = sin( m_ * phase_ ); + tmp /= m_ * denominator; + } + + phase_ += rate_; + if ( phase_ >= PI ) phase_ -= PI; + + lastFrame_[0] = tmp; + return lastFrame_[0]; +} + +inline StkFrames& Blit :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Blit::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i +#include + +namespace stk { + +/***************************************************/ +/*! \class BlitSaw + \brief STK band-limited sawtooth wave class. + + This class generates a band-limited sawtooth waveform using a + closed-form algorithm reported by Stilson and Smith in "Alias-Free + Digital Synthesis of Classic Analog Waveforms", 1996. The user + can specify both the fundamental frequency of the sawtooth and the + number of harmonics contained in the resulting signal. + + If nHarmonics is 0, then the signal will contain all harmonics up + to half the sample rate. Note, however, that this setting may + produce aliasing in the signal when the frequency is changing (no + automatic modification of the number of harmonics is performed by + the setFrequency() function). + + Based on initial code of Robin Davies, 2005. + Modified algorithm code by Gary Scavone, 2005. +*/ +/***************************************************/ + +class BlitSaw: public Generator +{ + public: + //! Class constructor. + BlitSaw( StkFloat frequency = 220.0 ); + + //! Class destructor. + ~BlitSaw(); + + //! Resets the oscillator state and phase to 0. + void reset(); + + //! Set the sawtooth oscillator rate in terms of a frequency in Hz. + void setFrequency( StkFloat frequency ); + + //! Set the number of harmonics generated in the signal. + /*! + This function sets the number of harmonics contained in the + resulting signal. It is equivalent to (2 * M) + 1 in the BLIT + algorithm. The default value of 0 sets the algorithm for maximum + harmonic content (harmonics up to half the sample rate). This + parameter is not checked against the current sample rate and + fundamental frequency. Thus, aliasing can result if one or more + harmonics for a given fundamental frequency exceeds fs / 2. This + behavior was chosen over the potentially more problematic solution + of automatically modifying the M parameter, which can produce + audible clicks in the signal. + */ + void setHarmonics( unsigned int nHarmonics = 0 ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + void updateHarmonics( void ); + + unsigned int nHarmonics_; + unsigned int m_; + StkFloat rate_; + StkFloat phase_; + StkFloat p_; + StkFloat C2_; + StkFloat a_; + StkFloat state_; + +}; + +inline StkFloat BlitSaw :: tick( void ) +{ + // The code below implements the BLIT algorithm of Stilson and + // Smith, followed by a summation and filtering operation to produce + // a sawtooth waveform. After experimenting with various approaches + // to calculate the average value of the BLIT over one period, I + // found that an estimate of C2_ = 1.0 / period (in samples) worked + // most consistently. A "leaky integrator" is then applied to the + // difference of the BLIT output and C2_. (GPS - 1 October 2005) + + // A fully optimized version of this code would replace the two sin + // calls with a pair of fast sin oscillators, for which stable fast + // two-multiply algorithms are well known. In the spirit of STK, + // which favors clarity over performance, the optimization has + // not been made here. + + // Avoid a divide by zero, or use of a denormalized divisor + // at the sinc peak, which has a limiting value of m_ / p_. + StkFloat tmp, denominator = sin( phase_ ); + if ( fabs(denominator) <= std::numeric_limits::epsilon() ) + tmp = a_; + else { + tmp = sin( m_ * phase_ ); + tmp /= p_ * denominator; + } + + tmp += state_ - C2_; + state_ = tmp * 0.995; + + phase_ += rate_; + if ( phase_ >= PI ) phase_ -= PI; + + lastFrame_[0] = tmp; + return lastFrame_[0]; +} + +inline StkFrames& BlitSaw :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "BlitSaw::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i +#include + +namespace stk { + +/***************************************************/ +/*! \class BlitSquare + \brief STK band-limited square wave class. + + This class generates a band-limited square wave signal. It is + derived in part from the approach reported by Stilson and Smith in + "Alias-Free Digital Synthesis of Classic Analog Waveforms", 1996. + The algorithm implemented in this class uses a SincM function with + an even M value to achieve a bipolar bandlimited impulse train. + This signal is then integrated to achieve a square waveform. The + integration process has an associated DC offset so a DC blocking + filter is applied at the output. + + The user can specify both the fundamental frequency of the + waveform and the number of harmonics contained in the resulting + signal. + + If nHarmonics is 0, then the signal will contain all harmonics up + to half the sample rate. Note, however, that this setting may + produce aliasing in the signal when the frequency is changing (no + automatic modification of the number of harmonics is performed by + the setFrequency() function). Also note that the harmonics of a + square wave fall at odd integer multiples of the fundamental, so + aliasing will happen with a lower fundamental than with the other + Blit waveforms. This class is not guaranteed to be well behaved + in the presence of significant aliasing. + + Based on initial code of Robin Davies, 2005. + Modified algorithm code by Gary Scavone, 2005--2006. +*/ +/***************************************************/ + +class BlitSquare: public Generator +{ + public: + //! Default constructor that initializes BLIT frequency to 220 Hz. + BlitSquare( StkFloat frequency = 220.0 ); + + //! Class destructor. + ~BlitSquare(); + + //! Resets the oscillator state and phase to 0. + void reset(); + + //! Set the phase of the signal. + /*! + Set the phase of the signal, in the range 0 to 1. + */ + void setPhase( StkFloat phase ) { phase_ = PI * phase; }; + + //! Get the current phase of the signal. + /*! + Get the phase of the signal, in the range [0 to 1.0). + */ + StkFloat getPhase() const { return phase_ / PI; }; + + //! Set the impulse train rate in terms of a frequency in Hz. + void setFrequency( StkFloat frequency ); + + //! Set the number of harmonics generated in the signal. + /*! + This function sets the number of harmonics contained in the + resulting signal. It is equivalent to (2 * M) + 1 in the BLIT + algorithm. The default value of 0 sets the algorithm for maximum + harmonic content (harmonics up to half the sample rate). This + parameter is not checked against the current sample rate and + fundamental frequency. Thus, aliasing can result if one or more + harmonics for a given fundamental frequency exceeds fs / 2. This + behavior was chosen over the potentially more problematic solution + of automatically modifying the M parameter, which can produce + audible clicks in the signal. + */ + void setHarmonics( unsigned int nHarmonics = 0 ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + void updateHarmonics( void ); + + unsigned int nHarmonics_; + unsigned int m_; + StkFloat rate_; + StkFloat phase_; + StkFloat p_; + StkFloat a_; + StkFloat lastBlitOutput_; + StkFloat dcbState_; +}; + +inline StkFloat BlitSquare :: tick( void ) +{ + StkFloat temp = lastBlitOutput_; + + // A fully optimized version of this would replace the two sin calls + // with a pair of fast sin oscillators, for which stable fast + // two-multiply algorithms are well known. In the spirit of STK, + // which favors clarity over performance, the optimization has + // not been made here. + + // Avoid a divide by zero, or use of a denomralized divisor + // at the sinc peak, which has a limiting value of 1.0. + StkFloat denominator = sin( phase_ ); + if ( fabs( denominator ) < std::numeric_limits::epsilon() ) { + // Inexact comparison safely distinguishes betwen *close to zero*, and *close to PI*. + if ( phase_ < 0.1f || phase_ > TWO_PI - 0.1f ) + lastBlitOutput_ = a_; + else + lastBlitOutput_ = -a_; + } + else { + lastBlitOutput_ = sin( m_ * phase_ ); + lastBlitOutput_ /= p_ * denominator; + } + + lastBlitOutput_ += temp; + + // Now apply DC blocker. + lastFrame_[0] = lastBlitOutput_ - dcbState_ + 0.999 * lastFrame_[0]; + dcbState_ = lastBlitOutput_; + + phase_ += rate_; + if ( phase_ >= TWO_PI ) phase_ -= TWO_PI; + + return lastFrame_[0]; +} + +inline StkFrames& BlitSquare :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "BlitSquare::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "BlowBotl::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "BlowHole::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i + +namespace stk { + +/***************************************************/ +/*! \class BowTable + \brief STK bowed string table class. + + This class implements a simple bowed string + non-linear function, as described by Smith + (1986). The output is an instantaneous + reflection coefficient value. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class BowTable : public Function +{ +public: + //! Default constructor. + BowTable( void ) : offset_(0.0), slope_(0.1), minOutput_(0.01), maxOutput_(0.98) {}; + + //! Set the table offset value. + /*! + The table offset is a bias which controls the + symmetry of the friction. If you want the + friction to vary with direction, use a non-zero + value for the offset. The default value is zero. + */ + void setOffset( StkFloat offset ) { offset_ = offset; }; + + //! Set the table slope value. + /*! + The table slope controls the width of the friction + pulse, which is related to bow force. + */ + void setSlope( StkFloat slope ) { slope_ = slope; }; + + //! Set the minimum table output value (0.0 - 1.0). + void setMinOutput( StkFloat minimum ) { minOutput_ = minimum; }; + + //! Set the maximum table output value (0.0 - 1.0). + void setMaxOutput( StkFloat maximum ) { maxOutput_ = maximum; }; + + //! Take one sample input and map to one sample of output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the table and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the table and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + +protected: + + StkFloat offset_; + StkFloat slope_; + StkFloat minOutput_; + StkFloat maxOutput_; + +}; + +inline StkFloat BowTable :: tick( StkFloat input ) +{ + // The input represents differential string vs. bow velocity. + StkFloat sample = input + offset_; // add bias to input + sample *= slope_; // then scale it + lastFrame_[0] = (StkFloat) fabs( (double) sample ) + (StkFloat) 0.75; + lastFrame_[0] = (StkFloat) pow( lastFrame_[0], (StkFloat) -4.0 ); + + // Set minimum threshold + if ( lastFrame_[0] < minOutput_ ) lastFrame_[0] = minOutput_; + + // Set maximum threshold + if ( lastFrame_[0] > maxOutput_ ) lastFrame_[0] = maxOutput_; + + return lastFrame_[0]; +} + +inline StkFrames& BowTable :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "BowTable::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i 1.0) *samples = 1.0; + } + + lastFrame_[0] = *(samples-hop); + return frames; +} + +inline StkFrames& BowTable :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel ) +{ +#if defined(_STK_DEBUG_) + if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "BowTable::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i 1.0) *oSamples = 1.0; + } + + lastFrame_[0] = *(oSamples-oHop); + return iFrames; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Bowed.h b/7.x/src/stk/include/Bowed.h new file mode 100644 index 0000000..4ad5726 --- /dev/null +++ b/7.x/src/stk/include/Bowed.h @@ -0,0 +1,157 @@ +#ifndef STK_BOWED_H +#define STK_BOWED_H + +#include "Instrmnt.h" +#include "DelayL.h" +#include "BowTable.h" +#include "OnePole.h" +#include "BiQuad.h" +#include "SineWave.h" +#include "ADSR.h" + +namespace stk { + +/***************************************************/ +/*! \class Bowed + \brief STK bowed string instrument class. + + This class implements a bowed string model, a + la Smith (1986), after McIntyre, Schumacher, + Woodhouse (1983). + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + + Control Change Numbers: + - Bow Pressure = 2 + - Bow Position = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Bow Velocity = 100 + - Frequency = 101 + - Volume = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. + Contributions by Esteban Maestre, 2011. +*/ +/***************************************************/ + +class Bowed : public Instrmnt +{ + public: + //! Class constructor, taking the lowest desired playing frequency. + Bowed( StkFloat lowestFrequency = 8.0 ); + + //! Class destructor. + ~Bowed( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Set vibrato gain. + void setVibrato( StkFloat gain ) { vibratoGain_ = gain; }; + + //! Apply breath pressure to instrument with given amplitude and rate of increase. + void startBowing( StkFloat amplitude, StkFloat rate ); + + //! Decrease breath pressure with given rate of decrease. + void stopBowing( StkFloat rate ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + DelayL neckDelay_; + DelayL bridgeDelay_; + BowTable bowTable_; + OnePole stringFilter_; + BiQuad bodyFilters_[6]; + SineWave vibrato_; + ADSR adsr_; + + bool bowDown_; + StkFloat maxVelocity_; + StkFloat baseDelay_; + StkFloat vibratoGain_; + StkFloat betaRatio_; + +}; + +inline StkFloat Bowed :: tick( unsigned int ) +{ + StkFloat bowVelocity = maxVelocity_ * adsr_.tick(); + StkFloat bridgeReflection = -stringFilter_.tick( bridgeDelay_.lastOut() ); + StkFloat nutReflection = -neckDelay_.lastOut(); + StkFloat stringVelocity = bridgeReflection + nutReflection; + StkFloat deltaV = bowVelocity - stringVelocity; // Differential velocity + + StkFloat newVelocity = 0.0; + if ( bowDown_ ) + newVelocity = deltaV * bowTable_.tick( deltaV ); // Non-Linear bow function + neckDelay_.tick( bridgeReflection + newVelocity); // Do string propagations + bridgeDelay_.tick(nutReflection + newVelocity); + + if ( vibratoGain_ > 0.0 ) { + neckDelay_.setDelay( (baseDelay_ * (1.0 - betaRatio_) ) + + (baseDelay_ * vibratoGain_ * vibrato_.tick()) ); + } + + lastFrame_[0] = 0.1248 * bodyFilters_[5].tick( bodyFilters_[4].tick( bodyFilters_[3].tick( bodyFilters_[2].tick( bodyFilters_[1].tick( bodyFilters_[0].tick( bridgeDelay_.lastOut() ) ) ) ) ) ); + + return lastFrame_[0]; +} + +inline StkFrames& Bowed :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Bowed::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i position. + deltaPressure *= deltaPressure; // Basic position to area mapping. + if ( deltaPressure > 1.0 ) deltaPressure = 1.0; // Non-linear saturation. + + // The following input scattering assumes the mouthPressure = area. + lastFrame_[0] = deltaPressure * mouthPressure + ( 1.0 - deltaPressure) * borePressure; + lastFrame_[0] = delayLine_.tick( dcBlock_.tick( lastFrame_[0] ) ); + + return lastFrame_[0]; +} + +inline StkFrames& Brass :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Brass::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i 1 ) { + oStream_ << "Chorus::lastOut(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + +inline StkFloat Chorus :: tick( StkFloat input, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel > 1 ) { + oStream_ << "Chorus::tick(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + delayLine_[0].setDelay( baseLength_ * 0.707 * ( 1.0 + modDepth_ * mods_[0].tick() ) ); + delayLine_[1].setDelay( baseLength_ * 0.5 * ( 1.0 - modDepth_ * mods_[1].tick() ) ); + lastFrame_[0] = effectMix_ * ( delayLine_[0].tick( input ) - input ) + input; + lastFrame_[1] = effectMix_ * ( delayLine_[1].tick( input ) - input ) + input; + return lastFrame_[channel]; +} + +inline StkFrames& Chorus :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() - 1 ) { + oStream_ << "Chorus::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels() - 1; + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() - 1 ) { + oStream_ << "Chorus::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "Clarinet::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i + +namespace stk { + +/***************************************************/ +/*! \class Cubic + \brief STK cubic non-linearity class. + + This class implements the cubic non-linearity + that was used in SynthBuilder. + + The formula implemented is: + + \code + output = gain * (a1 * input + a2 * input^2 + a3 * input^3) + \endcode + + followed by a limiter for values outside +-threshold. + + Ported to STK by Nick Porcaro, 2007. Updated for inclusion + in STK distribution by Gary Scavone, 2011. +*/ +/***************************************************/ + +class Cubic : public Function +{ +public: + //! Default constructor. + Cubic( void ) : a1_(0.5), a2_(0.5), a3_(0.5), gain_(1.0), threshold_(1.0) {}; + + //! Set the a1 coefficient value. + void setA1( StkFloat a1 ) { a1_ = a1; }; + + //! Set the a2 coefficient value. + void setA2( StkFloat a2 ) { a2_ = a2; }; + + //! Set the a3 coefficient value. + void setA3( StkFloat a3 ) { a3_ = a3; }; + + //! Set the gain value. + void setGain( StkFloat gain ) { gain_ = gain; }; + + //! Set the threshold value. + void setThreshold( StkFloat threshold ) { threshold_ = threshold; }; + + //! Input one sample to the function and return one output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the function and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the function and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + +protected: + + StkFloat a1_; + StkFloat a2_; + StkFloat a3_; + StkFloat gain_; + StkFloat threshold_; +}; + +inline StkFloat Cubic :: tick( StkFloat input ) +{ + StkFloat inSquared = input * input; + StkFloat inCubed = inSquared * input; + + lastFrame_[0] = gain_ * (a1_ * input + a2_ * inSquared + a3_ * inCubed); + + // Apply threshold if we are out of range. + if ( fabs( lastFrame_[0] ) > threshold_ ) { + lastFrame_[0] = ( lastFrame_[0] < 0 ? -threshold_ : threshold_ ); + } + + return lastFrame_[0]; +} + +inline StkFrames& Cubic :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Cubic::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "Cubic::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "Delay::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "Delay::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "DelayA::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "DelayA::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i inputs_.size() ) { // The value is too big. + oStream_ << "DelayL::setDelay: argument (" << delay << ") greater than maximum!"; + handleError( StkError::WARNING ); return; + } + + if (delay < 0 ) { + oStream_ << "DelayL::setDelay: argument (" << delay << ") less than zero!"; + handleError( StkError::WARNING ); return; + } + + StkFloat outPointer = inPoint_ - delay; // read chases write + delay_ = delay; + + while ( outPointer < 0 ) + outPointer += inputs_.size(); // modulo maximum length + + outPoint_ = (long) outPointer; // integer part + + alpha_ = outPointer - outPoint_; // fractional part + omAlpha_ = (StkFloat) 1.0 - alpha_; + + if ( outPoint_ == inputs_.size() ) outPoint_ = 0; + doNextOut_ = true; +} + +inline StkFloat DelayL :: tick( StkFloat input ) +{ + inputs_[inPoint_++] = input * gain_; + + // Increment input pointer modulo length. + if ( inPoint_ == inputs_.size() ) + inPoint_ = 0; + + lastFrame_[0] = nextOut(); + doNextOut_ = true; + + // Increment output pointer modulo length. + if ( ++outPoint_ == inputs_.size() ) + outPoint_ = 0; + + return lastFrame_[0]; +} + +inline StkFrames& DelayL :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "DelayL::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "DelayL::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i soundOrder_; + std::vector soundNumber_; + int nSounding_; +}; + +inline StkFloat Drummer :: tick( unsigned int ) +{ + lastFrame_[0] = 0.0; + if ( nSounding_ == 0 ) return lastFrame_[0]; + + for ( int i=0; i= 0 ) { + if ( waves_[i].isFinished() ) { + // Re-order the list. + for ( int j=0; j soundOrder_[i] ) + soundOrder_[j] -= 1; + } + soundOrder_[i] = -1; + nSounding_--; + } + else + lastFrame_[0] += filters_[i].tick( waves_[i].tick() ); + } + } + + return lastFrame_[0]; +} + +inline StkFrames& Drummer :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Drummer::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "Echo::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "Echo::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i + +namespace stk { + +/***************************************************/ +/*! \class Effect + \brief STK abstract effects parent class. + + This class provides common functionality for STK effects + subclasses. It is general enough to support both monophonic and + polyphonic input/output classes. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Effect : public Stk +{ + public: + //! Class constructor. + Effect( void ) { lastFrame_.resize( 1, 1, 0.0 ); }; + + //! Return the number of output channels for the class. + unsigned int channelsOut( void ) const { return lastFrame_.channels(); }; + + //! Return an StkFrames reference to the last output sample frame. + const StkFrames& lastFrame( void ) const { return lastFrame_; }; + + //! Reset and clear all internal state. + virtual void clear() = 0; + + //! Set the mixture of input and "effected" levels in the output (0.0 = input only, 1.0 = effect only). + virtual void setEffectMix( StkFloat mix ); + + protected: + + // Returns true if argument value is prime. + bool isPrime( unsigned int number ); + + StkFrames lastFrame_; + StkFloat effectMix_; + +}; + +inline void Effect :: setEffectMix( StkFloat mix ) +{ + if ( mix < 0.0 ) { + oStream_ << "Effect::setEffectMix: mix parameter is less than zero ... setting to zero!"; + handleError( StkError::WARNING ); + effectMix_ = 0.0; + } + else if ( mix > 1.0 ) { + oStream_ << "Effect::setEffectMix: mix parameter is greater than 1.0 ... setting to one!"; + handleError( StkError::WARNING ); + effectMix_ = 1.0; + } + else + effectMix_ = mix; +} + +inline bool Effect :: isPrime( unsigned int number ) +{ + if ( number == 2 ) return true; + if ( number & 1 ) { + for ( int i=3; i<(int)sqrt((double)number)+1; i+=2 ) + if ( (number % i) == 0 ) return false; + return true; // prime + } + else return false; // even +} + +} // stk namespace + +#endif + diff --git a/7.x/src/stk/include/Envelope.h b/7.x/src/stk/include/Envelope.h new file mode 100644 index 0000000..f104169 --- /dev/null +++ b/7.x/src/stk/include/Envelope.h @@ -0,0 +1,131 @@ +#ifndef STK_ENVELOPE_H +#define STK_ENVELOPE_H + +#include "Generator.h" + +namespace stk { + +/***************************************************/ +/*! \class Envelope + \brief STK linear line envelope class. + + This class implements a simple linear line envelope generator + which is capable of ramping to an arbitrary target value by a + specified \e rate. It also responds to simple \e keyOn and \e + keyOff messages, ramping to a specified target (default = 1.0) on + keyOn and to a specified target (default = 0.0) on keyOff. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Envelope : public Generator +{ + public: + + //! Default constructor. + Envelope( void ); + + //! Class destructor. + ~Envelope( void ); + + //! Assignment operator. + Envelope& operator= ( const Envelope& e ); + + //! Start ramping to specified target (default = 1). + void keyOn( StkFloat target = 1.0 ) { this->setTarget( target ); }; + + //! Start ramping to specified target (default = 0). + void keyOff( StkFloat target = 0.0 ) { this->setTarget( target ); }; + + //! Set the \e rate. + /*! + The \e rate must be positive (though a value of 0.0 is allowed). + */ + void setRate( StkFloat rate ); + + //! Set the \e rate based on a positive time duration (seconds). + /*! + The \e rate is calculated such that the envelope will ramp from + the current value to the current target in the specified time duration. + */ + void setTime( StkFloat time ); + + //! Set the target value. + void setTarget( StkFloat target ); + + //! Set current and target values to \e value. + void setValue( StkFloat value ); + + //! Return the current envelope \e state (0 = at target, 1 otherwise). + int getState( void ) const { return state_; }; + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); + + StkFloat value_; + StkFloat target_; + StkFloat rate_; + int state_; +}; + +inline StkFloat Envelope :: tick( void ) +{ + if ( state_ ) { + if ( target_ > value_ ) { + value_ += rate_; + if ( value_ >= target_ ) { + value_ = target_; + state_ = 0; + } + } + else { + value_ -= rate_; + if ( value_ <= target_ ) { + value_ = target_; + state_ = 0; + } + } + lastFrame_[0] = value_; + } + + return value_; +} + +inline StkFrames& Envelope :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Envelope::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i adsr_; + std::vector waves_; + SineWave vibrato_; + TwoZero twozero_; + unsigned int nOperators_; + StkFloat baseFrequency_; + std::vector ratios_; + std::vector gains_; + StkFloat modDepth_; + StkFloat control1_; + StkFloat control2_; + StkFloat fmGains_[100]; + StkFloat fmSusLevels_[16]; + StkFloat fmAttTimes_[32]; + +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/FMVoices.h b/7.x/src/stk/include/FMVoices.h new file mode 100644 index 0000000..120d80a --- /dev/null +++ b/7.x/src/stk/include/FMVoices.h @@ -0,0 +1,135 @@ +#ifndef STK_FMVOICES_H +#define STK_FMVOICES_H + +#include "FM.h" + +namespace stk { + +/***************************************************/ +/*! \class FMVoices + \brief STK singing FM synthesis instrument. + + This class implements 3 carriers and a common + modulator, also referred to as algorithm 6 of + the TX81Z. + + \code + Algorithm 6 is : + /->1 -\ + 4-|-->2 - +-> Out + \->3 -/ + \endcode + + Control Change Numbers: + - Vowel = 2 + - Spectral Tilt = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class FMVoices : public FM +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + FMVoices( void ); + + //! Class destructor. + ~FMVoices( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + int currentVowel_; + StkFloat tilt_[3]; + StkFloat mods_[3]; +}; + +inline StkFloat FMVoices :: tick( unsigned int ) +{ + StkFloat temp, temp2; + + temp = gains_[3] * adsr_[3]->tick() * waves_[3]->tick(); + temp2 = vibrato_.tick() * modDepth_ * 0.1; + + waves_[0]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[0]); + waves_[1]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[1]); + waves_[2]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[2]); + waves_[3]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[3]); + + waves_[0]->addPhaseOffset(temp * mods_[0]); + waves_[1]->addPhaseOffset(temp * mods_[1]); + waves_[2]->addPhaseOffset(temp * mods_[2]); + waves_[3]->addPhaseOffset( twozero_.lastOut() ); + twozero_.tick( temp ); + temp = gains_[0] * tilt_[0] * adsr_[0]->tick() * waves_[0]->tick(); + temp += gains_[1] * tilt_[1] * adsr_[1]->tick() * waves_[1]->tick(); + temp += gains_[2] * tilt_[2] * adsr_[2]->tick() * waves_[2]->tick(); + + lastFrame_[0] = temp * 0.33; + return lastFrame_[0]; +} + +inline StkFrames& FMVoices :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "FMVoices::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; isetRate( fileSize_ * frequency / Stk::sampleRate() ); }; + + //! Increment the read pointer by \e time samples, modulo file size. + void addTime( StkFloat time ); + + //! Increment current read pointer by \e angle, relative to a looping frequency. + /*! + This function increments the read pointer based on the file + size and the current Stk::sampleRate. The \e anAngle value + is a multiple of file size. + */ + void addPhase( StkFloat angle ); + + //! Add a phase offset to the current read pointer. + /*! + This function determines a time offset based on the file + size and the current Stk::sampleRate. The \e angle value + is a multiple of file size. + */ + void addPhaseOffset( StkFloat angle ); + + //! Return the specified channel value of the last computed frame. + /*! + For multi-channel files, use the lastFrame() function to get + all values from the last computed frame. If no file data is + loaded, the returned value is 0.0. The \c channel argument must + be less than the number of channels in the file data (the first + channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + StkFloat lastOut( unsigned int channel = 0 ) { return FileWvIn::lastOut( channel ); }; + + //! Compute a sample frame and return the specified \c channel value. + /*! + For multi-channel files, use the lastFrame() function to get + all values from the computed frame. If no file data is loaded, + the returned value is 0.0. The \c channel argument must be less + than the number of channels in the file data (the first channel is + specified by 0). However, range checking is only performed if + _STK_DEBUG_ is defined during compilation, in which case an + out-of-range value will trigger an StkError exception. + */ + StkFloat tick( unsigned int channel = 0 ); + + //! Fill the StkFrames object with computed sample frames, starting at the specified channel and return the same reference. + /*! + The \c channel argument plus the number of output channels must + be less than the number of channels in the StkFrames argument (the + first channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + virtual StkFrames& tick( StkFrames& frames,unsigned int channel = 0 ); + + protected: + + StkFrames firstFrame_; + StkFloat phaseOffset_; + +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/FileRead.h b/7.x/src/stk/include/FileRead.h new file mode 100644 index 0000000..e65b49c --- /dev/null +++ b/7.x/src/stk/include/FileRead.h @@ -0,0 +1,141 @@ +#ifndef STK_FILEREAD_H +#define STK_FILEREAD_H + +#include "Stk.h" + +namespace stk { + +/***************************************************/ +/*! \class FileRead + \brief STK audio file input class. + + This class provides input support for various + audio file formats. Multi-channel (>2) + soundfiles are supported. The file data is + returned via an external StkFrames object + passed to the read() function. This class + does not store its own copy of the file data, + rather the data is read directly from disk. + + FileRead currently supports uncompressed WAV, + AIFF/AIFC, SND (AU), MAT-file (Matlab), and + STK RAW file formats. Signed integer (8-, + 16-, 24-, and 32-bit) and floating-point (32- and + 64-bit) data types are supported. Compressed + data types are not supported. + + STK RAW files have no header and are assumed to + contain a monophonic stream of 16-bit signed + integers in big-endian byte order at a sample + rate of 22050 Hz. MAT-file data should be saved + in an array with each data channel filling a + matrix row. The sample rate for MAT-files should + be specified in a variable named "fs". If no + such variable is found, the sample rate is + assumed to be 44100 Hz. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class FileRead : public Stk +{ +public: + //! Default constructor. + FileRead( void ); + + //! Overloaded constructor that opens a file during instantiation. + /*! + An StkError will be thrown if the file is not found or its + format is unknown or unsupported. The optional arguments allow a + headerless file type to be supported. If \c typeRaw is false (the + default), the subsequent parameters are ignored. + */ + FileRead( std::string fileName, bool typeRaw = false, unsigned int nChannels = 1, + StkFormat format = STK_SINT16, StkFloat rate = 22050.0 ); + + //! Class destructor. + ~FileRead( void ); + + //! Open the specified file and determine its formatting. + /*! + An StkError will be thrown if the file is not found or its + format is unknown or unsupported. The optional arguments allow a + headerless file type to be supported. If \c typeRaw is false (the + default), the subsequent parameters are ignored. + */ + void open( std::string fileName, bool typeRaw = false, unsigned int nChannels = 1, + StkFormat format = STK_SINT16, StkFloat rate = 22050.0 ); + + //! If a file is open, close it. + void close( void ); + + //! Returns \e true if a file is currently open. + bool isOpen( void ); + + //! Return the file size in sample frames. + unsigned long fileSize( void ) const { return fileSize_; }; + + //! Return the number of audio channels in the file. + unsigned int channels( void ) const { return channels_; }; + + //! Return the data format of the file. + StkFormat format( void ) const { return dataType_; }; + + //! Return the file sample rate in Hz. + /*! + WAV, SND, and AIF formatted files specify a sample rate in + their headers. By definition, STK RAW files have a sample rate of + 22050 Hz. MAT-files are assumed to have a rate of 44100 Hz. + */ + StkFloat fileRate( void ) const { return fileRate_; }; + + //! Read sample frames from the file into an StkFrames object. + /*! + The number of sample frames to read will be determined from the + number of frames of the StkFrames argument. If this size is + larger than the available data in the file (given the file size + and starting frame index), the extra frames will be unaffected + (the StkFrames object will not be resized). Optional parameters + are provided to specify the starting sample frame within the file + (default = 0) and whether to normalize the data with respect to + fixed-point limits (default = true). An StkError will be thrown + if a file error occurs or if the number of channels in the + StkFrames argument is not equal to that in the file. + */ + void read( StkFrames& buffer, unsigned long startFrame = 0, bool doNormalize = true ); + +protected: + + // Get STK RAW file information. + bool getRawInfo( const char *fileName, unsigned int nChannels, + StkFormat format, StkFloat rate ); + + // Get WAV file header information. + bool getWavInfo( const char *fileName ); + + // Get SND (AU) file header information. + bool getSndInfo( const char *fileName ); + + // Get AIFF file header information. + bool getAifInfo( const char *fileName ); + + // Get MAT-file header information. + bool getMatInfo( const char *fileName ); + + // Helper function for MAT-file parsing. + bool findNextMatArray( SINT32 *chunkSize, SINT32 *rows, SINT32 *columns, SINT32 *nametype ); + + FILE *fd_; + bool byteswap_; + bool wavFile_; + unsigned long fileSize_; + unsigned long dataOffset_; + unsigned int channels_; + StkFormat dataType_; + StkFloat fileRate_; +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/FileWrite.h b/7.x/src/stk/include/FileWrite.h new file mode 100644 index 0000000..6378339 --- /dev/null +++ b/7.x/src/stk/include/FileWrite.h @@ -0,0 +1,116 @@ +#ifndef STK_FILEWRITE_H +#define STK_FILEWRITE_H + +#include "Stk.h" + +namespace stk { + +/***************************************************/ +/*! \class FileWrite + \brief STK audio file output class. + + This class provides output support for various + audio file formats. + + FileWrite writes samples to an audio file. It supports + multi-channel data. + + FileWrite currently supports uncompressed WAV, AIFF, AIFC, SND + (AU), MAT-file (Matlab), and STK RAW file formats. Signed integer + (8-, 16-, 24-, and 32-bit) and floating- point (32- and 64-bit) + data types are supported. STK RAW files use 16-bit integers by + definition. MAT-files will always be written as 64-bit floats. + If a data type specification does not match the specified file + type, the data type will automatically be modified. Compressed + data types are not supported. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class FileWrite : public Stk +{ + public: + + typedef unsigned long FILE_TYPE; + + static const FILE_TYPE FILE_RAW; /*!< STK RAW file type. */ + static const FILE_TYPE FILE_WAV; /*!< WAV file type. */ + static const FILE_TYPE FILE_SND; /*!< SND (AU) file type. */ + static const FILE_TYPE FILE_AIF; /*!< AIFF file type. */ + static const FILE_TYPE FILE_MAT; /*!< Matlab MAT-file type. */ + + //! Default constructor. + FileWrite( void ); + + //! Overloaded constructor used to specify a file name, type, and data format with this object. + /*! + An StkError is thrown for invalid argument values or if an error occurs when initializing the output file. + */ + FileWrite( std::string fileName, unsigned int nChannels = 1, FILE_TYPE type = FILE_WAV, Stk::StkFormat format = STK_SINT16 ); + + //! Class destructor. + virtual ~FileWrite(); + + //! Create a file of the specified type and name and output samples to it in the given data format. + /*! + An StkError is thrown for invalid argument values or if an error occurs when initializing the output file. + */ + void open( std::string fileName, unsigned int nChannels = 1, + FileWrite::FILE_TYPE type = FILE_WAV, Stk::StkFormat format = STK_SINT16 ); + + //! If a file is open, write out samples in the queue and then close it. + void close( void ); + + //! Returns \e true if a file is currently open. + bool isOpen( void ); + + //! Write sample frames from the StkFrames object to the file. + /*! + An StkError will be thrown if the number of channels in the + StkFrames argument does not agree with the number of channels + specified when opening the file. + */ + void write( StkFrames& buffer ); + + protected: + + // Write STK RAW file header. + bool setRawFile( std::string fileName ); + + // Write WAV file header. + bool setWavFile( std::string fileName ); + + // Close WAV file, updating the header. + void closeWavFile( void ); + + // Write SND (AU) file header. + bool setSndFile( std::string fileName ); + + // Close SND file, updating the header. + void closeSndFile( void ); + + // Write AIFF file header. + bool setAifFile( std::string fileName ); + + // Close AIFF file, updating the header. + void closeAifFile( void ); + + // Write MAT-file header. + bool setMatFile( std::string fileName ); + + // Close MAT-file, updating the header. + void closeMatFile( void ); + + FILE *fd_; + FILE_TYPE fileType_; + StkFormat dataType_; + unsigned int channels_; + unsigned long frameCounter_; + bool byteswap_; + +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/FileWvIn.h b/7.x/src/stk/include/FileWvIn.h new file mode 100644 index 0000000..208bafd --- /dev/null +++ b/7.x/src/stk/include/FileWvIn.h @@ -0,0 +1,208 @@ +#ifndef STK_FILEWVIN_H +#define STK_FILEWVIN_H + +#include "WvIn.h" +#include "FileRead.h" + +namespace stk { + +/***************************************************/ +/*! \class FileWvIn + \brief STK audio file input class. + + This class inherits from WvIn. It provides a "tick-level" + interface to the FileRead class. It also provides variable-rate + playback functionality. Audio file support is provided by the + FileRead class. Linear interpolation is used for fractional read + rates. + + FileWvIn supports multi-channel data. It is important to + distinguish the tick() method that computes a single frame (and + returns only the specified sample of a multi-channel frame) from + the overloaded one that takes an StkFrames object for + multi-channel and/or multi-frame data. + + FileWvIn will either load the entire content of an audio file into + local memory or incrementally read file data from disk in chunks. + This behavior is controlled by the optional constructor arguments + \e chunkThreshold and \e chunkSize. File sizes greater than \e + chunkThreshold (in sample frames) will be read incrementally in + chunks of \e chunkSize each (also in sample frames). + + For file data read completely into local memory, the \e doNormalize + flag can be used to normalize all values with respect to the maximum + absolute value of the data. + + If the file data format is fixed point, the flag \e doInt2FloatScaling + can be used to control whether the values are scaled with respect to + the corresponding fixed-point maximum. For example, if reading 16-bit + signed integers, the input values will be scaled by 1 / 32768.0. This + scaling will not happen for floating-point file data formats. + + When the file end is reached, subsequent calls to the tick() + functions return zeros and isFinished() returns \e true. + + See the FileRead class for a description of the supported audio + file formats. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class FileWvIn : public WvIn +{ +public: + //! Default constructor. + FileWvIn( unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024 ); + + //! Overloaded constructor for file input. + /*! + An StkError will be thrown if the file is not found, its format is + unknown, or a read error occurs. + */ + FileWvIn( std::string fileName, bool raw = false, bool doNormalize = true, + unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024, + bool doInt2FloatScaling = true ); + + //! Class destructor. + ~FileWvIn( void ); + + //! Open the specified file and load its data. + /*! + Data from a previously opened file will be overwritten by this + function. An StkError will be thrown if the file is not found, + its format is unknown, or a read error occurs. If the file length + is less than the chunkThreshold limit and \e doNormalize is true, + the file data will be normalized with respect to the maximum absolute + value of the data. If the \e doInt2FloatScaling flag is true and the + input data is fixed-point, a scaling will be applied with respect to + the fixed-point limits. + */ + virtual void openFile( std::string fileName, bool raw = false, bool doNormalize = true, bool doInt2FloatScaling = true ); + + //! Close a file if one is open. + virtual void closeFile( void ); + + //! Clear outputs and reset time (file) pointer to zero. + virtual void reset( void ); + + //! Normalize data to a maximum of +-1.0. + /*! + This function has no effect when data is incrementally loaded + from disk. + */ + virtual void normalize( void ); + + //! Normalize data to a maximum of \e +-peak. + /*! + This function has no effect when data is incrementally loaded + from disk. + */ + virtual void normalize( StkFloat peak ); + + //! Return the file size in sample frames. + virtual unsigned long getSize( void ) const { return fileSize_; }; + + //! Return the input file sample rate in Hz (not the data read rate). + /*! + WAV, SND, and AIF formatted files specify a sample rate in + their headers. STK RAW files have a sample rate of 22050 Hz + by definition. MAT-files are assumed to have a rate of 44100 Hz. + */ + virtual StkFloat getFileRate( void ) const { return data_.dataRate(); }; + + //! Query whether a file is open. + bool isOpen( void ) { return file_.isOpen(); }; + + //! Query whether reading is complete. + bool isFinished( void ) const { return finished_; }; + + //! Set the data read rate in samples. The rate can be negative. + /*! + If the rate value is negative, the data is read in reverse order. + */ + virtual void setRate( StkFloat rate ); + + //! Increment the read pointer by \e time samples. + /*! + Note that this function will not modify the interpolation flag status. + */ + virtual void addTime( StkFloat time ); + + //! Turn linear interpolation on/off. + /*! + Interpolation is automatically off when the read rate is + an integer value. If interpolation is turned off for a + fractional rate, the time index is truncated to an integer + value. + */ + void setInterpolate( bool doInterpolate ) { interpolate_ = doInterpolate; }; + + //! Return the specified channel value of the last computed frame. + /*! + If no file is loaded, the returned value is 0.0. The \c + channel argument must be less than the number of output channels, + which can be determined with the channelsOut() function (the first + channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. \sa + lastFrame() + */ + StkFloat lastOut( unsigned int channel = 0 ); + + //! Compute a sample frame and return the specified \c channel value. + /*! + For multi-channel files, use the lastFrame() function to get + all values from the computed frame. If no file data is loaded, + the returned value is 0.0. The \c channel argument must be less + than the number of channels in the file data (the first channel is + specified by 0). However, range checking is only performed if + _STK_DEBUG_ is defined during compilation, in which case an + out-of-range value will trigger an StkError exception. + */ + virtual StkFloat tick( unsigned int channel = 0 ); + + //! Fill the StkFrames object with computed sample frames, starting at the specified channel and return the same reference. + /*! + The \c channel argument plus the number of input channels must + be less than the number of channels in the StkFrames argument (the + first channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + +protected: + + void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); + + FileRead file_; + bool finished_; + bool interpolate_; + bool int2floatscaling_; + bool chunking_; + StkFloat time_; + StkFloat rate_; + unsigned long fileSize_; + unsigned long chunkThreshold_; + unsigned long chunkSize_; + long chunkPointer_; + +}; + +inline StkFloat FileWvIn :: lastOut( unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= data_.channels() ) { + oStream_ << "FileWvIn::lastOut(): channel argument and soundfile data are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + if ( finished_ ) return 0.0; + return lastFrame_[channel]; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/FileWvOut.h b/7.x/src/stk/include/FileWvOut.h new file mode 100644 index 0000000..886c85f --- /dev/null +++ b/7.x/src/stk/include/FileWvOut.h @@ -0,0 +1,102 @@ +#ifndef STK_FILEWVOUT_H +#define STK_FILEWVOUT_H + +#include "WvOut.h" +#include "FileWrite.h" + +namespace stk { + +/***************************************************/ +/*! \class FileWvOut + \brief STK audio file output class. + + This class inherits from WvOut. It provides a "tick-level" + interface to the FileWrite class. + + FileWvOut writes samples to an audio file and supports + multi-channel data. It is important to distinguish the tick() + method that outputs a single sample to all channels in a sample + frame from the overloaded one that takes a reference to an + StkFrames object for multi-channel and/or multi-frame data. + + See the FileWrite class for a description of the supported audio + file formats. + + Currently, FileWvOut is non-interpolating and the output rate is + always Stk::sampleRate(). + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class FileWvOut : public WvOut +{ + public: + + //! Default constructor with optional output buffer size argument. + /*! + The output buffer size defines the number of frames that are + accumulated between writes to disk. + */ + FileWvOut( unsigned int bufferFrames = 1024 ); + + //! Overloaded constructor used to specify a file name, type, and data format with this object. + /*! + An StkError is thrown for invalid argument values or if an error occurs when initializing the output file. + */ + FileWvOut( std::string fileName, + unsigned int nChannels = 1, + FileWrite::FILE_TYPE type = FileWrite::FILE_WAV, + Stk::StkFormat format = STK_SINT16, + unsigned int bufferFrames = 1024 ); + + //! Class destructor. + virtual ~FileWvOut(); + + //! Open a new file with the specified parameters. + /*! + If a file was previously open, it will be closed. An StkError + will be thrown if any of the specified arguments are invalid or a + file error occurs during opening. + */ + void openFile( std::string fileName, + unsigned int nChannels, + FileWrite::FILE_TYPE type, + Stk::StkFormat format ); + + //! Close a file if one is open. + /*! + Any data remaining in the internal buffer will be written to + the file before closing. + */ + void closeFile( void ); + + //! Output a single sample to all channels in a sample frame. + /*! + An StkError is thrown if an output error occurs. + */ + void tick( const StkFloat sample ); + + //! Output the StkFrames data. + /*! + An StkError will be thrown if an output error occurs. An + StkError will also be thrown if _STK_DEBUG_ is defined during + compilation and there is an incompatability between the number of + channels in the FileWvOut object and that in the StkFrames object. + */ + void tick( const StkFrames& frames ); + + protected: + + void incrementFrame( void ); + + FileWrite file_; + unsigned int bufferFrames_; + unsigned int bufferIndex_; + unsigned int iData_; + +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Filter.h b/7.x/src/stk/include/Filter.h new file mode 100644 index 0000000..b267e20 --- /dev/null +++ b/7.x/src/stk/include/Filter.h @@ -0,0 +1,124 @@ +#ifndef STK_FILTER_H +#define STK_FILTER_H + +#include "Stk.h" +#include +#include + +namespace stk { + +/***************************************************/ +/*! \class Filter + \brief STK abstract filter class. + + This class provides limited common functionality for STK digital + filter subclasses. It is general enough to support both + monophonic and polyphonic input/output classes. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Filter : public Stk +{ +public: + //! Class constructor. + Filter( void ) { gain_ = 1.0; channelsIn_ = 1; lastFrame_.resize( 1, 1, 0.0 ); }; + + //! Return the number of input channels for the class. + unsigned int channelsIn( void ) const { return channelsIn_; }; + + //! Return the number of output channels for the class. + unsigned int channelsOut( void ) const { return lastFrame_.channels(); }; + + //! Clears all internal states of the filter. + virtual void clear( void ); + + //! Set the filter gain. + /*! + The gain is applied at the filter input and does not affect the + coefficient values. The default gain value is 1.0. + */ + void setGain( StkFloat gain ) { gain_ = gain; }; + + //! Return the current filter gain. + StkFloat getGain( void ) const { return gain_; }; + + //! Return the filter phase delay at the specified frequency. + /*! + Note that the phase delay calculation accounts for the filter + gain. The frequency value should be greater than 0.0 and less + than or equal to one-half the sample rate. + */ + StkFloat phaseDelay( StkFloat frequency ); + + //! Return an StkFrames reference to the last output sample frame. + const StkFrames& lastFrame( void ) const { return lastFrame_; }; + + //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0; + +protected: + + StkFloat gain_; + unsigned int channelsIn_; + StkFrames lastFrame_; + + std::vector b_; + std::vector a_; + StkFrames outputs_; + StkFrames inputs_; + +}; + +inline void Filter :: clear( void ) +{ + unsigned int i; + for ( i=0; i 0.5 * Stk::sampleRate() ) { + oStream_ << "Filter::phaseDelay: argument (" << frequency << ") is out of range!"; + handleError( StkError::WARNING ); return 0.0; + } + + StkFloat omegaT = 2 * PI * frequency / Stk::sampleRate(); + StkFloat real = 0.0, imag = 0.0; + for ( unsigned int i=0; i &coefficients ); + + //! Class destructor. + ~Fir( void ); + + //! Set filter coefficients. + /*! + An StkError can be thrown if the coefficient vector size is + zero. The internal state of the filter is not cleared unless the + \e clearState flag is \c true. + */ + void setCoefficients( std::vector &coefficients, bool clearState = false ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Input one sample to the filter and return one output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + +protected: + +}; + +inline StkFloat Fir :: tick( StkFloat input ) +{ + lastFrame_[0] = 0.0; + inputs_[0] = gain_ * input; + + for ( unsigned int i=(unsigned int)(b_.size())-1; i>0; i-- ) { + lastFrame_[0] += b_[i] * inputs_[i]; + inputs_[i] = inputs_[i-1]; + } + lastFrame_[0] += b_[0] * inputs_[0]; + + return lastFrame_[0]; +} + +inline StkFrames& Fir :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Fir::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int i, hop = frames.channels(); + for ( unsigned int j=0; j0; i-- ) { + *samples += b_[i] * inputs_[i]; + inputs_[i] = inputs_[i-1]; + } + *samples += b_[0] * inputs_[0]; + } + + lastFrame_[0] = *(samples-hop); + return frames; +} + +inline StkFrames& Fir :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel ) +{ +#if defined(_STK_DEBUG_) + if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "Fir::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int i, iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int j=0; j0; i-- ) { + *oSamples += b_[i] * inputs_[i]; + inputs_[i] = inputs_[i-1]; + } + *oSamples += b_[0] * inputs_[0]; + } + + lastFrame_[0] = *(oSamples-oHop); + return iFrames; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Flute.h b/7.x/src/stk/include/Flute.h new file mode 100644 index 0000000..8a27181 --- /dev/null +++ b/7.x/src/stk/include/Flute.h @@ -0,0 +1,167 @@ +#ifndef STK_FLUTE_H +#define STK_FLUTE_H + +#include "Instrmnt.h" +#include "JetTable.h" +#include "DelayL.h" +#include "OnePole.h" +#include "PoleZero.h" +#include "Noise.h" +#include "ADSR.h" +#include "SineWave.h" + +namespace stk { + +/***************************************************/ +/*! \class Flute + \brief STK flute physical model class. + + This class implements a simple flute + physical model, as discussed by Karjalainen, + Smith, Waryznyk, etc. The jet model uses + a polynomial, a la Cook. + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + Control Change Numbers: + - Jet Delay = 2 + - Noise Gain = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Breath Pressure = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Flute : public Instrmnt +{ + public: + //! Class constructor, taking the lowest desired playing frequency. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + Flute( StkFloat lowestFrequency ); + + //! Class destructor. + ~Flute( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Set the reflection coefficient for the jet delay (-1.0 - 1.0). + void setJetReflection( StkFloat coefficient ) { jetReflection_ = coefficient; }; + + //! Set the reflection coefficient for the air column delay (-1.0 - 1.0). + void setEndReflection( StkFloat coefficient ) { endReflection_ = coefficient; }; + + //! Set the length of the jet delay in terms of a ratio of jet delay to air column delay lengths. + void setJetDelay( StkFloat aRatio ); + + //! Apply breath velocity to instrument with given amplitude and rate of increase. + void startBlowing( StkFloat amplitude, StkFloat rate ); + + //! Decrease breath velocity with given rate of decrease. + void stopBlowing( StkFloat rate ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + DelayL jetDelay_; + DelayL boreDelay_; + JetTable jetTable_; + OnePole filter_; + PoleZero dcBlock_; + Noise noise_; + ADSR adsr_; + SineWave vibrato_; + + StkFloat lastFrequency_; + StkFloat maxPressure_; + StkFloat jetReflection_; + StkFloat endReflection_; + StkFloat noiseGain_; + StkFloat vibratoGain_; + StkFloat outputGain_; + StkFloat jetRatio_; + +}; + +inline StkFloat Flute :: tick( unsigned int ) +{ + StkFloat pressureDiff; + StkFloat breathPressure; + + // Calculate the breath pressure (envelope + noise + vibrato) + breathPressure = maxPressure_ * adsr_.tick(); + breathPressure += breathPressure * ( noiseGain_ * noise_.tick() + vibratoGain_ * vibrato_.tick() ); + + StkFloat temp = -filter_.tick( boreDelay_.lastOut() ); + //temp = dcBlock_.tick( temp ); // Block DC on reflection. + + pressureDiff = breathPressure - (jetReflection_ * temp); + pressureDiff = jetDelay_.tick( pressureDiff ); + //pressureDiff = jetTable_.tick( pressureDiff ) + (endReflection_ * temp); + pressureDiff = dcBlock_.tick(jetTable_.tick( pressureDiff )) + (endReflection_ * temp); // moved the DC blocker to after the jet non-linearity (GPS, 29 Jan. 2020) + lastFrame_[0] = (StkFloat) 0.3 * boreDelay_.tick( pressureDiff ); + + lastFrame_[0] *= outputGain_; + return lastFrame_[0]; +} + +inline StkFrames& Flute :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Flute::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i= 1.0. The \e frequency value should be between zero and + half the sample rate. + */ + void setResonance( StkFloat frequency, StkFloat radius ); + + //! Set both the current and target resonance parameters. + void setStates( StkFloat frequency, StkFloat radius, StkFloat gain = 1.0 ); + + //! Set target resonance parameters. + void setTargets( StkFloat frequency, StkFloat radius, StkFloat gain = 1.0 ); + + //! Set the sweep rate (between 0.0 - 1.0). + /*! + The formant parameters are varied in increments of the + sweep rate between their current and target values. + A sweep rate of 1.0 will produce an immediate change in + resonance parameters from their current values to the + target values. A sweep rate of 0.0 will produce no + change in resonance parameters. + */ + void setSweepRate( StkFloat rate ); + + //! Set the sweep rate in terms of a time value in seconds. + /*! + This method adjusts the sweep rate based on a + given time for the formant parameters to reach + their target values. + */ + void setSweepTime( StkFloat time ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Input one sample to the filter and return a reference to one output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + + protected: + + virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); + + bool dirty_; + StkFloat frequency_; + StkFloat radius_; + StkFloat startFrequency_; + StkFloat startRadius_; + StkFloat startGain_; + StkFloat targetFrequency_; + StkFloat targetRadius_; + StkFloat targetGain_; + StkFloat deltaFrequency_; + StkFloat deltaRadius_; + StkFloat deltaGain_; + StkFloat sweepState_; + StkFloat sweepRate_; + +}; + +inline StkFloat FormSwep :: tick( StkFloat input ) +{ + if ( dirty_ ) { + sweepState_ += sweepRate_; + if ( sweepState_ >= 1.0 ) { + sweepState_ = 1.0; + dirty_ = false; + radius_ = targetRadius_; + frequency_ = targetFrequency_; + gain_ = targetGain_; + } + else { + radius_ = startRadius_ + (deltaRadius_ * sweepState_); + frequency_ = startFrequency_ + (deltaFrequency_ * sweepState_); + gain_ = startGain_ + (deltaGain_ * sweepState_); + } + this->setResonance( frequency_, radius_ ); + } + + inputs_[0] = gain_ * input; + lastFrame_[0] = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2]; + lastFrame_[0] -= a_[2] * outputs_[2] + a_[1] * outputs_[1]; + inputs_[2] = inputs_[1]; + inputs_[1] = inputs_[0]; + outputs_[2] = outputs_[1]; + outputs_[1] = lastFrame_[0]; + + return lastFrame_[0]; +} + +inline StkFrames& FormSwep :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "FormSwep::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "FormSwep::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i 1 ) { + oStream_ << "FreeVerb::lastOut(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + +inline StkFloat FreeVerb::tick( StkFloat inputL, StkFloat inputR, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel > 1 ) { + oStream_ << "FreeVerb::tick(): channel argument must be less than 2!"; + handleError(StkError::FUNCTION_ARGUMENT); + } +#endif + + StkFloat fInput = (inputL + inputR) * gain_; + StkFloat outL = 0.0; + StkFloat outR = 0.0; + + // Parallel LBCF filters + for ( int i = 0; i < nCombs; i++ ) { + // Left channel + //StkFloat yn = fInput + (roomSize_ * FreeVerb::undenormalize(combLPL_[i].tick(FreeVerb::undenormalize(combDelayL_[i].nextOut())))); + StkFloat yn = fInput + (roomSize_ * combLPL_[i].tick( combDelayL_[i].nextOut() ) ); + combDelayL_[i].tick(yn); + outL += yn; + + // Right channel + //yn = fInput + (roomSize_ * FreeVerb::undenormalize(combLPR_[i].tick(FreeVerb::undenormalize(combDelayR_[i].nextOut())))); + yn = fInput + (roomSize_ * combLPR_[i].tick( combDelayR_[i].nextOut() ) ); + combDelayR_[i].tick(yn); + outR += yn; + } + + // Series allpass filters + for ( int i = 0; i < nAllpasses; i++ ) { + // Left channel + //StkFloat vn_m = FreeVerb::undenormalize(allPassDelayL_[i].nextOut()); + StkFloat vn_m = allPassDelayL_[i].nextOut(); + StkFloat vn = outL + (g_ * vn_m); + allPassDelayL_[i].tick(vn); + + // calculate output + outL = -vn + (1.0 + g_)*vn_m; + + // Right channel + //vn_m = FreeVerb::undenormalize(allPassDelayR_[i].nextOut()); + vn_m = allPassDelayR_[i].nextOut(); + vn = outR + (g_ * vn_m); + allPassDelayR_[i].tick(vn); + + // calculate output + outR = -vn + (1.0 + g_)*vn_m; + } + + // Mix output + lastFrame_[0] = outL*wet1_ + outR*wet2_ + inputL*dry_; + lastFrame_[1] = outR*wet1_ + outL*wet2_ + inputR*dry_; + + /* + // Hard limiter ... there's not much else we can do at this point + if ( lastFrame_[0] >= 1.0 ) { + lastFrame_[0] = 0.9999; + } + if ( lastFrame_[0] <= -1.0 ) { + lastFrame_[0] = -0.9999; + } + if ( lastFrame_[1] >= 1.0 ) { + lastFrame_[1] = 0.9999; + } + if ( lastFrame_[1] <= -1.0 ) { + lastFrame_[1] = -0.9999; + } + */ + + return lastFrame_[channel]; +} + +} + +#endif diff --git a/7.x/src/stk/include/Function.h b/7.x/src/stk/include/Function.h new file mode 100644 index 0000000..87aa567 --- /dev/null +++ b/7.x/src/stk/include/Function.h @@ -0,0 +1,41 @@ +#ifndef STK_FUNCTION_H +#define STK_FUNCTION_H + +#include "Stk.h" + +namespace stk { + +/***************************************************/ +/*! \class Function + \brief STK abstract function parent class. + + This class provides common functionality for STK classes that + implement tables or other types of input to output function + mappings. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Function : public Stk +{ + public: + //! Class constructor. + Function( void ) { lastFrame_.resize( 1, 1, 0.0 ); }; + + //! Return the last computed output sample. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Take one sample input and compute one sample of output. + virtual StkFloat tick( StkFloat input ) = 0; + + protected: + + StkFrames lastFrame_; + +}; + +} // stk namespace + +#endif + diff --git a/7.x/src/stk/include/Generator.h b/7.x/src/stk/include/Generator.h new file mode 100644 index 0000000..ef64c9b --- /dev/null +++ b/7.x/src/stk/include/Generator.h @@ -0,0 +1,50 @@ +#ifndef STK_GENERATOR_H +#define STK_GENERATOR_H + +#include "Stk.h" + +namespace stk { + +/***************************************************/ +/*! \class Generator + \brief STK abstract unit generator parent class. + + This class provides limited common functionality for STK unit + generator sample-source subclasses. It is general enough to + support both monophonic and polyphonic output classes. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Generator : public Stk +{ + public: + + //! Class constructor. + Generator( void ) { lastFrame_.resize( 1, 1, 0.0 ); }; + + //! Return the number of output channels for the class. + unsigned int channelsOut( void ) const { return lastFrame_.channels(); }; + + //! Return an StkFrames reference to the last output sample frame. + const StkFrames& lastFrame( void ) const { return lastFrame_; }; + + //! Fill the StkFrames object with computed sample frames, starting at the specified channel. + /*! + The \c channel argument plus the number of output channels must + be less than the number of channels in the StkFrames argument (the + first channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0; + + protected: + + StkFrames lastFrame_; +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Granulate.h b/7.x/src/stk/include/Granulate.h new file mode 100644 index 0000000..cbaf445 --- /dev/null +++ b/7.x/src/stk/include/Granulate.h @@ -0,0 +1,209 @@ +#ifndef STK_GRANULATE_H +#define STK_GRANULATE_H + +#include +#include "Generator.h" +#include "Envelope.h" +#include "Noise.h" + +namespace stk { + +/***************************************************/ +/*! \class Granulate + \brief STK granular synthesis class. + + This class implements a real-time granular synthesis algorithm + that operates on an input soundfile. Multi-channel files are + supported. Various functions are provided to allow control over + voice and grain parameters. + + The functionality of this class is based on the program MacPod by + Chris Rolfe and Damian Keller, though there are likely to be a + number of differences in the actual implementation. + + by Gary Scavone, 2005--2021. +*/ +/***************************************************/ + +class Granulate: public Generator +{ + public: + //! Default constructor. + Granulate( void ); + + //! Constructor taking input audio file and number of voices arguments. + Granulate( unsigned int nVoices, std::string fileName, bool typeRaw = false ); + + //! Class destructor. + ~Granulate( void ); + + //! Load a monophonic soundfile to be "granulated". + /*! + An StkError will be thrown if the file is not found, its format + is unknown or unsupported, or the file has more than one channel. + */ + void openFile( std::string fileName, bool typeRaw = false ); + + //! Reset the file pointer and all existing grains to the file start. + /*! + Multiple grains are offset from one another in time by grain + duration / nVoices. + */ + void reset( void ); + + //! Set the number of simultaneous grain "voices" to use. + /*! + Multiple grains are offset from one another in time by grain + duration / nVoices. For this reason, it is best to set the grain + parameters before calling this function (during initialization). + */ + void setVoices( unsigned int nVoices = 1 ); + + //! Set the stretch factor used for grain playback (1 - 1000). + /*! + Granular synthesis allows for time-stetching without affecting + the original pitch of a sound. A stretch factor of 4 will produce + a resulting sound of length 4 times the orignal sound. The + default parameter of 1 produces no stretching. + */ + void setStretch( unsigned int stretchFactor = 1 ); + + //! Set global grain parameters used to determine individual grain settings. + /*! + Each grain is defined as having a length of \e duration + milliseconds which must be greater than zero. For values of \e + rampPercent (0 - 100) greater than zero, a linear envelope will be + applied to each grain. If \e rampPercent = 100, the resultant + grain "window" is triangular while \e rampPercent = 50 produces a + trapezoidal window. In addition, each grain can have a time delay + of length \e delay and a grain pointer increment of length \e + offset, which can be negative, before the next ramp onset (in + milliseconds). The \e offset parameter controls grain pointer + jumps between enveloped grain segments, while the \e delay + parameter causes grain calculations to pause between grains. The + actual values calculated for each grain will be randomized by a + factor set using the setRandomFactor() function. + */ + void setGrainParameters( unsigned int duration = 30, unsigned int rampPercent = 50, + int offset = 0, unsigned int delay = 0 ); + + //! This factor is used when setting individual grain parameters (0.0 - 1.0). + /*! + This random factor is applied when all grain state durations + are calculated. If set to 0.0, no randomness occurs. When + randomness = 1.0, a grain segment of length \e duration will be + randomly augmented by up to +- \e duration seconds (i.e., a 30 + millisecond length will be augmented by an extra length of up to + +30 or -30 milliseconds). + */ + void setRandomFactor( StkFloat randomness = 0.1 ); + + //! Return the specified channel value of the last computed frame. + /*! + The \c channel argument must be less than the number of output + channels, which can be determined with the channelsOut() function + (the first channel is specified by 0). However, range checking is + only performed if _STK_DEBUG_ is defined during compilation, in + which case an out-of-range value will trigger an StkError + exception. \sa lastFrame() + */ + StkFloat lastOut( unsigned int channel = 0 ); + + //! Compute one sample frame and return the specified \c channel value. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill the StkFrames object with computed sample frames, starting at the specified channel. + /*! + The \c channel argument plus the number of output channels must + be less than the number of channels in the StkFrames argument (the + first channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + enum GrainState { + GRAIN_STOPPED, + GRAIN_FADEIN, + GRAIN_SUSTAIN, + GRAIN_FADEOUT + }; + + protected: + + struct Grain { + StkFloat eScaler; + StkFloat eRate; + unsigned long attackCount; + unsigned long sustainCount; + unsigned long decayCount; + unsigned long delayCount; + unsigned long counter; + //unsigned long pointer; + StkFloat pointer; + unsigned long startPointer; + unsigned int repeats; + GrainState state; + + // Default constructor. + Grain() + :eScaler(0.0), eRate(0.0), attackCount(0), sustainCount(0), decayCount(0), + delayCount(0), counter(0), pointer(0), startPointer(0), repeats(0), state(GRAIN_STOPPED) {} + }; + + void calculateGrain( Granulate::Grain& grain ); + + StkFrames data_; + std::vector grains_; + Noise noise; + //long gPointer_; + StkFloat gPointer_; + + // Global grain parameters. + unsigned int gDuration_; + unsigned int gRampPercent_; + unsigned int gDelay_; + unsigned int gStretch_; + unsigned int stretchCounter_; + int gOffset_; + StkFloat gRandomFactor_; + StkFloat gain_; + +}; + +inline StkFloat Granulate :: lastOut( unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= lastFrame_.channels() ) { + oStream_ << "Granulate::lastOut(): channel argument is invalid!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + +inline StkFrames& Granulate :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Granulate::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + for ( unsigned int i=0; i strings_; + std::vector< int > stringState_; // 0 = off, 1 = decaying, 2 = on + std::vector< unsigned int > decayCounter_; + std::vector< unsigned int > filePointer_; + std::vector< StkFloat > pluckGains_; + + OnePole pickFilter_; + OnePole couplingFilter_; + StkFloat couplingGain_; + StkFrames excitation_; + StkFrames lastFrame_; +}; + +// NOTE: It is not possible to implement the Smith coupled string model here because the Twang class does +// not currently offer the chance to have access to a traveling-wave component. Thus, the coupling +// implemented here is approximate. +inline StkFloat Guitar :: tick( StkFloat input ) +{ + StkFloat temp, output = 0.0; + lastFrame_[0] = couplingGain_ * couplingFilter_.tick( lastFrame_[0] ) / strings_.size(); + for ( unsigned int i=0; i 0.2 ) + temp += pluckGains_[i] * excitation_[filePointer_[i]++]; + temp += lastFrame_[0]; // bridge coupling + output += strings_[i].tick( temp ); + // Check if string energy has decayed sufficiently to turn it off. + if ( stringState_[i] == 1 ) { + if ( fabs( strings_[i].lastOut() ) < 0.001 ) decayCounter_[i]++; + else decayCounter_[i] = 0; + if ( decayCounter_[i] > (unsigned int) floor( 0.1 * Stk::sampleRate() ) ) { + stringState_[i] = 0; + decayCounter_[i] = 0; + } + } + } + } + + return lastFrame_[0] = output; +} + +inline StkFrames& Guitar :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Guitar::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "Guitar::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i2-- + -->1-->Out + \endcode + + Control Change Numbers: + - Total Modulator Index = 2 + - Modulator Crossfade = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class HevyMetl : public FM +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + HevyMetl( void ); + + //! Class destructor. + ~HevyMetl( void ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + +}; + +inline StkFloat HevyMetl :: tick( unsigned int ) +{ + StkFloat temp; + + temp = vibrato_.tick() * modDepth_ * 0.2; + waves_[0]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[0]); + waves_[1]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[1]); + waves_[2]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[2]); + waves_[3]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[3]); + + temp = gains_[2] * adsr_[2]->tick() * waves_[2]->tick(); + waves_[1]->addPhaseOffset( temp ); + + waves_[3]->addPhaseOffset( twozero_.lastOut() ); + temp = (1.0 - (control2_ * 0.5)) * gains_[3] * adsr_[3]->tick() * waves_[3]->tick(); + twozero_.tick(temp); + + temp += control2_ * 0.5 * gains_[1] * adsr_[1]->tick() * waves_[1]->tick(); + temp = temp * control1_; + + waves_[0]->addPhaseOffset( temp ); + temp = gains_[0] * adsr_[0]->tick() * waves_[0]->tick(); + + lastFrame_[0] = temp * 0.5; + return lastFrame_[0]; +} + +inline StkFrames& HevyMetl :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "HevyMetl::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i &bCoefficients, std::vector &aCoefficients ); + + //! Class destructor. + ~Iir( void ); + + //! Set filter coefficients. + /*! + An StkError can be thrown if either of the coefficient vector + sizes is zero, or if the a[0] coefficient is equal to zero. If + a[0] is not equal to 1, the filter coeffcients are normalized by + a[0]. The internal state of the filter is not cleared unless the + \e clearState flag is \c true. + */ + void setCoefficients( std::vector &bCoefficients, std::vector &aCoefficients, bool clearState = false ); + + //! Set numerator coefficients. + /*! + An StkError can be thrown if coefficient vector is empty. Any + previously set denominator coefficients are left unaffected. Note + that the default constructor sets the single denominator + coefficient a[0] to 1.0. The internal state of the filter is not + cleared unless the \e clearState flag is \c true. + */ + void setNumerator( std::vector &bCoefficients, bool clearState = false ); + + //! Set denominator coefficients. + /*! + An StkError can be thrown if the coefficient vector is empty or + if the a[0] coefficient is equal to zero. Previously set + numerator coefficients are unaffected unless a[0] is not equal to + 1, in which case all coeffcients are normalized by a[0]. Note + that the default constructor sets the single numerator coefficient + b[0] to 1.0. The internal state of the filter is not cleared + unless the \e clearState flag is \c true. + */ + void setDenominator( std::vector &aCoefficients, bool clearState = false ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Input one sample to the filter and return one output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + +protected: + +}; + +inline StkFloat Iir :: tick( StkFloat input ) +{ + size_t i; + + outputs_[0] = 0.0; + inputs_[0] = gain_ * input; + for ( i=b_.size()-1; i>0; i-- ) { + outputs_[0] += b_[i] * inputs_[i]; + inputs_[i] = inputs_[i-1]; + } + outputs_[0] += b_[0] * inputs_[0]; + + for ( i=a_.size()-1; i>0; i-- ) { + outputs_[0] += -a_[i] * outputs_[i]; + outputs_[i] = outputs_[i-1]; + } + + lastFrame_[0] = outputs_[0]; + return lastFrame_[0]; +} + +inline StkFrames& Iir :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Iir::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + size_t i; + unsigned int hop = frames.channels(); + for ( unsigned int j=0; j0; i-- ) { + outputs_[0] += b_[i] * inputs_[i]; + inputs_[i] = inputs_[i-1]; + } + outputs_[0] += b_[0] * inputs_[0]; + + for ( i=a_.size()-1; i>0; i-- ) { + outputs_[0] += -a_[i] * outputs_[i]; + outputs_[i] = outputs_[i-1]; + } + + *samples = outputs_[0]; + } + + lastFrame_[0] = *(samples-hop); + return frames; +} + +inline StkFrames& Iir :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel ) +{ +#if defined(_STK_DEBUG_) + if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "Iir::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + size_t i; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int j=0; j0; i-- ) { + outputs_[0] += b_[i] * inputs_[i]; + inputs_[i] = inputs_[i-1]; + } + outputs_[0] += b_[0] * inputs_[0]; + + for ( i=a_.size()-1; i>0; i-- ) { + outputs_[0] += -a_[i] * outputs_[i]; + outputs_[i] = outputs_[i-1]; + } + + *oSamples = outputs_[0]; + } + + lastFrame_[0] = *(oSamples-oHop); + return iFrames; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Instrmnt.h b/7.x/src/stk/include/Instrmnt.h new file mode 100644 index 0000000..c15410c --- /dev/null +++ b/7.x/src/stk/include/Instrmnt.h @@ -0,0 +1,108 @@ +#ifndef STK_INSTRMNT_H +#define STK_INSTRMNT_H + +#include "Stk.h" + +namespace stk { + +/***************************************************/ +/*! \class Instrmnt + \brief STK instrument abstract base class. + + This class provides a common interface for + all STK instruments. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Instrmnt : public Stk +{ + public: + //! Class constructor. + Instrmnt( void ) { lastFrame_.resize( 1, 1, 0.0 ); }; + + //! Reset and clear all internal state (for subclasses). + /*! + Not all subclasses implement a clear() function. + */ + virtual void clear( void ) {}; + + //! Start a note with the given frequency and amplitude. + virtual void noteOn( StkFloat frequency, StkFloat amplitude ) = 0; + + //! Stop a note with the given amplitude (speed of decay). + virtual void noteOff( StkFloat amplitude ) = 0; + + //! Set instrument parameters for a particular frequency. + virtual void setFrequency( StkFloat frequency ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + virtual void controlChange(int number, StkFloat value); + + //! Return the number of output channels for the class. + unsigned int channelsOut( void ) const { return lastFrame_.channels(); }; + + //! Return an StkFrames reference to the last output sample frame. + const StkFrames& lastFrame( void ) const { return lastFrame_; }; + + //! Return the specified channel value of the last computed frame. + /*! + The \c channel argument must be less than the number of output + channels, which can be determined with the channelsOut() function + (the first channel is specified by 0). However, range checking is + only performed if _STK_DEBUG_ is defined during compilation, in + which case an out-of-range value will trigger an StkError + exception. \sa lastFrame() + */ + StkFloat lastOut( unsigned int channel = 0 ); + + //! Compute one sample frame and return the specified \c channel value. + /*! + For monophonic instruments, the \c channel argument is ignored. + */ + virtual StkFloat tick( unsigned int channel = 0 ) = 0; + + //! Fill the StkFrames object with computed sample frames, starting at the specified channel. + /*! + The \c channel argument plus the number of output channels must + be less than the number of channels in the StkFrames argument (the + first channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0; + + protected: + + StkFrames lastFrame_; + +}; + +inline void Instrmnt :: setFrequency( StkFloat frequency ) +{ + oStream_ << "Instrmnt::setFrequency: virtual setFrequency function call!"; + handleError( StkError::WARNING ); +} + +inline StkFloat Instrmnt :: lastOut( unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= lastFrame_.channels() ) { + oStream_ << "Instrmnt::lastOut(): channel argument is invalid!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + +inline void Instrmnt :: controlChange( int number, StkFloat value ) +{ + oStream_ << "Instrmnt::controlChange: virtual function call!"; + handleError( StkError::WARNING ); +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/JCRev.h b/7.x/src/stk/include/JCRev.h new file mode 100644 index 0000000..7acd0eb --- /dev/null +++ b/7.x/src/stk/include/JCRev.h @@ -0,0 +1,166 @@ +#ifndef STK_JCREV_H +#define STK_JCREV_H + +#include "Effect.h" +#include "Delay.h" +#include "OnePole.h" + +namespace stk { + +/***************************************************/ +/*! \class JCRev + \brief John Chowning's reverberator class. + + This class takes a monophonic input signal and + produces a stereo output signal. It is derived + from the CLM JCRev function, which is based on + the use of networks of simple allpass and comb + delay filters. This class implements three + series allpass units, followed by four parallel + comb filters, and two decorrelation delay lines + in parallel at the output. + + Although not in the original JC reverberator, + one-pole lowpass filters have been added inside + the feedback comb filters. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class JCRev : public Effect +{ + public: + //! Class constructor taking a T60 decay time argument (one second default value). + JCRev( StkFloat T60 = 1.0 ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set the reverberation T60 decay time. + void setT60( StkFloat T60 ); + + //! Return the specified channel value of the last computed stereo frame. + /*! + Use the lastFrame() function to get both values of the last + computed stereo frame. The \c channel argument must be 0 or 1 + (the first channel is specified by 0). However, range checking is + only performed if _STK_DEBUG_ is defined during compilation, in + which case an out-of-range value will trigger an StkError + exception. + */ + StkFloat lastOut( unsigned int channel = 0 ); + + //! Input one sample to the effect and return the specified \c channel value of the computed stereo frame. + /*! + Use the lastFrame() function to get both values of the computed + stereo output frame. The \c channel argument must be 0 or 1 (the + first channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + StkFloat tick( StkFloat input, unsigned int channel = 0 ); + + //! Take a channel of the StkFrames object as inputs to the effect and replace with stereo outputs. + /*! + The StkFrames argument reference is returned. The stereo + outputs are written to the StkFrames argument starting at the + specified \c channel. Therefore, the \c channel argument must be + less than ( channels() - 1 ) of the StkFrames argument (the first + channel is specified by 0). However, range checking is only + performed if _STK_DEBUG_ is defined during compilation, in which + case an out-of-range value will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the effect and write stereo outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. The \c iChannel + argument must be less than the number of channels in the \c + iFrames argument (the first channel is specified by 0). The \c + oChannel argument must be less than ( channels() - 1 ) of the \c + oFrames argument. However, range checking is only performed if + _STK_DEBUG_ is defined during compilation, in which case an + out-of-range value will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + + protected: + + Delay allpassDelays_[3]; + Delay combDelays_[4]; + OnePole combFilters_[4]; + Delay outLeftDelay_; + Delay outRightDelay_; + StkFloat allpassCoefficient_; + StkFloat combCoefficient_[4]; + +}; + +inline StkFloat JCRev :: lastOut( unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel > 1 ) { + oStream_ << "JCRev::lastOut(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + +inline StkFloat JCRev :: tick( StkFloat input, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel > 1 ) { + oStream_ << "JCRev::tick(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat temp, temp0, temp1, temp2, temp3, temp4, temp5, temp6; + StkFloat filtout; + + temp = allpassDelays_[0].lastOut(); + temp0 = allpassCoefficient_ * temp; + temp0 += input; + allpassDelays_[0].tick(temp0); + temp0 = -(allpassCoefficient_ * temp0) + temp; + + temp = allpassDelays_[1].lastOut(); + temp1 = allpassCoefficient_ * temp; + temp1 += temp0; + allpassDelays_[1].tick(temp1); + temp1 = -(allpassCoefficient_ * temp1) + temp; + + temp = allpassDelays_[2].lastOut(); + temp2 = allpassCoefficient_ * temp; + temp2 += temp1; + allpassDelays_[2].tick(temp2); + temp2 = -(allpassCoefficient_ * temp2) + temp; + + temp3 = temp2 + ( combFilters_[0].tick( combCoefficient_[0] * combDelays_[0].lastOut() ) ); + temp4 = temp2 + ( combFilters_[1].tick( combCoefficient_[1] * combDelays_[1].lastOut() ) ); + temp5 = temp2 + ( combFilters_[2].tick( combCoefficient_[2] * combDelays_[2].lastOut() ) ); + temp6 = temp2 + ( combFilters_[3].tick( combCoefficient_[3] * combDelays_[3].lastOut() ) ); + + combDelays_[0].tick(temp3); + combDelays_[1].tick(temp4); + combDelays_[2].tick(temp5); + combDelays_[3].tick(temp6); + + filtout = temp3 + temp4 + temp5 + temp6; + + lastFrame_[0] = effectMix_ * (outLeftDelay_.tick(filtout)); + lastFrame_[1] = effectMix_ * (outRightDelay_.tick(filtout)); + temp = (1.0 - effectMix_) * input; + lastFrame_[0] += temp; + lastFrame_[1] += temp; + + return 0.7 * lastFrame_[channel]; +} + +} // stk namespace + +#endif + diff --git a/7.x/src/stk/include/JetTable.h b/7.x/src/stk/include/JetTable.h new file mode 100644 index 0000000..1d628c8 --- /dev/null +++ b/7.x/src/stk/include/JetTable.h @@ -0,0 +1,112 @@ +#ifndef STK_JETTABL_H +#define STK_JETTABL_H + +#include "Function.h" + +namespace stk { + +/***************************************************/ +/*! \class JetTable + \brief STK jet table class. + + This class implements a flue jet non-linear + function, computed by a polynomial calculation. + Contrary to the name, this is not a "table". + + Consult Fletcher and Rossing, Karjalainen, + Cook, and others for more information. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class JetTable : public Function +{ +public: + + //! Take one sample input and map to one sample of output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the table and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the table and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + +}; + +inline StkFloat JetTable :: tick( StkFloat input ) +{ + // Perform "table lookup" using a polynomial + // calculation (x^3 - x), which approximates + // the jet sigmoid behavior. + lastFrame_[0] = input * (input * input - 1.0); + + // Saturate at +/- 1.0. + if ( lastFrame_[0] > 1.0 ) lastFrame_[0] = 1.0; + if ( lastFrame_[0] < -1.0 ) lastFrame_[0] = -1.0; + return lastFrame_[0]; +} + +inline StkFrames& JetTable :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "JetTable::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i 1.0) *samples = 1.0; + if ( *samples < -1.0) *samples = -1.0; + } + + lastFrame_[0] = *(samples-hop); + return frames; +} + +inline StkFrames& JetTable :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel ) +{ +#if defined(_STK_DEBUG_) + if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "JetTable::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i 1.0) *oSamples = 1.0; + if ( *oSamples < -1.0) *oSamples = -1.0; + } + + lastFrame_[0] = *(oSamples-oHop); + return iFrames; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/LentPitShift.h b/7.x/src/stk/include/LentPitShift.h new file mode 100644 index 0000000..dff5648 --- /dev/null +++ b/7.x/src/stk/include/LentPitShift.h @@ -0,0 +1,263 @@ +#ifndef STK_LENTPITSHIFT_H +#define STK_LENTPITSHIFT_H + +#include "Effect.h" +#include "Delay.h" + +namespace stk { + +/***************************************************/ +/*! \class LentPitShift + \brief Pitch shifter effect class based on the Lent algorithm. + + This class implements a pitch shifter using pitch + tracking and sample windowing and shifting. + + by Francois Germain, 2009. +*/ +/***************************************************/ + +class LentPitShift : public Effect +{ + public: + //! Class constructor. + LentPitShift( StkFloat periodRatio = 1.0, int tMax = RT_BUFFER_SIZE ); + + ~LentPitShift( void ) { + delete window; + delete dt; + delete dpt; + delete cumDt; + } + + //! Reset and clear all internal state. + void clear( void ); + + //! Set the pitch shift factor (1.0 produces no shift). + void setShift( StkFloat shift ); + + //! Input one sample to the filter and return one output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + + protected: + + //! Apply the effect on the input samples and store it. + /*! + The samples stored in the input frame vector are processed + and the delayed result are stored in the output frame vector. + */ + void process( ); + + // Frame storage vectors for process function + StkFrames inputFrames; + StkFrames outputFrames; + int ptrFrames; // writing pointer + + // Input delay line + Delay inputLine_; + int inputPtr; + + // Output delay line + Delay outputLine_; + double outputPtr; + + // Pitch tracker variables + unsigned long tMax_; // Maximal period measurable by the pitch tracker. + // It is also the size of the window used by the pitch tracker and + // the size of the frames that can be computed by the tick function + + StkFloat threshold_; // Threshold of detection for the pitch tracker + unsigned long lastPeriod_; // Result of the last pitch tracking loop + StkFloat* dt; // Array containing the euclidian distance coefficients + StkFloat* cumDt; // Array containing the cumulative sum of the coefficients in dt + StkFloat* dpt; // Array containing the pitch tracking function coefficients + + // Pitch shifter variables + StkFloat env[2]; // Coefficients for the linear interpolation when modifying the output samples + StkFloat* window; // Hamming window used for the input portion extraction + double periodRatio_; // Ratio of modification of the signal period + StkFrames zeroFrame; // Frame of tMax_ zero samples + + + // Coefficient delay line that could be used for a dynamic calculation of the pitch + //Delay* coeffLine_; + +}; + +inline void LentPitShift::process() +{ + StkFloat x_t; // input coefficient + StkFloat x_t_T; // previous input coefficient at T samples + StkFloat coeff; // new coefficient for the difference function + + unsigned long alternativePitch = tMax_; // Global minimum storage + lastPeriod_ = tMax_+1; // Storage of the lowest local minimum under the threshold + + // Loop variables + unsigned long delay_; + unsigned int n; + + // Initialization of the dt coefficients. Since the + // frames are of tMax_ length, there is no overlapping + // between the successive windows where pitch tracking + // is performed. + for ( delay_=1; delay_<=tMax_; delay_++ ) + dt[delay_] = 0.; + + // Calculation of the dt coefficients and update of the input delay line. + for ( n=0; n 1 && dpt[delay_-1]-dpt[delay_-2] < 0 && dpt[delay_]-dpt[delay_-1] > 0 ) { + // Check if the minimum is under the threshold + if ( dpt[delay_-1] < threshold_ ){ + lastPeriod_ = delay_-1; + // If a minimum is found, we can stop the loop + break; + } + else if ( dpt[alternativePitch] > dpt[delay_-1] ) + // Otherwise we store it if it is the current global minimum + alternativePitch = delay_-1; + } + } + + // Test for the last period length. + if ( dpt[delay_]-dpt[delay_-1] < 0 ) { + if ( dpt[delay_] < threshold_ ) + lastPeriod_ = delay_; + else if ( dpt[alternativePitch] > dpt[delay_] ) + alternativePitch = delay_; + } + + if ( lastPeriod_ == tMax_+1 ) + // No period has been under the threshold so we used the global minimum + lastPeriod_ = alternativePitch; + + // We put the new zero output coefficients in the output delay line and + // we get the previous calculated coefficients + outputLine_.tick( zeroFrame, outputFrames ); + + // Initialization of the Hamming window used in the algorithm + for ( int n=-(int)lastPeriod_; n<(int)lastPeriod_; n++ ) + window[n+lastPeriod_] = (1 + cos(PI*n/lastPeriod_)) / 2 ; + + long M; // Index of reading in the input delay line + long N; // Index of writing in the output delay line + double sample; // Temporary storage for the new coefficient + + // We loop for all the frames of length lastPeriod_ presents between inputPtr and tMax_ + for ( ; inputPtr<(int)(tMax_-lastPeriod_); inputPtr+=lastPeriod_ ) { + // Test for the decision of compression/expansion + while ( outputPtr < inputPtr ) { + // Coefficients for the linear interpolation + env[1] = fmod( outputPtr + tMax_, 1.0 ); + env[0] = 1.0 - env[1]; + M = tMax_ - inputPtr + lastPeriod_ - 1; // New reading pointer + N = 2*tMax_ - (unsigned long)floor(outputPtr + tMax_) + lastPeriod_ - 1; // New writing pointer + for ( unsigned int j=0; j<2*lastPeriod_; j++,M--,N-- ) { + sample = inputLine_.tapOut(M) * window[j] / 2.; + // Linear interpolation + outputLine_.addTo(env[0] * sample, N); + outputLine_.addTo(env[1] * sample, N-1); + } + outputPtr = outputPtr + lastPeriod_ * periodRatio_; // new output pointer + } + } + // Shifting of the pointers waiting for the new frame of length tMax_. + outputPtr -= tMax_; + inputPtr -= tMax_; +} + + +inline StkFloat LentPitShift :: tick( StkFloat input ) +{ + StkFloat sample; + + inputFrames[ptrFrames] = input; + + sample = outputFrames[ptrFrames++]; + + // Check for end condition + if ( ptrFrames == (int) inputFrames.size() ){ + ptrFrames = 0; + process( ); + } + + return sample; +} + +inline StkFrames& LentPitShift :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "LentPitShift::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "LentPitShift::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "Mandolin::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "Mesh2D::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i +#include +#include +#include + +namespace stk { + +/**********************************************************************/ +/*! \class MidiFileIn + \brief A standard MIDI file reading/parsing class. + + This class can be used to read events from a standard MIDI file. + Event bytes are copied to a C++ vector and must be subsequently + interpreted by the user. The function getNextMidiEvent() skips + meta and sysex events, returning only MIDI channel messages. + Event delta-times are returned in the form of "ticks" and a + function is provided to determine the current "seconds per tick". + Tempo changes are internally tracked by the class and reflected in + the values returned by the function getTickSeconds(). + + by Gary P. Scavone, 2003--2021. +*/ +/**********************************************************************/ + +class MidiFileIn : public Stk +{ + public: + //! Default constructor. + /*! + If an error occurs while opening or parsing the file header, an + StkError exception will be thrown. + */ + MidiFileIn( std::string fileName ); + + //! Class destructor. + ~MidiFileIn(); + + //! Return the MIDI file format (0, 1, or 2). + int getFileFormat() const { return format_; }; + + //! Return the number of tracks in the MIDI file. + unsigned int getNumberOfTracks() const { return nTracks_; }; + + //! Return the MIDI file division value from the file header. + /*! + Note that this value must be "parsed" in accordance with the + MIDI File Specification. In particular, if the MSB is set, the + file uses time-code representations for delta-time values. + */ + int getDivision() const { return division_; }; + + //! Move the specified track event reader to the beginning of its track. + /*! + The relevant track tempo value is reset as well. If an invalid + track number is specified, an StkError exception will be thrown. + */ + void rewindTrack( unsigned int track = 0 ); + + //! Get the current value, in seconds, of delta-time ticks for the specified track. + /*! + This value can change as events are read (via "Set Tempo" + Meta-Events). Therefore, one should call this function after + every call to getNextEvent() or getNextMidiEvent(). If an + invalid track number is specified, an StkError exception will be + thrown. + */ + double getTickSeconds( unsigned int track = 0 ); + + //! Fill the user-provided vector with the next event in the specified track and return the event delta-time in ticks. + /*! + MIDI File events consist of a delta time and a sequence of event + bytes. This function returns the delta-time value and writes + the subsequent event bytes directly to the event vector. The + user must parse the event bytes in accordance with the MIDI File + Specification. All returned MIDI channel events are complete + ... a status byte is provided even when running status is used + in the file. If the track has reached its end, no bytes will be + written and the event vector size will be zero. If an invalid + track number is specified or an error occurs while reading the + file, an StkError exception will be thrown. + */ + unsigned long getNextEvent( std::vector *event, unsigned int track = 0 ); + + //! Fill the user-provided vector with the next MIDI channel event in the specified track and return the event delta time in ticks. + /*! + All returned MIDI events are complete ... a status byte is + provided even when running status is used in the file. Meta and + sysex events in the track are skipped though "Set Tempo" events + are properly parsed for use by the getTickSeconds() function. + If the track has reached its end, no bytes will be written and + the event vector size will be zero. If an invalid track number + is specified or an error occurs while reading the file, an + StkError exception will be thrown. + */ + unsigned long getNextMidiEvent( std::vector *midiEvent, unsigned int track = 0 ); + + protected: + + // This protected class function is used for reading variable-length + // MIDI file values. It is assumed that this function is called with + // the file read pointer positioned at the start of a + // variable-length value. The function returns true if the value is + // successfully parsed. Otherwise, it returns false. + bool readVariableLength( unsigned long *value ); + + std::ifstream file_; + unsigned int nTracks_; + int format_; + int division_; + bool usingTimeCode_; + std::vector tickSeconds_; + std::vector trackPointers_; + std::vector trackOffsets_; + std::vector trackLengths_; + std::vector trackStatus_; + + // This structure and the following variables are used to save and + // keep track of a format 1 tempo map (and the initial tickSeconds + // parameter for formats 0 and 2). + struct TempoChange { + unsigned long count; + double tickSeconds; + }; + std::vector tempoEvents_; + std::vector trackCounters_; + std::vector trackTempoIndex_; +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Modal.h b/7.x/src/stk/include/Modal.h new file mode 100644 index 0000000..626ac6b --- /dev/null +++ b/7.x/src/stk/include/Modal.h @@ -0,0 +1,154 @@ +#ifndef STK_MODAL_H +#define STK_MODAL_H + +#include "Instrmnt.h" +#include "Envelope.h" +#include "FileLoop.h" +#include "SineWave.h" +#include "BiQuad.h" +#include "OnePole.h" + +namespace stk { + +/***************************************************/ +/*! \class Modal + \brief STK resonance model abstract base class. + + This class contains an excitation wavetable, + an envelope, an oscillator, and N resonances + (non-sweeping BiQuad filters), where N is set + during instantiation. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Modal : public Instrmnt +{ +public: + //! Class constructor, taking the desired number of modes to create. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + Modal( unsigned int modes = 4 ); + + //! Class destructor. + virtual ~Modal( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + virtual void setFrequency( StkFloat frequency ); + + //! Set the ratio and radius for a specified mode filter. + void setRatioAndRadius( unsigned int modeIndex, StkFloat ratio, StkFloat radius ); + + //! Set the master gain. + void setMasterGain( StkFloat aGain ) { masterGain_ = aGain; }; + + //! Set the direct gain. + void setDirectGain( StkFloat aGain ) { directGain_ = aGain; }; + + //! Set the gain for a specified mode filter. + void setModeGain( unsigned int modeIndex, StkFloat gain ); + + //! Initiate a strike with the given amplitude (0.0 - 1.0). + virtual void strike( StkFloat amplitude ); + + //! Damp modes with a given decay factor (0.0 - 1.0). + void damp( StkFloat amplitude ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + virtual void controlChange( int number, StkFloat value ) = 0; + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + +protected: + + Envelope envelope_; + FileWvIn *wave_; + BiQuad **filters_; + OnePole onepole_; + SineWave vibrato_; + + unsigned int nModes_; + std::vector ratios_; + std::vector radii_; + + StkFloat vibratoGain_; + StkFloat masterGain_; + StkFloat directGain_; + StkFloat stickHardness_; + StkFloat strikePosition_; + StkFloat baseFrequency_; +}; + +inline StkFloat Modal :: tick( unsigned int ) +{ + StkFloat temp = masterGain_ * onepole_.tick( wave_->tick() * envelope_.tick() ); + + StkFloat temp2 = 0.0; + for ( unsigned int i=0; itick(temp); + + temp2 -= temp2 * directGain_; + temp2 += directGain_ * temp; + + if ( vibratoGain_ != 0.0 ) { + // Calculate AM and apply to master out + temp = 1.0 + ( vibrato_.tick() * vibratoGain_ ); + temp2 = temp * temp2; + } + + lastFrame_[0] = temp2; + return lastFrame_[0]; +} + +inline StkFrames& Modal :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Modal::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i= noiseRate_ ) { + noise_.tick(); + noiseCounter_ = 0; + } + lastFrame_[0] += filter_.tick( noise_.lastOut() ); + return lastFrame_[0]; +} + +inline StkFrames& Modulate :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Modulate::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; isetFrequency( mSpeed ); }; + + //! Set the modulation (vibrato) depth. + void setModulationDepth( StkFloat mDepth ) { modDepth_ = mDepth * 0.5; }; + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + FormSwep filters_[2]; + StkFloat modDepth_; + StkFloat filterQ_; + StkFloat filterRate_; + +}; + +inline StkFloat Moog :: tick( unsigned int ) +{ + StkFloat temp; + + if ( modDepth_ != 0.0 ) { + temp = loops_[1]->tick() * modDepth_; + loops_[0]->setFrequency( baseFrequency_ * (1.0 + temp) ); + } + + temp = attackGain_ * attacks_[0]->tick(); + temp += loopGain_ * loops_[0]->tick(); + temp = filter_.tick( temp ); + temp *= adsr_.tick(); + temp = filters_[0].tick( temp ); + lastFrame_[0] = filters_[1].tick( temp ); + return lastFrame_[0] * 6.0; +} + +inline StkFrames& Moog :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Moog::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i 1 ) { + oStream_ << "NRev::lastOut(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + +inline StkFloat NRev :: tick( StkFloat input, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel > 1 ) { + oStream_ << "NRev::tick(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat temp, temp0, temp1, temp2, temp3; + int i; + + temp0 = 0.0; + for ( i=0; i<6; i++ ) { + temp = input + (combCoefficient_[i] * combDelays_[i].lastOut()); + temp0 += combDelays_[i].tick(temp); + } + + for ( i=0; i<3; i++ ) { + temp = allpassDelays_[i].lastOut(); + temp1 = allpassCoefficient_ * temp; + temp1 += temp0; + allpassDelays_[i].tick(temp1); + temp0 = -(allpassCoefficient_ * temp1) + temp; + } + + // One-pole lowpass filter. + lowpassState_ = 0.7 * lowpassState_ + 0.3 * temp0; + temp = allpassDelays_[3].lastOut(); + temp1 = allpassCoefficient_ * temp; + temp1 += lowpassState_; + allpassDelays_[3].tick( temp1 ); + temp1 = -( allpassCoefficient_ * temp1 ) + temp; + + temp = allpassDelays_[4].lastOut(); + temp2 = allpassCoefficient_ * temp; + temp2 += temp1; + allpassDelays_[4].tick( temp2 ); + lastFrame_[0] = effectMix_*( -( allpassCoefficient_ * temp2 ) + temp ); + + temp = allpassDelays_[5].lastOut(); + temp3 = allpassCoefficient_ * temp; + temp3 += temp1; + allpassDelays_[5].tick( temp3 ); + lastFrame_[1] = effectMix_*( - ( allpassCoefficient_ * temp3 ) + temp ); + + temp = ( 1.0 - effectMix_ ) * input; + lastFrame_[0] += temp; + lastFrame_[1] += temp; + + return lastFrame_[channel]; +} + +} // stk namespace + +#endif + diff --git a/7.x/src/stk/include/Noise.h b/7.x/src/stk/include/Noise.h new file mode 100644 index 0000000..3ea46e5 --- /dev/null +++ b/7.x/src/stk/include/Noise.h @@ -0,0 +1,84 @@ +#ifndef STK_NOISE_H +#define STK_NOISE_H + +#include "Generator.h" +#include + +namespace stk { + +/***************************************************/ +/*! \class Noise + \brief STK noise generator. + + Generic random number generation using the + C rand() function. The quality of the rand() + function varies from one OS to another. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Noise : public Generator +{ +public: + + //! Default constructor that can also take a specific seed value. + /*! + If the seed value is zero (the default value), the random number generator is + seeded with the system time. + */ + Noise( unsigned int seed = 0 ); + + //! Seed the random number generator with a specific seed value. + /*! + If no seed is provided or the seed value is zero, the random + number generator is seeded with the current system time. + */ + void setSeed( unsigned int seed = 0 ); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + +protected: + +}; + +inline StkFloat Noise :: tick( void ) +{ + return lastFrame_[0] = (StkFloat) ( 2.0 * rand() / (RAND_MAX + 1.0) - 1.0 ); +} + +inline StkFrames& Noise :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Noise::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "OnePole::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "OnePole::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "OneZero::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "OneZero::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i 1 ) { + oStream_ << "PRCRev::lastOut(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + + inline StkFloat PRCRev :: tick( StkFloat input, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel > 1 ) { + oStream_ << "PRCRev::tick(): channel argument must be less than 2!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat temp, temp0, temp1, temp2, temp3; + + temp = allpassDelays_[0].lastOut(); + temp0 = allpassCoefficient_ * temp; + temp0 += input; + allpassDelays_[0].tick(temp0); + temp0 = -(allpassCoefficient_ * temp0) + temp; + + temp = allpassDelays_[1].lastOut(); + temp1 = allpassCoefficient_ * temp; + temp1 += temp0; + allpassDelays_[1].tick(temp1); + temp1 = -(allpassCoefficient_ * temp1) + temp; + + temp2 = temp1 + ( combCoefficient_[0] * combDelays_[0].lastOut() ); + temp3 = temp1 + ( combCoefficient_[1] * combDelays_[1].lastOut() ); + + lastFrame_[0] = effectMix_ * (combDelays_[0].tick(temp2)); + lastFrame_[1] = effectMix_ * (combDelays_[1].tick(temp3)); + temp = (1.0 - effectMix_) * input; + lastFrame_[0] += temp; + lastFrame_[1] += temp; + + return lastFrame_[channel]; +} + +} // stk namespace + +#endif + diff --git a/7.x/src/stk/include/PercFlut.h b/7.x/src/stk/include/PercFlut.h new file mode 100644 index 0000000..1dbedef --- /dev/null +++ b/7.x/src/stk/include/PercFlut.h @@ -0,0 +1,127 @@ +#ifndef STK_PERCFLUT_H +#define STK_PERCFLUT_H + +#include "FM.h" + +namespace stk { + +/***************************************************/ +/*! \class PercFlut + \brief STK percussive flute FM synthesis instrument. + + This class implements algorithm 4 of the TX81Z. + + \code + Algorithm 4 is : 4->3--\ + 2-- + -->1-->Out + \endcode + + Control Change Numbers: + - Total Modulator Index = 2 + - Modulator Crossfade = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class PercFlut : public FM +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + PercFlut( void ); + + //! Class destructor. + ~PercFlut( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + +}; + +inline StkFloat PercFlut :: tick( unsigned int ) +{ + StkFloat temp; + + temp = vibrato_.tick() * modDepth_ * 0.2; + waves_[0]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[0]); + waves_[1]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[1]); + waves_[2]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[2]); + waves_[3]->setFrequency(baseFrequency_ * (1.0 + temp) * ratios_[3]); + + waves_[3]->addPhaseOffset( twozero_.lastOut() ); + temp = gains_[3] * adsr_[3]->tick() * waves_[3]->tick(); + + twozero_.tick(temp); + waves_[2]->addPhaseOffset( temp ); + temp = (1.0 - (control2_ * 0.5)) * gains_[2] * adsr_[2]->tick() * waves_[2]->tick(); + + temp += control2_ * 0.5 * gains_[1] * adsr_[1]->tick() * waves_[1]->tick(); + temp = temp * control1_; + + waves_[0]->addPhaseOffset(temp); + temp = gains_[0] * adsr_[0]->tick() * waves_[0]->tick(); + + lastFrame_[0] = temp * 0.5; + return lastFrame_[0]; +} + +inline StkFrames& PercFlut :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "PercFlut::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i maxDelay-12 ) delay_[0] -= delayLength_; + while ( delay_[0] < 12 ) delay_[0] += delayLength_; + + delay_[1] = delay_[0] + halfLength_; + while ( delay_[1] > maxDelay-12 ) delay_[1] -= delayLength_; + while ( delay_[1] < 12 ) delay_[1] += delayLength_; + + // Set the new delay line lengths. + delayLine_[0].setDelay( delay_[0] ); + delayLine_[1].setDelay( delay_[1] ); + + // Calculate a triangular envelope. + env_[1] = fabs( ( delay_[0] - halfLength_ + 12 ) * ( 1.0 / (halfLength_ + 12 ) ) ); + env_[0] = 1.0 - env_[1]; + + // Delay input and apply envelope. + lastFrame_[0] = env_[0] * delayLine_[0].tick( input ); + lastFrame_[0] += env_[1] * delayLine_[1].tick( input ); + + // Compute effect mix and output. + lastFrame_[0] *= effectMix_; + lastFrame_[0] += ( 1.0 - effectMix_ ) * input; + + return lastFrame_[0]; +} + +} // stk namespace + +#endif + diff --git a/7.x/src/stk/include/Plucked.h b/7.x/src/stk/include/Plucked.h new file mode 100644 index 0000000..26a2257 --- /dev/null +++ b/7.x/src/stk/include/Plucked.h @@ -0,0 +1,117 @@ +#ifndef STK_PLUCKED_H +#define STK_PLUCKED_H + +#include "Instrmnt.h" +#include "DelayA.h" +#include "OneZero.h" +#include "OnePole.h" +#include "Noise.h" + +namespace stk { + +/***************************************************/ +/*! \class Plucked + \brief STK basic plucked string class. + + This class implements a simple plucked string + physical model based on the Karplus-Strong + algorithm. + + For a more advanced plucked string implementation, + see the stk::Twang class. + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + There exist at least two patents, assigned to + Stanford, bearing the names of Karplus and/or + Strong. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Plucked : public Instrmnt +{ + public: + //! Class constructor, taking the lowest desired playing frequency. + Plucked( StkFloat lowestFrequency = 10.0 ); + + //! Class destructor. + ~Plucked( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Pluck the string with the given amplitude using the current frequency. + void pluck( StkFloat amplitude ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + DelayA delayLine_; + OneZero loopFilter_; + OnePole pickFilter_; + Noise noise_; + + StkFloat loopGain_; +}; + +inline StkFloat Plucked :: tick( unsigned int ) +{ + // Here's the whole inner loop of the instrument!! + return lastFrame_[0] = 3.0 * delayLine_.tick( loopFilter_.tick( delayLine_.lastOut() * loopGain_ ) ); +} + +inline StkFrames& Plucked :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Plucked::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "PoleZero::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "Recorder::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i 1, the reed has slammed shut and the + // reflection function value saturates at 1.0. + if ( lastFrame_[0] > 1.0) lastFrame_[0] = (StkFloat) 1.0; + + // This is nearly impossible in a physical system, but + // a reflection function value of -1.0 corresponds to + // an open end (and no discontinuity in bore profile). + if ( lastFrame_[0] < -1.0) lastFrame_[0] = (StkFloat) -1.0; + + return lastFrame_[0]; +} + +inline StkFrames& ReedTable :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "ReedTable::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i 1.0) *samples = 1.0; + if ( *samples < -1.0) *samples = -1.0; + } + + lastFrame_[0] = *(samples-hop); + return frames; +} + +inline StkFrames& ReedTable :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel ) +{ +#if defined(_STK_DEBUG_) + if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "ReedTable::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i 1.0) *oSamples = 1.0; + if ( *oSamples < -1.0) *oSamples = -1.0; + } + + lastFrame_[0] = *(oSamples-oHop); + return iFrames; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Resonate.h b/7.x/src/stk/include/Resonate.h new file mode 100644 index 0000000..4a3b7d4 --- /dev/null +++ b/7.x/src/stk/include/Resonate.h @@ -0,0 +1,124 @@ +#ifndef STK_RESONATE_H +#define STK_RESONATE_H + +#include "Instrmnt.h" +#include "ADSR.h" +#include "BiQuad.h" +#include "Noise.h" + +namespace stk { + +/***************************************************/ +/*! \class Resonate + \brief STK noise driven formant filter. + + This instrument contains a noise source, which + excites a biquad resonance filter, with volume + controlled by an ADSR. + + Control Change Numbers: + - Resonance Frequency (0-Nyquist) = 2 + - Pole Radii = 4 + - Notch Frequency (0-Nyquist) = 11 + - Zero Radii = 1 + - Envelope Gain = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Resonate : public Instrmnt +{ + public: + //! Class constructor. + Resonate( void ); + + //! Class destructor. + ~Resonate( void ); + + //! Set the filter for a resonance at the given frequency (Hz) and radius. + void setResonance( StkFloat frequency, StkFloat radius ); + + //! Set the filter for a notch at the given frequency (Hz) and radius. + void setNotch( StkFloat frequency, StkFloat radius ); + + //! Set the filter zero coefficients for contant resonance gain. + void setEqualGainZeroes( void ) { filter_.setEqualGainZeroes(); }; + + //! Initiate the envelope with a key-on event. + void keyOn( void ) { adsr_.keyOn(); }; + + //! Signal a key-off event to the envelope. + void keyOff( void ) { adsr_.keyOff(); }; + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + ADSR adsr_; + BiQuad filter_; + Noise noise_; + StkFloat poleFrequency_; + StkFloat poleRadius_; + StkFloat zeroFrequency_; + StkFloat zeroRadius_; + +}; + +inline StkFloat Resonate :: tick( unsigned int ) +{ + lastFrame_[0] = filter_.tick( noise_.tick() ); + lastFrame_[0] *= adsr_.tick(); + return lastFrame_[0]; +} + +inline StkFrames& Resonate :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Resonate::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i3--\ + + --> Out + 2->1--/ + \endcode + + Control Change Numbers: + - Modulator Index One = 2 + - Crossfade of Outputs = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Rhodey : public FM +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + Rhodey( void ); + + //! Class destructor. + ~Rhodey( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + +}; + +inline StkFloat Rhodey :: tick( unsigned int ) +{ + StkFloat temp, temp2; + + temp = gains_[1] * adsr_[1]->tick() * waves_[1]->tick(); + temp = temp * control1_; + + waves_[0]->addPhaseOffset( temp ); + waves_[3]->addPhaseOffset( twozero_.lastOut() ); + temp = gains_[3] * adsr_[3]->tick() * waves_[3]->tick(); + twozero_.tick(temp); + + waves_[2]->addPhaseOffset( temp ); + temp = ( 1.0 - (control2_ * 0.5)) * gains_[0] * adsr_[0]->tick() * waves_[0]->tick(); + temp += control2_ * 0.5 * gains_[2] * adsr_[2]->tick() * waves_[2]->tick(); + + // Calculate amplitude modulation and apply it to output. + temp2 = vibrato_.tick() * modDepth_; + temp = temp * (1.0 + temp2); + + lastFrame_[0] = temp * 0.5; + return lastFrame_[0]; +} + +inline StkFrames& Rhodey :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Rhodey::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i_ + + where is the string used in the SKINI stream. + + by Perry R. Cook, 1995--2021. +*/ +/*********************************************************/ + +namespace stk { + +#define NOPE -32767 +#define YEP 1 +#define SK_DBL -32766 +#define SK_INT -32765 +#define SK_STR -32764 +#define __SK_Exit_ 999 + +/***** MIDI COMPATIBLE MESSAGES *****/ +/*** (Status bytes for channel=0) ***/ + +#define __SK_NoteOff_ 128 +#define __SK_NoteOn_ 144 +#define __SK_PolyPressure_ 160 +#define __SK_ControlChange_ 176 +#define __SK_ProgramChange_ 192 +#define __SK_AfterTouch_ 208 +#define __SK_ChannelPressure_ __SK_AfterTouch_ +#define __SK_PitchWheel_ 224 +#define __SK_PitchBend_ __SK_PitchWheel_ +#define __SK_PitchChange_ 49 + +#define __SK_Clock_ 248 +#define __SK_SongStart_ 250 +#define __SK_Continue_ 251 +#define __SK_SongStop_ 252 +#define __SK_ActiveSensing_ 254 +#define __SK_SystemReset_ 255 + +#define __SK_Volume_ 7 +#define __SK_ModWheel_ 1 +#define __SK_Modulation_ __SK_ModWheel_ +#define __SK_Breath_ 2 +#define __SK_FootControl_ 4 +#define __SK_Portamento_ 65 +#define __SK_Balance_ 8 +#define __SK_Pan_ 10 +#define __SK_Sustain_ 64 +#define __SK_Damper_ __SK_Sustain_ +#define __SK_Expression_ 11 + +#define __SK_AfterTouch_Cont_ 128 +#define __SK_ModFrequency_ __SK_Expression_ + +#define __SK_ProphesyRibbon_ 16 +#define __SK_ProphesyWheelUp_ 2 +#define __SK_ProphesyWheelDown_ 3 +#define __SK_ProphesyPedal_ 18 +#define __SK_ProphesyKnob1_ 21 +#define __SK_ProphesyKnob2_ 22 + +/*** Instrument Family Specific ***/ + +#define __SK_NoiseLevel_ __SK_FootControl_ + +#define __SK_PickPosition_ __SK_FootControl_ +#define __SK_StringDamping_ __SK_Expression_ +#define __SK_StringDetune_ __SK_ModWheel_ +#define __SK_BodySize_ __SK_Breath_ +#define __SK_BowPressure_ __SK_Breath_ +#define __SK_BowPosition_ __SK_PickPosition_ +#define __SK_BowBeta_ __SK_BowPosition_ + +#define __SK_ReedStiffness_ __SK_Breath_ +#define __SK_ReedRestPos_ __SK_FootControl_ + +#define __SK_FluteEmbouchure_ __SK_Breath_ +#define __SK_JetDelay_ __SK_FluteEmbouchure_ + +#define __SK_LipTension_ __SK_Breath_ +#define __SK_SlideLength_ __SK_FootControl_ + +#define __SK_StrikePosition_ __SK_PickPosition_ +#define __SK_StickHardness_ __SK_Breath_ + +#define __SK_TrillDepth_ 1051 +#define __SK_TrillSpeed_ 1052 +#define __SK_StrumSpeed_ __SK_TrillSpeed_ +#define __SK_RollSpeed_ __SK_TrillSpeed_ + +#define __SK_FilterQ_ __SK_Breath_ +#define __SK_FilterFreq_ 1062 +#define __SK_FilterSweepRate_ __SK_FootControl_ + +#define __SK_ShakerInst_ 1071 +#define __SK_ShakerEnergy_ __SK_Breath_ +#define __SK_ShakerDamping_ __SK_ModFrequency_ +#define __SK_ShakerNumObjects_ __SK_FootControl_ + +#define __SK_Strumming_ 1090 +#define __SK_NotStrumming_ 1091 +#define __SK_Trilling_ 1092 +#define __SK_NotTrilling_ 1093 +#define __SK_Rolling_ __SK_Strumming_ +#define __SK_NotRolling_ __SK_NotStrumming_ + +#define __SK_PlayerSkill_ 2001 +#define __SK_Chord_ 2002 +#define __SK_ChordOff_ 2003 + +#define __SK_SINGER_FilePath_ 3000 +#define __SK_SINGER_Frequency_ 3001 +#define __SK_SINGER_NoteName_ 3002 +#define __SK_SINGER_Shape_ 3003 +#define __SK_SINGER_Glot_ 3004 +#define __SK_SINGER_VoicedUnVoiced_ 3005 +#define __SK_SINGER_Synthesize_ 3006 +#define __SK_SINGER_Silence_ 3007 +#define __SK_SINGER_VibratoAmt_ __SK_ModWheel_ +#define __SK_SINGER_RndVibAmt_ 3008 +#define __SK_SINGER_VibFreq_ __SK_Expression_ + +} // stk namespace diff --git a/7.x/src/stk/include/SKINItbl.h b/7.x/src/stk/include/SKINItbl.h new file mode 100644 index 0000000..cfe1fda --- /dev/null +++ b/7.x/src/stk/include/SKINItbl.h @@ -0,0 +1,135 @@ + +#include "SKINImsg.h" + +namespace stk { + +#define __SK_MaxMsgTypes_ 80 + +struct SkiniSpec { char messageString[32]; + long type; + long data2; + long data3; + }; + +/* SEE COMMENT BLOCK AT BOTTOM FOR FIELDS AND USES */ +/* MessageString , type, data2, data3 */ + +struct SkiniSpec skini_msgs[__SK_MaxMsgTypes_] = +{ + {"NoteOff" , __SK_NoteOff_, SK_DBL, SK_DBL}, + {"NoteOn" , __SK_NoteOn_, SK_DBL, SK_DBL}, + {"PolyPressure" , __SK_PolyPressure_, SK_DBL, SK_DBL}, + {"ControlChange" , __SK_ControlChange_, SK_INT, SK_DBL}, + {"ProgramChange" , __SK_ProgramChange_, SK_DBL, NOPE}, + {"AfterTouch" , __SK_AfterTouch_, SK_DBL, NOPE}, + {"ChannelPressure" ,__SK_ChannelPressure_, SK_DBL, NOPE}, + {"PitchWheel" , __SK_PitchWheel_, SK_DBL, NOPE}, + {"PitchBend" , __SK_PitchBend_, SK_DBL, NOPE}, + {"PitchChange" , __SK_PitchChange_, SK_DBL, NOPE}, + + {"Clock" , __SK_Clock_, NOPE, NOPE}, + {"Undefined" , 249, NOPE, NOPE}, + {"SongStart" , __SK_SongStart_, NOPE, NOPE}, + {"Continue" , __SK_Continue_, NOPE, NOPE}, + {"SongStop" , __SK_SongStop_, NOPE, NOPE}, + {"Undefined" , 253, NOPE, NOPE}, + {"ActiveSensing" , __SK_ActiveSensing_, NOPE, NOPE}, + {"SystemReset" , __SK_SystemReset_, NOPE, NOPE}, + + {"Volume" , __SK_ControlChange_, __SK_Volume_ , SK_DBL}, + {"ModWheel" , __SK_ControlChange_, __SK_ModWheel_ , SK_DBL}, + {"Modulation" , __SK_ControlChange_, __SK_Modulation_ , SK_DBL}, + {"Breath" , __SK_ControlChange_, __SK_Breath_ , SK_DBL}, + {"FootControl" , __SK_ControlChange_, __SK_FootControl_ , SK_DBL}, + {"Portamento" , __SK_ControlChange_, __SK_Portamento_ , SK_DBL}, + {"Balance" , __SK_ControlChange_, __SK_Balance_ , SK_DBL}, + {"Pan" , __SK_ControlChange_, __SK_Pan_ , SK_DBL}, + {"Sustain" , __SK_ControlChange_, __SK_Sustain_ , SK_DBL}, + {"Damper" , __SK_ControlChange_, __SK_Damper_ , SK_DBL}, + {"Expression" , __SK_ControlChange_, __SK_Expression_ , SK_DBL}, + + {"NoiseLevel" , __SK_ControlChange_, __SK_NoiseLevel_ , SK_DBL}, + {"PickPosition" , __SK_ControlChange_, __SK_PickPosition_ , SK_DBL}, + {"StringDamping" , __SK_ControlChange_, __SK_StringDamping_ , SK_DBL}, + {"StringDetune" , __SK_ControlChange_, __SK_StringDetune_ , SK_DBL}, + {"BodySize" , __SK_ControlChange_, __SK_BodySize_ , SK_DBL}, + {"BowPressure" , __SK_ControlChange_, __SK_BowPressure_ , SK_DBL}, + {"BowPosition" , __SK_ControlChange_, __SK_BowPosition_ , SK_DBL}, + {"BowBeta" , __SK_ControlChange_, __SK_BowBeta_ , SK_DBL}, + + {"ReedStiffness" , __SK_ControlChange_, __SK_ReedStiffness_ , SK_DBL}, + {"ReedRestPos" , __SK_ControlChange_, __SK_ReedRestPos_ , SK_DBL}, + {"FluteEmbouchure" , __SK_ControlChange_, __SK_FluteEmbouchure_ , SK_DBL}, + {"LipTension" , __SK_ControlChange_, __SK_LipTension_ , SK_DBL}, + {"StrikePosition" , __SK_ControlChange_, __SK_StrikePosition_ , SK_DBL}, + {"StickHardness" , __SK_ControlChange_, __SK_StickHardness_ , SK_DBL}, + + {"TrillDepth" , __SK_ControlChange_, __SK_TrillDepth_ , SK_DBL}, + {"TrillSpeed" , __SK_ControlChange_, __SK_TrillSpeed_ , SK_DBL}, + + {"Strumming" , __SK_ControlChange_, __SK_Strumming_ , 127 }, + {"NotStrumming" , __SK_ControlChange_, __SK_Strumming_ , 0 }, + + {"PlayerSkill" , __SK_ControlChange_, __SK_PlayerSkill_ , SK_DBL}, + + {"Chord" , __SK_Chord_ , SK_DBL, SK_STR}, + {"ChordOff" , __SK_ChordOff_ , SK_DBL, NOPE}, + + {"ShakerInst" , __SK_ControlChange_, __SK_ShakerInst_ , SK_DBL}, + {"Maraca" , __SK_ControlChange_, __SK_ShakerInst_ , 0 }, + {"Sekere" , __SK_ControlChange_, __SK_ShakerInst_ , 1 }, + {"Cabasa" , __SK_ControlChange_, __SK_ShakerInst_ , 2 }, + {"Bamboo" , __SK_ControlChange_, __SK_ShakerInst_ , 3 }, + {"Waterdrp" , __SK_ControlChange_, __SK_ShakerInst_ , 4 }, + {"Tambourn" , __SK_ControlChange_, __SK_ShakerInst_ , 5 }, + {"Sleighbl" , __SK_ControlChange_, __SK_ShakerInst_ , 6 }, + {"Guiro" , __SK_ControlChange_, __SK_ShakerInst_ , 7 }, + + {"OpenFile" , 256, SK_STR, NOPE}, + {"SetPath" , 257, SK_STR, NOPE}, + + {"FilePath" , __SK_SINGER_FilePath_ , SK_STR, NOPE}, + {"Frequency" , __SK_SINGER_Frequency_ , SK_STR, NOPE}, + {"NoteName" , __SK_SINGER_NoteName_ , SK_STR, NOPE}, + {"VocalShape" , __SK_SINGER_Shape_ , SK_STR, NOPE}, + {"Glottis" , __SK_SINGER_Glot_ , SK_STR, NOPE}, + {"VoicedUnVoiced" , __SK_SINGER_VoicedUnVoiced_, SK_DBL, SK_STR}, + {"Synthesize" , __SK_SINGER_Synthesize_ , SK_STR, NOPE}, + {"Silence" , __SK_SINGER_Silence_ , SK_STR, NOPE}, + {"RndVibAmt" , __SK_SINGER_RndVibAmt_ , SK_STR, NOPE}, + {"VibratoAmt" , __SK_ControlChange_ ,__SK_SINGER_VibratoAmt_,SK_DBL}, + {"VibFreq" , __SK_ControlChange_ ,__SK_SINGER_VibFreq_ ,SK_DBL} +}; + + +/** FORMAT: *************************************************************/ +/* */ +/* MessageStr$ , type, data2, data3, */ +/* */ +/* type is the message type sent back from the SKINI line parser. */ +/* data is either */ +/* NOPE : field not used, specifically, there aren't going */ +/* to be any more fields on this line. So if there */ +/* is NOPE in data2, data3 won't even be checked */ +/* SK_INT : byte (actually scanned as 32 bit signed integer) */ +/* If it's a MIDI data field which is required to */ +/* be an integer, like a controller number, it's */ +/* 0-127. Otherwise, get creative with SK_INTs. */ +/* SK_DBL : double precision floating point. SKINI uses these */ +/* in the MIDI context for note numbers with micro */ +/* tuning, velocities, controller values, etc. */ +/* SK_STR : only valid in final field. This allows (nearly) */ +/* arbitrary message types to be supported by simply */ +/* scanning the string to EndOfLine and then passing */ +/* it to a more intelligent handler. For example, */ +/* MIDI SYSEX (system exclusive) messages of up to */ +/* 256 bytes can be read as space-delimited integers */ +/* into the SK_STR buffer. Longer bulk dumps, */ +/* soundfiles, etc. should be handled as a new */ +/* message type pointing to a FileName stored in the */ +/* SK_STR field, or as a new type of multi-line */ +/* message. */ +/* */ +/*************************************************************************/ + +} // stk namespace diff --git a/7.x/src/stk/include/Sampler.h b/7.x/src/stk/include/Sampler.h new file mode 100644 index 0000000..3bc4d7e --- /dev/null +++ b/7.x/src/stk/include/Sampler.h @@ -0,0 +1,75 @@ +#ifndef STK_SAMPLER_H +#define STK_SAMPLER_H + +#include "Instrmnt.h" +#include "ADSR.h" +#include "FileLoop.h" +#include "OnePole.h" + +namespace stk { + +/***************************************************/ +/*! \class Sampler + \brief STK sampling synthesis abstract base class. + + This instrument provides an ADSR envelope, a one-pole filter, and + structures for an arbitrary number of attack and looped files. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Sampler : public Instrmnt +{ + public: + //! Default constructor. + Sampler( void ); + + //! Class destructor. + virtual ~Sampler( void ); + + //! Set instrument parameters for a particular frequency. + virtual void setFrequency( StkFloat frequency ) = 0; + + //! Initiate the envelopes with a key-on event and reset the attack waves. + void keyOn( void ); + + //! Signal a key-off event to the envelopes. + void keyOff( void ); + + //! Stop a note with the given amplitude (speed of decay). + virtual void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + virtual void controlChange( int number, StkFloat value ) = 0; + + //! Compute and return one output sample. + virtual StkFloat tick( unsigned int channel = 0 ) = 0; + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0; + + protected: + + ADSR adsr_; + std::vector attacks_; + std::vector loops_; + OnePole filter_; + StkFloat baseFrequency_; + std::vector attackRatios_; + std::vector loopRatios_; + StkFloat attackGain_; + StkFloat loopGain_; + +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/Saxofony.h b/7.x/src/stk/include/Saxofony.h new file mode 100644 index 0000000..110ec02 --- /dev/null +++ b/7.x/src/stk/include/Saxofony.h @@ -0,0 +1,166 @@ +#ifndef STK_SAXOFONY_H +#define STK_SAXOFONY_H + +#include "Instrmnt.h" +#include "DelayL.h" +#include "ReedTable.h" +#include "OneZero.h" +#include "Envelope.h" +#include "Noise.h" +#include "SineWave.h" + +namespace stk { + +/***************************************************/ +/*! \class Saxofony + \brief STK faux conical bore reed instrument class. + + This class implements a "hybrid" digital + waveguide instrument that can generate a + variety of wind-like sounds. It has also been + referred to as the "blowed string" model. The + waveguide section is essentially that of a + string, with one rigid and one lossy + termination. The non-linear function is a + reed table. The string can be "blown" at any + point between the terminations, though just as + with strings, it is impossible to excite the + system at either end. If the excitation is + placed at the string mid-point, the sound is + that of a clarinet. At points closer to the + "bridge", the sound is closer to that of a + saxophone. See Scavone (2002) for more details. + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + Control Change Numbers: + - Reed Stiffness = 2 + - Reed Aperture = 26 + - Noise Gain = 4 + - Blow Position = 11 + - Vibrato Frequency = 29 + - Vibrato Gain = 1 + - Breath Pressure = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Saxofony : public Instrmnt +{ + public: + //! Class constructor, taking the lowest desired playing frequency. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + Saxofony( StkFloat lowestFrequency ); + + //! Class destructor. + ~Saxofony( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Set the "blowing" position between the air column terminations (0.0 - 1.0). + void setBlowPosition( StkFloat aPosition ); + + //! Apply breath pressure to instrument with given amplitude and rate of increase. + void startBlowing( StkFloat amplitude, StkFloat rate ); + + //! Decrease breath pressure with given rate of decrease. + void stopBlowing( StkFloat rate ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + DelayL delays_[2]; + ReedTable reedTable_; + OneZero filter_; + Envelope envelope_; + Noise noise_; + SineWave vibrato_; + + StkFloat outputGain_; + StkFloat noiseGain_; + StkFloat vibratoGain_; + StkFloat position_; + +}; + +inline StkFloat Saxofony :: tick( unsigned int ) +{ + StkFloat pressureDiff; + StkFloat breathPressure; + StkFloat temp; + + // Calculate the breath pressure (envelope + noise + vibrato) + breathPressure = envelope_.tick(); + breathPressure += breathPressure * noiseGain_ * noise_.tick(); + breathPressure += breathPressure * vibratoGain_ * vibrato_.tick(); + + temp = -0.95 * filter_.tick( delays_[0].lastOut() ); + lastFrame_[0] = temp - delays_[1].lastOut(); + pressureDiff = breathPressure - lastFrame_[0]; + delays_[1].tick( temp ); + delays_[0].tick( breathPressure - (pressureDiff * reedTable_.tick(pressureDiff)) - temp ); + + lastFrame_[0] *= outputGain_; + return lastFrame_[0]; +} + +inline StkFrames& Saxofony :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Saxofony::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i +#include + +namespace stk { + +/***************************************************/ +/*! \class Shakers + \brief PhISEM and PhOLIES class. + + PhISEM (Physically Informed Stochastic Event Modeling) is an + algorithmic approach for simulating collisions of multiple + independent sound producing objects. This class is a meta-model + that can simulate a Maraca, Sekere, Cabasa, Bamboo Wind Chimes, + Water Drops, Tambourine, Sleighbells, and a Guiro. + + PhOLIES (Physically-Oriented Library of Imitated Environmental + Sounds) is a similar approach for the synthesis of environmental + sounds. This class implements simulations of breaking sticks, + crunchy snow (or not), a wrench, sandpaper, and more. + + Control Change Numbers: + - Shake Energy = 2 + - System Decay = 4 + - Number Of Objects = 11 + - Resonance Frequency = 1 + - Shake Energy = 128 + - Instrument Selection = 1071 + - Maraca = 0 + - Cabasa = 1 + - Sekere = 2 + - Tambourine = 3 + - Sleigh Bells = 4 + - Bamboo Chimes = 5 + - Sand Paper = 6 + - Coke Can = 7 + - Sticks = 8 + - Crunch = 9 + - Big Rocks = 10 + - Little Rocks = 11 + - Next Mug = 12 + - Penny + Mug = 13 + - Nickle + Mug = 14 + - Dime + Mug = 15 + - Quarter + Mug = 16 + - Franc + Mug = 17 + - Peso + Mug = 18 + - Guiro = 19 + - Wrench = 20 + - Water Drops = 21 + - Tuned Bamboo Chimes = 22 + + by Perry R. Cook with updates by Gary Scavone, 1995--2021. +*/ +/***************************************************/ + +class Shakers : public Instrmnt +{ + public: + //! Class constructor taking instrument type argument. + Shakers( int type = 0 ); + + //! Start a note with the given instrument and amplitude. + /*! + Use the instrument numbers above, converted to frequency values + as if MIDI note numbers, to select a particular instrument. + */ + void noteOn( StkFloat instrument, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + struct BiQuad { + StkFloat gain; + StkFloat b[3]; + StkFloat a[3]; // a0 term assumed equal to 1.0 + StkFloat inputs[3]; + StkFloat outputs[3]; + + // Default constructor. + BiQuad() + { + gain = 0.0; + for ( int i=0; i<3; i++ ) { + b[i] = 0.0; + a[i] = 0.0; + inputs[i] = 0.0; + outputs[i] = 0.0; + } + } + }; + + protected: + + void setType( int type ); + void setResonance( BiQuad &filter, StkFloat frequency, StkFloat radius ); + StkFloat tickResonance( BiQuad &filter, StkFloat input ); + void setEqualization( StkFloat b0, StkFloat b1, StkFloat b2 ); + StkFloat tickEqualize( StkFloat input ); + int randomInt( int max ); + StkFloat randomFloat( StkFloat max = 1.0 ); + StkFloat noise( void ); + void waterDrop( void ); + + int shakerType_; + unsigned int nResonances_; + StkFloat shakeEnergy_; + StkFloat soundDecay_; + StkFloat systemDecay_; + StkFloat nObjects_; + StkFloat sndLevel_; + StkFloat baseGain_; + StkFloat currentGain_; + StkFloat baseDecay_; + StkFloat baseObjects_; + StkFloat decayScale_; + BiQuad equalizer_; + StkFloat ratchetCount_; + StkFloat ratchetDelta_; + StkFloat baseRatchetDelta_; + int lastRatchetValue_; + + std::vector< BiQuad > filters_; + std::vector< StkFloat > baseFrequencies_; + std::vector< StkFloat > baseRadii_; + std::vector< bool > doVaryFrequency_; + std::vector< StkFloat > tempFrequencies_; + StkFloat varyFactor_; +}; + +inline void Shakers :: setResonance( BiQuad &filter, StkFloat frequency, StkFloat radius ) +{ + filter.a[1] = -2.0 * radius * cos( TWO_PI * frequency / Stk::sampleRate()); + filter.a[2] = radius * radius; +} + +inline StkFloat Shakers :: tickResonance( BiQuad &filter, StkFloat input ) +{ + filter.outputs[0] = input * filter.gain * currentGain_; + filter.outputs[0] -= filter.a[1] * filter.outputs[1] + filter.a[2] * filter.outputs[2]; + filter.outputs[2] = filter.outputs[1]; + filter.outputs[1] = filter.outputs[0]; + return filter.outputs[0]; +} + +inline void Shakers :: setEqualization( StkFloat b0, StkFloat b1, StkFloat b2 ) +{ + equalizer_.b[0] = b0; + equalizer_.b[1] = b1; + equalizer_.b[2] = b2; +} + +inline StkFloat Shakers :: tickEqualize( StkFloat input ) +{ + equalizer_.inputs[0] = input; + equalizer_.outputs[0] = equalizer_.b[0] * equalizer_.inputs[0] + equalizer_.b[1] * equalizer_.inputs[1] + equalizer_.b[2] * equalizer_.inputs[2]; + equalizer_.inputs[2] = equalizer_.inputs[1]; + equalizer_.inputs[1] = equalizer_.inputs[0]; + return equalizer_.outputs[0]; +} + +inline int Shakers :: randomInt( int max ) // Return random integer between 0 and max-1 +{ + return (int) ((float)max * rand() / (RAND_MAX + 1.0) ); +} + +inline StkFloat Shakers :: randomFloat( StkFloat max ) // Return random float between 0.0 and max +{ + return (StkFloat) (max * rand() / (RAND_MAX + 1.0) ); +} + +inline StkFloat Shakers :: noise( void ) // Return random StkFloat float between -1.0 and 1.0 +{ + return ( (StkFloat) ( 2.0 * rand() / (RAND_MAX + 1.0) ) - 1.0 ); +} + +const StkFloat MIN_ENERGY = 0.001; +const StkFloat WATER_FREQ_SWEEP = 1.0001; + +inline void Shakers :: waterDrop( void ) +{ + if ( randomInt( 32767 ) < nObjects_) { + sndLevel_ = shakeEnergy_; + unsigned int j = randomInt( 3 ); + if ( j == 0 && filters_[0].gain == 0.0 ) { // don't change unless fully decayed + tempFrequencies_[0] = baseFrequencies_[1] * (0.75 + (0.25 * noise())); + filters_[0].gain = fabs( noise() ); + } + else if (j == 1 && filters_[1].gain == 0.0) { + tempFrequencies_[1] = baseFrequencies_[1] * (1.0 + (0.25 * noise())); + filters_[1].gain = fabs( noise() ); + } + else if ( filters_[2].gain == 0.0 ) { + tempFrequencies_[2] = baseFrequencies_[1] * (1.25 + (0.25 * noise())); + filters_[2].gain = fabs( noise() ); + } + } + + // Sweep center frequencies. + for ( unsigned int i=0; i<3; i++ ) { // WATER_RESONANCES = 3 + filters_[i].gain *= baseRadii_[i]; + if ( filters_[i].gain > 0.001 ) { + tempFrequencies_[i] *= WATER_FREQ_SWEEP; + filters_[i].a[1] = -2.0 * baseRadii_[i] * cos( TWO_PI * tempFrequencies_[i] / Stk::sampleRate() ); + } + else + filters_[i].gain = 0.0; + } +} + +inline StkFloat Shakers :: tick( unsigned int ) +{ + unsigned int iTube = 0; + StkFloat input = 0.0; + if ( shakerType_ == 19 || shakerType_ == 20 ) { + if ( ratchetCount_ <= 0 ) return lastFrame_[0] = 0.0; + + shakeEnergy_ -= ( ratchetDelta_ + ( 0.002 * shakeEnergy_ ) ); + if ( shakeEnergy_ < 0.0 ) { + shakeEnergy_ = 1.0; + ratchetCount_--; + } + + if ( randomFloat( 1024 ) < nObjects_ ) + sndLevel_ += shakeEnergy_ * shakeEnergy_; + + // Sound is enveloped noise + input = sndLevel_ * noise() * shakeEnergy_; + } + else { + if ( shakeEnergy_ < MIN_ENERGY ) return lastFrame_[0] = 0.0; + + // Exponential system decay + shakeEnergy_ *= systemDecay_; + + // Random events + if ( shakerType_ == 21 ) { + waterDrop(); + input = sndLevel_; + } + else { + if ( randomFloat( 1024.0 ) < nObjects_ ) { + sndLevel_ += shakeEnergy_; + input = sndLevel_; + // Vary resonance frequencies if specified. + for ( unsigned int i=0; i 1.0 ) + // std::cout << "lastOutput = " << lastFrame_[0] << std::endl; + + return lastFrame_[0]; +} + +inline StkFrames& Shakers :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Shakers::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; itick(); + biquad_.tick( noise_.tick() ); + lastFrame_[0] += (1.0 - loopGain_) * biquad_.lastOut(); + lastFrame_[0] = filter_.tick( lastFrame_[0] ); + lastFrame_[0] *= adsr_.tick(); + return lastFrame_[0]; +} + +inline StkFrames& Simple :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Simple::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i= TABLE_SIZE ) + time_ -= TABLE_SIZE; + + iIndex_ = (unsigned int) time_; + alpha_ = time_ - iIndex_; + StkFloat tmp = table_[ iIndex_ ]; + tmp += ( alpha_ * ( table_[ iIndex_ + 1 ] - tmp ) ); + + // Increment time, which can be negative. + time_ += rate_; + + lastFrame_[0] = tmp; + return lastFrame_[0]; +} + +inline StkFrames& SineWave :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "SineWave::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + StkFloat tmp = 0.0; + + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= TABLE_SIZE ) + time_ -= TABLE_SIZE; + + iIndex_ = (unsigned int) time_; + alpha_ = time_ - iIndex_; + tmp = table_[ iIndex_ ]; + tmp += ( alpha_ * ( table_[ iIndex_ + 1 ] - tmp ) ); + *samples = tmp; + + // Increment time, which can be negative. + time_ += rate_; + } + + lastFrame_[0] = tmp; + return frames; +} + +} // stk namespace + +#endif + diff --git a/7.x/src/stk/include/SingWave.h b/7.x/src/stk/include/SingWave.h new file mode 100644 index 0000000..34107b6 --- /dev/null +++ b/7.x/src/stk/include/SingWave.h @@ -0,0 +1,136 @@ +#ifndef STK_SINGWAVE_H +#define STK_SINGWAVE_H + +#include "FileLoop.h" +#include "Modulate.h" +#include "Envelope.h" + +namespace stk { + +/***************************************************/ +/*! \class SingWave + \brief STK "singing" looped soundfile class. + + This class loops a specified soundfile and modulates it both + periodically and randomly to produce a pitched musical sound, like + a simple voice or violin. In general, it is not be used alone + because of "munchkinification" effects from pitch shifting. + Within STK, it is used as an excitation source for other + instruments. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class SingWave : public Generator +{ + public: + //! Class constructor taking filename argument. + /*! + An StkError will be thrown if the file is not found, its format + is unknown, or a read error occurs. If the soundfile has no + header, the second argument should be \e true and the file data + will be assumed to consist of 16-bit signed integers in big-endian + byte order at a sample rate of 22050 Hz. + */ + SingWave( std::string fileName, bool raw = false ); + + //! Class destructor. + ~SingWave( void ); + + //! Reset file to beginning. + void reset( void ) { wave_.reset(); lastFrame_[0] = 0.0; }; + + //! Normalize the file to a maximum of +-1.0. + void normalize( void ) { wave_.normalize(); }; + + //! Normalize the file to a maximum of \e +- peak. + void normalize( StkFloat peak ) { wave_.normalize( peak ); }; + + //! Set looping parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Set the vibrato frequency in Hz. + void setVibratoRate( StkFloat rate ) { modulator_.setVibratoRate( rate ); }; + + //! Set the vibrato gain. + void setVibratoGain( StkFloat gain ) { modulator_.setVibratoGain( gain ); }; + + //! Set the random-ness amount. + void setRandomGain( StkFloat gain ) { modulator_.setRandomGain( gain ); }; + + //! Set the sweep rate. + void setSweepRate( StkFloat rate ) { sweepRate_ = rate; }; + + //! Set the gain rate. + void setGainRate( StkFloat rate ) { envelope_.setRate( rate ); }; + + //! Set the gain target value. + void setGainTarget( StkFloat target ) { envelope_.setTarget( target ); }; + + //! Start a note. + void noteOn( void ) { envelope_.keyOn(); }; + + //! Stop a note. + void noteOff( void ) { envelope_.keyOff(); }; + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Compute and return one output sample. + StkFloat tick( void ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + FileLoop wave_; + Modulate modulator_; + Envelope envelope_; + Envelope pitchEnvelope_; + StkFloat rate_; + StkFloat sweepRate_; + +}; + +inline StkFloat SingWave :: tick( void ) +{ + // Set the wave rate. + StkFloat newRate = pitchEnvelope_.tick(); + newRate += newRate * modulator_.tick(); + wave_.setRate( newRate ); + + lastFrame_[0] = wave_.tick(); + lastFrame_[0] *= envelope_.tick(); + + return lastFrame_[0]; +} + +inline StkFrames& SingWave :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "SingWave::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i + +namespace stk { + +/***************************************************/ +/*! \class Sitar + \brief STK sitar string model class. + + This class implements a sitar plucked string + physical model based on the Karplus-Strong + algorithm. + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + There exist at least two patents, assigned to + Stanford, bearing the names of Karplus and/or + Strong. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Sitar : public Instrmnt +{ + public: + //! Class constructor, taking the lowest desired playing frequency. + Sitar( StkFloat lowestFrequency = 8.0 ); + + //! Class destructor. + ~Sitar( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Pluck the string with the given amplitude using the current frequency. + void pluck( StkFloat amplitude ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + DelayA delayLine_; + OneZero loopFilter_; + Noise noise_; + ADSR envelope_; + + StkFloat loopGain_; + StkFloat amGain_; + StkFloat delay_; + StkFloat targetDelay_; + +}; + +inline StkFloat Sitar :: tick( unsigned int ) +{ + if ( fabs(targetDelay_ - delay_) > 0.001 ) { + if ( targetDelay_ < delay_ ) + delay_ *= 0.99999; + else + delay_ *= 1.00001; + delayLine_.setDelay( delay_ ); + } + + lastFrame_[0] = delayLine_.tick( loopFilter_.tick( delayLine_.lastOut() * loopGain_ ) + + (amGain_ * envelope_.tick() * noise_.tick())); + + return lastFrame_[0]; +} + +inline StkFrames& Sitar :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Sitar::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i +#include +#include + +namespace stk { + +/***************************************************/ +/*! \class Skini + \brief STK SKINI parsing class + + This class parses SKINI formatted text + messages. It can be used to parse individual + messages or it can be passed an entire file. + The SKINI specification is Perry's and his + alone, but it's all text so it shouldn't be too + hard to figure out. + + SKINI (Synthesis toolKit Instrument Network + Interface) is like MIDI, but allows for + floating-point control changes, note numbers, + etc. The following example causes a sharp + middle C to be played with a velocity of 111.132: + + \code + noteOn 60.01 111.132 + \endcode + + \sa \ref skini + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Skini : public Stk +{ + public: + + //! A message structure to store and pass parsed SKINI messages. + struct Message { + long type; /*!< The message type, as defined in SKINImsg.h. */ + long channel; /*!< The message channel (not limited to 16!). */ + StkFloat time; /*!< The message time stamp in seconds (delta or absolute). */ + std::vector floatValues; /*!< The message values read as floats (values are type-specific). */ + std::vector intValues; /*!< The message values read as ints (number and values are type-specific). */ + std::string remainder; /*!< Any remaining message data, read as ascii text. */ + + // Default constructor. + Message() + :type(0), channel(0), time(0.0), floatValues(2), intValues(2) {} + }; + + //! Default constructor. + Skini(); + + //! Class destructor + ~Skini(); + + //! Set a SKINI formatted file for reading. + /*! + If the file is successfully opened, this function returns \e + true. Otherwise, \e false is returned. + */ + bool setFile( std::string fileName ); + + //! Parse the next file message (if a file is loaded) and return the message type. + /*! + This function skips over lines in a file which cannot be + parsed. A type value equal to zero in the referenced message + structure (and the returned value) indicates the file end is + reached or no file is open for reading. + */ + long nextMessage( Skini::Message& message ); + + //! Attempt to parse the given string and returning the message type. + /*! + A type value equal to zero in the referenced message structure + indicates an invalid message. + */ + long parseString( std::string& line, Skini::Message& message ); + + //! Return the SKINI type string for the given type value. + static std::string whatsThisType(long type); + + //! Return the SKINI controller string for the given controller number. + static std::string whatsThisController(long number); + + protected: + + void tokenize( const std::string& str, std::vector& tokens, const std::string& delimiters ); + + std::ifstream file_; +}; + +//! A static table of equal-tempered MIDI to frequency (Hz) values. +static const double Midi2Pitch[129] = { + 8.176, 8.662, 9.177, 9.723, 10.301, 10.913, 11.562, 12.25, + 12.978, 13.75, 14.568, 15.434, 16.352, 17.324, 18.354, 19.445, + 20.602, 21.827, 23.125, 24.50, 25.957, 27.50, 29.135, 30.868, + 32.703, 34.648, 36.708, 38.891, 41.203, 43.654, 46.249, 49.0, + 51.913, 55.0, 58.271, 61.735, 65.406, 69.296, 73.416, 77.782, + 82.407, 87.307, 92.499, 97.999, 103.826, 110.0, 116.541, 123.471, + 130.813, 138.591, 146.832, 155.563, 164.814, 174.614, 184.997, 195.998, + 207.652, 220.0, 233.082, 246.942, 261.626, 277.183, 293.665, 311.127, + 329.628, 349.228, 369.994, 391.995, 415.305, 440.0, 466.164, 493.883, + 523.251, 554.365, 587.33, 622.254, 659.255, 698.456, 739.989, 783.991, + 830.609, 880.0, 932.328, 987.767, 1046.502, 1108.731, 1174.659, 1244.508, + 1318.51, 1396.913, 1479.978, 1567.982, 1661.219, 1760.0, 1864.655, 1975.533, + 2093.005, 2217.461, 2349.318, 2489.016, 2637.02, 2793.826, 2959.955, 3135.963, + 3322.438, 3520.0, 3729.31, 3951.066, 4186.009, 4434.922, 4698.636, 4978.032, + 5274.041, 5587.652, 5919.911, 6271.927, 6644.875, 7040.0, 7458.62, 7902.133, + 8372.018, 8869.844, 9397.273, 9956.063, 10548.082, 11175.303, 11839.822, 12543.854, + 13289.75}; + +} // stk namespace + +#endif + + diff --git a/7.x/src/stk/include/Sphere.h b/7.x/src/stk/include/Sphere.h new file mode 100644 index 0000000..f54ada5 --- /dev/null +++ b/7.x/src/stk/include/Sphere.h @@ -0,0 +1,79 @@ +#ifndef STK_SPHERE_H +#define STK_SPHERE_H + +#include "Stk.h" +#include "Vector3D.h" + +namespace stk { + +/***************************************************/ +/*! \class Sphere + \brief STK sphere class. + + This class implements a spherical ball with + radius, mass, position, and velocity parameters. + + by Perry R. Cook, 1995--2021. +*/ +/***************************************************/ + +class Sphere : public Stk +{ +public: + //! Constructor taking an initial radius value. + Sphere( StkFloat radius = 1.0 ) { radius_ = radius; mass_ = 1.0; }; + + //! Set the 3D center position of the sphere. + void setPosition( StkFloat x, StkFloat y, StkFloat z ) { position_.setXYZ(x, y, z); }; + + //! Set the 3D velocity of the sphere. + void setVelocity( StkFloat x, StkFloat y, StkFloat z ) { velocity_.setXYZ(x, y, z); }; + + //! Set the radius of the sphere. + void setRadius( StkFloat radius ) { radius_ = radius; }; + + //! Set the mass of the sphere. + void setMass( StkFloat mass ) { mass_ = mass; }; + + //! Get the current position of the sphere as a 3D vector. + Vector3D* getPosition( void ) { return &position_; }; + + //! Get the relative position of the given point to the sphere as a 3D vector. + Vector3D* getRelativePosition( Vector3D *position ); + + //! Set the velocity of the sphere as a 3D vector. + StkFloat getVelocity( Vector3D* velocity ); + + //! Returns the distance from the sphere boundary to the given position (< 0 if inside). + StkFloat isInside( Vector3D *position ); + + //! Get the current sphere radius. + StkFloat getRadius( void ) { return radius_; }; + + //! Get the current sphere mass. + StkFloat getMass( void ) { return mass_; }; + + //! Increase the current sphere velocity by the given 3D components. + void addVelocity( StkFloat x, StkFloat y, StkFloat z ); + + //! Move the sphere for the given time increment. + void tick( StkFloat timeIncrement ); + +private: + Vector3D position_; + Vector3D velocity_; + Vector3D workingVector_; + StkFloat radius_; + StkFloat mass_; +}; + +inline void Sphere::tick( StkFloat timeIncrement ) +{ + position_.setX(position_.getX() + (timeIncrement * velocity_.getX())); + position_.setY(position_.getY() + (timeIncrement * velocity_.getY())); + position_.setZ(position_.getZ() + (timeIncrement * velocity_.getZ())); +}; + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/StifKarp.h b/7.x/src/stk/include/StifKarp.h new file mode 100644 index 0000000..51ed96f --- /dev/null +++ b/7.x/src/stk/include/StifKarp.h @@ -0,0 +1,153 @@ +#ifndef STK_STIFKARP_H +#define STK_STIFKARP_H + +#include "Instrmnt.h" +#include "DelayL.h" +#include "DelayA.h" +#include "OneZero.h" +#include "Noise.h" +#include "BiQuad.h" + +namespace stk { + +/***************************************************/ +/*! \class StifKarp + \brief STK plucked stiff string instrument. + + This class implements a simple plucked string + algorithm (Karplus Strong) with enhancements + (Jaffe-Smith, Smith, and others), including + string stiffness and pluck position controls. + The stiffness is modeled with allpass filters. + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + + Control Change Numbers: + - Pickup Position = 4 + - String Sustain = 11 + - String Stretch = 1 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class StifKarp : public Instrmnt +{ + public: + //! Class constructor, taking the lowest desired playing frequency. + StifKarp( StkFloat lowestFrequency = 10.0 ); + + //! Class destructor. + ~StifKarp( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Set the stretch "factor" of the string (0.0 - 1.0). + void setStretch( StkFloat stretch ); + + //! Set the pluck or "excitation" position along the string (0.0 - 1.0). + void setPickupPosition( StkFloat position ); + + //! Set the base loop gain. + /*! + The actual loop gain is set according to the frequency. + Because of high-frequency loop filter roll-off, higher + frequency settings have greater loop gains. + */ + void setBaseLoopGain( StkFloat aGain ); + + //! Pluck the string with the given amplitude using the current frequency. + void pluck( StkFloat amplitude ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ); + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + DelayA delayLine_; + DelayL combDelay_; + OneZero filter_; + Noise noise_; + BiQuad biquad_[4]; + + StkFloat loopGain_; + StkFloat baseLoopGain_; + StkFloat lastFrequency_; + StkFloat lastLength_; + StkFloat stretching_; + StkFloat pluckAmplitude_; + StkFloat pickupPosition_; + +}; + +inline StkFloat StifKarp :: tick( unsigned int ) +{ + StkFloat temp = delayLine_.lastOut() * loopGain_; + + // Calculate allpass stretching. + for (int i=0; i<4; i++) + temp = biquad_[i].tick(temp); + + // Moving average filter. + temp = filter_.tick(temp); + + lastFrame_[0] = delayLine_.tick(temp); + lastFrame_[0] = lastFrame_[0] - combDelay_.tick( lastFrame_[0] ); + return lastFrame_[0]; +} + +inline StkFrames& StifKarp :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "StifKarp::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i +#include +#include +#include +#include +#include +//#include + +/*! \namespace stk + \brief The STK namespace. + + Most Stk classes are defined within the STK namespace. Exceptions + to this include the classes RtAudio and RtMidi. +*/ +namespace stk { + +/***************************************************/ +/*! \class Stk + \brief STK base class + + Nearly all STK classes inherit from this class. + The global sample rate and rawwave path variables + can be queried and modified via Stk. In addition, + this class provides error handling and + byte-swapping functions. + + The Synthesis ToolKit in C++ (STK) is a set of open source audio + signal processing and algorithmic synthesis classes written in the + C++ programming language. STK was designed to facilitate rapid + development of music synthesis and audio processing software, with + an emphasis on cross-platform functionality, realtime control, + ease of use, and educational example code. STK currently runs + with realtime support (audio and MIDI) on Linux, Macintosh OS X, + and Windows computer platforms. Generic, non-realtime support has + been tested under NeXTStep, Sun, and other platforms and should + work with any standard C++ compiler. + + STK WWW site: http://ccrma.stanford.edu/software/stk/ + + The Synthesis ToolKit in C++ (STK) + Copyright (c) 1995--2021 Perry R. Cook and Gary P. Scavone + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + Any person wishing to distribute modifications to the Software is + asked to send the modifications to the original developer so that + they can be incorporated into the canonical version. This is, + however, not a binding provision of this license. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ +/***************************************************/ + +//#define _STK_DEBUG_ + +// Most data in STK is passed and calculated with the +// following user-definable floating-point type. You +// can change this to "float" if you prefer or perhaps +// a "long double" in the future. +typedef double StkFloat; + +//! STK error handling class. +/*! + This is a fairly abstract exception handling class. There could + be sub-classes to take care of more specific error conditions ... or + not. +*/ +class StkError : public std::exception +{ +public: + enum Type { + STATUS, + WARNING, + DEBUG_PRINT, + MEMORY_ALLOCATION, + MEMORY_ACCESS, + FUNCTION_ARGUMENT, + FILE_NOT_FOUND, + FILE_UNKNOWN_FORMAT, + FILE_ERROR, + PROCESS_THREAD, + PROCESS_SOCKET, + PROCESS_SOCKET_IPADDR, + AUDIO_SYSTEM, + MIDI_SYSTEM, + UNSPECIFIED + }; + +protected: + std::string message_; + Type type_; + +public: + //! The constructor. + StkError(const std::string& message, Type type = StkError::UNSPECIFIED) + : std::exception(), message_(message), type_(type) {} + + //! The destructor. + virtual ~StkError(void) throw() {}; + + //! Prints thrown error message to stderr. + virtual void printMessage(void) { std::cerr << '\n' << message_ << "\n\n"; } + + //! Returns the thrown error message type. + virtual const Type& getType(void) { return type_; } + + //! Returns the thrown error message string. + virtual const std::string& getMessage(void) { return message_; } + + //! Returns the thrown error message as a C string. + virtual const char *getMessageCString(void) { return message_.c_str(); } + + virtual const char *what(void) const throw() { return message_.c_str(); } +}; + + +class Stk +{ +public: + + typedef unsigned long StkFormat; + static const StkFormat STK_SINT8; /*!< -128 to +127 */ + static const StkFormat STK_SINT16; /*!< -32768 to +32767 */ + static const StkFormat STK_SINT24; /*!< Lower 3 bytes of 32-bit signed integer. */ + static const StkFormat STK_SINT32; /*!< -2147483648 to +2147483647. */ + static const StkFormat STK_FLOAT32; /*!< Normalized between plus/minus 1.0. */ + static const StkFormat STK_FLOAT64; /*!< Normalized between plus/minus 1.0. */ + + //! Static method that returns the current STK sample rate. + static StkFloat sampleRate( void ) { return srate_; } + + //! Static method that sets the STK sample rate. + /*! + The sample rate set using this method is queried by all STK + classes that depend on its value. It is initialized to the + default SRATE set in Stk.h. Many STK classes use the sample rate + during instantiation. Therefore, if you wish to use a rate that + is different from the default rate, it is imperative that it be + set \e BEFORE STK objects are instantiated. A few classes that + make use of the global STK sample rate are automatically notified + when the rate changes so that internal class data can be + appropriately updated. However, this has not been fully + implemented. Specifically, classes that appropriately update + their own data when either a setFrequency() or noteOn() function + is called do not currently receive the automatic notification of + rate change. If the user wants a specific class instance to + ignore such notifications, perhaps in a multi-rate context, the + function Stk::ignoreSampleRateChange() should be called. + */ + static void setSampleRate( StkFloat rate ); + + //! A function to enable/disable the automatic updating of class data when the STK sample rate changes. + /*! + This function allows the user to enable or disable class data + updates in response to global sample rate changes on a class by + class basis. + */ + void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; }; + + //! Static method that frees memory from alertList_. + static void clear_alertList(){std::vector().swap(alertList_);}; + + //! Static method that returns the current rawwave path. + static std::string rawwavePath(void) { return rawwavepath_; } + + //! Static method that sets the STK rawwave path. + static void setRawwavePath( std::string path ); + + //! Static method that byte-swaps a 16-bit data type. + static void swap16( unsigned char *ptr ); + + //! Static method that byte-swaps a 32-bit data type. + static void swap32( unsigned char *ptr ); + + //! Static method that byte-swaps a 64-bit data type. + static void swap64( unsigned char *ptr ); + + //! Static cross-platform method to sleep for a number of milliseconds. + static void sleep( unsigned long milliseconds ); + + //! Static method to check whether a value is within a specified range. + static bool inRange( StkFloat value, StkFloat min, StkFloat max ) { + if ( value < min ) return false; + else if ( value > max ) return false; + else return true; + } + + //! Static function for error reporting and handling using c-strings. + static void handleError( const char *message, StkError::Type type ); + + //! Static function for error reporting and handling using c++ strings. + static void handleError( std::string message, StkError::Type type ); + + //! Toggle display of WARNING and STATUS messages. + static void showWarnings( bool status ) { showWarnings_ = status; } + + //! Toggle display of error messages before throwing exceptions. + static void printErrors( bool status ) { printErrors_ = status; } + +private: + static StkFloat srate_; + static std::string rawwavepath_; + static bool showWarnings_; + static bool printErrors_; + static std::vector alertList_; + +protected: + + static std::ostringstream oStream_; + bool ignoreSampleRateChange_; + + //! Default constructor. + Stk( void ); + + //! Class destructor. + virtual ~Stk( void ); + + //! This function should be implemented in subclasses that depend on the sample rate. + virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); + + //! Add class pointer to list for sample rate change notification. + void addSampleRateAlert( Stk *ptr ); + + //! Remove class pointer from list for sample rate change notification. + void removeSampleRateAlert( Stk *ptr ); + + //! Internal function for error reporting that assumes message in \c oStream_ variable. + void handleError( StkError::Type type ) const; +}; + + +/***************************************************/ +/*! \class StkFrames + \brief An STK class to handle vectorized audio data. + + This class can hold single- or multi-channel audio data. The data + type is always StkFloat and the channel format is always + interleaved. In an effort to maintain efficiency, no + out-of-bounds checks are performed in this class unless + _STK_DEBUG_ is defined. + + Internally, the data is stored in a one-dimensional C array. An + indexing operator is available to set and retrieve data values. + Alternately, one can use pointers to access the data, using the + index operator to get an address for a particular location in the + data: + + StkFloat* ptr = &myStkFrames[0]; + + Note that this class can also be used as a table with interpolating + lookup. + + Possible future improvements in this class could include functions + to convert to and return other data types. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class StkFrames +{ +public: + + //! The default constructor initializes the frame data structure to size zero. + StkFrames( unsigned int nFrames = 0, unsigned int nChannels = 0 ); + + //! Overloaded constructor that initializes the frame data to the specified size with \c value. + StkFrames( const StkFloat& value, unsigned int nFrames, unsigned int nChannels ); + + //! The destructor. + virtual ~StkFrames(); + + // A copy constructor. + StkFrames( const StkFrames& f ); + + // Assignment operator that returns a reference to self. + virtual StkFrames& operator= ( const StkFrames& f ); + + //! Subscript operator that returns a reference to element \c n of self. + /*! + The result can be used as an lvalue. This reference is valid + until the resize function is called or the array is destroyed. The + index \c n must be between 0 and size less one. No range checking + is performed unless _STK_DEBUG_ is defined. + */ + StkFloat& operator[] ( size_t n ); + + //! Subscript operator that returns the value at element \c n of self. + /*! + The index \c n must be between 0 and size less one. No range + checking is performed unless _STK_DEBUG_ is defined. + */ + StkFloat operator[] ( size_t n ) const; + + //! Sum operator + /*! + The dimensions of the argument are expected to be the same as + self. No range checking is performed unless _STK_DEBUG_ is + defined. + */ + StkFrames operator+(const StkFrames &frames) const; + + //! Assignment by sum operator into self. + /*! + The dimensions of the argument are expected to be the same as + self. No range checking is performed unless _STK_DEBUG_ is + defined. + */ + StkFrames& operator+= ( StkFrames& f ); + + //! Assignment by product operator into self. + /*! + The dimensions of the argument are expected to be the same as + self. No range checking is performed unless _STK_DEBUG_ is + defined. + */ + StkFrames& operator*= ( StkFrames& f ); + + //! Scaling operator (StkFrame * StkFloat). + StkFrames operator* ( StkFloat v ) const; + + //! Scaling operator (StkFloat * StkFrame) + friend StkFrames operator*(StkFloat v, const StkFrames& f); + + //! Scaling operator (inline). + StkFrames& operator*= ( StkFloat v ); + + //! Channel / frame subscript operator that returns a reference. + /*! + The result can be used as an lvalue. This reference is valid + until the resize function is called or the array is destroyed. The + \c frame index must be between 0 and frames() - 1. The \c channel + index must be between 0 and channels() - 1. No range checking is + performed unless _STK_DEBUG_ is defined. + */ + StkFloat& operator() ( size_t frame, unsigned int channel ); + + //! Channel / frame subscript operator that returns a value. + /*! + The \c frame index must be between 0 and frames() - 1. The \c + channel index must be between 0 and channels() - 1. No range checking + is performed unless _STK_DEBUG_ is defined. + */ + StkFloat operator() ( size_t frame, unsigned int channel ) const; + + //! Return an interpolated value at the fractional frame index and channel. + /*! + This function performs linear interpolation. The \c frame + index must be between 0.0 and frames() - 1. The \c channel index + must be between 0 and channels() - 1. No range checking is + performed unless _STK_DEBUG_ is defined. + */ + StkFloat interpolate( StkFloat frame, unsigned int channel = 0 ) const; + + //! Returns the total number of audio samples represented by the object. + size_t size() const { return size_; }; + + //! Returns \e true if the object size is zero and \e false otherwise. + bool empty() const; + + //! Resize self to represent the specified number of channels and frames. + /*! + Changes the size of self based on the number of frames and + channels. No element assignment is performed. No memory + deallocation occurs if the new size is smaller than the previous + size. Further, no new memory is allocated when the new size is + smaller or equal to a previously allocated size. + */ + virtual void resize( size_t nFrames, unsigned int nChannels = 1 ); + + //! Resize self to represent the specified number of channels and frames and perform element initialization. + /*! + Changes the size of self based on the number of frames and + channels, and assigns \c value to every element. No memory + deallocation occurs if the new size is smaller than the previous + size. Further, no new memory is allocated when the new size is + smaller or equal to a previously allocated size. + */ + virtual void resize( size_t nFrames, unsigned int nChannels, StkFloat value ); + + //! Retrieves a single channel + /*! + Copies the specified \c channel into \c destinationFrames's \c destinationChannel. \c destinationChannel must be between 0 and destination.channels() - 1 and + \c channel must be between 0 and channels() - 1. destination.frames() must be >= frames(). + No range checking is performed unless _STK_DEBUG_ is defined. + */ + StkFrames& getChannel(unsigned int channel,StkFrames& destinationFrames, unsigned int destinationChannel) const; + + //! Sets a single channel + /*! + Copies the \c sourceChannel of \c sourceFrames into the \c channel of self. + SourceFrames.frames() must be equal to frames(). + No range checking is performed unless _STK_DEBUG_ is defined. + */ + void setChannel(unsigned int channel,const StkFrames &sourceFrames,unsigned int sourceChannel); + + //! Return the number of channels represented by the data. + unsigned int channels( void ) const { return nChannels_; }; + + //! Return the number of sample frames represented by the data. + unsigned int frames( void ) const { return (unsigned int)nFrames_; }; + + //! Set the sample rate associated with the StkFrames data. + /*! + By default, this value is set equal to the current STK sample + rate at the time of instantiation. + */ + void setDataRate( StkFloat rate ) { dataRate_ = rate; }; + + //! Return the sample rate associated with the StkFrames data. + /*! + By default, this value is set equal to the current STK sample + rate at the time of instantiation. + */ + StkFloat dataRate( void ) const { return dataRate_; }; + +protected: + + StkFloat *data_; + StkFloat dataRate_; + size_t nFrames_; + unsigned int nChannels_; + size_t size_; + size_t bufferSize_; + +}; + +inline bool StkFrames :: empty() const +{ + if ( size_ > 0 ) return false; + else return true; +} + +inline StkFloat& StkFrames :: operator[] ( size_t n ) +{ +#if defined(_STK_DEBUG_) + if ( n >= size_ ) { + std::ostringstream error; + error << "StkFrames::operator[]: invalid index (" << n << ") value!"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); + } +#endif + + return data_[n]; +} + +inline StkFloat StkFrames :: operator[] ( size_t n ) const +{ +#if defined(_STK_DEBUG_) + if ( n >= size_ ) { + std::ostringstream error; + error << "StkFrames::operator[]: invalid index (" << n << ") value!"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); + } +#endif + + return data_[n]; +} + +inline StkFloat& StkFrames :: operator() ( size_t frame, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( frame >= nFrames_ || channel >= nChannels_ ) { + std::ostringstream error; + error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); + } +#endif + + return data_[ frame * nChannels_ + channel ]; +} + +inline StkFloat StkFrames :: operator() ( size_t frame, unsigned int channel ) const +{ +#if defined(_STK_DEBUG_) + if ( frame >= nFrames_ || channel >= nChannels_ ) { + std::ostringstream error; + error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); + } +#endif + + return data_[ frame * nChannels_ + channel ]; +} + +inline StkFrames StkFrames::operator+(const StkFrames &f) const +{ +#if defined(_STK_DEBUG_) + if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) { + std::ostringstream error; + error << "StkFrames::operator+: frames argument must be of equal dimensions!"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); + } +#endif + StkFrames sum((unsigned int)nFrames_,nChannels_); + StkFloat *sumPtr = &sum[0]; + const StkFloat *fptr = f.data_; + const StkFloat *dPtr = data_; + for (unsigned int i = 0; i < size_; i++) { + *sumPtr++ = *fptr++ + *dPtr++; + } + return sum; +} + +inline StkFrames& StkFrames :: operator+= ( StkFrames& f ) +{ +#if defined(_STK_DEBUG_) + if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) { + std::ostringstream error; + error << "StkFrames::operator+=: frames argument must be of equal dimensions!"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); + } +#endif + + StkFloat *fptr = &f[0]; + StkFloat *dptr = data_; + for ( unsigned int i=0; i taps = std::vector( 1, 0 ), unsigned long maxDelay = 4095 ); + + //! Class destructor. + ~TapDelay(); + + //! Set the maximum delay-line length. + /*! + This method should generally only be used during initial setup + of the delay line. If it is used between calls to the tick() + function, without a call to clear(), a signal discontinuity will + likely occur. If the current maximum length is greater than the + new length, no change will be made. + */ + void setMaximumDelay( unsigned long delay ); + + //! Set the delay-line tap lengths. + /*! + The valid range for each tap length is from 0 to the maximum delay-line length. + */ + void setTapDelays( std::vector taps ); + + //! Return the current delay-line length. + std::vector getTapDelays( void ) const { return delays_; }; + + //! Return the specified tap value of the last computed frame. + /*! + Use the lastFrame() function to get all tap values from the + last computed frame. The \c tap argument must be less than the + number of delayline taps (the first tap is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFloat lastOut( unsigned int tap = 0 ) const; + + //! Input one sample to the delayline and return outputs at all tap positions. + /*! + The StkFrames argument reference is returned. The output + values are ordered according to the tap positions set using the + setTapDelays() function (no sorting is performed). The StkFrames + argument must contain at least as many channels as the number of + taps. However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFloat input, StkFrames& outputs ); + + //! Take a channel of the StkFrames object as inputs to the filter and write outputs back to the same object. + /*! + The StkFrames argument reference is returned. The output + values are ordered according to the tap positions set using the + setTapDelays() function (no sorting is performed). The StkFrames + argument must contain at least as many channels as the number of + taps. However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. The output values + are ordered according to the tap positions set using the + setTapDelays() function (no sorting is performed). The \c + iChannel argument must be less than the number of channels in + the \c iFrames argument (the first channel is specified by 0). + The \c oFrames argument must contain at least as many channels as + the number of taps. However, range checking is only performed if + _STK_DEBUG_ is defined during compilation, in which case an + out-of-range value will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0 ); + + protected: + + unsigned long inPoint_; + std::vector outPoint_; + std::vector delays_; + +}; + +inline StkFloat TapDelay :: lastOut( unsigned int tap ) const +{ +#if defined(_STK_DEBUG_) + if ( tap >= lastFrame_.size() ) { + oStream_ << "TapDelay::lastOut(): tap argument and number of taps are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[tap]; +} + +inline StkFrames& TapDelay :: tick( StkFloat input, StkFrames& outputs ) +{ +#if defined(_STK_DEBUG_) + if ( outputs.channels() < outPoint_.size() ) { + oStream_ << "TapDelay::tick(): number of taps > channels in StkFrames argument!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + inputs_[inPoint_++] = input * gain_; + + // Check for end condition + if ( inPoint_ == inputs_.size() ) + inPoint_ = 0; + + // Read out next values + StkFloat *outs = &outputs[0]; + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "TapDelay::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + if ( frames.channels() < outPoint_.size() ) { + oStream_ << "TapDelay::tick(): number of taps > channels in StkFrames argument!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &frames[channel]; + StkFloat *oSamples = &frames[0]; + std::size_t j; + unsigned int iHop = frames.channels(); + std::size_t oHop = frames.channels() - outPoint_.size(); + for ( unsigned long i=0; i= iFrames.channels() ) { + oStream_ << "TapDelay::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + if ( oFrames.channels() < outPoint_.size() ) { + oStream_ << "TapDelay::tick(): number of taps > channels in output StkFrames argument!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[0]; + std::size_t j; + unsigned int iHop = iFrames.channels(); + std::size_t oHop = oFrames.channels() - outPoint_.size(); + for ( unsigned long i=0; i3--\ + + --> Out + 2->1--/ + \endcode + + Control Change Numbers: + - Modulator Index One = 2 + - Crossfade of Outputs = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class TubeBell : public FM +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + TubeBell( void ); + + //! Class destructor. + ~TubeBell( void ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + +}; + +inline StkFloat TubeBell :: tick( unsigned int ) +{ + StkFloat temp, temp2; + + temp = gains_[1] * adsr_[1]->tick() * waves_[1]->tick(); + temp = temp * control1_; + + waves_[0]->addPhaseOffset( temp ); + waves_[3]->addPhaseOffset( twozero_.lastOut() ); + temp = gains_[3] * adsr_[3]->tick() * waves_[3]->tick(); + twozero_.tick( temp ); + + waves_[2]->addPhaseOffset( temp ); + temp = ( 1.0 - (control2_ * 0.5)) * gains_[0] * adsr_[0]->tick() * waves_[0]->tick(); + temp += control2_ * 0.5 * gains_[2] * adsr_[2]->tick() * waves_[2]->tick(); + + // Calculate amplitude modulation and apply it to output. + temp2 = vibrato_.tick() * modDepth_; + temp = temp * (1.0 + temp2); + + lastFrame_[0] = temp * 0.5; + return lastFrame_[0]; +} + +inline StkFrames& TubeBell :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "TubeBell::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i coefficients ); + + //! Return an StkFrames reference to the last output sample frame. + //const StkFrames& lastFrame( void ) const { return lastFrame_; }; + + //! Return the last computed output value. + // StkFloat lastOut( void ) { return lastFrame_[0]; }; + StkFloat lastOut( void ) { return lastOutput_; }; + + //! Compute and return one output sample. + StkFloat tick( StkFloat input ); + + //! Take a channel of the \c iFrames object as inputs to the class and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the effect and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + + protected: + + DelayA delayLine_; + DelayL combDelay_; + Fir loopFilter_; + + StkFloat lastOutput_; + StkFloat frequency_; + StkFloat loopGain_; + StkFloat pluckPosition_; +}; + +inline StkFloat Twang :: tick( StkFloat input ) +{ + lastOutput_ = delayLine_.tick( input + loopFilter_.tick( delayLine_.lastOut() ) ); + lastOutput_ -= combDelay_.tick( lastOutput_ ); // comb filtering on output + lastOutput_ *= 0.5; + + return lastOutput_; +} + +inline StkFrames& Twang :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "Twang::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "Twang::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i= 1.0. The + \e frequency value should be between zero and half the sample rate. + For a better resonance filter, use a BiQuad filter. \sa BiQuad + filter class + */ + void setResonance(StkFloat frequency, StkFloat radius, bool normalize = false); + + //! Return the last computed output value. + StkFloat lastOut( void ) const { return lastFrame_[0]; }; + + //! Input one sample to the filter and return one output. + StkFloat tick( StkFloat input ); + + //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs. + /*! + The StkFrames argument reference is returned. The \c channel + argument must be less than the number of channels in the + StkFrames argument (the first channel is specified by 0). + However, range checking is only performed if _STK_DEBUG_ is + defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object. + /*! + The \c iFrames object reference is returned. Each channel + argument must be less than the number of channels in the + corresponding StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 ); + + protected: + + virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); +}; + +inline StkFloat TwoPole :: tick( StkFloat input ) +{ + inputs_[0] = gain_ * input; + lastFrame_[0] = b_[0] * inputs_[0] - a_[1] * outputs_[1] - a_[2] * outputs_[2]; + outputs_[2] = outputs_[1]; + outputs_[1] = lastFrame_[0]; + + return lastFrame_[0]; +} + +inline StkFrames& TwoPole :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "TwoPole::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "TwoPole::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i= frames.channels() ) { + oStream_ << "TwoZero::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "TwoZero::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i + +namespace stk { + +/***************************************************/ +/*! \class Vector3D + \brief STK 3D vector class. + + This class implements a three-dimensional vector. + + by Perry R. Cook, 1995--2021. +*/ +/***************************************************/ + +class Vector3D : public Stk +{ + +public: + //! Default constructor taking optional initial X, Y, and Z values. + Vector3D( StkFloat x = 0.0, StkFloat y = 0.0, StkFloat z = 0.0 ) { setXYZ( x, y, z ); }; + + //! Get the current X value. + StkFloat getX( void ) { return X_; }; + + //! Get the current Y value. + StkFloat getY( void ) { return Y_; }; + + //! Get the current Z value. + StkFloat getZ( void ) { return Z_; }; + + //! Calculate the vector length. + StkFloat getLength( void ); + + //! Set the X, Y, and Z values simultaniously. + void setXYZ( StkFloat x, StkFloat y, StkFloat z ) { X_ = x; Y_ = y; Z_ = z; }; + + //! Set the X value. + void setX( StkFloat x ) { X_ = x; }; + + //! Set the Y value. + void setY( StkFloat y ) { Y_ = y; }; + + //! Set the Z value. + void setZ( StkFloat z ) { Z_ = z; }; + +protected: + StkFloat X_; + StkFloat Y_; + StkFloat Z_; +}; + +inline StkFloat Vector3D :: getLength( void ) +{ + StkFloat temp; + temp = X_ * X_; + temp += Y_ * Y_; + temp += Z_ * Z_; + temp = sqrt( temp ); + return temp; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/include/VoicForm.h b/7.x/src/stk/include/VoicForm.h new file mode 100644 index 0000000..3c24104 --- /dev/null +++ b/7.x/src/stk/include/VoicForm.h @@ -0,0 +1,161 @@ +#ifndef STK_VOICFORM_H +#define STK_VOICFORM_H + +#include "Instrmnt.h" +#include "Envelope.h" +#include "Noise.h" +#include "SingWave.h" +#include "FormSwep.h" +#include "OnePole.h" +#include "OneZero.h" + +namespace stk { + +/***************************************************/ +/*! \class VoicForm + \brief Four formant synthesis instrument. + + This instrument contains an excitation singing + wavetable (looping wave with random and + periodic vibrato, smoothing on frequency, + etc.), excitation noise, and four sweepable + complex resonances. + + Measured formant data is included, and enough + data is there to support either parallel or + cascade synthesis. In the floating point case + cascade synthesis is the most natural so + that's what you'll find here. + + Control Change Numbers: + - Voiced/Unvoiced Mix = 2 + - Vowel/Phoneme Selection = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Loudness (Spectral Tilt) = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class VoicForm : public Instrmnt +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + VoicForm( void ); + + //! Class destructor. + ~VoicForm( void ); + + //! Reset and clear all internal state. + void clear( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Set instrument parameters for the given phoneme. Returns false if phoneme not found. + bool setPhoneme( const char* phoneme ); + + //! Set the voiced component gain. + void setVoiced( StkFloat vGain ) { voiced_->setGainTarget(vGain); }; + + //! Set the unvoiced component gain. + void setUnVoiced( StkFloat nGain ) { noiseEnv_.setTarget(nGain); }; + + //! Set the sweep rate for a particular formant filter (0-3). + void setFilterSweepRate( unsigned int whichOne, StkFloat rate ); + + //! Set voiced component pitch sweep rate. + void setPitchSweepRate( StkFloat rate ) { voiced_->setSweepRate(rate); }; + + //! Start the voice. + void speak( void ) { voiced_->noteOn(); }; + + //! Stop the voice. + void quiet( void ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Stop a note with the given amplitude (speed of decay). + void noteOff( StkFloat amplitude ) { this->quiet(); }; + + //! Perform the control change specified by \e number and \e value (0.0 - 128.0). + void controlChange( int number, StkFloat value ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + +protected: + + SingWave *voiced_; + Noise noise_; + Envelope noiseEnv_; + FormSwep filters_[4]; + OnePole onepole_; + OneZero onezero_; + +}; + +inline StkFloat VoicForm :: tick( unsigned int ) +{ + StkFloat temp; + temp = onepole_.tick( onezero_.tick( voiced_->tick() ) ); + temp += noiseEnv_.tick() * noise_.tick(); + lastFrame_[0] = filters_[0].tick(temp); + lastFrame_[0] += filters_[1].tick(temp); + lastFrame_[0] += filters_[2].tick(temp); + lastFrame_[0] += filters_[3].tick(temp); + /* + temp += noiseEnv_.tick() * noise_.tick(); + lastFrame_[0] = filters_[0].tick(temp); + lastFrame_[0] = filters_[1].tick(lastFrame_[0]); + lastFrame_[0] = filters_[2].tick(lastFrame_[0]); + lastFrame_[0] = filters_[3].tick(lastFrame_[0]); + */ + return lastFrame_[0]; +} + +inline StkFrames& VoicForm :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "VoicForm::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i + +namespace stk { + +/***************************************************/ +/*! \class Voicer + \brief STK voice manager class. + + This class can be used to manage a group of STK instrument + classes. Individual voices can be controlled via unique note + tags. Instrument groups can be controlled by group number. + + A previously constructed STK instrument class is linked with a + voice manager using the addInstrument() function. An optional + group number argument can be specified to the addInstrument() + function as well (default group = 0). The voice manager does not + delete any instrument instances ... it is the responsibility of + the user to allocate and deallocate all instruments. + + The tick() function returns the mix of all sounding voices. Each + noteOn returns a unique tag (credits to the NeXT MusicKit), so you + can send control changes to specific voices within an ensemble. + Alternately, control changes can be sent to all voices in a given + group. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Voicer : public Stk +{ + public: + //! Class constructor taking an optional note decay time (in seconds). + Voicer( StkFloat decayTime = 0.2 ); + + //! Add an instrument with an optional group number to the voice manager. + /*! + A set of instruments can be grouped by group number and + controlled via the functions that take a group number argument. + */ + void addInstrument( Instrmnt *instrument, int group=0 ); + + //! Remove the given instrument pointer from the voice manager's control. + /*! + It is important that any instruments which are to be deleted by + the user while the voice manager is running be first removed from + the manager's control via this function!! + */ + void removeInstrument( Instrmnt *instrument ); + + //! Initiate a noteOn event with the given note number and amplitude and return a unique note tag. + /*! + Send the noteOn message to the first available unused voice. + If all voices are sounding, the oldest voice is interrupted and + sent the noteOn message. If the optional group argument is + non-zero, only voices in that group are used. If no voices are + found for a specified non-zero group value, the function returns + -1. The amplitude value should be in the range 0.0 - 128.0. + */ + long noteOn( StkFloat noteNumber, StkFloat amplitude, int group=0 ); + + //! Send a noteOff to all voices having the given noteNumber and optional group (default group = 0). + /*! + The amplitude value should be in the range 0.0 - 128.0. + */ + void noteOff( StkFloat noteNumber, StkFloat amplitude, int group=0 ); + + //! Send a noteOff to the voice with the given note tag. + /*! + The amplitude value should be in the range 0.0 - 128.0. + */ + void noteOff( long tag, StkFloat amplitude ); + + //! Send a frequency update message to all voices assigned to the optional group argument (default group = 0). + /*! + The \e noteNumber argument corresponds to a MIDI note number, though it is a floating-point value and can range beyond the normal 0-127 range. + */ + void setFrequency( StkFloat noteNumber, int group=0 ); + + //! Send a frequency update message to the voice with the given note tag. + /*! + The \e noteNumber argument corresponds to a MIDI note number, though it is a floating-point value and can range beyond the normal 0-127 range. + */ + void setFrequency( long tag, StkFloat noteNumber ); + + //! Send a pitchBend message to all voices assigned to the optional group argument (default group = 0). + void pitchBend( StkFloat value, int group=0 ); + + //! Send a pitchBend message to the voice with the given note tag. + void pitchBend( long tag, StkFloat value ); + + //! Send a controlChange to all instruments assigned to the optional group argument (default group = 0). + void controlChange( int number, StkFloat value, int group=0 ); + + //! Send a controlChange to the voice with the given note tag. + void controlChange( long tag, int number, StkFloat value ); + + //! Send a noteOff message to all existing voices. + void silence( void ); + + //! Return the current number of output channels. + unsigned int channelsOut( void ) const { return lastFrame_.channels(); }; + + //! Return an StkFrames reference to the last output sample frame. + const StkFrames& lastFrame( void ) const { return lastFrame_; }; + + //! Return the specified channel value of the last computed frame. + /*! + The \c channel argument must be less than the number of output + channels, which can be determined with the channelsOut() function + (the first channel is specified by 0). However, range checking is + only performed if _STK_DEBUG_ is defined during compilation, in + which case an out-of-range value will trigger an StkError + exception. \sa lastFrame() + */ + StkFloat lastOut( unsigned int channel = 0 ); + + //! Mix one sample frame of all sounding voices and return the specified \c channel value. + /*! + The \c channel argument must be less than the number of output + channels, which can be determined with the channelsOut() function + (the first channel is specified by 0). However, range checking is + only performed if _STK_DEBUG_ is defined during compilation, in + which case an out-of-range value will trigger an StkError + exception. + */ + StkFloat tick( unsigned int channel = 0 ); + + //! Fill the StkFrames argument with computed frames and return the same reference. + /*! + The number of channels in the StkFrames argument must equal + the number of channels in the file data. However, this is only + checked if _STK_DEBUG_ is defined during compilation, in which + case an incompatibility will trigger an StkError exception. If no + file data is loaded, the function does nothing (a warning will be + issued if _STK_DEBUG_ is defined during compilation). + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + + struct Voice { + Instrmnt *instrument; + long tag; + StkFloat noteNumber; + StkFloat frequency; + int sounding; + int group; + + // Default constructor. + Voice() + :instrument(0), tag(0), noteNumber(-1.0), frequency(0.0), sounding(0), group(0) {} + }; + + std::vector voices_; + long tags_; + int muteTime_; + StkFrames lastFrame_; +}; + +inline StkFloat Voicer :: lastOut( unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= lastFrame_.channels() ) { + oStream_ << "Voicer::lastOut(): channel argument is invalid!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + return lastFrame_[channel]; +} + + +inline StkFloat Voicer :: tick( unsigned int channel ) +{ + unsigned int j; + for ( j=0; jtick(); + for ( j=0; jchannelsOut(); j++ ) lastFrame_[j] += voices_[i].instrument->lastOut( j ); + } + if ( voices_[i].sounding < 0 ) + voices_[i].sounding++; + if ( voices_[i].sounding == 0 ) + voices_[i].noteNumber = -1; + } + + return lastFrame_[channel]; +} + +inline StkFrames& Voicer :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Voicer::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "Whistle::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i3--\ + + --> Out + 2->1--/ + \endcode + + Control Change Numbers: + - Modulator Index One = 2 + - Crossfade of Outputs = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +class Wurley : public FM +{ + public: + //! Class constructor. + /*! + An StkError will be thrown if the rawwave path is incorrectly set. + */ + Wurley( void ); + + //! Class destructor. + ~Wurley( void ); + + //! Set instrument parameters for a particular frequency. + void setFrequency( StkFloat frequency ); + + //! Start a note with the given frequency and amplitude. + void noteOn( StkFloat frequency, StkFloat amplitude ); + + //! Compute and return one output sample. + StkFloat tick( unsigned int channel = 0 ); + + //! Fill a channel of the StkFrames object with computed outputs. + /*! + The \c channel argument must be less than the number of + channels in the StkFrames argument (the first channel is specified + by 0). However, range checking is only performed if _STK_DEBUG_ + is defined during compilation, in which case an out-of-range value + will trigger an StkError exception. + */ + StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ); + + protected: + +}; + +inline StkFloat Wurley :: tick( unsigned int ) +{ + StkFloat temp, temp2; + + temp = gains_[1] * adsr_[1]->tick() * waves_[1]->tick(); + temp = temp * control1_; + + waves_[0]->addPhaseOffset( temp ); + waves_[3]->addPhaseOffset( twozero_.lastOut() ); + temp = gains_[3] * adsr_[3]->tick() * waves_[3]->tick(); + twozero_.tick(temp); + + waves_[2]->addPhaseOffset( temp ); + temp = ( 1.0 - (control2_ * 0.5)) * gains_[0] * adsr_[0]->tick() * waves_[0]->tick(); + temp += control2_ * 0.5 * gains_[2] * adsr_[2]->tick() * waves_[2]->tick(); + + // Calculate amplitude modulation and apply it to output. + temp2 = vibrato_.tick() * modDepth_; + temp = temp * (1.0 + temp2); + + lastFrame_[0] = temp * 0.5; + return lastFrame_[0]; +} + +inline StkFrames& Wurley :: tick( StkFrames& frames, unsigned int channel ) +{ + unsigned int nChannels = lastFrame_.channels(); +#if defined(_STK_DEBUG_) + if ( channel > frames.channels() - nChannels ) { + oStream_ << "Wurley::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i 1.0 ) { + sample = 1.0; + clip = true; + } + else if ( sample < -1.0 ) { + sample = -1.0; + clip = true; + } + + if ( clip == true && clipping_ == false ) { + // First occurrence of clipping since instantiation or reset. + clipping_ = true; + oStream_ << "WvOut: data value(s) outside +-1.0 detected ... clamping at outer bound!"; + handleError( StkError::WARNING ); + } + + return sample; +} + +} // stk namespace + +#endif diff --git a/7.x/src/stk/rawwaves/ahh.raw b/7.x/src/stk/rawwaves/ahh.raw new file mode 100644 index 0000000000000000000000000000000000000000..dda5f557f55beb212e4d1561e29ec0bef5577a1c GIT binary patch literal 184 zcmV;p07w7*m-&VAgX=x#J>~M~!}VDT103`#-8qaw2R$pwOYkS>qvBxVZs?-$L-wuwRR2%^&;kPm zy$HJw{Ta9*ups;%T^KM81^+PfL+uXjkn?E#TLy~|Bo>wzJrarxiU+m?1p$lz`U5=% mjRznE&H`Qlll}VpCHsK@5(Q8P`3RZ{O$ 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 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/dope.raw b/7.x/src/stk/rawwaves/dope.raw new file mode 100644 index 0000000000000000000000000000000000000000..6a7a1ff6831fc3d254809aea99e51acb83430cc7 GIT binary patch literal 20480 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 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/fwavblnk.raw b/7.x/src/stk/rawwaves/fwavblnk.raw new file mode 100644 index 0000000000000000000000000000000000000000..14da0748110b02d3f8acff38c37b3948cdc42d55 GIT binary patch literal 512 zcmZQzU~}i`7CJ8RLtauFB zGKY%hs+t;D6BV%?nD&Kk|Cnu_K!hvKaT4|7ju<)ocU`WSaDsxkCS ops|m=yNu&mn=rGT2EVoCRMq7rC4LAU=jmp1XBcq%8Adb!00;GMEdT%j literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/halfwave.raw b/7.x/src/stk/rawwaves/halfwave.raw new file mode 100644 index 0000000000000000000000000000000000000000..b34639b0be745e0779f14f7afd5a93398ba73310 GIT binary patch literal 512 zcmZQzU{+ys=gi{i=3gyzT=b#D4;gNGNhM`fbqzIbIXwY`-^TaMc3Sq>gxQNZo^`2m zm+{=}WAC>=&^UNj=$8nmsK%Jhan}-FCw)wLo^~!{X;w~-a_-6exPpg8A;nuunado? zvn!e_JF9A{V`?;O9@Tc%$<)oM=crGtUsiv;{%iezAifS{C)RV+&8d^A?W}oJqgfqO zRa4nn(OjNg=1|I9ytOE#;9-7T?#UeGtelLcY3EX&Cw)wK9d|8eb5vu5Q|OoAS%JoW z`+e*^H@nNYR5_lt7qbbo>@nMEe9z#wo`ANThMKCnlCr#{47bD&(T76E`B(FFb7rx* KGpjI+Z~y@L*J#TC literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/hihatcym.raw b/7.x/src/stk/rawwaves/hihatcym.raw new file mode 100644 index 0000000000000000000000000000000000000000..f61389ec8eb6b5e14b9b3967b03bee47c680d7bd GIT binary patch literal 4976 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 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/impuls20.raw b/7.x/src/stk/rawwaves/impuls20.raw new file mode 100644 index 0000000000000000000000000000000000000000..9d89aec1040720ac5d9cb26d74fce5cf04c7cbb6 GIT binary patch literal 512 zcmWNOJxC)_6ouc*7>O{kkQ9Phf2u5+N`}~p7@JiQM6{GeK|~CKg@Vl@SSVtlSS66y zSt>@>Mr6Q3(ghI_Z5Cpum>H9odH24*o&Lag&UgOko&7a7cQWGkEJpginziG9*_!w) z1-rD~aUI{bYq3(K6TK$$m%ZmkIw;6GeTt^re?{Z;L%EP|ZLxNC5Il%pU8d*Olr>3j zOq+OzWU$a;+`?h$nIpOyNzhGGR@3;xeIDbpa49M}K?v=pNz$dqWj{Kc@e5c-lnwn# zGUP8A)xH`K6HtX8Fpn$JR&QpBjFGI#sc-4v8RX$N7%?NcJ~g-Gr*U;r*&>H2ID|XA zl7p&ZQpPjB8B$f5!FzawB06G25xr*$gqVWfQ$%c_14Vemdzn#HGZf}MlTsBqh*xk2 zhnNyMW$U7GL&mK>m0Zk#3E6o(laBf}Ig%w~W=XwC8&_aH>{}HRYC!vBG~AKVud;y% z>->TH*NIBnzW|q zxh{*|;DH^m_SP2Ul}kUO@$io{eUkN{&`5jF{&JI{7wL?Z>{@)g&|;Vyt}hF&vSm~dGb7U+z*k=$55qH??q$rVx&dazBhGMRU0-O z7d<`jH_NWmzSga%q1Yx7U-DkY1YvkdK3y=XF?t z0+(>X)aU{_R9v?3(`M(%jv9qUDw;|2!Y3-H=J?R8*57DNB|

qiqiiGvTzlMn7n+ qhos$!I!)~U&FTU49JgUZRdv;NT8p&Ai_w_gt8{)0MKb*`b^H&@0XE41 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/makefunc.c b/7.x/src/stk/rawwaves/makefunc.c new file mode 100644 index 0000000..b318065 --- /dev/null +++ b/7.x/src/stk/rawwaves/makefunc.c @@ -0,0 +1,55 @@ +/**********************************************/ +/** Utility to make various functions **/ +/** like exponential and log gain curves. **/ +/** **/ +/** Included here: **/ +/** Yamaha TX81Z curves for master gain, **/ +/** Envelope Rates (in normalized units), **/ +/** envelope sustain level, and more.... **/ +/**********************************************/ + +#include +#include +#include + +void main() +{ + int i,j; + double temp; + double data[128]; + + /*************** TX81Z Master Gain *************/ + for (i=0;i<100;i++) { + data[i] = pow(2.0,-(99-i)/10.0); + } + data[0] = 0.0; + printf("double __FM4Op_gains[99] = {"); + for (i=0;i<100;i++) { + if (i%8 == 0) printf("\n"); + printf("%lf,",data[i]); + } + printf("};\n"); + /*************** TX81Z Sustain Level ***********/ + for (i=0;i<16;i++) { + data[i] = pow(2.0,-(15-i)/2.0); + } + data[0] = 0.0; + printf("double __FM4Op_susLevels[16] = {"); + for (i=0;i<16;i++) { + if (i%8 == 0) printf("\n"); + printf("%lf,",data[i]); + } + printf("};\n"); + /****************** Attack Rate ***************/ + for (i=0;i<32;i++) { + data[i] = 6.0 * pow(5.7,-(i-1)/5.0); + } + printf("double __FM4Op_attTimes[16] = {"); + for (i=0;i<32;i++) { + if (i%8 == 0) printf("\n"); + printf("%lf,",data[i]); + } + printf("};\n"); + exit(1); +} + diff --git a/7.x/src/stk/rawwaves/makemidi.c b/7.x/src/stk/rawwaves/makemidi.c new file mode 100644 index 0000000..480f638 --- /dev/null +++ b/7.x/src/stk/rawwaves/makemidi.c @@ -0,0 +1,33 @@ +/**********************************************/ +/** Utility to make various functions **/ +/** like exponential and log gain curves. **/ +/** Specifically for direct MIDI parameter **/ +/** conversions. **/ +/** Included here: **/ +/** A440 Referenced Equal Tempered Pitches **/ +/** as a function of MIDI note number. **/ +/** **/ +/**********************************************/ + +#include +#include +#include + +void main() +{ + int i,j; + double temp; + double data[128]; + + /********* Pitch as fn. of MIDI Note **********/ + + printf("double __MIDI_To_Pitch[128] = {"); + for (i=0;i<128;i++) { + if (i%8 == 0) printf("\n"); + temp = 220.0 * pow(2.0,((double) i - 57) / 12.0); + printf("%.2lf,",temp); + } + printf("};\n"); + exit(1); +} + diff --git a/7.x/src/stk/rawwaves/makewavs.c b/7.x/src/stk/rawwaves/makewavs.c new file mode 100644 index 0000000..20a89ac --- /dev/null +++ b/7.x/src/stk/rawwaves/makewavs.c @@ -0,0 +1,116 @@ +/**********************************************/ +/** Utility to make various flavors of **/ +/** sine wave (rectified, etc), and **/ +/** other commonly needed waveforms, like **/ +/** triangles, ramps, etc. **/ +/** The files generated are all 16 bit **/ +/** linear signed integer, of length **/ +/** as defined by LENGTH below **/ +/**********************************************/ + +#include +#include +#include + +#define LENGTH 256 +#define PI 3.14159265358979323846 + +void main() +{ + int i,j; + double temp; + short data[LENGTH + 2]; + FILE *fd; + + /////////// Yer Basic TX81Z Waves, Including Sine /////////// + fd = fopen("halfwave.raw","wb"); + for (i=0;i4U<*XzxtyK?6J+I&Ux_18)`^~w3xXyj9>%Kmp>-v0d0Q|+;t90|t zRWD2Z2E6Yduvb~vZfD>cuPi0TG{rJdOEb0U7}D)Uk4uKqdjGmq+j!Fj!*+7EENxuf zvOw%|4Q~!_N^2Nqb=u1G^Y-6re|m)V_n^00(3;!u%6hoj;)a8bcdWY_-mQJBHrl%Q_0(6Rn}Z!8&P6Ym)*fw~X8XqFYnyEU z8KO-YZ3@f-Ob1juXNs*DIn3had%VLHi*6{_5=>Q|S)#5r)>&`3 zWqD}Y#JgN2?j7W$P!Rxr$_7;^NA$;z+xE5&v-@k&TW`^KayuNtjiN-{pc9~}gN^xy zKWM+B%uz`N%C9(`m%(=Rsh*BpR=NTV(bT=iNjvKpbUfOWO zWy53bOG8_a3eVRb<=PbWjM2v<-q=U8Yf;JsDig~o9!iy7fO@ODST7La`WbhQbA`Rd zk>;Ktz?E;Wu{Ss`y9PU+JEC1)`exy&57HM1IS-k|Hk!$4e4A^a0cSul?8ax>YU5>( zRmLWxmsYHd^JzwuHX46%U=RMFJeuuwc zDEm-Pu~>hg7wSiJtMC^|;+j~dKh;m_6=JMtp%qlcV|Xdm(kYJM3ck*{5Qx*1wQ65A zLhU4Z>)KN7n3gX2C#c?PKXr+ksSZ;fDy8aY8mKSSP{kXENVGWU%sSWbez^%>`j#|t zTI>`FqNi@xAM0229eSo@SR?w0d1AXL6)u`c#XOd)pd0veJ)f2D+EWSbrE~O>!}v55 z;wB`lz(ni@MKFk+@D41J^X`L6jKD11iHk4_$KotZ#>v`AZ5A| zuZ&Q-pi}XdF-GyjBAL&^5-h_^w7_B50NIcPA3#?KfI#q+O04H`+>!1{q%~5d6pEu! z6hdJ%myXd>s;4S?!Ui768@W){PUJp3m_O%C-p3dCCO_m_c0&+Mg%pT~DA_p#!XOet zW%myy)?KKELWwvBHp-X}UqLG5z(ug(0GugVhoTvz?cpCd2P+^N2Ek}ZlkO{m^YUDj zF5CjiFad@@ko0s3=Wqgl$|HC@C-HZDh!1cU&*3N@$bC78J*Zml^cK~#g@dKGVH_@V ziM)>UWL*v)=1S@5NSF+BB}zKvNi7RtuT=UZ+?SjX9MA$n{)k|yT`<0lCiFyK?1U;j Og7P=#%?AFz4g3d5T&>dp literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mand10.raw b/7.x/src/stk/rawwaves/mand10.raw new file mode 100644 index 0000000000000000000000000000000000000000..4b35376aeacdfc50cbef89ea76259403ac542b69 GIT binary patch literal 2048 zcmeHF`BRov6h8O9tA4nYpkfT8d@_h;peUoc1nLk$8n}R?;*ySNpbai#iA#!!1}bXm zFp7+rVkRy)WT-(z>P*r&G^hxfD2igEv3%S6-uJzy`%m@qeR<*-8@Dpx8UT7Vp)^wZ|a8MKt_fo^yp{irU{gL>rYL)91Rc6kgP%^k)C zGt`*mE%TmnZ|hpr-Q>yleD9jmS=I5PE6IJ&9pEyoNmM59*y+{{s8)*fMAct@OPlD3 zaCAEKp01v44%zQ^pAo$q93!-!)I#;KR-iKJ8ie3VI3i7uyCi}atN`1 z1Q?8MGuzDmzD}><`ObaXRprX^NWNCKkY$@qb}teq=PQ*;rt(1jTB(s6XdPUF0 ztRyHWmGjDOHCQXrB9-GxfaIe0>F?4rxkOqHQ|%5r-tt-%qRu^5YJG0)WOZhZQD-bP zf_;_|0M()u~s|V&cGD1n3l;%IG@Fbf-$CDS-%Q^KZ@ag_+v2VD2701B zC0@gHSkvvtSVS`DCp4B`mCniMl^iuxEmk^}Xf;f0*RScD^elac9<3c!)0HTBhvbs> zORFR&O(zo|3a{Zj9%B8#?yyvr!E)IZ##j@pXKpJ{_;Az3X0iFEX+C7l_Brf>9dL=n zkWHkNj-n4}H!YwG=oP6iMOrQ<2%+ILltzLYcH{H*cMObRX7eSAP_c!kK~ee8buT7Y?@4y=yrOVmeGAQQ=B5HA9+ol zkUOM?ToidJq&M7!n{Wj(@ii{xjJNQoyn)}~ukc-*kLehLL(m@`+~m*r-@KmRMGdE8 z5xx?=Cc|nd7yV?YgF{dNr=SM@5cTfDW!Md$!cc6+ay*JT0+ETR^G06A5AtLDrohqU zh&np3FAhK_j=@-*himbG$gjoc5Co~P70$wQ5=17DSTd7*MmCVI$Zk?XD#&q?MP`#E zl1{dhy<`vBO45iETHpj^!28e(pWqo>ff3y1&0>>Uep?`UlrQGvxRZzS(R>n56sOJn zqYFd0u$Ne0OzbID{fj0_+;xS$a##J1~UE=+|8 z2!{U916_jcdi+f={w?mu!*~pfu~ewC5nZ5(n&A)$qlArx@h}mlz(+6xk|6=6i5edW z9H+p?;wE1BI7ops5sw0Yw6Fz##)D#)M8QK0j>j+@C@fUW8-c@we-Ec&8m<<4+lV^_ z(pT}3=r>aQUjdt7k3i%)Gz*6O$RH9zoC3{$#6c85@IouxhDs=dlW-XFAqO_VQkW?w zih@A&U;|#py_kt9n2bsIp-^?0;3*uV1e5VNN3gY6s3Q~C;TGJ5`69Ov%Y^Fd@dfl0 s+a?GG)5H`T1dm%_t%#PwN?0S}Z{Psz6FvhLh>Tf~^v2#G@P8ukAJ5hp%>V!Z literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mand11.raw b/7.x/src/stk/rawwaves/mand11.raw new file mode 100644 index 0000000000000000000000000000000000000000..94889be6f0d6dfeaa63449e06a39df1356508dac GIT binary patch literal 2048 zcmeH``EyTa6vm(P-ft2imKrLUPLYXff1tHjky?sQgrI62YY|(SAf(oIbc$+4Ofb|^ zBGQsB7!{&w9W6nW+DRp?C2do!toQrAPfz>}{n0#g-@D8`=RWV}ITv88{mZrr&h+b7 z`mU3=BT$Yw2NMXr6H;oD%z%*akn3hMZhEakhlSjfbUQIP(&b^iOZP|lbNI--&D6?6 zWfRIb`v1B@oU?N)QC_XAU&TWIt{d&T*noe}o-uvAp%TXrINvl35+?Z7bkR>HmZq16Lfxa}&~2tLx>tl+%hKI>eJjrV6&3@KY) zp6CR~z;lee$|w@|=Tx5g#27B{+V8|M4gv*os%KdCZ0*v^$Q$NlWm@T(W= zEioB#N+OYqBe*G_m@@CWcf-3EXdf6BXzk54ZKXDrVH3_ueaVy*Sljl5FN_g0&74_>mDWU`G&vFT+B%w9PlJ!O??XL?Fs^ko4vIEVe&lH%68Np7b* zuiEYE*c6-R2D^Q(#1**9F2lvUsV>#!y0b2uk=%n$B$sh2i?IhKIEsmA%ODT)LvBNT zBw-$+c$F7nSjKe5v4`$(GbgjFer+~~>$(<#mdxi4UO+3vBLXe37C{*-{iUCbl&;4>vx~Ha_L{wD zkJ`ibq&;gNIB_-YW1DBsxezzUopSjMa2aX}Ew{W>u z#&e_+T*+-br0-v55uQOi-9djO;A3pZ0i6MnX3}0>f1()W6))W-TEfMX0E%!3tFREs z%5EH9LnJGBhv%5h?b>w)W7*VIxEt=G=3eN0He@??VH-AMV@9(B`*IW$bXO~McB&j) zXNe}>9M7Syo}vTou%LF6BRb45;6lst8n9MWBJQ?tm`JDHd^0 P99Ox1s;310cLM(bY{@Uw literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mand12.raw b/7.x/src/stk/rawwaves/mand12.raw new file mode 100644 index 0000000000000000000000000000000000000000..a128642bf6de4fdac74a1fa03bf32bc6003bb685 GIT binary patch literal 2048 zcmeH``BPR^7{|ZQ``*hwfI=>$Ah<atq$A=ExTNBe8y2P`3QlM>BW-H# zD`{%DP`RW|7AlG(I)UOOxgd(5rYyeid+#|<&-6F+qx1dYo^#K==lMRL^F08n?Gvv1 z9%tj;`a&zm$2;(=z-s?<&Jy-;r7nWuw2W*oZ|^9t0_RXWR~74Hjt|TTdRgcJ{JZ0|9R+=?ey+*?* zLC>~B+{fJc?%u9KPl~<8?%_&*neOgkC0O@7yFFo6KP%Dp;VU#vKd^GF?s|iBy!T4q zOa62G-ZFx?t^S>UFiMS`G@S1`CL529SnN>StuIufexxt*UbMis80|Y$EP*HlLpuXd?2wbpi6 zBkeprm}g)Db|L|tv6C7cb&mOtAZM5nYs5QGJGU80W{P>;JZgSt&N1#eD;!&BG4^0G z>gXcfq_xxr1-xIC+l%e)_I=f;r-~kME4@~S>r8!8N2@(5&d##RtQyrxSMY6Kq0ey~ zR-qPMIUm6kO!2sf8@Nv)xQ!S-&82(?2F4->tJuZqynxs7e!j&w`2cT|@p$gRgV=?K zG>t~$3I4$MSdD@5t&5*Z&G5HWTzDovO2SF%x&@6yA>z zER_09BAY^G&(XAlDyfvx$zQ515=Kq*Gv$h#4Dy$*+i?>s^u|1?nVG4$z8M_gNQCNWKvR5el_$B|wnLL3< zaW8J6EnTIH^*+5tAJCQDio1#10P!5m?Rg-l@p`_%FQocdakNVqoI)8a3Y0Ex;3}@8 z5-w^-skD){(#Jw>BF&^UN}y0w;V`nL?hK3*-)UHZZ?Fc5Z1YK8!&A8rhiKLfTC+c! z`nj&qMf$9GxvB5U_^dvm%e9AFipwOt1hAerBiwcW@Q>T@s>ebH6^ z?IN87Nd00y%-e#Fdvy%CW*=vEtg6w<+(((5Hm4JGBXqdg~gk~qJt#h4Pn_{Mv;=IPy~wt Nh1x5M-Jr8-F<{I8I-o3?rz|+Pvsm0Gd+jB?t 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 Pta~8a3%pR^e^cN;QOOs4 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mand5.raw b/7.x/src/stk/rawwaves/mand5.raw new file mode 100644 index 0000000000000000000000000000000000000000..9b308a860b4966a4bfa6148f01bdfa70fdc99495 GIT binary patch literal 2048 zcmeH``Bzm{6vy{I_ulv5f%s4asiXP`OQ&HN9)y>(#z(WkOzxv6K%7#F#GwIY{zs6mEKVe z>I-(m=;J-ZHznY?B`7f8T;ByP2ZP@W85=yWd%ITJ9&=W<~_^&&^MsNBClUNBzYZC zx~Pxr)$Sr9QKT*6o%jK_r7hXk%eh~@?!4RfXWIkUPHxmH)fHN>7*BC97!z?gJ1%cA zY&E7S9hEg6#iny!Zm+jI5)9$WXyt;ECm)k@DmXH3VYZ?tfPUd(O%q| zYm0Xdb+@=avpelMj%AL}wxn0i=6Y*>YoE55_7jfl?r7Cl9iuj@bG1&CrwsQ5k5Ww9SN=`EnM5Go>9}aHu1CIB1goKCv=CkFdjNW z8M~)+HTWtgp@gF#o@yW#cQ7B=F7&++ipUpXJenV&M6f|E zM1mh37fx}S{>B1!oP~lD=D~UlWA93{q+02;++Qg)WGd&SMyaPHM7^ud(uVO#JW7+?SKKGnB(+X`tTAn_mZbTsC)8psLc7N& z3KRw6mRKRuX$gFb+t?6xN*X4GvnQ-kx+>Qw8ohDYKiW1#)obVH7v5NZAS#r}ON}U08*j&0)t_IjdpStVuFU5mKZyL^81gHX6%t9~RG9QxBO zohpPpb%xEt!f*3Kd>=o`Pw|6%6`#)I_%i+x@1eD6cJ8C+2h=;uhBzxKMYAC4NP*Oi2G9grK+9mLLUBmsiG$*Xa8Pd=M{{TmWzl}xOU2Xx78nN$V5d&= z0Lr0M->g!ofNI@OEm*;c2JDO$^hZzqHX5M}3LzI#V5xp5Nw5j_!(RR6b-gz5KN$EA DK%KG2 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mand6.raw b/7.x/src/stk/rawwaves/mand6.raw new file mode 100644 index 0000000000000000000000000000000000000000..05f083d8912b7622d17e058ced75e9c06d65f25d GIT binary patch literal 2048 zcmeHG`%_g_82!F|&OLB17mO>$wa{qtL8j&tA3YFi%v2P`C+ZNHWh(eWv!c;LkwnLV zP|-3;F>8!;G##HMY7fh_2P%wd778e+TsW6|&pmtZul+~#qqAoJvS;>Q>sxDm0I(tW z?%f~j`M-neUTPZRG#i^uFI}&&J$9#qHFaaksCxEU#aFJ?47C?PcbGfDstnQrZw*cdMb!cb4Z_ zFZxQ_t{BgF@;dB@A=ZHgV}DfGU>>SUf=!Q-=A719( z#RiGRatF-kZS9Bd*WA0=KA0bca?OxcZLc)0t6y_>vTwxwtb3DvlLD_=qg#hI^=b}l zIpV+JZ}DyQ75j68cPyuU(48KRFV7p z@a-&#mcYj>7J69Krq|bO9toyeaaMj10+)l|23|6=S}WUoTIqI}=mRfky;!DtiW`w`)x)rg+IojCe*yz};Wzi}A zuC+Ii?XNT2%qo9E`&)r6?Y3W->)U#?o@(W7d(4IAY;&Z)EU+)6+lkx|{iq}S2q$r> zHq)`hm}L}(EpWPBc@g{F+afcgDmxsHYIPU8E=Bwtnc@D_wLE-h*g<2sHXp{yw?&S< z)zSiATFLfA`;*nWroK zHeM^7yox_zPYe}>%Iq)1bTS|u_FxP?iL0;zccaM$uzanvc2w`Hr|W5Yv*9&P8)FCv=7yp(9L#3aEz5@F#k3HQH4d_58X*^n3h_9vQTb%@QG6!P;~()8yj{eL-oh(7 zi&0{esF!`@GFe3qdX`oy_8hp6$(WAMVLW!mZkULfSdOsks%{4e3yTETy z02weD-h@?93ZK9_m<9bImO}Ikt*2Qug%;3z>d$plLdCS27E=zrO@*{Y&ACb8W7?%u zo}{1YGTop%WPuyHLlTUGm*Hs$r#d=Id)3AhYjK@A`O3`?a4Am3q4*fO;2!(|-#{_s z!fcoT10e=bsc)p8sDkn+Rc%O({7R*ir#R;-<}{UEmRu|gWraK@f0h48zw#}Xdee)P zN%?e;>Y)P+fHat=JSkF2N}(L~!7;Vd)o=yQ!wJ=~L+~~1P;TYIRCpfxDI_ZH9uN&q S#cxrAO7P4BJaFLuao|5Krp?L# literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mand7.raw b/7.x/src/stk/rawwaves/mand7.raw new file mode 100644 index 0000000000000000000000000000000000000000..64941e9f98421aa1b2b353abbfa5a25cd9942295 GIT binary patch literal 2048 zcmeH``E!m}6vxlG&-+>;jiiJS6U3S-(ay9|RHLnF2vW4QG}hQ=q)|$0i#=#8iO|Fn zV(FwxFoM=rOJf@ojZqB}OU)Evm@u?S-uJoZ+w(v4S99jvXSvV4_j^9y^AO>Y?6DDU zg>`F5c#bSL@> zd`o?mz6#%JUk5irqTE_vbj_{WyY2$9SS#)9I}&VfN(e^sY0m)fQg2shzZ37ttkcxH z-8-x9?)vfdCe?eh&JpLH)6m>BPt0A-i=2wh2$H>0BvsPc7P~LpZvJSW_3!pi@ZI-^ zxu4oJyV@P@Hgm7p`fi-R%En5u%(G+dN!dy9CeFF)`NI=nGEJa~<#am3lbn{G8qY%~ znKSVcE#)@G;C&e@lO^1iN*7yd6Kr>RK*Mka5i&d=5T(S6DbP`5@V;jcicw)9=;l1x#kVu zO26?Ra#P%eZnk~hCfZ8z*yqw*#>qW|V?D*Nm%rp-`in|OaNAV}zkn$-K>*aAKB00Y9E17rpSB_|O0yFaifqf*lwvw`8d- zl47vDl%29nE+P)ch^Y&GPPz1$J8~2o0{7%Ke3;j968GcDe1fY@ePg&<jT6o6k*sPQ9~V;p*;u2e{#d@RORY1Y^>yWeKn44Y#wNu*4dgF0U>mt~ja z%Vp)a7&oXH^`%iXfu>P9?V&pyzzyhMxBq%0rdE^gxq)uC`| z1s~2~502m(E-0^Mn2Q-0jsA$m2k3`kn23>h4mv9h>7J7P;R<=UxT#G#H*MFdz8tFb^6r>e-DS#SN z6ve8l>8fj`p0-YX&Q*0=C{M>+^)5r{Eu;mSX_QPus26qC9U4&+YO8(m21QZ}^`?ow z3Ds)^wb2MurB9VzCH_VQO7RUOq{={hr;zE$5R z&cRmQ-D)7+N71r5h#D zMp8);npoPXE`({Qs=c;hR2ze7g_6lV=RAGoZ|INiJLjJ7J@?%AJkRHS&joma!ETg2 zXj5HpUc@bl^(a))s?dw@s`U)**IKPbu`1Hlbv~=pMW6RFR0zvls<~m3O@TROd)QUB zSsL+FZ-7GuK9}fQT^cc zleW6Q7pfA~I2DUduFAEurFNVRHRa}rv9_)qWK-;TyWO6%o9$fp1P7uSlF$_kR8Lju z#i@I0pW3CqQCF4ox_Z+*zc<87kdt1O+=<=*m8JTq(L$gA#rRXjsUBFuGPZUlu8~c% zkC?3{-Hb9DY^beocA4P7AEuv4GpS~zDX@|DJzMI+T`n7Q0?UvBs)=f~y6L5OrQQy2 zp0~oQ(o^&by;|q%lfF~+?vdisu z7vcuFSU1$=xyy{@3Z6q_bihE OuR0QK$HzhzV#4`G?c4&m8r5-j>=b?)OO*w zUtN*D@YH>EQ+=-%sdU*9g3BmECWfOu?{T-}eVOC=BBNY|Tkc+SX>OXE>_)pd7wr;V zf{SrUZmKJCm*m7)rt+0qZ69zis}PFTh{r@MlURx@%!ePd@Q%!@kc(~j8I>wXHC9bj zePIlxRf?ea0-`j1!qx?9oUGK;&80=YHxJJW1_uU za-HRV7V;A=<2<1=jB$)%Pj+G}>9FQ(!${GS#4&uGe({#i67J(sR!YSip$#I@Numon zOU5X)MLU_}B!4&Qng~S8dbG@uayxpWNA0IB=!3yR;%VvK6nRe;J^hi0r_f6{b(4;2 zfhIz>6|0LU&*DyatRlSkC}Xf8A2|d zljJFr3&h>W!n%k%#qCL6<6R-xTq>A^QJ5foJyR+_2XD(f9W!LSDZ`HicvsdkWXEU> zmAds32T|gut>_5_gx_7>mKtA`9ylSlYCrdgny-Xsk&I1p;zo%a>56sCl^)q9-|mqr z9u?geqvA*aNS^`oREM`{dQ`sVDzBt?{Jj=`8FX L#zO-C1A+elz2fQ< literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mand9.raw b/7.x/src/stk/rawwaves/mand9.raw new file mode 100644 index 0000000000000000000000000000000000000000..9e88a0c91317db8a3f2ba7969fe7aa0e0b2e029f GIT binary patch literal 2048 zcmeHF`%_g_7+w3EdoSSSDJY5g7{y0HC|V?z!eA;E8kJ+FH7a6^`AU0eXg*4-8D}(8 z(@e(@b(#t%9YIQL98yC=bbR0ogz$l>sDoFz+;h%eeeyr_oA;YN_w4=cy}oa)^#SPX z>}tIgNYzUi??2*8YprmHc`tiQLVO``?M9;UdQd}fi6_&hss7?O_)<5xT+{Xq;AS(MQd9Pxt)bicmdO zym>HaLeOS+llxN-f@8g%y)7X%K~)~Fdy8wQ*~5%9maDJT5Vct4bE$LD4p@T%hXXZM zcp%;XdCLlaxm~1BJ2mzy`=;*hT(b{Y8CIOL7F|>{k~l+ecPgB5R;ks=KEj{P1lJ`q zTaChTb=bIITsJ4W4|p!PGt61WEwjOO*fqpVGWWVRnN`?pSGR6xIqKgWsI*7e@z#6x z82y~C*DpI4^+s$kGL0-%t_I>7erGd3!ycp5+-8)jT&%@AC|2WDmC@cE(J0 zUF@un>2hY{MU|n>sT-#G3dMZh zW)T;$tDfS_w2SOsw%2~&u5(5^cl8PSuoK@R2Lmt`g(_6#r~xSBMMmhO`UVrI^lfJG z3?HzB3A#wvGY4T4Wxt`^S!xHSr z-zda9yhNM(IhF0TPdgkYH@@dq)?+xn!4A2Rj|}vLqQ)TXQr*>5HC837B=w4#tNP)8yi@Nu(=*Lh$1 zYe({5>G3QtOD-JU(F=XhA48EYIw#6khIlnuRw6CIt6&}dXeSCkk8zkTnKW@g^S+>5 z=UvJ4#(329wy0U6{y`%oPt;a24Y!ug&k7%X^E@;Xj<^lXb>;@2Zay``59XfOFliSV|%rs(zf L_gI1dL4p4OW?%Wt literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/mandpluk.raw b/7.x/src/stk/rawwaves/mandpluk.raw new file mode 100644 index 0000000000000000000000000000000000000000..162a0da9e1d448ee915c7b4ba441c8da46b6298a GIT binary patch literal 8900 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 PsADLOD`3`rMg6CLjECH- literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/ooo.raw b/7.x/src/stk/rawwaves/ooo.raw new file mode 100644 index 0000000000000000000000000000000000000000..1b8331e3d9a9ce5522961877759e898b3dc23fdb GIT binary patch literal 184 zcmV;p07w7-VFBF#F8pNu8~wBVo%_uDJNmWz%Kbb1Tlxt3FZ%!dTlx3))%R5P)9vWt zN!?52qv}HCJmo?9s}e*K3kz}?-7GgJO&IAHJstNU0T|y4{S3_)aS`VHi}Murm+pGo zqtVpSZ_{zrqt%7jF5<`SL+~E)f%aJO mEe0C@h4^&&ukdvB zXAXG~bv@x}I$N%JadGAL`hS(%i;Hv3)7cW9MqLki;Lq&o>b%0v(BhHte!bILT&lH- z8nV2S2BMRMO!;MbJUREVSF<)TUu7y~Ok$V|w434o&Hu^&=Kbydqy4MyN9#AI&)Yvd zetY^=-m?pjKHs}>tNH4;i>7BBkINlAzb9hb?hSueD=gKVFFoVeq?0|pZJrHGZJs^7 zlTOa~HD7wE=4yovf4A-46LIkTak(>&7fr8zyVZQ}#-q>AF1*Tnd-}uU&)dH_{b>DF T_ecA0_rH1nlmFjj7~uc_6d!%U literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/ppksblnk.raw b/7.x/src/stk/rawwaves/ppksblnk.raw new file mode 100644 index 0000000000000000000000000000000000000000..95a44464af8f4edbe304e7ed4a7fc70fd6d4b8d3 GIT binary patch literal 512 zcmZQzU{Gh6%b3Je%6yfziM^V0ACD)$tdObbBuN8VUPTSnS}iWU)5iNP9@!Z>ukdvB zXAXG~bv@x}I$N%JadGAL`hS(%i;Hv3)7cW9MqLki;Lq&o>b%0v(BhHte!bILT&lH- p8nV2S2BMRMO!;MbJUREVSF<)TUu7y~Ok$V|w0q#~2RdQo0sv6FP*(r| literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/ridecymb.raw b/7.x/src/stk/rawwaves/ridecymb.raw new file mode 100644 index 0000000000000000000000000000000000000000..722fa5a1477517a733d858d9a2d610051a22358f GIT binary patch literal 32394 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άsPNm-(DyaSbE?~RdQf2xOG(>;fG_8(zQWpz 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 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/silence.raw b/7.x/src/stk/rawwaves/silence.raw new file mode 100644 index 0000000000000000000000000000000000000000..4b8a1b3e49c7b867bb4cb3d412403b88b765c9de GIT binary patch literal 448 NcmZQz7zIN)1ONfR00961 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/sine.c b/7.x/src/stk/rawwaves/sine.c new file mode 100644 index 0000000..c43dc82 --- /dev/null +++ b/7.x/src/stk/rawwaves/sine.c @@ -0,0 +1,22 @@ +// Utility to make a rawwave sine table (assumes big-endian machine). + +#include +#include +#include + +#define LENGTH 1024 +#define PI 3.14159265358979323846 + +void main() +{ + int i,j; + double temp; + short data[LENGTH + 2]; + FILE *fd; + + fd = fopen("sinewave.raw","wb"); + for (i=0; iFB zGKY%hs+t;D6BV%?nD&Kk|Cnu_K!hvKaT4|7ju<)ocU`WSaDsxkCS zps|m=yNu&mn=rGT2EVoCRMq7rC4LAU=jmp1XJGib^K;Yme#N0S$B5x!5vTb86RGC()~Q^l}ER3K6w6| PCfhm3QL%Zqyz_bpy6-YGsc zzB7I`K`22t0h5rH(3}8x znt)~@2J`{?4DCZ~=m`1_oq%%$?)%{F1E|e{oQ%cEhMWz`-txE3yr6;g9G5jCjLa!tKJ?fSY0H3Sg)ZG7#b(d;qv=1kr*pfh@pU zF`z5J+<(zO(C-NRgQRbruO_w^YvMEM-{_x9cm$5uxfhcx>y_8xXLJ1yHXTh6<_cP8(k zY)Y&Ttle(+-q;CC0 zlzb_{l0f|!bgn^sMO^9!`?J|%V`3bldLrS%O+srzQi8T;G6aVC5BarD`}0*H<`E*i zraXA=POeW}N~c^n^Eqf7949*8gOBTumX6LInja9^-K=ev$~TX%#ru={JYNj8BB)K-G$3SsYc&T~t_vEbJ^aE1(yI7x3j%@^$j2^8)gCbE|U= zbCz@PIda(p*x|Vc0aW=6bF(%PGQI@z%d`+Yfqlq>| zbs~bWP8cFo6Nm(Ff+^u5K@?`e444MD!xT6Z#=-uuGi(W?VHB(e%fk||C@cUYU~c#n z%n1%RxC?+c2~bl5J!sJD3}$d(mI5?rK#N5X1-hm{p9uC05!Q(au-69crvM+jiL$^` z4DdFabQ<^!0e%;g#enxDkl~1=2l8~0SSk7--(V^NWGzZvPE!Th2hs%rhvxL-3~RvU zYo-NYbdYs7t2rA1xDDjU0fx)DhPl;wynyR;zD_=+fDf>y7n&7z79ooYi@Cu+FiTuY zrb=&?z94In8_N{SDj!KcDk>K%&#e%y$f*>m%%_M`$d6?o*Hm4oYOB_-91?wvsE;aN$v3augG`jIjV^xz*(`2(x^U1T)7Oj?v-~3v6TWi{k+8DpXRC(%P zyH^Kq$J0)$&fTt(=LXN$yEA*Vd+0Any&AoXFH`zZeT@FBfvW?XgXAHzA@*?NE7uXB zk-^c(G1al9*LgHk+VLOMKmErQ#up|ECM~CUruwIGZ?xZR|JD4~cLq7L`i}D6ZB}Y_ zVU9fSv>>@Kzerwkrc2Z5%ap${3?&A0rExWAO>=F3y=Mdek1>;vIq{+3U#CsE&5e&u z|Al|j+v3<7`<%UPzaz7=vHNT<>WjfX&;I1s;%^=-71lPp`+#_8esuO|>A3ED@QKd< DB?bC1 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/snardrum.raw b/7.x/src/stk/rawwaves/snardrum.raw new file mode 100644 index 0000000000000000000000000000000000000000..93005ad04e1adee215a3a7cbcdd949311f2513bf GIT binary patch literal 16660 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 L0_bl}h7k?`T})ND literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/tambourn.raw b/7.x/src/stk/rawwaves/tambourn.raw new file mode 100644 index 0000000000000000000000000000000000000000..fa8125220f692abc78cd1554ab2fc4899219b646 GIT binary patch literal 9240 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 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/tomhidrm.raw b/7.x/src/stk/rawwaves/tomhidrm.raw new file mode 100644 index 0000000000000000000000000000000000000000..0cf482b93778deb85fe70762346d3c4133a6a0e7 GIT binary patch literal 27642 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 B9JBxc literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/tomlowdr.raw b/7.x/src/stk/rawwaves/tomlowdr.raw new file mode 100644 index 0000000000000000000000000000000000000000..9813513dd9c05dc3b2aad5eef14ad08cc5e839c9 GIT binary patch literal 39200 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 N^G5$K9{%6E{XcWfP;dYM literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/tommiddr.raw b/7.x/src/stk/rawwaves/tommiddr.raw new file mode 100644 index 0000000000000000000000000000000000000000..4d042575a03819ac4ee527ee89b2d50f9f63c464 GIT binary patch literal 28292 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 literal 0 HcmV?d00001 diff --git a/7.x/src/stk/rawwaves/twopeaks.raw b/7.x/src/stk/rawwaves/twopeaks.raw new file mode 100644 index 0000000000000000000000000000000000000000..d383a24bda8d6364f31a4d99f0eba84db414bd05 GIT binary patch literal 512 zcmV+b0{{I0000R9CjeLgodEU$Vgcd;bpsp&)dZpif(CU5dkB*Wz6$#cNe!wG9T1=r zH51zvk{4MSFdG*g4IdLBC?iWHeJ8vs3M^zU%P~JQzcx!a;yZ*sF+k`;s77*0MNA-1 z15xf&;8)mM*InCS zCjbcm0RQ*@+5f2jWB&^Np8g*Fi~QvLEBjvhe))^|h4*dtLiGjnxAIo-jdX&%YSFSh=*x>Er^W^E~ z(CDY?ZtNxP%kNh53v6e*0ehEBxgBi~b(|p8pE}WB;iC+5h(j C?EQiO literal 0 HcmV?d00001 diff --git a/7.x/src/stk/src/ADSR.cpp b/7.x/src/stk/src/ADSR.cpp new file mode 100644 index 0000000..7c13948 --- /dev/null +++ b/7.x/src/stk/src/ADSR.cpp @@ -0,0 +1,181 @@ +/***************************************************/ +/*! \class ADSR + \brief STK ADSR envelope class. + + This class implements a traditional ADSR (Attack, Decay, Sustain, + Release) envelope. It responds to simple keyOn and keyOff + messages, keeping track of its state. The \e state = ADSR::IDLE + before being triggered and after the envelope value reaches 0.0 in + the ADSR::RELEASE state. All rate, target and level settings must + be non-negative. All time settings must be positive. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "ADSR.h" + +namespace stk { + +ADSR :: ADSR( void ) +{ + target_ = 0.0; + value_ = 0.0; + attackRate_ = 0.001; + decayRate_ = 0.001; + releaseRate_ = 0.005; + releaseTime_ = -1.0; + sustainLevel_ = 0.5; + state_ = IDLE; + Stk::addSampleRateAlert( this ); +} + +ADSR :: ~ADSR( void ) +{ + Stk::removeSampleRateAlert( this ); +} + +void ADSR :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) { + attackRate_ = oldRate * attackRate_ / newRate; + decayRate_ = oldRate * decayRate_ / newRate; + releaseRate_ = oldRate * releaseRate_ / newRate; + } +} + +void ADSR :: keyOn() +{ + if ( target_ <= 0.0 ) target_ = 1.0; + state_ = ATTACK; +} + +void ADSR :: keyOff() +{ + target_ = 0.0; + state_ = RELEASE; + + // FIXED October 2010 - Nick Donaldson + // Need to make release rate relative to current value!! + // Only update if we have set a TIME rather than a RATE, + // in which case releaseTime_ will be -1 + if ( releaseTime_ > 0.0 ) + releaseRate_ = value_ / ( releaseTime_ * Stk::sampleRate() ); +} + +void ADSR :: setAttackRate( StkFloat rate ) +{ + if ( rate < 0.0 ) { + oStream_ << "ADSR::setAttackRate: argument must be >= 0.0!"; + handleError( StkError::WARNING ); return; + } + + attackRate_ = rate; +} + +void ADSR :: setAttackTarget( StkFloat target ) +{ + if ( target < 0.0 ) { + oStream_ << "ADSR::setAttackTarget: negative target not allowed!"; + handleError( StkError::WARNING ); return; + } + + target_ = target; +} + +void ADSR :: setDecayRate( StkFloat rate ) +{ + if ( rate < 0.0 ) { + oStream_ << "ADSR::setDecayRate: negative rates not allowed!"; + handleError( StkError::WARNING ); return; + } + + decayRate_ = rate; +} + +void ADSR :: setSustainLevel( StkFloat level ) +{ + if ( level < 0.0 ) { + oStream_ << "ADSR::setSustainLevel: negative level not allowed!"; + handleError( StkError::WARNING ); return; + } + + sustainLevel_ = level; +} + +void ADSR :: setReleaseRate( StkFloat rate ) +{ + if ( rate < 0.0 ) { + oStream_ << "ADSR::setReleaseRate: negative rates not allowed!"; + handleError( StkError::WARNING ); return; + } + + releaseRate_ = rate; + + // Set to negative value so we don't update the release rate on keyOff() + releaseTime_ = -1.0; +} + +void ADSR :: setAttackTime( StkFloat time ) +{ + if ( time <= 0.0 ) { + oStream_ << "ADSR::setAttackTime: negative or zero times not allowed!"; + handleError( StkError::WARNING ); return; + } + + attackRate_ = 1.0 / ( time * Stk::sampleRate() ); +} + +void ADSR :: setDecayTime( StkFloat time ) +{ + if ( time <= 0.0 ) { + oStream_ << "ADSR::setDecayTime: negative or zero times not allowed!"; + handleError( StkError::WARNING ); return; + } + + decayRate_ = (1.0 - sustainLevel_) / ( time * Stk::sampleRate() ); +} + +void ADSR :: setReleaseTime( StkFloat time ) +{ + if ( time <= 0.0 ) { + oStream_ << "ADSR::setReleaseTime: negative or zero times not allowed!"; + handleError( StkError::WARNING ); return; + } + + releaseRate_ = sustainLevel_ / ( time * Stk::sampleRate() ); + releaseTime_ = time; +} + +void ADSR :: setAllTimes( StkFloat aTime, StkFloat dTime, StkFloat sLevel, StkFloat rTime ) +{ + this->setAttackTime( aTime ); + this->setSustainLevel( sLevel ); + this->setDecayTime( dTime ); + this->setReleaseTime( rTime ); +} + +void ADSR :: setTarget( StkFloat target ) +{ + if ( target < 0.0 ) { + oStream_ << "ADSR::setTarget: negative target not allowed!"; + handleError( StkError::WARNING ); return; + } + + target_ = target; + + this->setSustainLevel( target_ ); + if ( value_ < target_ ) state_ = ATTACK; + if ( value_ > target_ ) state_ = DECAY; +} + +void ADSR :: setValue( StkFloat value ) +{ + state_ = SUSTAIN; + target_ = value; + value_ = value; + this->setSustainLevel( value ); + lastFrame_[0] = value; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Asymp.cpp b/7.x/src/stk/src/Asymp.cpp new file mode 100644 index 0000000..7be0519 --- /dev/null +++ b/7.x/src/stk/src/Asymp.cpp @@ -0,0 +1,112 @@ +/***************************************************/ +/*! \class Asymp + \brief STK asymptotic curve envelope class + + This class implements a simple envelope generator + which asymptotically approaches a target value. + The algorithm used is of the form: + + y[n] = a y[n-1] + (1-a) target, + + where a = exp(-T/tau), T is the sample period, and + tau is a time constant. The user can set the time + constant (default value = 0.3) and target value. + Theoretically, this recursion never reaches its + target, though the calculations in this class are + stopped when the current value gets within a small + threshold value of the target (at which time the + current value is set to the target). It responds + to \e keyOn and \e keyOff messages by ramping to + 1.0 on keyOn and to 0.0 on keyOff. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Asymp.h" +#include + +namespace stk { + +Asymp :: Asymp( void ) +{ + value_ = 0.0; + target_ = 0.0; + state_ = 0; + factor_ = exp( -1.0 / ( 0.3 * Stk::sampleRate() ) ); + constant_ = 0.0; + Stk::addSampleRateAlert( this ); +} + +Asymp :: ~Asymp( void ) +{ + Stk::removeSampleRateAlert( this ); +} + +void Asymp :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) { + StkFloat tau = -1.0 / ( std::log( factor_ ) * oldRate ); + factor_ = std::exp( -1.0 / ( tau * newRate ) ); + } +} + +void Asymp :: keyOn( void ) +{ + this->setTarget( 1.0 ); +} + +void Asymp :: keyOff( void ) +{ + this->setTarget( 0.0 ); +} + +void Asymp :: setTau( StkFloat tau ) +{ + if ( tau <= 0.0 ) { + oStream_ << "Asymp::setTau: negative or zero tau not allowed!"; + handleError( StkError::WARNING ); return; + } + + factor_ = std::exp( -1.0 / ( tau * Stk::sampleRate() ) ); + constant_ = ( 1.0 - factor_ ) * target_; +} + +void Asymp :: setTime( StkFloat time ) +{ + if ( time <= 0.0 ) { + oStream_ << "Asymp::setTime: negative or zero times not allowed!"; + handleError( StkError::WARNING ); return; + } + + StkFloat tau = -time / std::log( TARGET_THRESHOLD ); + factor_ = std::exp( -1.0 / ( tau * Stk::sampleRate() ) ); + constant_ = ( 1.0 - factor_ ) * target_; +} + +void Asymp :: setT60( StkFloat t60 ) +{ + if ( t60 <= 0.0 ) { + oStream_ << "Asymp::setT60: negative or zero t60 not allowed!"; + handleError( StkError::WARNING ); return; + } + + setTau( t60 / 6.91 ); +} + +void Asymp :: setTarget( StkFloat target ) +{ + target_ = target; + if ( value_ != target_ ) state_ = 1; + constant_ = ( 1.0 - factor_ ) * target_; +} + +void Asymp :: setValue( StkFloat value ) +{ + state_ = 0; + target_ = value; + value_ = value; +} + +} // stk namespace + diff --git a/7.x/src/stk/src/BandedWG.cpp b/7.x/src/stk/src/BandedWG.cpp new file mode 100644 index 0000000..5df80ac --- /dev/null +++ b/7.x/src/stk/src/BandedWG.cpp @@ -0,0 +1,364 @@ +/***************************************************/ +/*! \class BandedWG + \brief Banded waveguide modeling class. + + This class uses banded waveguide techniques to + model a variety of sounds, including bowed + bars, glasses, and bowls. For more + information, see Essl, G. and Cook, P. "Banded + Waveguides: Towards Physical Modelling of Bar + Percussion Instruments", Proceedings of the + 1999 International Computer Music Conference. + + Control Change Numbers: + - Bow Pressure = 2 + - Bow Motion = 4 + - Strike Position = 8 (not implemented) + - Vibrato Frequency = 11 + - Gain = 1 + - Bow Velocity = 128 + - Set Striking = 64 + - Instrument Presets = 16 + - Uniform Bar = 0 + - Tuned Bar = 1 + - Glass Harmonica = 2 + - Tibetan Bowl = 3 + + by Georg Essl, 1999--2004. + Modified for STK 4.0 by Gary Scavone. +*/ +/***************************************************/ + +#include "BandedWG.h" +#include "SKINImsg.h" +#include + +namespace stk { + +BandedWG :: BandedWG( void ) +{ + doPluck_ = true; + + bowTable_.setSlope( 3.0 ); + adsr_.setAllTimes( 0.02, 0.005, 0.9, 0.01 ); + + frequency_ = 220.0; + this->setPreset(0); + + bowPosition_ = 0; + baseGain_ = 0.999; + + integrationConstant_ = 0.0; + trackVelocity_ = false; + + bowVelocity_ = 0.0; + bowTarget_ = 0.0; + + strikeAmp_ = 0.0; +} + +BandedWG :: ~BandedWG( void ) +{ +} + +void BandedWG :: clear( void ) +{ + for ( int i=0; i 1568.0) frequency = 1568.0; + + StkFloat radius; + StkFloat base = Stk::sampleRate() / frequency; + StkFloat length; + for (int i=0; i 2.0) { + delay_[i].setDelay( length ); + gains_[i]=basegains_[i]; + // gains_[i]=(StkFloat) pow(basegains_[i], 1/((StkFloat)delay_[i].getDelay())); + // std::cerr << gains_[i]; + } + else { + nModes_ = i; + break; + } + // std::cerr << std::endl; + + // Set the bandpass filter resonances + radius = 1.0 - PI * 32 / Stk::sampleRate(); //frequency_ * modes_[i] / Stk::sampleRate()/32; + if ( radius < 0.0 ) radius = 0.0; + bandpass_[i].setResonance(frequency * modes_[i], radius, true); + + delay_[i].clear(); + bandpass_[i].clear(); + } + + //int olen = (int)(delay_[0].getDelay()); + //strikePosition_ = (int)(strikePosition_*(length/modes_[0])/olen); +} + +void BandedWG :: setStrikePosition( StkFloat position ) +{ + strikePosition_ = (int)(delay_[0].getDelay() * position / 2.0); +} + +void BandedWG :: startBowing( StkFloat amplitude, StkFloat rate ) +{ + adsr_.setAttackRate(rate); + adsr_.keyOn(); + maxVelocity_ = 0.03 + (0.1 * amplitude); +} + +void BandedWG :: stopBowing( StkFloat rate ) +{ + adsr_.setReleaseRate(rate); + adsr_.keyOff(); +} + +void BandedWG :: pluck( StkFloat amplitude ) +{ + int j; + StkFloat min_len = delay_[nModes_-1].getDelay(); + for (int i=0; isetFrequency( frequency ); + + if ( doPluck_ ) + this->pluck( amplitude ); + else + this->startBowing( amplitude, amplitude * 0.001 ); +} + +void BandedWG :: noteOff( StkFloat amplitude ) +{ + if ( !doPluck_ ) + this->stopBowing( (1.0 - amplitude) * 0.005 ); +} + +StkFloat BandedWG :: tick( unsigned int ) +{ + int k; + + StkFloat input = 0.0; + if ( doPluck_ ) { + input = 0.0; + // input = strikeAmp_/nModes_; + // strikeAmp_ = 0.0; + } + else { + if ( integrationConstant_ == 0.0 ) + velocityInput_ = 0.0; + else + velocityInput_ = integrationConstant_ * velocityInput_; + + for ( k=0; k 128.0 ) ) { + oStream_ << "BandedWG::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_BowPressure_) { // 2 + if ( normalizedValue == 0.0 ) + doPluck_ = true; + else { + doPluck_ = false; + bowTable_.setSlope( 10.0 - (9.0 * normalizedValue)); + } + } + else if (number == 4) { // 4 + if ( !trackVelocity_ ) trackVelocity_ = true; + bowTarget_ += 0.005 * (normalizedValue - bowPosition_); + bowPosition_ = normalizedValue; + //adsr_.setTarget(bowPosition_); + } + else if (number == 8) // 8 + this->setStrikePosition( normalizedValue ); + else if (number == __SK_AfterTouch_Cont_) { // 128 + //bowTarget_ += 0.02 * (normalizedValue - bowPosition_); + //bowPosition_ = normalizedValue; + if ( trackVelocity_ ) trackVelocity_ = false; + maxVelocity_ = 0.13 * normalizedValue; + adsr_.setTarget(normalizedValue); + } + else if (number == __SK_ModWheel_) { // 1 + // baseGain_ = 0.9989999999 + (0.001 * normalizedValue ); + baseGain_ = 0.8999999999999999 + (0.1 * normalizedValue); + // std::cerr << "Yuck!" << std::endl; + for (int i=0; isetPreset((int) value); +#if defined(_STK_DEBUG_) + else { + oStream_ << "BandedWG::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/BeeThree.cpp b/7.x/src/stk/src/BeeThree.cpp new file mode 100644 index 0000000..a9e53b8 --- /dev/null +++ b/7.x/src/stk/src/BeeThree.cpp @@ -0,0 +1,79 @@ +/***************************************************/ +/*! \class BeeThree + \brief STK Hammond-oid organ FM synthesis instrument. + + This class implements a simple 4 operator + topology, also referred to as algorithm 8 of + the TX81Z. + + \code + Algorithm 8 is : + 1 --. + 2 -\| + +-> Out + 3 -/| + 4 -- + \endcode + + Control Change Numbers: + - Operator 4 (feedback) Gain = 2 + - Operator 3 Gain = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "BeeThree.h" + +namespace stk { + +BeeThree :: BeeThree( void ) + : FM() +{ + // Concatenate the STK rawwave path to the rawwave files + for ( unsigned int i=0; i<3; i++ ) + waves_[i] = new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ); + waves_[3] = new FileLoop( (Stk::rawwavePath() + "fwavblnk.raw").c_str(), true ); + + this->setRatio( 0, 0.999 ); + this->setRatio( 1, 1.997 ); + this->setRatio( 2, 3.006 ); + this->setRatio( 3, 6.009 ); + + gains_[0] = fmGains_[95]; + gains_[1] = fmGains_[95]; + gains_[2] = fmGains_[99]; + gains_[3] = fmGains_[95]; + + adsr_[0]->setAllTimes( 0.005, 0.003, 1.0, 0.01 ); + adsr_[1]->setAllTimes( 0.005, 0.003, 1.0, 0.01 ); + adsr_[2]->setAllTimes( 0.005, 0.003, 1.0, 0.01 ); + adsr_[3]->setAllTimes( 0.005, 0.001, 0.4, 0.03 ); + + twozero_.setGain( 0.1 ); +} + +BeeThree :: ~BeeThree( void ) +{ +} + +void BeeThree :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + gains_[0] = amplitude * fmGains_[95]; + gains_[1] = amplitude * fmGains_[95]; + gains_[2] = amplitude * fmGains_[99]; + gains_[3] = amplitude * fmGains_[95]; + this->setFrequency( frequency ); + this->keyOn(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/BiQuad.cpp b/7.x/src/stk/src/BiQuad.cpp new file mode 100644 index 0000000..024a65f --- /dev/null +++ b/7.x/src/stk/src/BiQuad.cpp @@ -0,0 +1,103 @@ +/***************************************************/ +/*! \class BiQuad + \brief STK biquad (two-pole, two-zero) filter class. + + This class implements a two-pole, two-zero digital filter. + Methods are provided for creating a resonance or notch in the + frequency response while maintaining a constant filter gain. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "BiQuad.h" +#include + +namespace stk { + +BiQuad :: BiQuad() : Filter() +{ + b_.resize( 3, 0.0 ); + a_.resize( 3, 0.0 ); + b_[0] = 1.0; + a_[0] = 1.0; + inputs_.resize( 3, 1, 0.0 ); + outputs_.resize( 3, 1, 0.0 ); + + Stk::addSampleRateAlert( this ); +} + +BiQuad :: ~BiQuad() +{ + Stk::removeSampleRateAlert( this ); +} + +void BiQuad :: setCoefficients( StkFloat b0, StkFloat b1, StkFloat b2, StkFloat a1, StkFloat a2, bool clearState ) +{ + b_[0] = b0; + b_[1] = b1; + b_[2] = b2; + a_[1] = a1; + a_[2] = a2; + + if ( clearState ) this->clear(); +} + +void BiQuad :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) { + oStream_ << "BiQuad::sampleRateChanged: you may need to recompute filter coefficients!"; + handleError( StkError::WARNING ); + } +} + +void BiQuad :: setResonance( StkFloat frequency, StkFloat radius, bool normalize ) +{ +#if defined(_STK_DEBUG_) + if ( frequency < 0.0 || frequency > 0.5 * Stk::sampleRate() ) { + oStream_ << "BiQuad::setResonance: frequency argument (" << frequency << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + if ( radius < 0.0 || radius >= 1.0 ) { + oStream_ << "BiQuad::setResonance: radius argument (" << radius << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + a_[2] = radius * radius; + a_[1] = -2.0 * radius * cos( TWO_PI * frequency / Stk::sampleRate() ); + + if ( normalize ) { + // Use zeros at +- 1 and normalize the filter peak gain. + b_[0] = 0.5 - 0.5 * a_[2]; + b_[1] = 0.0; + b_[2] = -b_[0]; + } +} + +void BiQuad :: setNotch( StkFloat frequency, StkFloat radius ) +{ +#if defined(_STK_DEBUG_) + if ( frequency < 0.0 || frequency > 0.5 * Stk::sampleRate() ) { + oStream_ << "BiQuad::setNotch: frequency argument (" << frequency << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + if ( radius < 0.0 ) { + oStream_ << "BiQuad::setNotch: radius argument (" << radius << ") is negative!"; + handleError( StkError::WARNING ); return; + } +#endif + + // This method does not attempt to normalize the filter gain. + b_[2] = radius * radius; + b_[1] = (StkFloat) -2.0 * radius * cos( TWO_PI * (double) frequency / Stk::sampleRate() ); +} + +void BiQuad :: setEqualGainZeroes( void ) +{ + b_[0] = 1.0; + b_[1] = 0.0; + b_[2] = -1.0; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Blit.cpp b/7.x/src/stk/src/Blit.cpp new file mode 100644 index 0000000..cff786e --- /dev/null +++ b/7.x/src/stk/src/Blit.cpp @@ -0,0 +1,78 @@ +/***************************************************/ +/*! \class Blit + \brief STK band-limited impulse train class. + + This class generates a band-limited impulse train using a + closed-form algorithm reported by Stilson and Smith in "Alias-Free + Digital Synthesis of Classic Analog Waveforms", 1996. The user + can specify both the fundamental frequency of the impulse train + and the number of harmonics contained in the resulting signal. + + The signal is normalized so that the peak value is +/-1.0. + + If nHarmonics is 0, then the signal will contain all harmonics up + to half the sample rate. Note, however, that this setting may + produce aliasing in the signal when the frequency is changing (no + automatic modification of the number of harmonics is performed by + the setFrequency() function). + + Original code by Robin Davies, 2005. + Revisions by Gary Scavone for STK, 2005. +*/ +/***************************************************/ + +#include "Blit.h" + +namespace stk { + +Blit:: Blit( StkFloat frequency ) +{ + if ( frequency <= 0.0 ) { + oStream_ << "Blit::Blit: argument (" << frequency << ") must be positive!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + nHarmonics_ = 0; + this->setFrequency( frequency ); + this->reset(); +} + +Blit :: ~Blit() +{ +} + +void Blit :: reset() +{ + phase_ = 0.0; + lastFrame_[0] = 0.0; +} + +void Blit :: setFrequency( StkFloat frequency ) +{ + if ( frequency <= 0.0 ) { + oStream_ << "Blit::setFrequency: argument (" << frequency << ") must be positive!"; + handleError( StkError::WARNING ); return; + } + + p_ = Stk::sampleRate() / frequency; + rate_ = PI / p_; + this->updateHarmonics(); +} + +void Blit :: setHarmonics( unsigned int nHarmonics ) +{ + nHarmonics_ = nHarmonics; + this->updateHarmonics(); +} + +void Blit :: updateHarmonics( void ) +{ + if ( nHarmonics_ <= 0 ) { + unsigned int maxHarmonics = (unsigned int) floor( 0.5 * p_ ); + m_ = 2 * maxHarmonics + 1; + } + else + m_ = 2 * nHarmonics_ + 1; +} + +} // stk namespace diff --git a/7.x/src/stk/src/BlitSaw.cpp b/7.x/src/stk/src/BlitSaw.cpp new file mode 100644 index 0000000..f732a8e --- /dev/null +++ b/7.x/src/stk/src/BlitSaw.cpp @@ -0,0 +1,91 @@ +/***************************************************/ +/*! \class BlitSaw + \brief STK band-limited sawtooth wave class. + + This class generates a band-limited sawtooth waveform using a + closed-form algorithm reported by Stilson and Smith in "Alias-Free + Digital Synthesis of Classic Analog Waveforms", 1996. The user + can specify both the fundamental frequency of the sawtooth and the + number of harmonics contained in the resulting signal. + + If nHarmonics is 0, then the signal will contain all harmonics up + to half the sample rate. Note, however, that this setting may + produce aliasing in the signal when the frequency is changing (no + automatic modification of the number of harmonics is performed by + the setFrequency() function). + + Based on initial code of Robin Davies, 2005. + Modified algorithm code by Gary Scavone, 2005. +*/ +/***************************************************/ + +#include "BlitSaw.h" + +namespace stk { + +BlitSaw:: BlitSaw( StkFloat frequency ) +{ + if ( frequency <= 0.0 ) { + oStream_ << "BlitSaw::BlitSaw: argument (" << frequency << ") must be positive!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + nHarmonics_ = 0; + this->reset(); + this->setFrequency( frequency ); +} + +BlitSaw :: ~BlitSaw() +{ +} + +void BlitSaw :: reset() +{ + phase_ = 0.0f; + state_ = 0.0; + lastFrame_[0] = 0.0; +} + +void BlitSaw :: setFrequency( StkFloat frequency ) +{ + if ( frequency <= 0.0 ) { + oStream_ << "BlitSaw::setFrequency: argument (" << frequency << ") must be positive!"; + handleError( StkError::WARNING ); return; + } + + p_ = Stk::sampleRate() / frequency; + C2_ = 1 / p_; + rate_ = PI * C2_; + this->updateHarmonics(); +} + +void BlitSaw :: setHarmonics( unsigned int nHarmonics ) +{ + nHarmonics_ = nHarmonics; + this->updateHarmonics(); + + // I found that the initial DC offset could be minimized with an + // initial state setting as given below. This initialization should + // only happen before starting the oscillator for the first time + // (but after setting the frequency and number of harmonics). I + // struggled a bit to decide where best to put this and finally + // settled on here. In general, the user shouldn't be messing with + // the number of harmonics once the oscillator is running because + // this is automatically taken care of in the setFrequency() + // function. (GPS - 1 October 2005) + state_ = -0.5 * a_; +} + +void BlitSaw :: updateHarmonics( void ) +{ + if ( nHarmonics_ <= 0 ) { + unsigned int maxHarmonics = (unsigned int) floor( 0.5 * p_ ); + m_ = 2 * maxHarmonics + 1; + } + else + m_ = 2 * nHarmonics_ + 1; + + a_ = m_ / p_; +} + +} // stk namespace diff --git a/7.x/src/stk/src/BlitSquare.cpp b/7.x/src/stk/src/BlitSquare.cpp new file mode 100644 index 0000000..2a51b07 --- /dev/null +++ b/7.x/src/stk/src/BlitSquare.cpp @@ -0,0 +1,95 @@ +/***************************************************/ +/*! \class BlitSquare + \brief STK band-limited square wave class. + + This class generates a band-limited square wave signal. It is + derived in part from the approach reported by Stilson and Smith in + "Alias-Free Digital Synthesis of Classic Analog Waveforms", 1996. + The algorithm implemented in this class uses a SincM function with + an even M value to achieve a bipolar bandlimited impulse train. + This signal is then integrated to achieve a square waveform. The + integration process has an associated DC offset so a DC blocking + filter is applied at the output. + + The user can specify both the fundamental frequency of the + waveform and the number of harmonics contained in the resulting + signal. + + If nHarmonics is 0, then the signal will contain all harmonics up + to half the sample rate. Note, however, that this setting may + produce aliasing in the signal when the frequency is changing (no + automatic modification of the number of harmonics is performed by + the setFrequency() function). Also note that the harmonics of a + square wave fall at odd integer multiples of the fundamental, so + aliasing will happen with a lower fundamental than with the other + Blit waveforms. This class is not guaranteed to be well behaved + in the presence of significant aliasing. + + Based on initial code of Robin Davies, 2005 + Modified algorithm code by Gary Scavone, 2005--2010. +*/ +/***************************************************/ + +#include "BlitSquare.h" + +namespace stk { + +BlitSquare:: BlitSquare( StkFloat frequency ) +{ + if ( frequency <= 0.0 ) { + oStream_ << "BlitSquare::BlitSquare: argument (" << frequency << ") must be positive!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + nHarmonics_ = 0; + this->setFrequency( frequency ); + this->reset(); +} + +BlitSquare :: ~BlitSquare() +{ +} + +void BlitSquare :: reset() +{ + phase_ = 0.0; + lastFrame_[0] = 0.0; + dcbState_ = 0.0; + lastBlitOutput_ = 0; +} + +void BlitSquare :: setFrequency( StkFloat frequency ) +{ + if ( frequency <= 0.0 ) { + oStream_ << "BlitSquare::setFrequency: argument (" << frequency << ") must be positive!"; + handleError( StkError::WARNING ); return; + } + + // By using an even value of the parameter M, we get a bipolar blit + // waveform at half the blit frequency. Thus, we need to scale the + // frequency value here by 0.5. (GPS, 2006). + p_ = 0.5 * Stk::sampleRate() / frequency; + rate_ = PI / p_; + this->updateHarmonics(); +} + +void BlitSquare :: setHarmonics( unsigned int nHarmonics ) +{ + nHarmonics_ = nHarmonics; + this->updateHarmonics(); +} + +void BlitSquare :: updateHarmonics( void ) +{ + // Make sure we end up with an even value of the parameter M here. + if ( nHarmonics_ <= 0 ) { + unsigned int maxHarmonics = (unsigned int) floor( 0.5 * p_ ); + m_ = 2 * (maxHarmonics + 1); + } + else + m_ = 2 * (nHarmonics_ + 1); + + a_ = m_ / p_; +} + +} // stk namespace diff --git a/7.x/src/stk/src/BlowBotl.cpp b/7.x/src/stk/src/BlowBotl.cpp new file mode 100644 index 0000000..2882712 --- /dev/null +++ b/7.x/src/stk/src/BlowBotl.cpp @@ -0,0 +1,122 @@ +/***************************************************/ +/*! \class BlowBotl + \brief STK blown bottle instrument class. + + This class implements a helmholtz resonator + (biquad filter) with a polynomial jet + excitation (a la Cook). + + Control Change Numbers: + - Noise Gain = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Volume = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "BlowBotl.h" +#include "SKINImsg.h" + +namespace stk { + +#define __BOTTLE_RADIUS_ 0.999 + +BlowBotl :: BlowBotl( void ) +{ + dcBlock_.setBlockZero(); + + vibrato_.setFrequency( 5.925 ); + vibratoGain_ = 0.0; + + resonator_.setResonance( 500.0, __BOTTLE_RADIUS_, true ); + adsr_.setAllTimes( 0.005, 0.01, 0.8, 0.010 ); + + noiseGain_ = 20.0; + maxPressure_ = 0.0; +} + +BlowBotl :: ~BlowBotl( void ) +{ +} + +void BlowBotl :: clear( void ) +{ + resonator_.clear(); +} + +void BlowBotl :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "BlowBotl::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + resonator_.setResonance( frequency, __BOTTLE_RADIUS_, true ); +} + +void BlowBotl :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "BlowBotl::startBowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setAttackRate( rate ); + maxPressure_ = amplitude; + adsr_.keyOn(); +} + +void BlowBotl :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "BlowBotl::stopBowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setReleaseRate( rate ); + adsr_.keyOff(); +} + +void BlowBotl :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + startBlowing( 1.1 + (amplitude * 0.20), amplitude * 0.02); + outputGain_ = amplitude + 0.001; +} + +void BlowBotl :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.02 ); +} + +void BlowBotl :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( value < 0 || ( number != 101 && value > 128.0 ) ) { + oStream_ << "BlowBotl::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_NoiseLevel_) // 4 + noiseGain_ = normalizedValue * 30.0; + else if (number == __SK_ModFrequency_) // 11 + vibrato_.setFrequency( normalizedValue * 12.0 ); + else if (number == __SK_ModWheel_) // 1 + vibratoGain_ = normalizedValue * 0.4; + else if (number == __SK_AfterTouch_Cont_) // 128 + adsr_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "BlowBotl::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/BlowHole.cpp b/7.x/src/stk/src/BlowHole.cpp new file mode 100644 index 0000000..5f34251 --- /dev/null +++ b/7.x/src/stk/src/BlowHole.cpp @@ -0,0 +1,224 @@ +/***************************************************/ +/*! \class BlowHole + \brief STK clarinet physical model with one + register hole and one tonehole. + + This class is based on the clarinet model, + with the addition of a two-port register hole + and a three-port dynamic tonehole + implementation, as discussed by Scavone and + Cook (1998). + + In this implementation, the distances between + the reed/register hole and tonehole/bell are + fixed. As a result, both the tonehole and + register hole will have variable influence on + the playing frequency, which is dependent on + the length of the air column. In addition, + the highest playing freqeuency is limited by + these fixed lengths. + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + Control Change Numbers: + - Reed Stiffness = 2 + - Noise Gain = 4 + - Tonehole State = 11 + - Register State = 1 + - Breath Pressure = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "BlowHole.h" +#include "SKINImsg.h" +#include + +namespace stk { + +BlowHole :: BlowHole( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "BlowHole::BlowHole: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long nDelays = (unsigned long) ( 0.5 * Stk::sampleRate() / lowestFrequency ); + + // delays[0] is the delay line between the reed and the register vent. + delays_[0].setDelay( 5.0 * Stk::sampleRate() / 22050.0 ); + // delays[1] is the delay line between the register vent and the tonehole. + delays_[1].setMaximumDelay( nDelays + 1 ); + // delays[2] is the delay line between the tonehole and the end of the bore. + delays_[2].setDelay( 4.0 * Stk::sampleRate() / 22050.0 ); + + reedTable_.setOffset( 0.7 ); + reedTable_.setSlope( -0.3 ); + + // Calculate the initial tonehole three-port scattering coefficient + StkFloat rb = 0.0075; // main bore radius + StkFloat rth = 0.003; // tonehole radius + scatter_ = -pow(rth,2) / ( pow(rth,2) + 2*pow(rb,2) ); + + // Calculate tonehole coefficients and set for initially open. + StkFloat te = 1.4 * rth; // effective length of the open hole + thCoeff_ = (te*2*Stk::sampleRate() - 347.23) / (te*2*Stk::sampleRate() + 347.23); + tonehole_.setA1( -thCoeff_ ); + tonehole_.setB0( thCoeff_ ); + tonehole_.setB1( -1.0 ); + + // Calculate register hole filter coefficients + double r_rh = 0.0015; // register vent radius + te = 1.4 * r_rh; // effective length of the open hole + double xi = 0.0; // series resistance term + double zeta = 347.23 + 2*PI*pow(rb,2)*xi/1.1769; + double psi = 2*PI*pow(rb,2)*te / (PI*pow(r_rh,2)); + StkFloat rhCoeff = (zeta - 2 * Stk::sampleRate() * psi) / (zeta + 2 * Stk::sampleRate() * psi); + rhGain_ = -347.23 / (zeta + 2 * Stk::sampleRate() * psi); + vent_.setA1( rhCoeff ); + vent_.setB0( 1.0 ); + vent_.setB1( 1.0 ); + // Start with register vent closed + vent_.setGain( 0.0 ); + + vibrato_.setFrequency((StkFloat) 5.735); + outputGain_ = 1.0; + noiseGain_ = 0.2; + vibratoGain_ = 0.01; + + this->setFrequency( 220.0 ); + this->clear(); +} + +BlowHole :: ~BlowHole( void ) +{ +} + +void BlowHole :: clear( void ) +{ + delays_[0].clear(); + delays_[1].clear(); + delays_[2].clear(); + filter_.tick( 0.0 ); + tonehole_.tick( 0.0 ); + vent_.tick( 0.0 ); +} + +void BlowHole :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "BlowHole::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + // Account for approximate filter delays and one sample "lastOut" delay. + StkFloat delay = ( Stk::sampleRate() / frequency ) * 0.5 - 3.5; + delay -= delays_[0].getDelay() + delays_[2].getDelay(); + + delays_[1].setDelay( delay ); +} + +void BlowHole :: setVent( StkFloat newValue ) +{ + // This method allows setting of the register vent "open-ness" at + // any point between "Open" (newValue = 1) and "Closed" + // (newValue = 0). + + StkFloat gain; + + if ( newValue <= 0.0 ) + gain = 0.0; + else if ( newValue >= 1.0 ) + gain = rhGain_; + else + gain = newValue * rhGain_; + + vent_.setGain( gain ); +} + +void BlowHole :: setTonehole( StkFloat newValue ) +{ + // This method allows setting of the tonehole "open-ness" at + // any point between "Open" (newValue = 1) and "Closed" + // (newValue = 0). + StkFloat new_coeff; + + if ( newValue <= 0.0 ) + new_coeff = 0.9995; + else if ( newValue >= 1.0 ) + new_coeff = thCoeff_; + else + new_coeff = ( newValue * (thCoeff_ - 0.9995) ) + 0.9995; + + tonehole_.setA1( -new_coeff ); + tonehole_.setB0( new_coeff ); +} + +void BlowHole :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "BlowHole::startBlowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( rate ); + envelope_.setTarget( amplitude ); +} + +void BlowHole :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "BlowHole::stopBlowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( rate ); + envelope_.setTarget( 0.0 ); +} + +void BlowHole :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->startBlowing( 0.55 + (amplitude * 0.30), amplitude * 0.005 ); + outputGain_ = amplitude + 0.001; +} + +void BlowHole :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.01 ); +} + +void BlowHole :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "BlowHole::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_ReedStiffness_) // 2 + reedTable_.setSlope( -0.44 + (0.26 * normalizedValue) ); + else if (number == __SK_NoiseLevel_) // 4 + noiseGain_ = ( normalizedValue * 0.4); + else if (number == __SK_ModFrequency_) // 11 + this->setTonehole( normalizedValue ); + else if (number == __SK_ModWheel_) // 1 + this->setVent( normalizedValue ); + else if (number == __SK_AfterTouch_Cont_) // 128 + envelope_.setValue( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "BlowHole::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Bowed.cpp b/7.x/src/stk/src/Bowed.cpp new file mode 100644 index 0000000..7e955ba --- /dev/null +++ b/7.x/src/stk/src/Bowed.cpp @@ -0,0 +1,180 @@ +/***************************************************/ +/*! \class Bowed + \brief STK bowed string instrument class. + + This class implements a bowed string model, a + la Smith (1986), after McIntyre, Schumacher, + Woodhouse (1983). + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + + Control Change Numbers: + - Bow Pressure = 2 + - Bow Position = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Bow Velocity = 100 + - Frequency = 101 + - Volume = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. + Contributions by Esteban Maestre, 2011. +*/ +/***************************************************/ + +#include "Bowed.h" +#include "SKINImsg.h" + +namespace stk { + +Bowed :: Bowed( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "Bowed::Bowed: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long nDelays = (unsigned long) ( Stk::sampleRate() / lowestFrequency ); + + neckDelay_.setMaximumDelay( nDelays + 1 ); + neckDelay_.setDelay( 100.0 ); + + bridgeDelay_.setMaximumDelay( nDelays + 1 ); + bridgeDelay_.setDelay( 29.0 ); + + bowTable_.setSlope( 3.0 ); + bowTable_.setOffset( 0.001); + bowDown_ = false; + maxVelocity_ = 0.25; + + vibrato_.setFrequency( 6.12723 ); + vibratoGain_ = 0.0; + + stringFilter_.setPole( 0.75 - (0.2 * 22050.0 / Stk::sampleRate()) ); + stringFilter_.setGain( 0.95 ); + + // Old single body filter + //bodyFilter_.setResonance( 500.0, 0.85, true ); + //bodyFilter_.setGain( 0.2 ); + + // New body filter provided by Esteban Maestre (cascade of second-order sections) + bodyFilters_[0].setCoefficients( 1.0, 1.5667, 0.3133, -0.5509, -0.3925 ); + bodyFilters_[1].setCoefficients( 1.0, -1.9537, 0.9542, -1.6357, 0.8697 ); + bodyFilters_[2].setCoefficients( 1.0, -1.6683, 0.8852, -1.7674, 0.8735 ); + bodyFilters_[3].setCoefficients( 1.0, -1.8585, 0.9653, -1.8498, 0.9516 ); + bodyFilters_[4].setCoefficients( 1.0, -1.9299, 0.9621, -1.9354, 0.9590 ); + bodyFilters_[5].setCoefficients( 1.0, -1.9800, 0.9888, -1.9867, 0.9923 ); + + adsr_.setAllTimes( 0.02, 0.005, 0.9, 0.01 ); + + betaRatio_ = 0.127236; + + // Necessary to initialize internal variables. + this->setFrequency( 220.0 ); + this->clear(); +} + +Bowed :: ~Bowed( void ) +{ +} + +void Bowed :: clear( void ) +{ + neckDelay_.clear(); + bridgeDelay_.clear(); + stringFilter_.clear(); + for ( int i=0; i<6; i++ ) bodyFilters_[i].clear(); +} + +void Bowed :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Bowed::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + // Delay = length - approximate filter delay. + baseDelay_ = Stk::sampleRate() / frequency - 4.0; + if ( baseDelay_ <= 0.0 ) baseDelay_ = 0.3; + bridgeDelay_.setDelay( baseDelay_ * betaRatio_ ); // bow to bridge length + neckDelay_.setDelay( baseDelay_ * (1.0 - betaRatio_) ); // bow to nut (finger) length +} + +void Bowed :: startBowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "Bowed::startBowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setAttackRate( rate ); + adsr_.keyOn(); + maxVelocity_ = 0.03 + ( 0.2 * amplitude ); + bowDown_ = true; +} + +void Bowed :: stopBowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "Bowed::stopBowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setReleaseRate( rate ); + adsr_.keyOff(); +} + +void Bowed :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->startBowing( amplitude, amplitude * 0.001 ); + this->setFrequency( frequency ); +} + +void Bowed :: noteOff( StkFloat amplitude ) +{ + this->stopBowing( (1.0 - amplitude) * 0.005 ); +} + +void Bowed :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( value < 0 || ( number != 101 && value > 128.0 ) ) { + oStream_ << "Bowed::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if ( number == __SK_BowPressure_ ) { // 2 + if ( normalizedValue > 0.0 ) bowDown_ = true; + else bowDown_ = false; + bowTable_.setSlope( 5.0 - (4.0 * normalizedValue) ); + } + else if ( number == __SK_BowPosition_ ) { // 4 + betaRatio_ = normalizedValue; + bridgeDelay_.setDelay( baseDelay_ * betaRatio_ ); + neckDelay_.setDelay( baseDelay_ * (1.0 - betaRatio_) ); + } + else if ( number == __SK_ModFrequency_ ) // 11 + vibrato_.setFrequency( normalizedValue * 12.0 ); + else if ( number == __SK_ModWheel_ ) // 1 + vibratoGain_ = ( normalizedValue * 0.4 ); + else if ( number == 100 ) // 100: set instantaneous bow velocity + adsr_.setTarget( normalizedValue ); + else if ( number == 101 ) // 101: set instantaneous value of frequency + this->setFrequency( value ); + else if (number == __SK_AfterTouch_Cont_) // 128 + adsr_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Bowed::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Brass.cpp b/7.x/src/stk/src/Brass.cpp new file mode 100644 index 0000000..6a65983 --- /dev/null +++ b/7.x/src/stk/src/Brass.cpp @@ -0,0 +1,158 @@ +/***************************************************/ +/*! \class Brass + \brief STK simple brass instrument class. + + This class implements a simple brass instrument + waveguide model, a la Cook (TBone, HosePlayer). + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + + Control Change Numbers: + - Lip Tension = 2 + - Slide Length = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Volume = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Brass.h" +#include "SKINImsg.h" +#include + +namespace stk { + +Brass :: Brass( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "Brass::Brass: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long nDelays = (unsigned long) ( Stk::sampleRate() / lowestFrequency ); + delayLine_.setMaximumDelay( nDelays + 1 ); + + lipFilter_.setGain( 0.03 ); + dcBlock_.setBlockZero(); + adsr_.setAllTimes( 0.005, 0.001, 1.0, 0.010 ); + + vibrato_.setFrequency( 6.137 ); + vibratoGain_ = 0.0; + maxPressure_ = 0.0; + lipTarget_ = 0.0; + + this->clear(); + + // This is necessary to initialize variables. + this->setFrequency( 220.0 ); +} + +Brass :: ~Brass( void ) +{ +} + +void Brass :: clear( void ) +{ + delayLine_.clear(); + lipFilter_.clear(); + dcBlock_.clear(); +} + +void Brass :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Brass::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + // Fudge correction for filter delays. + slideTarget_ = ( Stk::sampleRate() / frequency * 2.0 ) + 3.0; + delayLine_.setDelay( slideTarget_ ); // play a harmonic + + lipTarget_ = frequency; + lipFilter_.setResonance( frequency, 0.997 ); +} + +void Brass :: setLip( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Brass::setLip: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + lipFilter_.setResonance( frequency, 0.997 ); +} + +void Brass :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "Brass::startBlowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setAttackRate( rate ); + maxPressure_ = amplitude; + adsr_.keyOn(); +} + +void Brass :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "Brass::stopBlowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setReleaseRate( rate ); + adsr_.keyOff(); +} + +void Brass :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->startBlowing( amplitude, amplitude * 0.001 ); +} + +void Brass :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.005 ); +} + +void Brass :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Brass::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_LipTension_) { // 2 + StkFloat temp = lipTarget_ * pow( 4.0, (2.0 * normalizedValue) - 1.0 ); + this->setLip( temp ); + } + else if (number == __SK_SlideLength_) // 4 + delayLine_.setDelay( slideTarget_ * (0.5 + normalizedValue) ); + else if (number == __SK_ModFrequency_) // 11 + vibrato_.setFrequency( normalizedValue * 12.0 ); + else if (number == __SK_ModWheel_ ) // 1 + vibratoGain_ = normalizedValue * 0.4; + else if (number == __SK_AfterTouch_Cont_) // 128 + adsr_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Brass::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Chorus.cpp b/7.x/src/stk/src/Chorus.cpp new file mode 100644 index 0000000..1efd1db --- /dev/null +++ b/7.x/src/stk/src/Chorus.cpp @@ -0,0 +1,56 @@ +/***************************************************/ +/*! \class Chorus + \brief STK chorus effect class. + + This class implements a chorus effect. It takes a monophonic + input signal and produces a stereo output signal. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Chorus.h" + +namespace stk { + +Chorus :: Chorus( StkFloat baseDelay ) +{ + lastFrame_.resize( 1, 2, 0.0 ); // resize lastFrame_ for stereo output + delayLine_[0].setMaximumDelay( (unsigned long) (baseDelay * 1.414) + 2); + delayLine_[0].setDelay( baseDelay ); + delayLine_[1].setMaximumDelay( (unsigned long) (baseDelay * 1.414) + 2); + delayLine_[1].setDelay( baseDelay ); + baseLength_ = baseDelay; + + mods_[0].setFrequency( 0.2 ); + mods_[1].setFrequency( 0.222222 ); + modDepth_ = 0.05; + effectMix_ = 0.5; + this->clear(); +} + +void Chorus :: clear( void ) +{ + delayLine_[0].clear(); + delayLine_[1].clear(); + lastFrame_[0] = 0.0; + lastFrame_[1] = 0.0; +} + + void Chorus :: setModDepth( StkFloat depth ) +{ + if ( depth < 0.0 || depth > 1.0 ) { + oStream_ << "Chorus::setModDepth(): depth argument must be between 0.0 - 1.0!"; + handleError( StkError::WARNING ); return; + } + + modDepth_ = depth; +}; + +void Chorus :: setModFrequency( StkFloat frequency ) +{ + mods_[0].setFrequency( frequency ); + mods_[1].setFrequency( frequency * 1.1111 ); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Clarinet.cpp b/7.x/src/stk/src/Clarinet.cpp new file mode 100644 index 0000000..f81e0bf --- /dev/null +++ b/7.x/src/stk/src/Clarinet.cpp @@ -0,0 +1,138 @@ +/***************************************************/ +/*! \class Clarinet + \brief STK clarinet physical model class. + + This class implements a simple clarinet + physical model, as discussed by Smith (1986), + McIntyre, Schumacher, Woodhouse (1983), and + others. + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + Control Change Numbers: + - Reed Stiffness = 2 + - Noise Gain = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Breath Pressure = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Clarinet.h" +#include "SKINImsg.h" + +namespace stk { + +Clarinet :: Clarinet( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "Clarinet::Clarinet: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long nDelays = (unsigned long) ( 0.5 * Stk::sampleRate() / lowestFrequency ); + delayLine_.setMaximumDelay( nDelays + 1 ); + + reedTable_.setOffset( 0.7 ); + reedTable_.setSlope( -0.3 ); + + vibrato_.setFrequency( 5.735 ); + outputGain_ = 1.0; + noiseGain_ = 0.2; + vibratoGain_ = 0.1; + + this->setFrequency( 220.0 ); + this->clear(); +} + +Clarinet :: ~Clarinet( void ) +{ +} + +void Clarinet :: clear( void ) +{ + delayLine_.clear(); + filter_.tick( 0.0 ); +} + +void Clarinet :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Clarinet::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + // Account for filter delay and one sample "lastOut" delay. + StkFloat delay = ( Stk::sampleRate() / frequency ) * 0.5 - filter_.phaseDelay( frequency ) - 1.0; + delayLine_.setDelay( delay ); +} + +void Clarinet :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "Clarinet::startBlowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( rate ); + envelope_.setTarget( amplitude ); +} + +void Clarinet :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "Clarinet::stopBlowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( rate ); + envelope_.setTarget( 0.0 ); +} + +void Clarinet :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->startBlowing( 0.55 + (amplitude * 0.30), amplitude * 0.005 ); + outputGain_ = amplitude + 0.001; +} + +void Clarinet :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.01 ); +} + +void Clarinet :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Clarinet::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if ( number == __SK_ReedStiffness_ ) // 2 + reedTable_.setSlope( -0.44 + ( 0.26 * normalizedValue ) ); + else if ( number == __SK_NoiseLevel_ ) // 4 + noiseGain_ = ( normalizedValue * 0.4 ); + else if ( number == __SK_ModFrequency_ ) // 11 + vibrato_.setFrequency( normalizedValue * 12.0 ); + else if ( number == __SK_ModWheel_ ) // 1 + vibratoGain_ = ( normalizedValue * 0.5 ); + else if ( number == __SK_AfterTouch_Cont_ ) // 128 + envelope_.setValue( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Clarinet::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Delay.cpp b/7.x/src/stk/src/Delay.cpp new file mode 100644 index 0000000..27e1cc8 --- /dev/null +++ b/7.x/src/stk/src/Delay.cpp @@ -0,0 +1,110 @@ +/***************************************************/ +/*! \class Delay + \brief STK non-interpolating delay line class. + + This class implements a non-interpolating digital delay-line. If + the delay and maximum length are not specified during + instantiation, a fixed maximum length of 4095 and a delay of zero + is set. + + A non-interpolating delay line is typically used in fixed + delay-length applications, such as for reverberation. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Delay.h" + +namespace stk { + +Delay :: Delay( unsigned long delay, unsigned long maxDelay ) +{ + // Writing before reading allows delays from 0 to length-1. + // If we want to allow a delay of maxDelay, we need a + // delay-line of length = maxDelay+1. + if ( delay > maxDelay ) { + oStream_ << "Delay::Delay: maxDelay must be > than delay argument!\n"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( ( maxDelay + 1 ) > inputs_.size() ) + inputs_.resize( maxDelay + 1, 1, 0.0 ); + + inPoint_ = 0; + this->setDelay( delay ); +} + +Delay :: ~Delay() +{ +} + +void Delay :: setMaximumDelay( unsigned long delay ) +{ + if ( delay < inputs_.size() ) return; + inputs_.resize( delay + 1, 1, 0.0 ); +} + +void Delay :: setDelay( unsigned long delay ) +{ + if ( delay > inputs_.size() - 1 ) { // The value is too big. + oStream_ << "Delay::setDelay: argument (" << delay << ") greater than maximum!\n"; + handleError( StkError::WARNING ); return; + } + + // read chases write + if ( inPoint_ >= delay ) outPoint_ = inPoint_ - delay; + else outPoint_ = inputs_.size() + inPoint_ - delay; + delay_ = delay; +} + +StkFloat Delay :: energy( void ) const +{ + unsigned long i; + StkFloat e = 0; + if ( inPoint_ >= outPoint_ ) { + for ( i=outPoint_; i= 0.5!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( delay > (StkFloat) maxDelay ) { + oStream_ << "DelayA::DelayA: maxDelay must be > than delay argument!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + // Writing before reading allows delays from 0 to length-1. + if ( maxDelay + 1 > inputs_.size() ) + inputs_.resize( maxDelay + 1, 1, 0.0 ); + + inPoint_ = 0; + this->setDelay( delay ); + apInput_ = 0.0; + doNextOut_ = true; +} + +DelayA :: ~DelayA() +{ +} + +void DelayA :: clear() +{ + for ( unsigned int i=0; i length ) { // The value is too big. + oStream_ << "DelayA::setDelay: argument (" << delay << ") greater than maximum!"; + handleError( StkError::WARNING ); return; + } + + if ( delay < 0.5 ) { + oStream_ << "DelayA::setDelay: argument (" << delay << ") less than 0.5 not possible!"; + handleError( StkError::WARNING ); + } + + StkFloat outPointer = inPoint_ - delay + 1.0; // outPoint chases inpoint + delay_ = delay; + + while ( outPointer < 0 ) + outPointer += length; // modulo maximum length + + outPoint_ = (long) outPointer; // integer part + if ( outPoint_ == length ) outPoint_ = 0; + alpha_ = 1.0 + outPoint_ - outPointer; // fractional part + + if ( alpha_ < 0.5 ) { + // The optimal range for alpha is about 0.5 - 1.5 in order to + // achieve the flattest phase delay response. + outPoint_ += 1; + if ( outPoint_ >= length ) outPoint_ -= length; + alpha_ += (StkFloat) 1.0; + } + + coeff_ = (1.0 - alpha_) / (1.0 + alpha_); // coefficient for allpass +} + +StkFloat DelayA :: tapOut( unsigned long tapDelay ) +{ + long tap = inPoint_ - tapDelay - 1; + while ( tap < 0 ) // Check for wraparound. + tap += inputs_.size(); + + return inputs_[tap]; +} + +void DelayA :: tapIn( StkFloat value, unsigned long tapDelay ) +{ + long tap = inPoint_ - tapDelay - 1; + while ( tap < 0 ) // Check for wraparound. + tap += inputs_.size(); + + inputs_[tap] = value; +} + +} // stk namespace diff --git a/7.x/src/stk/src/DelayL.cpp b/7.x/src/stk/src/DelayL.cpp new file mode 100644 index 0000000..1dfc8d4 --- /dev/null +++ b/7.x/src/stk/src/DelayL.cpp @@ -0,0 +1,73 @@ +/***************************************************/ +/*! \class DelayL + \brief STK linear interpolating delay line class. + + This class implements a fractional-length digital delay-line using + first-order linear interpolation. If the delay and maximum length + are not specified during instantiation, a fixed maximum length of + 4095 and a delay of zero is set. + + Linear interpolation is an efficient technique for achieving + fractional delay lengths, though it does introduce high-frequency + signal attenuation to varying degrees depending on the fractional + delay setting. The use of higher order Lagrange interpolators can + typically improve (minimize) this attenuation characteristic. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "DelayL.h" + +namespace stk { + +DelayL :: DelayL( StkFloat delay, unsigned long maxDelay ) +{ + if ( delay < 0.0 ) { + oStream_ << "DelayL::DelayL: delay must be >= 0.0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( delay > (StkFloat) maxDelay ) { + oStream_ << "DelayL::DelayL: maxDelay must be > than delay argument!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + // Writing before reading allows delays from 0 to length-1. + if ( maxDelay + 1 > inputs_.size() ) + inputs_.resize( maxDelay + 1, 1, 0.0 ); + + inPoint_ = 0; + this->setDelay( delay ); + doNextOut_ = true; +} + +DelayL :: ~DelayL() +{ +} + +void DelayL :: setMaximumDelay( unsigned long delay ) +{ + if ( delay < inputs_.size() ) return; + inputs_.resize(delay + 1, 1, 0.0); +} + +StkFloat DelayL :: tapOut( unsigned long tapDelay ) +{ + long tap = inPoint_ - tapDelay - 1; + while ( tap < 0 ) // Check for wraparound. + tap += inputs_.size(); + + return inputs_[tap]; +} + +void DelayL :: tapIn( StkFloat value, unsigned long tapDelay ) +{ + long tap = inPoint_ - tapDelay - 1; + while ( tap < 0 ) // Check for wraparound. + tap += inputs_.size(); + + inputs_[tap] = value; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Drummer.cpp b/7.x/src/stk/src/Drummer.cpp new file mode 100644 index 0000000..51f627c --- /dev/null +++ b/7.x/src/stk/src/Drummer.cpp @@ -0,0 +1,141 @@ +/***************************************************/ +/*! \class Drummer + \brief STK drum sample player class. + + This class implements a drum sampling + synthesizer using FileWvIn objects and one-pole + filters. The drum rawwave files are sampled + at 22050 Hz, but will be appropriately + interpolated for other sample rates. You can + specify the maximum polyphony (maximum number + of simultaneous voices) via a #define in the + Drummer.h. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Drummer.h" +#include + +namespace stk { + +// Not really General MIDI yet. +unsigned char genMIDIMap[128] = + { 0,0,0,0,0,0,0,0, // 0-7 + 0,0,0,0,0,0,0,0, // 8-15 + 0,0,0,0,0,0,0,0, // 16-23 + 0,0,0,0,0,0,0,0, // 24-31 + 0,0,0,0,1,0,2,0, // 32-39 + 2,3,6,3,6,4,7,4, // 40-47 + 5,8,5,0,0,0,10,0, // 48-55 + 9,0,0,0,0,0,0,0, // 56-63 + 0,0,0,0,0,0,0,0, // 64-71 + 0,0,0,0,0,0,0,0, // 72-79 + 0,0,0,0,0,0,0,0, // 80-87 + 0,0,0,0,0,0,0,0, // 88-95 + 0,0,0,0,0,0,0,0, // 96-103 + 0,0,0,0,0,0,0,0, // 104-111 + 0,0,0,0,0,0,0,0, // 112-119 + 0,0,0,0,0,0,0,0 // 120-127 + }; + +char waveNames[DRUM_NUMWAVES][16] = + { + "dope.raw", + "bassdrum.raw", + "snardrum.raw", + "tomlowdr.raw", + "tommiddr.raw", + "tomhidrm.raw", + "hihatcym.raw", + "ridecymb.raw", + "crashcym.raw", + "cowbell1.raw", + "tambourn.raw" + }; + +Drummer :: Drummer( void ) : Instrmnt() +{ + // This counts the number of sounding voices. + nSounding_ = 0; + soundOrder_ = std::vector (DRUM_POLYPHONY, -1); + soundNumber_ = std::vector (DRUM_POLYPHONY, -1); +} + +Drummer :: ~Drummer( void ) +{ +} + +void Drummer :: noteOn( StkFloat instrument, StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "Drummer::noteOn: amplitude parameter is out of bounds!"; + handleError( StkError::WARNING ); return; + } + + // Yes, this is tres kludgey. + int noteNumber = (int) ( ( 12 * log( instrument / 220.0 ) / log( 2.0 ) ) + 57.01 ); + + // If we already have a wave of this note number loaded, just reset + // it. Otherwise, look first for an unused wave or preempt the + // oldest if already at maximum polyphony. + int iWave; + for ( iWave=0; iWave soundOrder_[iWave] ) + soundOrder_[j] -= 1; + } + } + soundOrder_[iWave] = nSounding_ - 1; + soundNumber_[iWave] = noteNumber; + //std::cout << "iWave = " << iWave << ", nSounding = " << nSounding_ << ", soundOrder[] = " << soundOrder_[iWave] << std::endl; + + // Concatenate the STK rawwave path to the rawwave file + waves_[iWave].openFile( (Stk::rawwavePath() + waveNames[ genMIDIMap[ noteNumber ] ]).c_str(), true ); + if ( Stk::sampleRate() != 22050.0 ) + waves_[iWave].setRate( 22050.0 / Stk::sampleRate() ); + filters_[iWave].setPole( 0.999 - (amplitude * 0.6) ); + filters_[iWave].setGain( amplitude ); + } + + /* +#if defined(_STK_DEBUG_) + oStream_ << "Drummer::noteOn: number sounding = " << nSounding_ << ", notes: "; + for ( int i=0; i + +namespace stk { + +Echo :: Echo( unsigned long maximumDelay ) : Effect() +{ + this->setMaximumDelay( maximumDelay ); + delayLine_.setDelay( length_ >> 1 ); + effectMix_ = 0.5; + this->clear(); +} + +void Echo :: clear( void ) +{ + delayLine_.clear(); + lastFrame_[0] = 0.0; +} + +void Echo :: setMaximumDelay( unsigned long delay ) +{ + if ( delay == 0 ) { + oStream_ << "Echo::setMaximumDelay: parameter cannot be zero!"; + handleError( StkError::WARNING ); return; + } + + length_ = delay; + delayLine_.setMaximumDelay( delay ); +} + +void Echo :: setDelay( unsigned long delay ) +{ + if ( delay > length_ ) { + oStream_ << "Echo::setDelay: parameter is greater than maximum delay length!"; + handleError( StkError::WARNING ); return; + } + + delayLine_.setDelay( delay ); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Envelope.cpp b/7.x/src/stk/src/Envelope.cpp new file mode 100644 index 0000000..0c1afeb --- /dev/null +++ b/7.x/src/stk/src/Envelope.cpp @@ -0,0 +1,87 @@ +/***************************************************/ +/*! \class Envelope + \brief STK linear line envelope class. + + This class implements a simple linear line envelope generator + which is capable of ramping to an arbitrary target value by a + specified \e rate. It also responds to simple \e keyOn and \e + keyOff messages, ramping to a specified target (default = 1.0) on + keyOn and to a specified target (default = 0.0) on keyOff. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Envelope.h" +#include + +namespace stk { + +Envelope :: Envelope( void ) : Generator() +{ + target_ = 0.0; + value_ = 0.0; + rate_ = 0.001; + state_ = 0; + Stk::addSampleRateAlert( this ); +} + +Envelope :: ~Envelope( void ) +{ + Stk::removeSampleRateAlert( this ); +} + +Envelope& Envelope :: operator= ( const Envelope& e ) +{ + if ( this != &e ) { + target_ = e.target_; + value_ = e.value_; + rate_ = e.rate_; + state_ = e.state_; + } + + return *this; +} + +void Envelope :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) + rate_ = oldRate * rate_ / newRate; +} + +void Envelope :: setRate( StkFloat rate ) +{ + if ( rate < 0.0 ) { + oStream_ << "Envelope::setRate: argument must be >= 0.0!"; + handleError( StkError::WARNING ); return; + } + + rate_ = rate; +} + +void Envelope :: setTime( StkFloat time ) +{ + if ( time <= 0.0 ) { + oStream_ << "Envelope::setTime: argument must be > 0.0!"; + handleError( StkError::WARNING ); return; + } + + //rate_ = 1.0 / ( time * Stk::sampleRate() ); + rate_ = fabs(target_ - value_) / ( time * Stk::sampleRate() ); +} + +void Envelope :: setTarget( StkFloat target ) +{ + target_ = target; + if ( value_ != target_ ) state_ = 1; +} + +void Envelope :: setValue( StkFloat value ) +{ + state_ = 0; + target_ = value; + value_ = value; + lastFrame_[0] = value_; +} + +} // stk namespace diff --git a/7.x/src/stk/src/FM.cpp b/7.x/src/stk/src/FM.cpp new file mode 100644 index 0000000..d5f3ae7 --- /dev/null +++ b/7.x/src/stk/src/FM.cpp @@ -0,0 +1,179 @@ +/***************************************************/ +/*! \class FM + \brief STK abstract FM synthesis base class. + + This class controls an arbitrary number of + waves and envelopes, determined via a + constructor argument. + + Control Change Numbers: + - Control One = 2 + - Control Two = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "FM.h" +#include "SKINImsg.h" + +namespace stk { + +FM :: FM( unsigned int operators ) + : nOperators_(operators) +{ + if ( nOperators_ == 0 ) { + oStream_ << "FM::FM: Number of operators must be greater than zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + twozero_.setB2( -1.0 ); + twozero_.setGain( 0.0 ); + + vibrato_.setFrequency( 6.0 ); + + unsigned int j; + adsr_.resize( nOperators_ ); + waves_.resize( nOperators_ ); + for (j=0; j=0; i--) { + fmGains_[i] = temp; + temp *= 0.933033; + } + + temp = 1.0; + for (i=15; i>=0; i--) { + fmSusLevels_[i] = temp; + temp *= 0.707101; + } + + temp = 8.498186; + for (i=0; i<32; i++) { + fmAttTimes_[i] = temp; + temp *= 0.707101; + } +} + +FM :: ~FM( void ) +{ + for (unsigned int i=0; isetFrequency( baseFrequency_ * ratios_[i] ); +} + +void FM :: setRatio( unsigned int waveIndex, StkFloat ratio ) +{ + if ( waveIndex >= nOperators_ ) { + oStream_ << "FM:setRatio: waveIndex parameter is greater than the number of operators!"; + handleError( StkError::WARNING ); return; + } + + ratios_[waveIndex] = ratio; + if (ratio > 0.0) + waves_[waveIndex]->setFrequency( baseFrequency_ * ratio ); + else + waves_[waveIndex]->setFrequency( ratio ); +} + +void FM :: setGain( unsigned int waveIndex, StkFloat gain ) +{ + if ( waveIndex >= nOperators_ ) { + oStream_ << "FM::setGain: waveIndex parameter is greater than the number of operators!"; + handleError( StkError::WARNING ); return; + } + + gains_[waveIndex] = gain; +} + +void FM :: keyOn( void ) +{ + for ( unsigned int i=0; ikeyOn(); +} + +void FM :: keyOff( void ) +{ + for ( unsigned int i=0; ikeyOff(); +} + +void FM :: noteOff( StkFloat amplitude ) +{ + this->keyOff(); +} + +void FM :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "FM::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_Breath_) // 2 + this->setControl1( normalizedValue ); + else if (number == __SK_FootControl_) // 4 + this->setControl2( normalizedValue ); + else if (number == __SK_ModFrequency_) // 11 + this->setModulationSpeed( normalizedValue * 12.0); + else if (number == __SK_ModWheel_) // 1 + this->setModulationDepth( normalizedValue ); + else if (number == __SK_AfterTouch_Cont_) { // 128 + //adsr_[0]->setTarget( normalizedValue ); + adsr_[1]->setTarget( normalizedValue ); + //adsr_[2]->setTarget( normalizedValue ); + adsr_[3]->setTarget( normalizedValue ); + } +#if defined(_STK_DEBUG_) + else { + oStream_ << "FM::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/FMVoices.cpp b/7.x/src/stk/src/FMVoices.cpp new file mode 100644 index 0000000..469e1a3 --- /dev/null +++ b/7.x/src/stk/src/FMVoices.cpp @@ -0,0 +1,164 @@ +/***************************************************/ +/*! \class FMVoices + \brief STK singing FM synthesis instrument. + + This class implements 3 carriers and a common + modulator, also referred to as algorithm 6 of + the TX81Z. + + \code + Algorithm 6 is : + /->1 -\ + 4-|-->2 - +-> Out + \->3 -/ + \endcode + + Control Change Numbers: + - Vowel = 2 + - Spectral Tilt = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "FMVoices.h" +#include "SKINImsg.h" +#include "Phonemes.h" + +namespace stk { + +FMVoices :: FMVoices( void ) + : FM() +{ + // Concatenate the STK rawwave path to the rawwave files + for ( unsigned int i=0; i<3; i++ ) + waves_[i] = new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ); + waves_[3] = new FileLoop( (Stk::rawwavePath() + "fwavblnk.raw").c_str(), true ); + + this->setRatio(0, 2.00); + this->setRatio(1, 4.00); + this->setRatio(2, 12.0); + this->setRatio(3, 1.00); + + gains_[3] = fmGains_[80]; + + adsr_[0]->setAllTimes( 0.05, 0.05, fmSusLevels_[15], 0.05); + adsr_[1]->setAllTimes( 0.05, 0.05, fmSusLevels_[15], 0.05); + adsr_[2]->setAllTimes( 0.05, 0.05, fmSusLevels_[15], 0.05); + adsr_[3]->setAllTimes( 0.01, 0.01, fmSusLevels_[15], 0.5); + + twozero_.setGain( 0.0 ); + modDepth_ = (StkFloat) 0.005; + currentVowel_ = 0; + tilt_[0] = 1.0; + tilt_[1] = 0.5; + tilt_[2] = 0.2; + mods_[0] = 1.0; + mods_[1] = 1.1; + mods_[2] = 1.1; + baseFrequency_ = 110.0; + this->setFrequency( 110.0 ); +} + +FMVoices :: ~FMVoices( void ) +{ +} + +void FMVoices :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "FMVoices::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat temp, temp2 = 0.0; + int tempi = 0; + unsigned int i = 0; + + if (currentVowel_ < 32) { + i = currentVowel_; + temp2 = 0.9; + } + else if (currentVowel_ < 64) { + i = currentVowel_ - 32; + temp2 = 1.0; + } + else if (currentVowel_ < 96) { + i = currentVowel_ - 64; + temp2 = 1.1; + } + else if (currentVowel_ < 128) { + i = currentVowel_ - 96; + temp2 = 1.2; + } + else return; + + baseFrequency_ = frequency; + temp = (temp2 * Phonemes::formantFrequency(i, 0) / baseFrequency_) + 0.5; + tempi = (int) temp; + this->setRatio( 0, (StkFloat) tempi ); + temp = (temp2 * Phonemes::formantFrequency(i, 1) / baseFrequency_) + 0.5; + tempi = (int) temp; + this->setRatio( 1, (StkFloat) tempi ); + temp = (temp2 * Phonemes::formantFrequency(i, 2) / baseFrequency_) + 0.5; + tempi = (int) temp; + this->setRatio( 2, (StkFloat) tempi ); + gains_[0] = 1.0; + gains_[1] = 1.0; + gains_[2] = 1.0; +} + +void FMVoices :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + tilt_[0] = amplitude; + tilt_[1] = amplitude * amplitude; + tilt_[2] = tilt_[1] * amplitude; + this->keyOn(); +} + +void FMVoices :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "FMVoices::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_Breath_) // 2 + gains_[3] = fmGains_[(int) ( normalizedValue * 99.9 )]; + else if (number == __SK_FootControl_) { // 4 + currentVowel_ = (int) (normalizedValue * 127.0); + this->setFrequency(baseFrequency_); + } + else if (number == __SK_ModFrequency_) // 11 + this->setModulationSpeed( normalizedValue * 12.0); + else if (number == __SK_ModWheel_) // 1 + this->setModulationDepth( normalizedValue ); + else if (number == __SK_AfterTouch_Cont_) { // 128 + tilt_[0] = normalizedValue; + tilt_[1] = normalizedValue * normalizedValue; + tilt_[2] = tilt_[1] * normalizedValue; + } +#if defined(_STK_DEBUG_) + else { + oStream_ << "FMVoices::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/FileLoop.cpp b/7.x/src/stk/src/FileLoop.cpp new file mode 100644 index 0000000..67ff0e9 --- /dev/null +++ b/7.x/src/stk/src/FileLoop.cpp @@ -0,0 +1,237 @@ +/***************************************************/ +/*! \class FileLoop + \brief STK file looping / oscillator class. + + This class provides audio file looping functionality. Any audio + file that can be loaded by FileRead can be looped using this + class. + + FileLoop supports multi-channel data. It is important to + distinguish the tick() method that computes a single frame (and + returns only the specified sample of a multi-channel frame) from + the overloaded one that takes an StkFrames object for + multi-channel and/or multi-frame data. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "FileLoop.h" +#include + +namespace stk { + +FileLoop :: FileLoop( unsigned long chunkThreshold, unsigned long chunkSize ) + : FileWvIn( chunkThreshold, chunkSize ), phaseOffset_(0.0) +{ + Stk::addSampleRateAlert( this ); +} + +FileLoop :: FileLoop( std::string fileName, bool raw, bool doNormalize, + unsigned long chunkThreshold, unsigned long chunkSize, + bool doInt2FloatScaling ) + : FileWvIn( chunkThreshold, chunkSize ), phaseOffset_(0.0) +{ + this->openFile( fileName, raw, doNormalize, doInt2FloatScaling ); + Stk::addSampleRateAlert( this ); +} + +FileLoop :: ~FileLoop( void ) +{ + Stk::removeSampleRateAlert( this ); +} + +void FileLoop :: openFile( std::string fileName, bool raw, bool doNormalize, bool doInt2FloatScaling ) +{ + // Call close() in case another file is already open. + this->closeFile(); + + // Attempt to open the file ... an error might be thrown here. + file_.open( fileName, raw ); + + // Determine whether chunking or not. + if ( file_.fileSize() > chunkThreshold_ ) { + chunking_ = true; + chunkPointer_ = 0; + data_.resize( chunkSize_ + 1, file_.channels() ); + } + else { + chunking_ = false; + data_.resize( file_.fileSize() + 1, file_.channels() ); + } + + if ( doInt2FloatScaling ) + int2floatscaling_ = true; + else + int2floatscaling_ = false; + + // Load all or part of the data. + file_.read( data_, 0, int2floatscaling_ ); + + if ( chunking_ ) { // If chunking, save the first sample frame for later. + firstFrame_.resize( 1, data_.channels() ); + for ( unsigned int i=0; isetRate( data_.dataRate() / Stk::sampleRate() ); + + if ( doNormalize & !chunking_ ) this->normalize(); + + this->reset(); +} + +void FileLoop :: setRate( StkFloat rate ) +{ + rate_ = rate; + + if ( fmod( rate_, 1.0 ) != 0.0 ) interpolate_ = true; + else interpolate_ = false; +} + +void FileLoop :: addTime( StkFloat time ) +{ + // Add an absolute time in samples. + time_ += time; + + while ( time_ < 0.0 ) + time_ += fileSize_; + while ( time_ >= fileSize_ ) + time_ -= fileSize_; +} + +void FileLoop :: addPhase( StkFloat angle ) +{ + // Add a time in cycles (one cycle = fileSize). + time_ += fileSize_ * angle; + + while ( time_ < 0.0 ) + time_ += fileSize_; + while ( time_ >= fileSize_ ) + time_ -= fileSize_; +} + +void FileLoop :: addPhaseOffset( StkFloat angle ) +{ + // Add a phase offset in cycles, where 1.0 = fileSize. + phaseOffset_ = fileSize_ * angle; +} + +StkFloat FileLoop :: tick( unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= data_.channels() ) { + oStream_ << "FileLoop::tick(): channel argument and soundfile data are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + if ( finished_ ) return 0.0; + + // Check limits of time address ... if necessary, recalculate modulo + // fileSize. + while ( time_ < 0.0 ) + time_ += fileSize_; + while ( time_ >= fileSize_ ) + time_ -= fileSize_; + + StkFloat tyme = time_; + if ( phaseOffset_ ) { + tyme += phaseOffset_; + while ( tyme < 0.0 ) + tyme += fileSize_; + while ( tyme >= fileSize_ ) + tyme -= fileSize_; + } + + if ( chunking_ ) { + + // Check the time address vs. our current buffer limits. + if ( ( time_ < (StkFloat) chunkPointer_ ) || + ( time_ > (StkFloat) ( chunkPointer_ + chunkSize_ - 1 ) ) ) { + + while ( time_ < (StkFloat) chunkPointer_ ) { // negative rate + chunkPointer_ -= chunkSize_ - 1; // overlap chunks by one frame + if ( chunkPointer_ < 0 ) chunkPointer_ = 0; + } + while ( time_ > (StkFloat) ( chunkPointer_ + chunkSize_ - 1 ) ) { // positive rate + chunkPointer_ += chunkSize_ - 1; // overlap chunks by one frame + if ( chunkPointer_ + chunkSize_ > fileSize_ ) { // at end of file + chunkPointer_ = fileSize_ - chunkSize_ + 1; // leave extra frame at end of buffer + // Now fill extra frame with first frame data. + for ( unsigned int j=0; j frames.channels() - nChannels ) { + oStream_ << "FileLoop::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; i2) + soundfiles are supported. The file data is + returned via an external StkFrames object + passed to the read() function. This class + does not store its own copy of the file data, + rather the data is read directly from disk. + + FileRead currently supports uncompressed WAV, + AIFF/AIFC, SND (AU), MAT-file (Matlab), and + STK RAW file formats. Signed integer (8-, + 16-, 24- and 32-bit) and floating-point (32- and + 64-bit) data types are supported. Compressed + data types are not supported. + + STK RAW files have no header and are assumed to + contain a monophonic stream of 16-bit signed + integers in big-endian byte order at a sample + rate of 22050 Hz. MAT-file data should be saved + in an array with each data channel filling a + matrix row. The sample rate for MAT-files should + be specified in a variable named "fs". If no + such variable is found, the sample rate is + assumed to be 44100 Hz. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "FileRead.h" +#include +#include +#include +#include +#include + +namespace stk { + +FileRead :: FileRead() + : fd_(0), fileSize_(0), channels_(0), dataType_(0), fileRate_(0.0) +{ +} + +FileRead :: FileRead( std::string fileName, bool typeRaw, unsigned int nChannels, + StkFormat format, StkFloat rate ) + : fd_(0) +{ + open( fileName, typeRaw, nChannels, format, rate ); +} + +FileRead :: ~FileRead() +{ + if ( fd_ ) + fclose( fd_ ); +} + +void FileRead :: close( void ) +{ + if ( fd_ ) fclose( fd_ ); + fd_ = 0; + wavFile_ = false; + fileSize_ = 0; + channels_ = 0; + dataType_ = 0; + fileRate_ = 0.0; +} + +bool FileRead :: isOpen( void ) +{ + if ( fd_ ) return true; + else return false; +} + +void FileRead :: open( std::string fileName, bool typeRaw, unsigned int nChannels, + StkFormat format, StkFloat rate ) +{ + // If another file is open, close it. + close(); + + // Try to open the file. + fd_ = fopen( fileName.c_str(), "rb" ); + if ( !fd_ ) { + oStream_ << "FileRead::open: could not open or find file (" << fileName << ")!"; + handleError( StkError::FILE_NOT_FOUND ); + } + + // Attempt to determine file type from header (unless RAW). + bool result = false; + if ( typeRaw ) + result = getRawInfo( fileName.c_str(), nChannels, format, rate ); + else { + char header[12]; + if ( fread( &header, 4, 3, fd_ ) != 3 ) goto error; + if ( !strncmp( header, "RIFF", 4 ) && + !strncmp( &header[8], "WAVE", 4 ) ) + result = getWavInfo( fileName.c_str() ); + else if ( !strncmp( header, ".snd", 4 ) ) + result = getSndInfo( fileName.c_str() ); + else if ( !strncmp( header, "FORM", 4 ) && + ( !strncmp( &header[8], "AIFF", 4 ) || !strncmp(&header[8], "AIFC", 4) ) ) + result = getAifInfo( fileName.c_str() ); + else { + if ( fseek( fd_, 126, SEEK_SET ) == -1 ) goto error; + if ( fread( &header, 2, 1, fd_ ) != 1 ) goto error; + if ( !strncmp( header, "MI", 2 ) || + !strncmp( header, "IM", 2 ) ) + result = getMatInfo( fileName.c_str() ); + else { + oStream_ << "FileRead::open: file (" << fileName << ") format unknown."; + handleError( StkError::FILE_UNKNOWN_FORMAT ); + } + } + } + + // If here, we had a file type candidate but something else went wrong. + if ( result == false ) + handleError( StkError::FILE_ERROR ); + + // Check for empty files. + if ( fileSize_ == 0 ) { + oStream_ << "FileRead::open: file (" << fileName << ") data size is zero!"; + handleError( StkError::FILE_ERROR ); + } + + return; + + error: + oStream_ << "FileRead::open: error reading file (" << fileName << ")!"; + handleError( StkError::FILE_ERROR ); +} + +bool FileRead :: getRawInfo( const char *fileName, unsigned int nChannels, StkFormat format, StkFloat rate ) +{ + // Use the system call "stat" to determine the file length. + struct stat filestat; + if ( stat(fileName, &filestat) == -1 ) { + oStream_ << "FileRead: Could not stat RAW file (" << fileName << ")."; + return false; + } + if ( nChannels == 0 ) { + oStream_ << "FileRead: number of channels can't be 0 (" << fileName << ")."; + return false; + } + + // Rawwave files have no header and by default, are assumed to + // contain a monophonic stream of 16-bit signed integers in + // big-endian byte order at a sample rate of 22050 Hz. However, + // different parameters can be specified if desired. + dataOffset_ = 0; + channels_ = nChannels; + dataType_ = format; + fileRate_ = rate; + int sampleBytes = 0; + if ( format == STK_SINT8 ) sampleBytes = 1; + else if ( format == STK_SINT16 ) sampleBytes = 2; + else if ( format == STK_SINT32 || format == STK_FLOAT32 ) sampleBytes = 4; + else if ( format == STK_FLOAT64 ) sampleBytes = 8; + else { + oStream_ << "FileRead: StkFormat " << format << " is invalid (" << fileName << ")."; + return false; + } + + fileSize_ = (long) filestat.st_size / sampleBytes / channels_; // length in frames + + byteswap_ = false; +#ifdef __LITTLE_ENDIAN__ + byteswap_ = true; +#endif + + return true; +} + +bool FileRead :: getWavInfo( const char *fileName ) +{ + // Find "format" chunk ... it must come before the "data" chunk. + char id[4]; + SINT32 chunkSize; + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + while ( strncmp(id, "fmt ", 4) ) { + if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap32((unsigned char *)&chunkSize); +#endif + if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error; + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + } + + // Check that the data is not compressed. + unsigned short format_tag; + if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error; // Read fmt chunk size. + if ( fread(&format_tag, 2, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap16((unsigned char *)&format_tag); + swap32((unsigned char *)&chunkSize); +#endif + if ( format_tag == 0xFFFE ) { // WAVE_FORMAT_EXTENSIBLE + dataOffset_ = ftell(fd_); + if ( fseek(fd_, 14, SEEK_CUR) == -1 ) goto error; + unsigned short extSize; + if ( fread(&extSize, 2, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap16((unsigned char *)&extSize); +#endif + if ( extSize == 0 ) goto error; + if ( fseek(fd_, 6, SEEK_CUR) == -1 ) goto error; + if ( fread(&format_tag, 2, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap16((unsigned char *)&format_tag); +#endif + if ( fseek(fd_, dataOffset_, SEEK_SET) == -1 ) goto error; + } + if ( format_tag != 1 && format_tag != 3 ) { // PCM = 1, FLOAT = 3 + oStream_ << "FileRead: "<< fileName << " contains an unsupported data format type (" << format_tag << ")."; + return false; + } + + // Get number of channels from the header. + SINT16 temp; + if ( fread(&temp, 2, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap16((unsigned char *)&temp); +#endif + channels_ = (unsigned int ) temp; + + // Get file sample rate from the header. + SINT32 srate; + if ( fread(&srate, 4, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap32((unsigned char *)&srate); +#endif + fileRate_ = (StkFloat) srate; + + // Determine the data type. + dataType_ = 0; + if ( fseek(fd_, 6, SEEK_CUR) == -1 ) goto error; // Locate bits_per_sample info. + if ( fread(&temp, 2, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap16((unsigned char *)&temp); +#endif + if ( format_tag == 1 ) { + if ( temp == 8 ) + dataType_ = STK_SINT8; + else if ( temp == 16 ) + dataType_ = STK_SINT16; + else if ( temp == 24 ) + dataType_ = STK_SINT24; + else if ( temp == 32 ) + dataType_ = STK_SINT32; + } + else if ( format_tag == 3 ) { + if ( temp == 32 ) + dataType_ = STK_FLOAT32; + else if ( temp == 64 ) + dataType_ = STK_FLOAT64; + } + if ( dataType_ == 0 ) { + oStream_ << "FileRead: " << temp << " bits per sample with data format " << format_tag << " are not supported (" << fileName << ")."; + return false; + } + + // Jump over any remaining part of the "fmt" chunk. + if ( fseek(fd_, chunkSize-16, SEEK_CUR) == -1 ) goto error; + + // Find "data" chunk ... it must come after the "fmt" chunk. + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + + while ( strncmp(id, "data", 4) ) { + if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap32((unsigned char *)&chunkSize); +#endif + chunkSize += chunkSize % 2; // chunk sizes must be even + if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error; + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + } + + // Get length of data from the header. + SINT32 bytes; + if ( fread(&bytes, 4, 1, fd_) != 1 ) goto error; +#ifndef __LITTLE_ENDIAN__ + swap32((unsigned char *)&bytes); +#endif + fileSize_ = bytes / temp / channels_; // sample frames + fileSize_ *= 8; // sample frames + + dataOffset_ = ftell(fd_); + byteswap_ = false; +#ifndef __LITTLE_ENDIAN__ + byteswap_ = true; +#endif + + wavFile_ = true; + return true; + + error: + oStream_ << "FileRead: error reading WAV file (" << fileName << ")."; + return false; +} + +bool FileRead :: getSndInfo( const char *fileName ) +{ + // Determine the data type. + UINT32 format; + if ( fseek(fd_, 12, SEEK_SET) == -1 ) goto error; // Locate format + if ( fread(&format, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&format); +#endif + + if (format == 2) dataType_ = STK_SINT8; + else if (format == 3) dataType_ = STK_SINT16; + else if (format == 4) dataType_ = STK_SINT24; + else if (format == 5) dataType_ = STK_SINT32; + else if (format == 6) dataType_ = STK_FLOAT32; + else if (format == 7) dataType_ = STK_FLOAT64; + else { + oStream_ << "FileRead: data format in file " << fileName << " is not supported."; + return false; + } + + // Get file sample rate from the header. + UINT32 srate; + if ( fread(&srate, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&srate); +#endif + fileRate_ = (StkFloat) srate; + + // Get number of channels from the header. + UINT32 chans; + if ( fread(&chans, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&chans); +#endif + channels_ = chans; + + UINT32 offset; + if ( fseek(fd_, 4, SEEK_SET) == -1 ) goto error; + if ( fread(&offset, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&offset); +#endif + dataOffset_ = offset; + + // Get length of data from the header. + if ( fread(&fileSize_, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&fileSize_); +#endif + // Convert to sample frames. + if ( dataType_ == STK_SINT8 ) + fileSize_ /= channels_; + if ( dataType_ == STK_SINT16 ) + fileSize_ /= 2 * channels_; + else if ( dataType_ == STK_SINT24 ) + fileSize_ /= 3 * channels_; + else if ( dataType_ == STK_SINT32 || dataType_ == STK_FLOAT32 ) + fileSize_ /= 4 * channels_; + else if ( dataType_ == STK_FLOAT64 ) + fileSize_ /= 8 * channels_; + + byteswap_ = false; +#ifdef __LITTLE_ENDIAN__ + byteswap_ = true; +#endif + + return true; + + error: + oStream_ << "FileRead: Error reading SND file (" << fileName << ")."; + return false; +} + +bool FileRead :: getAifInfo( const char *fileName ) +{ + bool aifc = false; + char id[4]; + + // Determine whether this is AIFF or AIFC. + if ( fseek(fd_, 8, SEEK_SET) == -1 ) goto error; + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + if ( !strncmp(id, "AIFC", 4) ) aifc = true; + + // Find "common" chunk + SINT32 chunkSize; + if ( fread(&id, 4, 1, fd_) != 1) goto error; + while ( strncmp(id, "COMM", 4) ) { + if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&chunkSize); +#endif + chunkSize += chunkSize % 2; // chunk sizes must be even + if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error; + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + } + + // Get number of channels from the header. + SINT16 temp; + if ( fseek(fd_, 4, SEEK_CUR) == -1 ) goto error; // Jump over chunk size + if ( fread(&temp, 2, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap16((unsigned char *)&temp); +#endif + channels_ = temp; + + // Get length of data from the header. + SINT32 frames; + if ( fread(&frames, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&frames); +#endif + fileSize_ = frames; // sample frames + + // Read the number of bits per sample. + if ( fread(&temp, 2, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap16((unsigned char *)&temp); +#endif + + // Get file sample rate from the header. For AIFF files, this value + // is stored in a 10-byte, IEEE Standard 754 floating point number, + // so we need to convert it first. + unsigned char srate[10]; + unsigned char exp; + unsigned long mantissa; + unsigned long last; + if ( fread(&srate, 10, 1, fd_) != 1 ) goto error; + mantissa = (unsigned long) *(unsigned long *)(srate+2); +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&mantissa); +#endif + exp = 30 - *(srate+1); + last = 0; + while (exp--) { + last = mantissa; + mantissa >>= 1; + } + if (last & 0x00000001) mantissa++; + fileRate_ = (StkFloat) mantissa; + + byteswap_ = false; +#ifdef __LITTLE_ENDIAN__ + byteswap_ = true; +#endif + + // Determine the data format. + dataType_ = 0; + if ( aifc == false ) { + if ( temp <= 8 ) dataType_ = STK_SINT8; + else if ( temp <= 16 ) dataType_ = STK_SINT16; + else if ( temp <= 24 ) dataType_ = STK_SINT24; + else if ( temp <= 32 ) dataType_ = STK_SINT32; + } + else { + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + if ( !strncmp(id, "sowt", 4) ) { // uncompressed little-endian + if ( byteswap_ == false ) byteswap_ = true; + else byteswap_ = false; + } + if ( !strncmp(id, "NONE", 4) || !strncmp(id, "sowt", 4) ) { + if ( temp <= 8 ) dataType_ = STK_SINT8; + else if ( temp <= 16 ) dataType_ = STK_SINT16; + else if ( temp <= 24 ) dataType_ = STK_SINT24; + else if ( temp <= 32 ) dataType_ = STK_SINT32; + } + else if ( (!strncmp(id, "fl32", 4) || !strncmp(id, "FL32", 4)) && temp == 32 ) dataType_ = STK_FLOAT32; + else if ( (!strncmp(id, "fl64", 4) || !strncmp(id, "FL64", 4)) && temp == 64 ) dataType_ = STK_FLOAT64; + } + if ( dataType_ == 0 ) { + oStream_ << "FileRead: AIFF/AIFC file (" << fileName << ") has unsupported data type (" << id << ")."; + return false; + } + + // Start at top to find data (SSND) chunk ... chunk order is undefined. + if ( fseek(fd_, 12, SEEK_SET) == -1 ) goto error; + + // Find data (SSND) chunk + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + while ( strncmp(id, "SSND", 4) ) { + if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&chunkSize); +#endif + chunkSize += chunkSize % 2; // chunk sizes must be even + if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error; + if ( fread(&id, 4, 1, fd_) != 1 ) goto error; + } + + // Skip over chunk size, offset, and blocksize fields + if ( fseek(fd_, 12, SEEK_CUR) == -1 ) goto error; + + dataOffset_ = ftell(fd_); + return true; + + error: + oStream_ << "FileRead: Error reading AIFF file (" << fileName << ")."; + return false; +} + +bool FileRead :: findNextMatArray( SINT32 *chunkSize, SINT32 *rows, SINT32 *columns, SINT32 *nametype ) +{ + // Look for the next data array element. The file pointer should be + // at the data element type when this function is called. + SINT32 datatype; + *chunkSize = 0; + do { + if ( fseek(fd_, *chunkSize, SEEK_CUR) == -1 ) return false; + if ( fread(&datatype, 4, 1, fd_) != 1 ) return false; + if ( byteswap_ ) swap32((unsigned char *)&datatype); + if ( fread(chunkSize, 4, 1, fd_) != 1 ) return false; + if ( byteswap_ ) swap32((unsigned char *)chunkSize); + } while ( datatype != 14 ); + + // Check dimension subelement size to make sure 2D + if ( fseek(fd_, 20, SEEK_CUR) == -1 ) return false; + SINT32 size; + if ( fread(&size, 4, 1, fd_) != 1 ) return false; + if ( byteswap_ ) swap32((unsigned char *)&size); + if ( size != 8 ) return false; + + // Read dimensions data + if ( fread(rows, 4, 1, fd_) != 1 ) return false; + if ( byteswap_ ) swap32((unsigned char *)rows); + if ( fread(columns, 4, 1, fd_) != 1 ) return false; + if ( byteswap_ ) swap32((unsigned char *)columns); + + // Read array name subelement type + if ( fread(nametype, 4, 1, fd_) != 1 ) return false; + if ( byteswap_ ) swap32((unsigned char *)nametype); + + return true; +} + +bool FileRead :: getMatInfo( const char *fileName ) +{ + // MAT-file formatting information is available at: + // http://www.mathworks.com/access/helpdesk/help/pdf_doc/matlab/matfile_format.pdf + + // Verify this is a version 5 MAT-file format. + char head[5]; + if ( fseek(fd_, 0, SEEK_SET) == -1 ) goto error; + if ( fread(&head, 4, 1, fd_) != 1 ) goto error; + // If any of the first 4 characters of the header = 0, then this is + // a Version 4 MAT-file. + head[4] = '\0'; + if ( strstr(head, "0") ) { + oStream_ << "FileRead: " << fileName << " appears to be a Version 4 MAT-file, which is not currently supported."; + return false; + } + + // Determine the endian-ness of the file. + char mi[2]; + byteswap_ = false; + // Locate "M" and "I" characters in header. + if ( fseek(fd_, 126, SEEK_SET) == -1 ) goto error; + if ( fread(&mi, 2, 1, fd_) != 1) goto error; +#ifdef __LITTLE_ENDIAN__ + if ( !strncmp(mi, "MI", 2) ) + byteswap_ = true; + else if ( strncmp(mi, "IM", 2) ) goto error; +#else + if ( !strncmp(mi, "IM", 2)) + byteswap_ = true; + else if ( strncmp(mi, "MI", 2) ) goto error; +#endif + + // We are expecting a data element containing the audio data and an + // optional data element containing the sample rate (with an array + // name of "fs"). Both elements should be stored as a Matlab array + // type (14). + + bool doneParsing, haveData, haveSampleRate; + SINT32 chunkSize, rows, columns, nametype; + long dataoffset; + doneParsing = false; + haveData = false; + haveSampleRate = false; + while ( !doneParsing ) { + + dataoffset = ftell( fd_ ); // save location in file + if ( findNextMatArray( &chunkSize, &rows, &columns, &nametype ) == false ) { + // No more Matlab array type chunks found. + if ( !haveData ) { + oStream_ << "FileRead: No audio data found in MAT-file (" << fileName << ")."; + return false; + } + else if ( !haveSampleRate ) { + fileRate_ = 44100.0; + oStream_ << "FileRead: No sample rate found ... assuming 44100.0"; + handleError( StkError::WARNING ); + return true; + } + else return true; + } + + if ( !haveSampleRate && rows == 1 && columns == 1 ) { // Parse for sample rate. + + SINT32 namesize = 4; + if ( nametype == 1 ) { // array name > 4 characters + if ( fread(&namesize, 4, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap32((unsigned char *)&namesize); + if ( namesize != 2 ) goto tryagain; // expecting name = "fs" + namesize = 8; // field must be padded to multiple of 8 bytes + } + char name[3]; name[2] = '\0'; + if ( fread(&name, 2, 1, fd_) != 1) goto error; + if ( strncmp(name, "fs", 2) ) goto tryagain; + + // Jump to real part data subelement, which is likely to be in a + // small data format. + if ( fseek(fd_, namesize-2, SEEK_CUR) == -1 ) goto error; + UINT32 type; + StkFloat srate; + if ( fread(&type, 4, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap32((unsigned char *)&type); + if ( (type & 0xffff0000) != 0 ) // small data format + type = (type & 0x0000ffff); + else + if ( fseek(fd_, 4, SEEK_CUR) == -1 ) goto error; + if ( type == 1 ) { // SINT8 + signed char rate; + if ( fread(&rate, 1, 1, fd_) != 1 ) goto error; + srate = (StkFloat) rate; + } + else if ( type == 2 ) { // UINT8 + unsigned char rate; + if ( fread(&rate, 1, 1, fd_) != 1 ) goto error; + srate = (StkFloat) rate; + } + else if ( type == 3 ) { // SINT16 + SINT16 rate; + if ( fread(&rate, 2, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap16((unsigned char *)&rate); + srate = (StkFloat) rate; + } + else if ( type == 4 ) { // UINT16 + UINT16 rate; + if ( fread(&rate, 2, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap16((unsigned char *)&rate); + srate = (StkFloat) rate; + } + else if ( type == 5 ) { // SINT32 + SINT32 rate; + if ( fread(&rate, 4, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap32((unsigned char *)&rate); + srate = (StkFloat) rate; + } + else if ( type == 6 ) { // UINT32 + UINT32 rate; + if ( fread(&rate, 4, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap32((unsigned char *)&rate); + srate = (StkFloat) rate; + } + else if ( type == 7 ) { // FLOAT32 + FLOAT32 rate; + if ( fread(&rate, 4, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap32((unsigned char *)&rate); + srate = (StkFloat) rate; + } + else if ( type == 9 ) { // FLOAT64 + FLOAT64 rate; + if ( fread(&rate, 8, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap64((unsigned char *)&rate); + srate = (StkFloat) rate; + } + else + goto tryagain; + + if ( srate > 0 ) fileRate_ = srate; + haveSampleRate = true; + } + else if ( !haveData ) { // Parse for data. + + // Assume channels = smaller of rows or columns. + if ( rows < columns ) { + channels_ = rows; + fileSize_ = columns; + } + else { + oStream_ << "FileRead: Transpose the MAT-file array so that audio channels fill matrix rows (not columns)."; + return false; + } + + SINT32 namesize = 4; + if ( nametype == 1 ) { // array name > 4 characters + if ( fread(&namesize, 4, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap32((unsigned char *)&namesize); + namesize = (SINT32) ceil((float)namesize / 8); + if ( fseek( fd_, namesize*8, SEEK_CUR) == -1 ) goto error; // jump over array name + } + else { + if ( fseek( fd_, 4, SEEK_CUR ) == -1 ) goto error; + } + + // Now at real part data subelement + SINT32 type; + if ( fread(&type, 4, 1, fd_) != 1 ) goto error; + if ( byteswap_ ) swap32((unsigned char *)&type); + if ( type == 1 ) dataType_ = STK_SINT8; + else if ( type == 3 ) dataType_ = STK_SINT16; + else if ( type == 5 ) dataType_ = STK_SINT32; + else if ( type == 7 ) dataType_ = STK_FLOAT32; + else if ( type == 9 ) dataType_ = STK_FLOAT64; + else { + oStream_ << "FileRead: The MAT-file array data format (" << type << ") is not supported."; + return false; + } + + // Jump to the data. + if ( fseek(fd_, 4, SEEK_CUR) == -1 ) goto error; + dataOffset_ = ftell(fd_); + haveData = true; + } + + tryagain: + if ( haveData && haveSampleRate ) doneParsing = true; + else // jump to end of data element and keep trying + if ( fseek( fd_, dataoffset+chunkSize+8, SEEK_SET) == -1 ) goto error; + } + + return true; + + error: + oStream_ << "FileRead: Error reading MAT-file (" << fileName << ") header."; + return false; +} + +void FileRead :: read( StkFrames& buffer, unsigned long startFrame, bool doNormalize ) +{ + // Make sure we have an open file. + if ( fd_ == 0 ) { + oStream_ << "FileRead::read: a file is not open!"; + Stk::handleError( StkError::WARNING ); return; + } + + // Check the buffer size. + unsigned long nFrames = buffer.frames(); + if ( nFrames == 0 ) { + oStream_ << "FileRead::read: StkFrames buffer size is zero ... no data read!"; + Stk::handleError( StkError::WARNING ); return; + } + + if ( buffer.channels() != channels_ ) { + oStream_ << "FileRead::read: StkFrames argument has incompatible number of channels!"; + Stk::handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( startFrame >= fileSize_ ) { + oStream_ << "FileRead::read: startFrame argument is greater than or equal to the file size!"; + Stk::handleError( StkError::FUNCTION_ARGUMENT ); + } + + // Check for file end. + if ( startFrame + nFrames > fileSize_ ) + nFrames = fileSize_ - startFrame; + + long i, nSamples = (long) ( nFrames * channels_ ); + unsigned long offset = startFrame * channels_; + + // Read samples into StkFrames data buffer. + if ( dataType_ == STK_SINT16 ) { + SINT16 *buf = (SINT16 *) &buffer[0]; + if ( fseek( fd_, dataOffset_+(offset*2), SEEK_SET ) == -1 ) goto error; + if ( fread( buf, nSamples * 2, 1, fd_ ) != 1 ) goto error; + if ( byteswap_ ) { + SINT16 *ptr = buf; + for ( i=nSamples-1; i>=0; i-- ) + swap16( (unsigned char *) ptr++ ); + } + if ( doNormalize ) { + StkFloat gain = 1.0 / 32768.0; + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i] * gain; + } + else { + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i]; + } + } + else if ( dataType_ == STK_SINT32 ) { + SINT32 *buf = (SINT32 *) &buffer[0]; + if ( fseek( fd_, dataOffset_+(offset*4 ), SEEK_SET ) == -1 ) goto error; + if ( fread( buf, nSamples * 4, 1, fd_ ) != 1 ) goto error; + if ( byteswap_ ) { + SINT32 *ptr = buf; + for ( i=nSamples-1; i>=0; i-- ) + swap32( (unsigned char *) ptr++ ); + } + if ( doNormalize ) { + StkFloat gain = 1.0 / 2147483648.0; + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i] * gain; + } + else { + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i]; + } + } + else if ( dataType_ == STK_FLOAT32 ) { + FLOAT32 *buf = (FLOAT32 *) &buffer[0]; + if ( fseek( fd_, dataOffset_+(offset*4), SEEK_SET ) == -1 ) goto error; + if ( fread( buf, nSamples * 4, 1, fd_ ) != 1 ) goto error; + if ( byteswap_ ) { + FLOAT32 *ptr = buf; + for ( i=nSamples-1; i>=0; i-- ) + swap32( (unsigned char *) ptr++ ); + } + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i]; + } + else if ( dataType_ == STK_FLOAT64 ) { + FLOAT64 *buf = (FLOAT64 *) &buffer[0]; + if ( fseek( fd_, dataOffset_+(offset*8), SEEK_SET ) == -1 ) goto error; + if ( fread( buf, nSamples * 8, 1, fd_ ) != 1 ) goto error; + if ( byteswap_ ) { + FLOAT64 *ptr = buf; + for ( i=nSamples-1; i>=0; i-- ) + swap64( (unsigned char *) ptr++ ); + } + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i]; + } + else if ( dataType_ == STK_SINT8 && wavFile_ ) { // 8-bit WAV data is unsigned! + unsigned char *buf = (unsigned char *) &buffer[0]; + if ( fseek( fd_, dataOffset_+offset, SEEK_SET ) == -1 ) goto error; + if ( fread( buf, nSamples, 1, fd_) != 1 ) goto error; + if ( doNormalize ) { + StkFloat gain = 1.0 / 128.0; + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = ( buf[i] - 128 ) * gain; + } + else { + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i] - 128.0; + } + } + else if ( dataType_ == STK_SINT8 ) { // signed 8-bit data + char *buf = (char *) &buffer[0]; + if ( fseek( fd_, dataOffset_+offset, SEEK_SET ) == -1 ) goto error; + if ( fread( buf, nSamples, 1, fd_ ) != 1 ) goto error; + if ( doNormalize ) { + StkFloat gain = 1.0 / 128.0; + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i] * gain; + } + else { + for ( i=nSamples-1; i>=0; i-- ) + buffer[i] = buf[i]; + } + } + else if ( dataType_ == STK_SINT24 ) { + // 24-bit values are harder to import efficiently since there is + // no native 24-bit type. The following routine works but is much + // less efficient than that used for the other data types. + SINT32 temp; + unsigned char *ptr = (unsigned char *) &temp; + StkFloat gain = 1.0 / 2147483648.0; + if ( fseek(fd_, dataOffset_+(offset*3), SEEK_SET ) == -1 ) goto error; + for ( i=0; i +#include +#include +#include + +namespace stk { + +const FileWrite::FILE_TYPE FileWrite :: FILE_RAW = 1; +const FileWrite::FILE_TYPE FileWrite :: FILE_WAV = 2; +const FileWrite::FILE_TYPE FileWrite :: FILE_SND = 3; +const FileWrite::FILE_TYPE FileWrite :: FILE_AIF = 4; +const FileWrite::FILE_TYPE FileWrite :: FILE_MAT = 5; + +// WAV header structure. See +// http://www-mmsp.ece.mcgill.ca/documents/audioformats/WAVE/Docs/rfc2361.txt +// for information regarding format codes. +struct WaveHeader { + char riff[4]; // "RIFF" + SINT32 fileSize; // in bytes + char wave[4]; // "WAVE" + char fmt[4]; // "fmt " + SINT32 chunkSize; // in bytes (16 for PCM) + SINT16 formatCode; // 1=PCM, 2=ADPCM, 3=IEEE float, 6=A-Law, 7=Mu-Law + SINT16 nChannels; // 1=mono, 2=stereo + SINT32 sampleRate; + SINT32 bytesPerSecond; + SINT16 bytesPerSample; // 2=16-bit mono, 4=16-bit stereo + SINT16 bitsPerSample; + SINT16 cbSize; // size of extension + SINT16 validBits; // valid bits per sample + SINT32 channelMask; // speaker position mask + char subformat[16]; // format code and GUID + char fact[4]; // "fact" + SINT32 factSize; // fact chunk size + SINT32 frames; // sample frames +}; + +// SND (AU) header structure (NeXT and Sun). +struct SndHeader { + char pref[4]; + SINT32 headerBytes; + SINT32 dataBytes; + SINT32 format; + SINT32 sampleRate; + SINT32 nChannels; + char comment[16]; +}; + +// AIFF/AIFC header structure ... only the part common to both +// formats. +struct AifHeader { + char form[4]; // "FORM" + SINT32 formSize; // in bytes + char aiff[4]; // "AIFF" or "AIFC" + char comm[4]; // "COMM" + SINT32 commSize; // "COMM" chunk size (18 for AIFF, 24 for AIFC) + SINT16 nChannels; // number of channels + unsigned long sampleFrames; // sample frames of audio data + SINT16 sampleSize; // in bits + unsigned char srate[10]; // IEEE 754 floating point format +}; + +struct AifSsnd { + char ssnd[4]; // "SSND" + SINT32 ssndSize; // "SSND" chunk size + unsigned long offset; // data offset in data block (should be 0) + unsigned long blockSize; // not used by STK (should be 0) +}; + +// MAT-file 5 header structure. +struct MatHeader { + char heading[124]; // Header text field + SINT16 hff[2]; // Header flag fields + SINT32 fs[16]; // Sample rate data element + SINT32 adf[11]; // Array data format fields + // There's more, but it's of variable length +}; + +FileWrite :: FileWrite() + : fd_( 0 ) +{ +} + +FileWrite::FileWrite( std::string fileName, unsigned int nChannels, FILE_TYPE type, Stk::StkFormat format ) + : fd_( 0 ) +{ + this->open( fileName, nChannels, type, format ); +} + +FileWrite :: ~FileWrite() +{ + this->close(); +} + +void FileWrite :: close( void ) +{ + if ( fd_ == 0 ) return; + + if ( fileType_ == FILE_RAW ) + fclose( fd_ ); + else if ( fileType_ == FILE_WAV ) + this->closeWavFile(); + else if ( fileType_ == FILE_SND ) + this->closeSndFile(); + else if ( fileType_ == FILE_AIF ) + this->closeAifFile(); + else if ( fileType_ == FILE_MAT ) + this->closeMatFile(); + + fd_ = 0; +} + +bool FileWrite :: isOpen( void ) +{ + if ( fd_ ) return true; + else return false; +} + +void FileWrite :: open( std::string fileName, unsigned int nChannels, FileWrite::FILE_TYPE type, Stk::StkFormat format ) +{ + // Call close() in case another file is already open. + this->close(); + + if ( nChannels < 1 ) { + oStream_ << "FileWrite::open: then channels argument must be greater than zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + channels_ = nChannels; + fileType_ = type; + + if ( format != STK_SINT8 && format != STK_SINT16 && + format != STK_SINT24 && format != STK_SINT32 && + format != STK_FLOAT32 && format != STK_FLOAT64 ) { + oStream_ << "FileWrite::open: unknown data type (" << format << ") specified!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + dataType_ = format; + + bool result = false; + if ( fileType_ == FILE_RAW ) { + if ( channels_ != 1 ) { + oStream_ << "FileWrite::open: STK RAW files are, by definition, always monaural (channels = " << nChannels << " not supported)!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + result = setRawFile( fileName ); + } + else if ( fileType_ == FILE_WAV ) + result = setWavFile( fileName ); + else if ( fileType_ == FILE_SND ) + result = setSndFile( fileName ); + else if ( fileType_ == FILE_AIF ) + result = setAifFile( fileName ); + else if ( fileType_ == FILE_MAT ) + result = setMatFile( fileName ); + else { + oStream_ << "FileWrite::open: unknown file type (" << fileType_ << ") specified!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( result == false ) + handleError( StkError::FILE_ERROR ); + + frameCounter_ = 0; +} + +bool FileWrite :: setRawFile( std::string fileName ) +{ + if ( fileName.find( ".raw" ) == std::string::npos ) fileName += ".raw"; + fd_ = fopen( fileName.c_str(), "wb" ); + if ( !fd_ ) { + oStream_ << "FileWrite: could not create RAW file: " << fileName << '.'; + return false; + } + + if ( dataType_ != STK_SINT16 ) { + dataType_ = STK_SINT16; + oStream_ << "FileWrite: using 16-bit signed integer data format for file " << fileName << '.'; + handleError( StkError::WARNING ); + } + + byteswap_ = false; +#ifdef __LITTLE_ENDIAN__ + byteswap_ = true; +#endif + + oStream_ << "FileWrite: creating RAW file: " << fileName; + handleError( StkError::STATUS ); + return true; +} + +bool FileWrite :: setWavFile( std::string fileName ) +{ + if ( fileName.find( ".wav" ) == std::string::npos ) fileName += ".wav"; + fd_ = fopen( fileName.c_str(), "wb" ); + if ( !fd_ ) { + oStream_ << "FileWrite: could not create WAV file: " << fileName; + return false; + } + + struct WaveHeader hdr = { {'R','I','F','F'}, 44, {'W','A','V','E'}, {'f','m','t',' '}, 16, 1, 1, + (SINT32) Stk::sampleRate(), 0, 2, 16, 0, 0, 0, + {'\x01','\x00','\x00','\x00','\x00','\x00','\x10','\x00','\x80','\x00','\x00','\xAA','\x00','\x38','\x9B','\x71'}, + {'f','a','c','t'}, 4, 0 }; + hdr.nChannels = (SINT16) channels_; + if ( dataType_ == STK_SINT8 ) + hdr.bitsPerSample = 8; + else if ( dataType_ == STK_SINT16 ) + hdr.bitsPerSample = 16; + else if ( dataType_ == STK_SINT24 ) + hdr.bitsPerSample = 24; + else if ( dataType_ == STK_SINT32 ) + hdr.bitsPerSample = 32; + else if ( dataType_ == STK_FLOAT32 ) { + hdr.formatCode = 3; + hdr.bitsPerSample = 32; + } + else if ( dataType_ == STK_FLOAT64 ) { + hdr.formatCode = 3; + hdr.bitsPerSample = 64; + } + hdr.bytesPerSample = (SINT16) (channels_ * hdr.bitsPerSample / 8); + hdr.bytesPerSecond = (SINT32) (hdr.sampleRate * hdr.bytesPerSample); + + unsigned int bytesToWrite = 36; + if ( channels_ > 2 || hdr.bitsPerSample > 16 ) { // use extensible format + bytesToWrite = 72; + hdr.chunkSize += 24; + hdr.formatCode = 0xFFFE; + hdr.cbSize = 22; + hdr.validBits = hdr.bitsPerSample; + SINT16 *subFormat = (SINT16 *)&hdr.subformat[0]; + if ( dataType_ == STK_FLOAT32 || dataType_ == STK_FLOAT64 ) + *subFormat = 3; + else *subFormat = 1; + } + + byteswap_ = false; +#ifndef __LITTLE_ENDIAN__ + byteswap_ = true; + swap32((unsigned char *)&hdr.chunkSize); + swap16((unsigned char *)&hdr.formatCode); + swap16((unsigned char *)&hdr.nChannels); + swap32((unsigned char *)&hdr.sampleRate); + swap32((unsigned char *)&hdr.bytesPerSecond); + swap16((unsigned char *)&hdr.bytesPerSample); + swap16((unsigned char *)&hdr.bitsPerSample); + swap16((unsigned char *)&hdr.cbSize); + swap16((unsigned char *)&hdr.validBits); + swap16((unsigned char *)&hdr.subformat[0]); + swap32((unsigned char *)&hdr.factSize); +#endif + + char data[4] = {'d','a','t','a'}; + SINT32 dataSize = 0; + if ( fwrite(&hdr, 1, bytesToWrite, fd_) != bytesToWrite ) goto error; + if ( fwrite(&data, 4, 1, fd_) != 1 ) goto error; + if ( fwrite(&dataSize, 4, 1, fd_) != 1 ) goto error; + + oStream_ << "FileWrite: creating WAV file: " << fileName; + handleError( StkError::STATUS ); + return true; + + error: + oStream_ << "FileWrite: could not write WAV header for file: " << fileName; + return false; +} + +void FileWrite :: closeWavFile( void ) +{ + int bytesPerSample = 1; + if ( dataType_ == STK_SINT16 ) + bytesPerSample = 2; + else if ( dataType_ == STK_SINT24 ) + bytesPerSample = 3; + else if ( dataType_ == STK_SINT32 || dataType_ == STK_FLOAT32 ) + bytesPerSample = 4; + else if ( dataType_ == STK_FLOAT64 ) + bytesPerSample = 8; + + bool useExtensible = false; + int dataLocation = 40; + if ( bytesPerSample > 2 || channels_ > 2 ) { + useExtensible = true; + dataLocation = 76; + } + + SINT32 bytes = (SINT32) (frameCounter_ * channels_ * bytesPerSample); + if ( bytes % 2 ) { // pad extra byte if odd + signed char sample = 0; + fwrite( &sample, 1, 1, fd_ ); + } +#ifndef __LITTLE_ENDIAN__ + swap32((unsigned char *)&bytes); +#endif + fseek( fd_, dataLocation, SEEK_SET ); // jump to data length + fwrite( &bytes, 4, 1, fd_ ); + + bytes = (SINT32) (frameCounter_ * channels_ * bytesPerSample + 44); + if ( useExtensible ) bytes += 36; +#ifndef __LITTLE_ENDIAN__ + swap32((unsigned char *)&bytes); +#endif + fseek( fd_, 4, SEEK_SET ); // jump to file size + fwrite( &bytes, 4, 1, fd_ ); + + if ( useExtensible ) { // fill in the "fact" chunk frames value + bytes = (SINT32) frameCounter_; +#ifndef __LITTLE_ENDIAN__ + swap32((unsigned char *)&bytes); +#endif + fseek( fd_, 68, SEEK_SET ); + fwrite( &bytes, 4, 1, fd_ ); + } + + fclose( fd_ ); +} + +bool FileWrite :: setSndFile( std::string fileName ) +{ + std::string name( fileName ); + if ( fileName.find( ".snd" ) == std::string::npos ) fileName += ".snd"; + fd_ = fopen( fileName.c_str(), "wb" ); + if ( !fd_ ) { + oStream_ << "FileWrite: could not create SND file: " << fileName; + return false; + } + + struct SndHeader hdr = {".sn", 40, 0, 3, (SINT32) Stk::sampleRate(), 1, "Created by STK"}; + hdr.pref[3] = 'd'; + hdr.nChannels = channels_; + if ( dataType_ == STK_SINT8 ) + hdr.format = 2; + else if ( dataType_ == STK_SINT16 ) + hdr.format = 3; + else if ( dataType_ == STK_SINT24 ) + hdr.format = 4; + else if ( dataType_ == STK_SINT32 ) + hdr.format = 5; + else if ( dataType_ == STK_FLOAT32 ) + hdr.format = 6; + else if ( dataType_ == STK_FLOAT64 ) + hdr.format = 7; + + byteswap_ = false; +#ifdef __LITTLE_ENDIAN__ + byteswap_ = true; + swap32 ((unsigned char *)&hdr.headerBytes); + swap32 ((unsigned char *)&hdr.format); + swap32 ((unsigned char *)&hdr.sampleRate); + swap32 ((unsigned char *)&hdr.nChannels); +#endif + + if ( fwrite(&hdr, 4, 10, fd_) != 10 ) { + oStream_ << "FileWrite: Could not write SND header for file " << fileName << '.'; + return false; + } + + oStream_ << "FileWrite: creating SND file: " << fileName; + handleError( StkError::STATUS ); + return true; +} + +void FileWrite :: closeSndFile( void ) +{ + int bytesPerSample = 1; + if ( dataType_ == STK_SINT16 ) + bytesPerSample = 2; + else if ( dataType_ == STK_SINT24 ) + bytesPerSample = 3; + else if ( dataType_ == STK_SINT32 ) + bytesPerSample = 4; + else if ( dataType_ == STK_FLOAT32 ) + bytesPerSample = 4; + else if ( dataType_ == STK_FLOAT64 ) + bytesPerSample = 8; + + SINT32 bytes = (SINT32) (frameCounter_ * bytesPerSample * channels_); +#ifdef __LITTLE_ENDIAN__ + swap32 ((unsigned char *)&bytes); +#endif + fseek(fd_, 8, SEEK_SET); // jump to data size + fwrite(&bytes, 4, 1, fd_); + fclose(fd_); +} + +bool FileWrite :: setAifFile( std::string fileName ) +{ + std::string name( fileName ); + if ( fileName.find( ".aif" ) == std::string::npos ) fileName += ".aif"; + fd_ = fopen( fileName.c_str(), "wb" ); + if ( !fd_ ) { + oStream_ << "FileWrite: could not create AIF file: " << fileName; + return false; + } + + // Common parts of AIFF/AIFC header. + struct AifHeader hdr = {{'F','O','R','M'}, 46, {'A','I','F','F'}, {'C','O','M','M'}, 18, 0, 0, 16, "0"}; + struct AifSsnd ssnd = {{'S','S','N','D'}, 8, 0, 0}; + hdr.nChannels = channels_; + if ( dataType_ == STK_SINT8 ) + hdr.sampleSize = 8; + else if ( dataType_ == STK_SINT16 ) + hdr.sampleSize = 16; + else if ( dataType_ == STK_SINT24 ) + hdr.sampleSize = 24; + else if ( dataType_ == STK_SINT32 ) + hdr.sampleSize = 32; + else if ( dataType_ == STK_FLOAT32 ) { + hdr.aiff[3] = 'C'; + hdr.sampleSize = 32; + hdr.commSize = 24; + } + else if ( dataType_ == STK_FLOAT64 ) { + hdr.aiff[3] = 'C'; + hdr.sampleSize = 64; + hdr.commSize = 24; + } + + // For AIFF files, the sample rate is stored in a 10-byte, + // IEEE Standard 754 floating point number, so we need to + // convert to that. + SINT16 i; + unsigned long exp; + unsigned long rate = (unsigned long) Stk::sampleRate(); + memset( hdr.srate, 0, 10 ); + exp = rate; + for ( i=0; i<32; i++ ) { + exp >>= 1; + if ( !exp ) break; + } + i += 16383; +#ifdef __LITTLE_ENDIAN__ + swap16((unsigned char *)&i); +#endif + memcpy( hdr.srate, &i, sizeof(SINT16) ); + + for ( i=32; i; i-- ) { + if ( rate & 0x80000000 ) break; + rate <<= 1; + } + +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&rate); +#endif + memcpy( hdr.srate + 2, &rate, sizeof(rate) ); + + byteswap_ = false; +#ifdef __LITTLE_ENDIAN__ + byteswap_ = true; + swap32((unsigned char *)&hdr.formSize); + swap32((unsigned char *)&hdr.commSize); + swap16((unsigned char *)&hdr.nChannels); + swap16((unsigned char *)&hdr.sampleSize); + swap32((unsigned char *)&ssnd.ssndSize); + swap32((unsigned char *)&ssnd.offset); + swap32((unsigned char *)&ssnd.blockSize); +#endif + + // The structure boundaries don't allow a single write of 54 bytes. + if ( fwrite(&hdr, 4, 5, fd_) != 5 ) goto error; + if ( fwrite(&hdr.nChannels, 2, 1, fd_) != 1 ) goto error; + if ( fwrite(&hdr.sampleFrames, 4, 1, fd_) != 1 ) goto error; + if ( fwrite(&hdr.sampleSize, 2, 1, fd_) != 1 ) goto error; + if ( fwrite(&hdr.srate, 10, 1, fd_) != 1 ) goto error; + + if ( dataType_ == STK_FLOAT32 ) { + char type[4] = {'f','l','3','2'}; + char zeroes[2] = { 0, 0 }; + if ( fwrite(&type, 4, 1, fd_) != 1 ) goto error; + if ( fwrite(&zeroes, 2, 1, fd_) != 1 ) goto error; + } + else if ( dataType_ == STK_FLOAT64 ) { + char type[4] = {'f','l','6','4'}; + char zeroes[2] = { 0, 0 }; + if ( fwrite(&type, 4, 1, fd_) != 1 ) goto error; + if ( fwrite(&zeroes, 2, 1, fd_) != 1 ) goto error; + } + + if ( fwrite(&ssnd, 4, 4, fd_) != 4 ) goto error; + + oStream_ << "FileWrite: creating AIF file: " << fileName; + handleError( StkError::STATUS ); + return true; + + error: + oStream_ << "FileWrite: could not write AIF header for file: " << fileName; + return false; +} + +void FileWrite :: closeAifFile( void ) +{ + unsigned long frames = (unsigned long) frameCounter_; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&frames); +#endif + fseek(fd_, 22, SEEK_SET); // jump to "COMM" sampleFrames + fwrite(&frames, 4, 1, fd_); + + int bytesPerSample = 1; + if ( dataType_ == STK_SINT16 ) + bytesPerSample = 2; + if ( dataType_ == STK_SINT24 ) + bytesPerSample = 3; + else if ( dataType_ == STK_SINT32 || dataType_ == STK_FLOAT32 ) + bytesPerSample = 4; + else if ( dataType_ == STK_FLOAT64 ) + bytesPerSample = 8; + + unsigned long bytes = frameCounter_ * bytesPerSample * channels_ + 46; + if ( dataType_ == STK_FLOAT32 || dataType_ == STK_FLOAT64 ) bytes += 6; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&bytes); +#endif + fseek(fd_, 4, SEEK_SET); // jump to file size + fwrite(&bytes, 4, 1, fd_); + + bytes = frameCounter_ * bytesPerSample * channels_ + 8; + if ( dataType_ == STK_FLOAT32 || dataType_ == STK_FLOAT64 ) bytes += 6; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&bytes); +#endif + if ( dataType_ == STK_FLOAT32 || dataType_ == STK_FLOAT64 ) + fseek(fd_, 48, SEEK_SET); // jump to "SSND" chunk size + else + fseek(fd_, 42, SEEK_SET); // jump to "SSND" chunk size + fwrite(&bytes, 4, 1, fd_); + + fclose( fd_ ); +} + +bool FileWrite :: setMatFile( std::string fileName ) +{ + if ( fileName.find( ".mat" ) == std::string::npos ) fileName += ".mat"; + fd_ = fopen( fileName.c_str(), "w+b" ); + if ( !fd_ ) { + oStream_ << "FileWrite: could not create MAT file: " << fileName; + return false; + } + + if ( dataType_ != STK_FLOAT64 ) { + dataType_ = STK_FLOAT64; + oStream_ << "FileWrite: using 64-bit floating-point data format for file " << fileName << '.'; + handleError( StkError::DEBUG_PRINT ); + } + + struct MatHeader hdr; + strcpy( hdr.heading,"MATLAB 5.0 MAT-file, Generated using the Synthesis ToolKit in C++ (STK). By Perry R. Cook and Gary P. Scavone." ); + for ( size_t i =strlen(hdr.heading); i<124; i++ ) hdr.heading[i] = ' '; + + // Header Flag Fields + hdr.hff[0] = (SINT16) 0x0100; // Version field + hdr.hff[1] = (SINT16) 'M'; // Endian indicator field ("MI") + hdr.hff[1] <<= 8; + hdr.hff[1] += 'I'; + + // Write sample rate in array data element + hdr.fs[0] = (SINT32) 14; // Matlab array data type value + hdr.fs[1] = (SINT32) 56; // Size of data element to follow (in bytes) + + // Numeric Array Subelements (4): + // 1. Array Flags + hdr.fs[2] = (SINT32) 6; // Matlab 32-bit unsigned integer data type value + hdr.fs[3] = (SINT32) 8; // 8 bytes of data to follow + hdr.fs[4] = (SINT32) 6; // Double-precision array, no array flags set + hdr.fs[5] = (SINT32) 0; // 4 bytes undefined + // 2. Array Dimensions + hdr.fs[6] = (SINT32) 5; // Matlab 32-bit signed integer data type value + hdr.fs[7] = (SINT32) 8; // 8 bytes of data to follow (2D array) + hdr.fs[8] = (SINT32) 1; // 1 row + hdr.fs[9] = (SINT32) 1; // 1 column + // 3. Array Name (small data format element) + hdr.fs[10] = 0x00020001; + hdr.fs[11] = 's' << 8; + hdr.fs[11] += 'f'; + // 4. Real Part + hdr.fs[12] = 9; // Matlab IEEE 754 double data type + hdr.fs[13] = 8; // 8 bytes of data to follow + FLOAT64 *sampleRate = (FLOAT64 *)&hdr.fs[14]; + *sampleRate = (FLOAT64) Stk::sampleRate(); + + // Write audio samples in array data element + hdr.adf[0] = (SINT32) 14; // Matlab array data type value + hdr.adf[1] = (SINT32) 0; // Size of file after this point to end (in bytes) + + // Numeric Array Subelements (4): + // 1. Array Flags + hdr.adf[2] = (SINT32) 6; // Matlab 32-bit unsigned integer data type value + hdr.adf[3] = (SINT32) 8; // 8 bytes of data to follow + hdr.adf[4] = (SINT32) 6; // Double-precision array, no array flags set + hdr.adf[5] = (SINT32) 0; // 4 bytes undefined + // 2. Array Dimensions + hdr.adf[6] = (SINT32) 5; // Matlab 32-bit signed integer data type value + hdr.adf[7] = (SINT32) 8; // 8 bytes of data to follow (2D array) + hdr.adf[8] = (SINT32) channels_; // This is the number of rows + hdr.adf[9] = (SINT32) 0; // This is the number of columns + + // 3. Array Name We'll use fileName for the matlab array name (as + // well as the file name), though we might need to strip off a + // leading directory path. If fileName is 4 characters or less, we + // have to use a small data format element for the array name data + // element. Otherwise, the array name must be formatted in 8-byte + // increments (up to 31 characters + NULL). + std::string name = fileName; + size_t found; + found = name.find_last_of("/\\"); + name = name.substr(found+1); + SINT32 namelength = (SINT32) name.size() - 4; // strip off the ".mat" extension + if ( namelength > 31 ) namelength = 31; // Truncate name to 31 characters. + if ( namelength > 4 ) { + hdr.adf[10] = (SINT32) 1; // Matlab 8-bit signed integer data type value + } + else { // Compressed data element format + hdr.adf[10] = (namelength << 16) + 1; + } + + SINT32 headsize = 40; // Number of bytes in audio data element so far. + + // Write the fixed portion of the header + if ( fwrite(&hdr, 236, 1, fd_) != 1 ) goto error; + + // Write MATLAB array name + SINT32 tmp; + if ( namelength > 4 ) { + if ( fwrite(&namelength, 4, 1, fd_) != 1) goto error; + if ( fwrite(name.c_str(), namelength, 1, fd_) != 1 ) goto error; + tmp = (SINT32) ceil((float)namelength / 8); + if ( fseek(fd_, tmp*8-namelength, SEEK_CUR) == -1 ) goto error; + headsize += tmp * 8; + } + else { // Compressed data element format + if ( fwrite(name.c_str(), namelength, 1, fd_) != 1 ) goto error; + tmp = 4 - namelength; + if ( fseek(fd_, tmp, SEEK_CUR) == -1 ) goto error; + } + + // Finish writing known header information + //4. Real Part + tmp = 9; // Matlab IEEE 754 double data type + if ( fwrite(&tmp, 4, 1, fd_) != 1 ) goto error; + tmp = 0; // Size of real part subelement in bytes (8 per sample) + if ( fwrite(&tmp, 4, 1, fd_) != 1 ) goto error; + headsize += 8; // Total number of bytes in data element so far + + if ( fseek(fd_, 196, SEEK_SET) == -1 ) goto error; + if ( fwrite(&headsize, 4, 1, fd_) != 1 ) goto error; // Write header size ... will update at end + if ( fseek(fd_, 0, SEEK_END) == -1 ) goto error; + + byteswap_ = false; + oStream_ << "FileWrite: creating MAT-file: " << fileName; + handleError( StkError::STATUS ); + + return true; + + error: + oStream_ << "FileWrite: could not write MAT-file header for file " << fileName << '.'; + return false; +} + +void FileWrite :: closeMatFile( void ) +{ + fseek(fd_, 228, SEEK_SET); // jump to number of columns + fwrite(&frameCounter_, 4, 1, fd_); + + SINT32 headsize, temp; + fseek(fd_, 196, SEEK_SET); // jump to header size + if (fread(&headsize, 4, 1, fd_) != 1) { + oStream_ << "FileWrite: could not read MAT-file header size."; + handleError( StkError::WARNING ); + goto close_file; + } + + temp = headsize; + headsize += (SINT32) (frameCounter_ * 8 * channels_); + fseek(fd_, 196, SEEK_SET); + // Write file size (minus some header info) + fwrite(&headsize, 4, 1, fd_); + + fseek(fd_, temp+196, SEEK_SET); // jump to data size (in bytes) + temp = (SINT32) (frameCounter_ * 8 * channels_); + fwrite(&temp, 4, 1, fd_); + +close_file: + fclose(fd_); +} + +void FileWrite :: write( StkFrames& buffer ) +{ + if ( fd_ == 0 ) { + oStream_ << "FileWrite::write(): a file has not yet been opened!"; + handleError( StkError::WARNING ); + return; + } + + if ( buffer.channels() != channels_ ) { + oStream_ << "FileWrite::write(): number of channels in the StkFrames argument does not match that specified to open() function!"; + handleError( StkError::FUNCTION_ARGUMENT ); + return; + } + + unsigned long nSamples = buffer.size(); + if ( dataType_ == STK_SINT16 ) { + SINT16 sample; + for ( unsigned long k=0; k + +namespace stk { + +FileWvIn :: FileWvIn( unsigned long chunkThreshold, unsigned long chunkSize ) + : finished_(true), interpolate_(false), time_(0.0), rate_(0.0), + chunkThreshold_(chunkThreshold), chunkSize_(chunkSize) +{ + Stk::addSampleRateAlert( this ); +} + +FileWvIn :: FileWvIn( std::string fileName, bool raw, bool doNormalize, + unsigned long chunkThreshold, unsigned long chunkSize, + bool doInt2FloatScaling ) + : finished_(true), interpolate_(false), time_(0.0), rate_(0.0), + chunkThreshold_(chunkThreshold), chunkSize_(chunkSize) +{ + openFile( fileName, raw, doNormalize, doInt2FloatScaling ); + Stk::addSampleRateAlert( this ); +} + +FileWvIn :: ~FileWvIn() +{ + this->closeFile(); + Stk::removeSampleRateAlert( this ); +} + +void FileWvIn :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) + this->setRate( oldRate * rate_ / newRate ); +} + +void FileWvIn :: closeFile( void ) +{ + if ( file_.isOpen() ) file_.close(); + finished_ = true; + lastFrame_.resize( 0, 0 ); +} + +void FileWvIn :: openFile( std::string fileName, bool raw, bool doNormalize, bool doInt2FloatScaling ) +{ + // Call close() in case another file is already open. + this->closeFile(); + + // Attempt to open the file ... an error might be thrown here. + file_.open( fileName, raw ); + + // Determine whether chunking or not. + if ( file_.fileSize() > chunkThreshold_ ) { + chunking_ = true; + chunkPointer_ = 0; + data_.resize( chunkSize_, file_.channels() ); + } + else { + chunking_ = false; + data_.resize( (size_t) file_.fileSize(), file_.channels() ); + } + + if ( doInt2FloatScaling ) + int2floatscaling_ = true; + else + int2floatscaling_ = false; + + // Load all or part of the data. + file_.read( data_, 0, int2floatscaling_ ); + + // Resize our lastFrame container. + lastFrame_.resize( 1, file_.channels() ); + + // Close the file unless chunking + fileSize_ = file_.fileSize(); + if ( !chunking_ ) file_.close(); + + // Set default rate based on file sampling rate. + this->setRate( data_.dataRate() / Stk::sampleRate() ); + + if ( doNormalize & !chunking_ ) this->normalize(); + + this->reset(); +} + +void FileWvIn :: reset(void) +{ + time_ = (StkFloat) 0.0; + for ( unsigned int i=0; inormalize( 1.0 ); +} + +// Normalize all channels equally by the greatest magnitude in all of the data. +void FileWvIn :: normalize( StkFloat peak ) +{ + // When chunking, the "normalization" scaling is performed by FileRead. + if ( chunking_ ) return; + + size_t i; + StkFloat max = 0.0; + + for ( i=0; i max ) + max = (StkFloat) fabs((double) data_[i]); + } + + if ( max > 0.0 ) { + max = 1.0 / max; + max *= peak; + for ( i=0; i fileSize_ - 1.0 ) { + time_ = fileSize_ - 1.0; + for ( unsigned int i=0; i= data_.channels() ) { + oStream_ << "FileWvIn::tick(): channel argument and soundfile data are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + if ( finished_ ) return 0.0; + + if ( time_ < 0.0 || time_ > (StkFloat) ( fileSize_ - 1.0 ) ) { + for ( unsigned int i=0; i (StkFloat) ( chunkPointer_ + chunkSize_ - 1 ) ) ) { + + while ( time_ < (StkFloat) chunkPointer_ ) { // negative rate + chunkPointer_ -= chunkSize_ - 1; // overlap chunks by one frame + if ( chunkPointer_ < 0 ) chunkPointer_ = 0; + } + while ( time_ > (StkFloat) ( chunkPointer_ + chunkSize_ - 1 ) ) { // positive rate + chunkPointer_ += chunkSize_ - 1; // overlap chunks by one frame + if ( chunkPointer_ + chunkSize_ > fileSize_ ) // at end of file + chunkPointer_ = fileSize_ - chunkSize_; + } + + // Load more data. + file_.read( data_, chunkPointer_, int2floatscaling_ ); + } + + // Adjust index for the current buffer. + tyme -= chunkPointer_; + } + + if ( interpolate_ ) { + for ( unsigned int i=0; i frames.channels() - nChannels ) { + oStream_ << "FileWvIn::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int j, hop = frames.channels() - nChannels; + if ( nChannels == 1 ) { + for ( unsigned int i=0; iopenFile( fileName, nChannels, type, format ); +} + +FileWvOut :: ~FileWvOut() +{ + this->closeFile(); +} + +void FileWvOut :: closeFile( void ) +{ + if ( file_.isOpen() ) { + + // Output any remaining samples in the buffer before closing. + if ( bufferIndex_ > 0 ) { + data_.resize( bufferIndex_, data_.channels() ); + file_.write( data_ ); + } + + file_.close(); + frameCounter_ = 0; + } +} + +void FileWvOut :: openFile( std::string fileName, + unsigned int nChannels, + FileWrite::FILE_TYPE type, + Stk::StkFormat format ) +{ + closeFile(); + + if ( nChannels < 1 ) { + oStream_ << "FileWvOut::openFile: the channels argument must be greater than zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + // An StkError can be thrown by the FileWrite class here. + file_.open( fileName, nChannels, type, format ); + + // Allocate new memory if necessary. + data_.resize( bufferFrames_, nChannels ); + + bufferIndex_ = 0; + iData_ = 0; +} + +void FileWvOut :: incrementFrame( void ) +{ + frameCounter_++; + bufferIndex_++; + + if ( bufferIndex_ == bufferFrames_ ) { + file_.write( data_ ); + bufferIndex_ = 0; + iData_ = 0; + } +} + +void FileWvOut :: tick( const StkFloat sample ) +{ +#if defined(_STK_DEBUG_) + if ( !file_.isOpen() ) { + oStream_ << "FileWvOut::tick(): no file open!"; + handleError( StkError::WARNING ); + return; + } +#endif + + unsigned int nChannels = data_.channels(); + StkFloat input = sample; + clipTest( input ); + for ( unsigned int j=0; jincrementFrame(); +} + +void FileWvOut :: tick( const StkFrames& frames ) +{ +#if defined(_STK_DEBUG_) + if ( !file_.isOpen() ) { + oStream_ << "FileWvOut::tick(): no file open!"; + handleError( StkError::WARNING ); + return; + } + + if ( data_.channels() != frames.channels() ) { + oStream_ << "FileWvOut::tick(): incompatible channel value in StkFrames argument!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + unsigned int iFrames = 0; + unsigned int j, nChannels = data_.channels(); + for ( unsigned int i=0; iincrementFrame(); + } +} + +} // stk namespace diff --git a/7.x/src/stk/src/Fir.cpp b/7.x/src/stk/src/Fir.cpp new file mode 100644 index 0000000..42c4b7f --- /dev/null +++ b/7.x/src/stk/src/Fir.cpp @@ -0,0 +1,74 @@ +/***************************************************/ +/*! \class Fir + \brief STK general finite impulse response filter class. + + This class provides a generic digital filter structure that can be + used to implement FIR filters. For filters with feedback terms, + the Iir class should be used. + + In particular, this class implements the standard difference + equation: + + y[n] = b[0]*x[n] + ... + b[nb]*x[n-nb] + + The \e gain parameter is applied at the filter input and does not + affect the coefficient values. The default gain value is 1.0. + This structure results in one extra multiply per computed sample, + but allows easy control of the overall filter gain. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Fir.h" +#include + +namespace stk { + +Fir :: Fir() +{ + // The default constructor should setup for pass-through. + b_.push_back( 1.0 ); + + inputs_.resize( 1, 1, 0.0 ); +} + +Fir :: Fir( std::vector &coefficients ) +{ + // Check the arguments. + if ( coefficients.size() == 0 ) { + oStream_ << "Fir: coefficient vector must have size > 0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + gain_ = 1.0; + b_ = coefficients; + + inputs_.resize( b_.size(), 1, 0.0 ); + this->clear(); +} + +Fir :: ~Fir() +{ +} + +void Fir :: setCoefficients( std::vector &coefficients, bool clearState ) +{ + // Check the argument. + if ( coefficients.size() == 0 ) { + oStream_ << "Fir::setCoefficients: coefficient vector must have size > 0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( b_.size() != coefficients.size() ) { + b_ = coefficients; + inputs_.resize( b_.size(), 1, 0.0 ); + } + else { + for ( unsigned int i=0; iclear(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Flute.cpp b/7.x/src/stk/src/Flute.cpp new file mode 100644 index 0000000..887a472 --- /dev/null +++ b/7.x/src/stk/src/Flute.cpp @@ -0,0 +1,163 @@ +/***************************************************/ +/*! \Class Flute + \brief STK flute physical model class. + + This class implements a simple flute + physical model, as discussed by Karjalainen, + Smith, Waryznyk, etc. The jet model uses + a polynomial, a la Cook. + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + Control Change Numbers: + - Jet Delay = 2 + - Noise Gain = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Breath Pressure = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Flute.h" +#include "SKINImsg.h" + +namespace stk { + +Flute :: Flute( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "Flute::Flute: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long nDelays = (unsigned long) ( Stk::sampleRate() / lowestFrequency ); + boreDelay_.setMaximumDelay( nDelays + 1 ); + + jetDelay_.setMaximumDelay( nDelays + 1 ); + jetDelay_.setDelay( 49.0 ); + + vibrato_.setFrequency( 5.925 ); + filter_.setPole( 0.7 - ( 0.1 * 22050.0 / Stk::sampleRate() ) ); + dcBlock_.setBlockZero(); + + adsr_.setAllTimes( 0.005, 0.01, 0.8, 0.010 ); + endReflection_ = 0.5; + jetReflection_ = 0.5; + noiseGain_ = 0.15; // Breath pressure random component + vibratoGain_ = 0.05; // Breath periodic vibrato component + jetRatio_ = 0.32; + + maxPressure_ = 0.0; + this->clear(); + this->setFrequency( 220.0 ); +} + +Flute :: ~Flute( void ) +{ +} + +void Flute :: clear( void ) +{ + jetDelay_.clear(); + boreDelay_.clear(); + filter_.clear(); + dcBlock_.clear(); +} + +void Flute :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Flute::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + // We're overblowing here. + lastFrequency_ = frequency * 0.66666; + + // Account for filter delay and one sample "lastOut" delay + // (previously approximated as 2.0 samples). The tuning is still + // not perfect but I'm not sure why. Also, we are not accounting + // for the dc blocking filter delay. + StkFloat delay = Stk::sampleRate() / lastFrequency_ - filter_.phaseDelay( lastFrequency_ ) - 1.0; + + boreDelay_.setDelay( delay ); + jetDelay_.setDelay( delay * jetRatio_ ); +} + +void Flute :: setJetDelay( StkFloat aRatio ) +{ + jetRatio_ = aRatio; + jetDelay_.setDelay( boreDelay_.getDelay() * aRatio ); // Scaled by ratio. +} + +void Flute :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "Flute::startBlowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setAttackRate( rate ); + maxPressure_ = amplitude / (StkFloat) 0.8; + adsr_.keyOn(); +} + +void Flute :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "Flute::stopBlowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setReleaseRate( rate ); + adsr_.keyOff(); +} + +void Flute :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->startBlowing( 1.1 + (amplitude * 0.20), amplitude * 0.02 ); + outputGain_ = amplitude + 0.001; +} + +void Flute :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.02 ); +} + + +void Flute :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Flute::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_JetDelay_) // 2 + this->setJetDelay( (StkFloat) (0.08 + (0.48 * normalizedValue)) ); + else if (number == __SK_NoiseLevel_) // 4 + noiseGain_ = ( normalizedValue * 0.4); + else if (number == __SK_ModFrequency_) // 11 + vibrato_.setFrequency( normalizedValue * 12.0); + else if (number == __SK_ModWheel_) // 1 + vibratoGain_ = ( normalizedValue * 0.4 ); + else if (number == __SK_AfterTouch_Cont_) // 128 + adsr_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Flute::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/FormSwep.cpp b/7.x/src/stk/src/FormSwep.cpp new file mode 100644 index 0000000..dd8abaa --- /dev/null +++ b/7.x/src/stk/src/FormSwep.cpp @@ -0,0 +1,136 @@ +/***************************************************/ +/*! \class FormSwep + \brief STK sweepable formant filter class. + + This class implements a formant (resonance) which can be "swept" + over time from one frequency setting to another. It provides + methods for controlling the sweep rate and target frequency. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "FormSwep.h" +#include + +namespace stk { + +FormSwep :: FormSwep( void ) +{ + frequency_ = 0.0; + radius_ = 0.0; + targetGain_ = 1.0; + targetFrequency_ = 0.0; + targetRadius_ = 0.0; + deltaGain_ = 0.0; + deltaFrequency_ = 0.0; + deltaRadius_ = 0.0; + sweepState_ = 0.0; + sweepRate_ = 0.002; + dirty_ = false; + + b_.resize( 3, 0.0 ); + a_.resize( 3, 0.0 ); + a_[0] = 1.0; + inputs_.resize( 3, 1, 0.0 ); + outputs_.resize( 3, 1, 0.0 ); + + Stk::addSampleRateAlert( this ); +} + +FormSwep :: ~FormSwep() +{ + Stk::removeSampleRateAlert( this ); +} + +void FormSwep :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) { + oStream_ << "FormSwep::sampleRateChanged: you may need to recompute filter coefficients!"; + handleError( StkError::WARNING ); + } +} + +void FormSwep :: setResonance( StkFloat frequency, StkFloat radius ) +{ +#if defined(_STK_DEBUG_) + if ( frequency < 0.0 || frequency > 0.5 * Stk::sampleRate() ) { + oStream_ << "FormSwep::setResonance: frequency argument (" << frequency << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + if ( radius < 0.0 || radius >= 1.0 ) { + oStream_ << "FormSwep::setResonance: radius argument (" << radius << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + radius_ = radius; + frequency_ = frequency; + + a_[2] = radius * radius; + a_[1] = -2.0 * radius * cos( TWO_PI * frequency / Stk::sampleRate() ); + + // Use zeros at +- 1 and normalize the filter peak gain. + b_[0] = 0.5 - 0.5 * a_[2]; + b_[1] = 0.0; + b_[2] = -b_[0]; +} + +void FormSwep :: setStates( StkFloat frequency, StkFloat radius, StkFloat gain ) +{ + dirty_ = false; + + if ( frequency_ != frequency || radius_ != radius ) + this->setResonance( frequency, radius ); + + gain_ = gain; + targetFrequency_ = frequency; + targetRadius_ = radius; + targetGain_ = gain; +} + +void FormSwep :: setTargets( StkFloat frequency, StkFloat radius, StkFloat gain ) +{ + if ( frequency < 0.0 || frequency > 0.5 * Stk::sampleRate() ) { + oStream_ << "FormSwep::setTargets: frequency argument (" << frequency << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + if ( radius < 0.0 || radius >= 1.0 ) { + oStream_ << "FormSwep::setTargets: radius argument (" << radius << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + + dirty_ = true; + startFrequency_ = frequency_; + startRadius_ = radius_; + startGain_ = gain_; + targetFrequency_ = frequency; + targetRadius_ = radius; + targetGain_ = gain; + deltaFrequency_ = frequency - frequency_; + deltaRadius_ = radius - radius_; + deltaGain_ = gain - gain_; + sweepState_ = 0.0; +} + +void FormSwep :: setSweepRate( StkFloat rate ) +{ + if ( rate < 0.0 || rate > 1.0 ) { + oStream_ << "FormSwep::setSweepRate: argument (" << rate << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + + sweepRate_ = rate; +} + +void FormSwep :: setSweepTime( StkFloat time ) +{ + if ( time <= 0.0 ) { + oStream_ << "FormSwep::setSweepTime: argument (" << time << ") must be > 0.0!"; + handleError( StkError::WARNING ); return; + } + + this->setSweepRate( 1.0 / ( time * Stk::sampleRate() ) ); +} + +} // stk namespace diff --git a/7.x/src/stk/src/FreeVerb.cpp b/7.x/src/stk/src/FreeVerb.cpp new file mode 100644 index 0000000..2461777 --- /dev/null +++ b/7.x/src/stk/src/FreeVerb.cpp @@ -0,0 +1,227 @@ +/***********************************************************************/ +/*! \class FreeVerb + \brief Jezar at Dreampoint's FreeVerb, implemented in STK. + + Freeverb is a free and open-source Schroeder reverberator + originally implemented in C++. The parameters of the reverberation + model are exceptionally well tuned. FreeVerb uses 8 + lowpass-feedback-comb-filters in parallel, followed by 4 Schroeder + allpass filters in series. The input signal can be either mono or + stereo, and the output signal is stereo. The delay lengths are + optimized for a sample rate of 44100 Hz. + + Ported to STK by Gregory Burlet, 2012. +*/ +/***********************************************************************/ + +#include "FreeVerb.h" +#include +#include + +using namespace stk; + +// Set static delay line lengths +const StkFloat FreeVerb::fixedGain = 0.015; +const StkFloat FreeVerb::scaleWet = 3; +const StkFloat FreeVerb::scaleDry = 2; +const StkFloat FreeVerb::scaleDamp = 0.4; +const StkFloat FreeVerb::scaleRoom = 0.28; +const StkFloat FreeVerb::offsetRoom = 0.7; +int FreeVerb::cDelayLengths[] = {1617, 1557, 1491, 1422, 1356, 1277, 1188, 1116}; +int FreeVerb::aDelayLengths[] = {225, 556, 441, 341}; + +FreeVerb::FreeVerb( void ) +{ + // Resize lastFrame_ for stereo output + lastFrame_.resize( 1, 2, 0.0 ); + + // Initialize parameters + Effect::setEffectMix( 0.75 ); // set initially to 3/4 wet 1/4 dry signal (different than original freeverb) + roomSizeMem_ = (0.75 * scaleRoom) + offsetRoom; // feedback attenuation in LBFC + dampMem_ = 0.25 * scaleDamp; // pole of lowpass filters in the LBFC + width_ = 1.0; + frozenMode_ = false; + update(); + + gain_ = fixedGain; // input gain before sending to filters + g_ = 0.5; // allpass coefficient, immutable in FreeVerb + + // Scale delay line lengths according to the current sampling rate + double fsScale = Stk::sampleRate() / 44100.0; + if ( fsScale != 1.0 ) { + // scale comb filter delay lines + for ( int i = 0; i < nCombs; i++ ) { + cDelayLengths[i] = (int) floor(fsScale * cDelayLengths[i]); + } + + // Scale allpass filter delay lines + for ( int i = 0; i < nAllpasses; i++ ) { + aDelayLengths[i] = (int) floor(fsScale * aDelayLengths[i]); + } + } + + // Initialize delay lines for the LBFC filters + for ( int i = 0; i < nCombs; i++ ) { + combDelayL_[i].setMaximumDelay( cDelayLengths[i] ); + combDelayL_[i].setDelay( cDelayLengths[i] ); + combDelayR_[i].setMaximumDelay( cDelayLengths[i] + stereoSpread ); + combDelayR_[i].setDelay( cDelayLengths[i] + stereoSpread ); + } + + // initialize delay lines for the allpass filters + for (int i = 0; i < nAllpasses; i++) { + allPassDelayL_[i].setMaximumDelay( aDelayLengths[i] ); + allPassDelayL_[i].setDelay( aDelayLengths[i] ); + allPassDelayR_[i].setMaximumDelay( aDelayLengths[i] + stereoSpread ); + allPassDelayR_[i].setDelay( aDelayLengths[i] + stereoSpread ); + } +} + +FreeVerb::~FreeVerb() +{ +} + +void FreeVerb::setEffectMix( StkFloat mix ) +{ + Effect::setEffectMix( mix ); + update(); +} + +void FreeVerb::setRoomSize( StkFloat roomSize ) +{ + roomSizeMem_ = (roomSize * scaleRoom) + offsetRoom; + update(); +} + +StkFloat FreeVerb::getRoomSize() +{ + return (roomSizeMem_ - offsetRoom) / scaleRoom; +} + +void FreeVerb::setDamping( StkFloat damping ) +{ + dampMem_ = damping * scaleDamp; + update(); +} + +StkFloat FreeVerb::getDamping() +{ + return dampMem_ / scaleDamp; +} + +void FreeVerb::setWidth( StkFloat width ) +{ + width_ = width; + update(); +} + +StkFloat FreeVerb::getWidth() +{ + return width_; +} + +void FreeVerb::setMode( bool isFrozen ) +{ + frozenMode_ = isFrozen; + update(); +} + +StkFloat FreeVerb::getMode() +{ + return frozenMode_; +} + +void FreeVerb::update() +{ + StkFloat wet = scaleWet * effectMix_; + dry_ = scaleDry * (1.0-effectMix_); + + // Use the L1 norm so the output gain will sum to one while still + // preserving the ratio of scalings in original FreeVerb + wet /= (wet + dry_); + dry_ /= (wet + dry_); + + wet1_ = wet * (width_/2.0 + 0.5); + wet2_ = wet * (1.0 - width_)/2.0; + + if ( frozenMode_ ) { + // put into freeze mode + roomSize_ = 1.0; + damp_ = 0.0; + gain_ = 0.0; + } + else { + roomSize_ = roomSizeMem_; + damp_ = dampMem_; + gain_ = fixedGain; + } + + for ( int i=0; i= frames.channels() - 1 ) { + oStream_ << "FreeVerb::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() - 1 ) { + oStream_ << "FreeVerb::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(); + unsigned int oHop = oFrames.channels(); + bool stereoInput = ( iFrames.channels() > iChannel+1 ) ? true : false; + for ( unsigned int i=0; i + +namespace stk { + +Granulate :: Granulate( void ) +{ + this->setGrainParameters(); // use default values + this->setRandomFactor(); + gStretch_ = 0; + stretchCounter_ = 0; + gain_ = 1.0; +} + +Granulate :: Granulate( unsigned int nVoices, std::string fileName, bool typeRaw ) +{ + this->setGrainParameters(); // use default values + this->setRandomFactor(); + gStretch_ = 0; + stretchCounter_ = 0; + this->openFile( fileName, typeRaw ); + this->setVoices( nVoices ); +} + +Granulate :: ~Granulate( void ) +{ +} + +void Granulate :: setStretch( unsigned int stretchFactor ) +{ + if ( stretchFactor <= 1 ) + gStretch_ = 0; + else if ( gStretch_ >= 1000 ) + gStretch_ = 1000; + else + gStretch_ = stretchFactor - 1; +} + +void Granulate :: setGrainParameters( unsigned int duration, unsigned int rampPercent, + int offset, unsigned int delay ) +{ + gDuration_ = duration; + if ( gDuration_ == 0 ) { + gDuration_ = 1; + oStream_ << "Granulate::setGrainParameters: duration argument cannot be zero ... setting to 1 millisecond."; + handleError( StkError::WARNING ); + } + + gRampPercent_ = rampPercent; + if ( gRampPercent_ > 100 ) { + gRampPercent_ = 100; + oStream_ << "Granulate::setGrainParameters: rampPercent argument cannot be greater than 100 ... setting to 100."; + handleError( StkError::WARNING ); + } + + gOffset_ = offset; + gDelay_ = delay; +} + +void Granulate :: setRandomFactor( StkFloat randomness ) +{ + if ( randomness < 0.0 ) gRandomFactor_ = 0.0; + else if ( randomness > 1.0 ) gRandomFactor_ = 0.97; + else gRandomFactor_ = 0.97 * randomness; +} + +void Granulate :: openFile( std::string fileName, bool typeRaw ) +{ + // Attempt to load the soundfile data. + FileRead file( fileName, typeRaw ); + data_.resize( file.fileSize(), file.channels() ); + file.read( data_ ); + lastFrame_.resize( 1, file.channels(), 0.0 ); + + this->reset(); + +#if defined(_STK_DEBUG_) + std::ostringstream message; + message << "Granulate::openFile: file = " << fileName << ", file frames = " << file.fileSize() << '.'; + handleError( message.str(), StkError::DEBUG_PRINT ); +#endif + +} + +void Granulate :: reset( void ) +{ + gPointer_ = 0; + + // Reset grain parameters. + size_t count; + size_t nVoices = (unsigned int)grains_.size(); + for ( unsigned int i=0; icalculateGrain( grains_[i] ); + break; + + case GRAIN_FADEIN: + // We're done ramping up the envelope + if ( grains_[i].sustainCount > 0 ) { + grains_[i].counter = grains_[i].sustainCount; + grains_[i].state = GRAIN_SUSTAIN; + break; + } + // else no sustain state (i.e. perfect triangle window) + + case GRAIN_SUSTAIN: + // We're done with flat part of envelope ... setup to ramp down + if ( grains_[i].decayCount > 0 ) { + grains_[i].counter = grains_[i].decayCount; + grains_[i].eRate = -grains_[i].eRate; + grains_[i].state = GRAIN_FADEOUT; + break; + } + // else no fade out state (gRampPercent = 0) + + case GRAIN_FADEOUT: + // We're done ramping down ... setup for wait between grains + if ( grains_[i].delayCount > 0 ) { + grains_[i].counter = grains_[i].delayCount; + grains_[i].state = GRAIN_STOPPED; + break; + } + // else no delay (gDelay = 0) + + this->calculateGrain( grains_[i] ); + } + } + + // Accumulate the grain outputs. + if ( grains_[i].state > 0 ) { + for ( j=0; j= data_.frames() ) + grains_[i].pointer = 0; + } + + // Decrement counter for all states. + grains_[i].counter--; + } + + // Increment our global file pointer at the stretch rate. + if ( stretchCounter_++ == gStretch_ ) { + gPointer_++; + if ( (unsigned long) gPointer_ >= data_.frames() ) gPointer_ = 0; + stretchCounter_ = 0; + } + + return lastFrame_[channel]; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Guitar.cpp b/7.x/src/stk/src/Guitar.cpp new file mode 100644 index 0000000..2218348 --- /dev/null +++ b/7.x/src/stk/src/Guitar.cpp @@ -0,0 +1,244 @@ +/***************************************************/ +/*! \class Guitar + \brief STK guitar model class. + + This class implements a guitar model with an arbitrary number of + strings (specified during instantiation). Each string is + represented by an stk::Twang object. The model supports commuted + synthesis, as discussed by Smith and Karjalainen. It also includes + a basic body coupling model and supports feedback. + + This class does not attempt voice management. Rather, most + functions support a parameter to specify a particular string + number and string (voice) management is assumed to occur + externally. Note that this class does not inherit from + stk::Instrmnt because of API inconsistencies. + + This is a digital waveguide model, making its use possibly subject + to patents held by Stanford University, Yamaha, and others. + + Control Change Numbers: + - Bridge Coupling Gain = 2 + - Pluck Position = 4 + - Loop Gain = 11 + - Coupling Filter Pole = 1 + - Pick Filter Pole = 128 + + by Gary P. Scavone, 2012. +*/ +/***************************************************/ + +#include "Guitar.h" +#include "FileWvIn.h" +#include "Noise.h" +#include "SKINImsg.h" +#include + +namespace stk { + +#define BASE_COUPLING_GAIN 0.01 + +Guitar :: Guitar( unsigned int nStrings, std::string bodyfile ) +{ + strings_.resize( nStrings ); + stringState_.resize( nStrings, 0 ); + decayCounter_.resize( nStrings, 0 ); + filePointer_.resize( nStrings, 0 ); + pluckGains_.resize( nStrings, 0 ); + + setBodyFile( bodyfile ); + + couplingGain_ = BASE_COUPLING_GAIN; + couplingFilter_.setPole( 0.9 ); + pickFilter_.setPole( 0.95 ); + lastFrame_.resize(1, 1, 0.0); +} + +void Guitar :: clear( void ) +{ + for ( unsigned int i=0; i 1.0 ) { + oStream_ << "Guitar::setPluckPosition: position parameter out of range!"; + handleError( StkError::WARNING ); return; + } + + if ( string >= (int) strings_.size() ) { + oStream_ << "Guitar::setPluckPosition: string parameter is greater than number of strings!"; + handleError( StkError::WARNING ); return; + } + + if ( string < 0 ) // set all strings + for ( unsigned int i=0; i 1.0 ) { + oStream_ << "Guitar::setLoopGain: gain parameter out of range!"; + handleError( StkError::WARNING ); return; + } + + if ( string >= (int) strings_.size() ) { + oStream_ << "Guitar::setLoopGain: string parameter is greater than number of strings!"; + handleError( StkError::WARNING ); return; + } + + if ( string < 0 ) // set all strings + for ( unsigned int i=0; i= strings_.size() ) { + oStream_ << "Guitar::setFrequency: string parameter is greater than number of strings!"; + handleError( StkError::WARNING ); return; + } +#endif + + strings_[string].setFrequency( frequency ); +} + +void Guitar :: noteOn( StkFloat frequency, StkFloat amplitude, unsigned int string ) +{ +#if defined(_STK_DEBUG_) + if ( string >= strings_.size() ) { + oStream_ << "Guitar::noteOn: string parameter is greater than number of strings!"; + handleError( StkError::WARNING ); return; + } + + if ( Stk::inRange( amplitude, 0.0, 1.0 ) == false ) { + oStream_ << "Guitar::noteOn: amplitude parameter is outside range 0.0 - 1.0!"; + handleError( StkError::WARNING ); return; + } +#endif + + this->setFrequency( frequency, string ); + stringState_[string] = 2; + filePointer_[string] = 0; + strings_[string].setLoopGain( 0.995 ); + pluckGains_[string] = amplitude; +} + +void Guitar :: noteOff( StkFloat amplitude, unsigned int string ) +{ +#if defined(_STK_DEBUG_) + if ( string >= strings_.size() ) { + oStream_ << "Guitar::noteOff: string parameter is greater than number of strings!"; + handleError( StkError::WARNING ); return; + } + + if ( Stk::inRange( amplitude, 0.0, 1.0 ) == false ) { + oStream_ << "Guitar::noteOff: amplitude parameter is outside range 0.0 - 1.0!"; + handleError( StkError::WARNING ); return; + } +#endif + + strings_[string].setLoopGain( (1.0 - amplitude) * 0.9 ); + stringState_[string] = 1; +} + +void Guitar :: controlChange( int number, StkFloat value, int string ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Guitar::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + + if ( string > 0 && string >= (int) strings_.size() ) { + oStream_ << "Guitar::controlChange: string parameter is greater than number of strings!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if ( number == 2 ) + couplingGain_ = 1.5 * BASE_COUPLING_GAIN * normalizedValue; + else if ( number == __SK_PickPosition_ ) // 4 + this->setPluckPosition( normalizedValue, string ); + else if ( number == __SK_StringDamping_ ) // 11 + this->setLoopGain( 0.97 + (normalizedValue * 0.03), string ); + else if ( number == __SK_ModWheel_ ) // 1 + couplingFilter_.setPole( 0.98 * normalizedValue ); + else if (number == __SK_AfterTouch_Cont_) // 128 + pickFilter_.setPole( 0.95 * normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Guitar::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/HevyMetl.cpp b/7.x/src/stk/src/HevyMetl.cpp new file mode 100644 index 0000000..e295fbb --- /dev/null +++ b/7.x/src/stk/src/HevyMetl.cpp @@ -0,0 +1,75 @@ +/***************************************************/ +/*! \class HevyMetl + \brief STK heavy metal FM synthesis instrument. + + This class implements 3 cascade operators with + feedback modulation, also referred to as + algorithm 3 of the TX81Z. + + Algorithm 3 is : 4--\ + 3-->2-- + -->1-->Out + + Control Change Numbers: + - Total Modulator Index = 2 + - Modulator Crossfade = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "HevyMetl.h" + +namespace stk { + +HevyMetl :: HevyMetl( void ) + : FM() +{ + // Concatenate the STK rawwave path to the rawwave files + for ( unsigned int i=0; i<3; i++ ) + waves_[i] = new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ); + waves_[3] = new FileLoop( (Stk::rawwavePath() + "fwavblnk.raw").c_str(), true ); + + this->setRatio(0, 1.0 * 1.000); + this->setRatio(1, 4.0 * 0.999); + this->setRatio(2, 3.0 * 1.001); + this->setRatio(3, 0.5 * 1.002); + + gains_[0] = fmGains_[92]; + gains_[1] = fmGains_[76]; + gains_[2] = fmGains_[91]; + gains_[3] = fmGains_[68]; + + adsr_[0]->setAllTimes( 0.001, 0.001, 1.0, 0.01); + adsr_[1]->setAllTimes( 0.001, 0.010, 1.0, 0.50); + adsr_[2]->setAllTimes( 0.010, 0.005, 1.0, 0.20); + adsr_[3]->setAllTimes( 0.030, 0.010, 0.2, 0.20); + + twozero_.setGain( 2.0 ); + vibrato_.setFrequency( 5.5 ); + modDepth_ = 0.0; +} + +HevyMetl :: ~HevyMetl( void ) +{ +} + +void HevyMetl :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + gains_[0] = amplitude * fmGains_[92]; + gains_[1] = amplitude * fmGains_[76]; + gains_[2] = amplitude * fmGains_[91]; + gains_[3] = amplitude * fmGains_[68]; + this->setFrequency( frequency ); + this->keyOn(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Iir.cpp b/7.x/src/stk/src/Iir.cpp new file mode 100644 index 0000000..d4a6936 --- /dev/null +++ b/7.x/src/stk/src/Iir.cpp @@ -0,0 +1,125 @@ +/***************************************************/ +/*! \class Iir + \brief STK general infinite impulse response filter class. + + This class provides a generic digital filter structure that can be + used to implement IIR filters. For filters containing only + feedforward terms, the Fir class is slightly more efficient. + + In particular, this class implements the standard difference + equation: + + a[0]*y[n] = b[0]*x[n] + ... + b[nb]*x[n-nb] - + a[1]*y[n-1] - ... - a[na]*y[n-na] + + If a[0] is not equal to 1, the filter coeffcients are normalized + by a[0]. + + The \e gain parameter is applied at the filter input and does not + affect the coefficient values. The default gain value is 1.0. + This structure results in one extra multiply per computed sample, + but allows easy control of the overall filter gain. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Iir.h" + +namespace stk { + +Iir :: Iir() +{ + // The default constructor should setup for pass-through. + b_.push_back( 1.0 ); + a_.push_back( 1.0 ); + + inputs_.resize( 1, 1, 0.0 ); + outputs_.resize( 1, 1, 0.0 ); +} + +Iir :: Iir( std::vector &bCoefficients, std::vector &aCoefficients ) +{ + // Check the arguments. + if ( bCoefficients.size() == 0 || aCoefficients.size() == 0 ) { + oStream_ << "Iir: a and b coefficient vectors must both have size > 0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( aCoefficients[0] == 0.0 ) { + oStream_ << "Iir: a[0] coefficient cannot == 0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + gain_ = 1.0; + b_ = bCoefficients; + a_ = aCoefficients; + + inputs_.resize( b_.size(), 1, 0.0 ); + outputs_.resize( a_.size(), 1, 0.0 ); + this->clear(); +} + +Iir :: ~Iir() +{ +} + +void Iir :: setCoefficients( std::vector &bCoefficients, std::vector &aCoefficients, bool clearState ) +{ + this->setNumerator( bCoefficients, false ); + this->setDenominator( aCoefficients, false ); + + if ( clearState ) this->clear(); +} + +void Iir :: setNumerator( std::vector &bCoefficients, bool clearState ) +{ + // Check the argument. + if ( bCoefficients.size() == 0 ) { + oStream_ << "Iir::setNumerator: coefficient vector must have size > 0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( b_.size() != bCoefficients.size() ) { + b_ = bCoefficients; + inputs_.resize( b_.size(), 1, 0.0 ); + } + else { + for ( unsigned int i=0; iclear(); +} + +void Iir :: setDenominator( std::vector &aCoefficients, bool clearState ) +{ + // Check the argument. + if ( aCoefficients.size() == 0 ) { + oStream_ << "Iir::setDenominator: coefficient vector must have size > 0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( aCoefficients[0] == 0.0 ) { + oStream_ << "Iir::setDenominator: a[0] coefficient cannot == 0!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + if ( a_.size() != aCoefficients.size() ) { + a_ = aCoefficients; + outputs_.resize( a_.size(), 1, 0.0 ); + } + else { + for ( unsigned int i=0; iclear(); + + // Scale coefficients by a[0] if necessary + if ( a_[0] != 1.0 ) { + unsigned int i; + for ( i=0; i + +namespace stk { + +JCRev :: JCRev( StkFloat T60 ) +{ + if ( T60 <= 0.0 ) { + oStream_ << "JCRev::JCRev: argument (" << T60 << ") must be positive!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + lastFrame_.resize( 1, 2, 0.0 ); // resize lastFrame_ for stereo output + + // Delay lengths for 44100 Hz sample rate. + int lengths[9] = {1116, 1356, 1422, 1617, 225, 341, 441, 211, 179}; + double scaler = Stk::sampleRate() / 44100.0; + + int delay, i; + if ( scaler != 1.0 ) { + for ( i=0; i<9; i++ ) { + delay = (int) floor( scaler * lengths[i] ); + if ( (delay & 1) == 0) delay++; + while ( !this->isPrime(delay) ) delay += 2; + lengths[i] = delay; + } + } + + for ( i=0; i<3; i++ ) { + allpassDelays_[i].setMaximumDelay( lengths[i+4] ); + allpassDelays_[i].setDelay( lengths[i+4] ); + } + + for ( i=0; i<4; i++ ) { + combDelays_[i].setMaximumDelay( lengths[i] ); + combDelays_[i].setDelay( lengths[i] ); + combFilters_[i].setPole( 0.2 ); + } + + this->setT60( T60 ); + outLeftDelay_.setMaximumDelay( lengths[7] ); + outLeftDelay_.setDelay( lengths[7] ); + outRightDelay_.setMaximumDelay( lengths[8] ); + outRightDelay_.setDelay( lengths[8] ); + allpassCoefficient_ = 0.7; + effectMix_ = 0.3; + this->clear(); +} + +void JCRev :: clear() +{ + allpassDelays_[0].clear(); + allpassDelays_[1].clear(); + allpassDelays_[2].clear(); + combDelays_[0].clear(); + combDelays_[1].clear(); + combDelays_[2].clear(); + combDelays_[3].clear(); + outRightDelay_.clear(); + outLeftDelay_.clear(); + lastFrame_[0] = 0.0; + lastFrame_[1] = 0.0; +} + +void JCRev :: setT60( StkFloat T60 ) +{ + if ( T60 <= 0.0 ) { + oStream_ << "JCRev::setT60: argument (" << T60 << ") must be positive!"; + handleError( StkError::WARNING ); return; + } + + for ( int i=0; i<4; i++ ) + combCoefficient_[i] = pow(10.0, (-3.0 * combDelays_[i].getDelay() / (T60 * Stk::sampleRate()))); +} + +StkFrames& JCRev :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() - 1 ) { + oStream_ << "JCRev::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() - 1 ) { + oStream_ << "JCRev::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; isetFrequency( 220.0 ); + this->setPluckPosition( 0.4 ); +} + +Mandolin :: ~Mandolin( void ) +{ +} + +void Mandolin :: clear( void ) +{ + strings_[0].clear(); + strings_[1].clear(); +} + +void Mandolin :: setPluckPosition( StkFloat position ) +{ + if ( position < 0.0 || position > 1.0 ) { + oStream_ << "Mandolin::setPluckPosition: position parameter out of range!"; + handleError( StkError::WARNING ); return; + } + + strings_[0].setPluckPosition( position ); + strings_[1].setPluckPosition( position ); +} + +void Mandolin :: setDetune( StkFloat detune ) +{ + if ( detune <= 0.0 ) { + oStream_ << "Mandolin::setDeturn: parameter is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + detuning_ = detune; + strings_[1].setFrequency( frequency_ * detuning_ ); +} + +void Mandolin :: setBodySize( StkFloat size ) +{ + // Scale the commuted body response by its sample rate (22050). + StkFloat rate = size * 22050.0 / Stk::sampleRate(); + for ( int i=0; i<12; i++ ) + soundfile_[i].setRate( rate ); +} + +void Mandolin :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Mandolin::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + frequency_ = frequency; + strings_[0].setFrequency( frequency_ ); + strings_[1].setFrequency( frequency_ * detuning_ ); +} + +void Mandolin :: pluck( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "Mandolin::pluck: amplitude parameter out of range!"; + handleError( StkError::WARNING ); return; + } + + soundfile_[mic_].reset(); + pluckAmplitude_ = amplitude; + + //strings_[0].setLoopGain( 0.97 + pluckAmplitude_ * 0.03 ); + //strings_[1].setLoopGain( 0.97 + pluckAmplitude_ * 0.03 ); +} + +void Mandolin :: pluck( StkFloat amplitude, StkFloat position ) +{ + this->setPluckPosition( position ); + this->pluck( amplitude ); +} + +void Mandolin :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->pluck( amplitude ); +} + +void Mandolin :: noteOff( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "Mandolin::noteOff: amplitude is out of range!"; + handleError( StkError::WARNING ); return; + } + + //strings_[0].setLoopGain( 0.97 + (1 - amplitude) * 0.03 ); + //strings_[1].setLoopGain( 0.97 + (1 - amplitude) * 0.03 ); +} + +void Mandolin :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Mandolin::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if ( number == __SK_BodySize_ ) // 2 + this->setBodySize( normalizedValue * 2.0 ); + else if ( number == __SK_PickPosition_ ) // 4 + this->setPluckPosition( normalizedValue ); + else if ( number == __SK_StringDamping_ ) { // 11 + strings_[0].setLoopGain( 0.97 + (normalizedValue * 0.03) ); + strings_[1].setLoopGain( 0.97 + (normalizedValue * 0.03) ); + } + else if ( number == __SK_StringDetune_ ) // 1 + this->setDetune( 1.0 - (normalizedValue * 0.1) ); + else if ( number == __SK_AfterTouch_Cont_ ) // 128 + mic_ = (int) (normalizedValue * 11.0); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Mandolin::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Mesh2D.cpp b/7.x/src/stk/src/Mesh2D.cpp new file mode 100644 index 0000000..d126f99 --- /dev/null +++ b/7.x/src/stk/src/Mesh2D.cpp @@ -0,0 +1,367 @@ +/***************************************************/ +/*! \class Mesh2D + \brief Two-dimensional rectilinear waveguide mesh class. + + This class implements a rectilinear, + two-dimensional digital waveguide mesh + structure. For details, see Van Duyne and + Smith, "Physical Modeling with the 2-D Digital + Waveguide Mesh", Proceedings of the 1993 + International Computer Music Conference. + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + Control Change Numbers: + - X Dimension = 2 + - Y Dimension = 4 + - Mesh Decay = 11 + - X-Y Input Position = 1 + + by Julius Smith, 2000--2002. + Revised by Gary Scavone for STK, 2002. +*/ +/***************************************************/ + +#include "Mesh2D.h" +#include "SKINImsg.h" + +namespace stk { + +Mesh2D :: Mesh2D( unsigned short nX, unsigned short nY ) +{ + if ( nX == 0.0 || nY == 0.0 ) { + oStream_ << "Mesh2D::Mesh2D: one or more argument is equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + this->setNX( nX ); + this->setNY( nY ); + + StkFloat pole = 0.05; + unsigned short i; + for ( i=0; iclearMesh(); + + counter_ = 0; + xInput_ = 0; + yInput_ = 0; +} + +Mesh2D :: ~Mesh2D( void ) +{ +} + +void Mesh2D :: clear( void ) +{ + this->clearMesh(); + + unsigned short i; + for ( i=0; i NXMAX ) { + oStream_ << "Mesh2D::setNX(" << lenX << "): Maximum length is " << NXMAX << '!'; + handleError( StkError::WARNING ); return; + } + + NX_ = lenX; +} + +void Mesh2D :: setNY( unsigned short lenY ) +{ + if ( lenY < 2 ) { + oStream_ << "Mesh2D::setNY(" << lenY << "): Minimum length is 2!"; + handleError( StkError::WARNING ); return; + } + else if ( lenY > NYMAX ) { + oStream_ << "Mesh2D::setNY(" << lenY << "): Maximum length is " << NXMAX << '!'; + handleError( StkError::WARNING ); return; + } + + NY_ = lenY; +} + +void Mesh2D :: setDecay( StkFloat decayFactor ) +{ + if ( decayFactor < 0.0 || decayFactor > 1.0 ) { + oStream_ << "Mesh2D::setDecay: decayFactor is out of range!"; + handleError( StkError::WARNING ); return; + } + + int i; + for ( i=0; i 1.0 ) { + oStream_ << "Mesh2D::setInputPosition xFactor value is out of range!"; + handleError( StkError::WARNING ); return; + } + + if ( yFactor < 0.0 || yFactor > 1.0 ) { + oStream_ << "Mesh2D::setInputPosition yFactor value is out of range!"; + handleError( StkError::WARNING ); return; + } + + xInput_ = (unsigned short) (xFactor * (NX_ - 1)); + yInput_ = (unsigned short) (yFactor * (NY_ - 1)); +} + +void Mesh2D :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + // Input at corner. + if ( counter_ & 1 ) { + vxp1_[xInput_][yInput_] += amplitude; + vyp1_[xInput_][yInput_] += amplitude; + } + else { + vxp_[xInput_][yInput_] += amplitude; + vyp_[xInput_][yInput_] += amplitude; + } +} + +void Mesh2D :: noteOff( StkFloat amplitude ) +{ + return; +} + +StkFloat Mesh2D :: inputTick( StkFloat input ) +{ + if ( counter_ & 1 ) { + vxp1_[xInput_][yInput_] += input; + vyp1_[xInput_][yInput_] += input; + lastFrame_[0] = tick1(); + } + else { + vxp_[xInput_][yInput_] += input; + vyp_[xInput_][yInput_] += input; + lastFrame_[0] = tick0(); + } + + counter_++; + return lastFrame_[0]; +} + +StkFloat Mesh2D :: tick( unsigned int ) +{ + lastFrame_[0] = ((counter_ & 1) ? this->tick1() : this->tick0()); + counter_++; + return lastFrame_[0]; +} + +const StkFloat VSCALE = 0.5; + +StkFloat Mesh2D :: tick0( void ) +{ + int x, y; + StkFloat outsamp = 0; + + // Update junction velocities. + for (x=0; xsetNX( (unsigned short) (normalizedValue * (NXMAX-2) + 2) ); + else if ( number == 4 ) // 4 + this->setNY( (unsigned short) (normalizedValue * (NYMAX-2) + 2) ); + else if ( number == 11 ) // 11 + this->setDecay( 0.9 + (normalizedValue * 0.1) ); + else if ( number == __SK_ModWheel_ ) // 1 + this->setInputPosition( normalizedValue, normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Mesh2D::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/MidiFileIn.cpp b/7.x/src/stk/src/MidiFileIn.cpp new file mode 100644 index 0000000..d5c8384 --- /dev/null +++ b/7.x/src/stk/src/MidiFileIn.cpp @@ -0,0 +1,353 @@ +/**********************************************************************/ +/*! \class MidiFileIn + \brief A standard MIDI file reading/parsing class. + + This class can be used to read events from a standard MIDI file. + Event bytes are copied to a C++ vector and must be subsequently + interpreted by the user. The function getNextMidiEvent() skips + meta and sysex events, returning only MIDI channel messages. + Event delta-times are returned in the form of "ticks" and a + function is provided to determine the current "seconds per tick". + Tempo changes are internally tracked by the class and reflected in + the values returned by the function getTickSeconds(). + + by Gary P. Scavone, 2003--2021. +*/ +/**********************************************************************/ + +#include "MidiFileIn.h" +#include +#include + +namespace stk { + +MidiFileIn :: MidiFileIn( std::string fileName ) +{ + // Attempt to open the file. + file_.open( fileName.c_str(), std::ios::in | std::ios::binary ); + if ( !file_ ) { + oStream_ << "MidiFileIn: error opening or finding file (" << fileName << ")."; + handleError( StkError::FILE_NOT_FOUND ); + } + + // Parse header info. + char chunkType[4]; + char buffer[4]; + SINT32 *length; + if ( !file_.read( chunkType, 4 ) ) goto error; + if ( !file_.read( buffer, 4 ) ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap32((unsigned char *)&buffer); +#endif + length = (SINT32 *) &buffer; + if ( strncmp( chunkType, "MThd", 4 ) || ( *length != 6 ) ) { + oStream_ << "MidiFileIn: file (" << fileName << ") does not appear to be a MIDI file!"; + handleError( StkError::FILE_UNKNOWN_FORMAT ); + } + + // Read the MIDI file format. + SINT16 *data; + if ( !file_.read( buffer, 2 ) ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap16((unsigned char *)&buffer); +#endif + data = (SINT16 *) &buffer; + if ( *data < 0 || *data > 2 ) { + oStream_ << "MidiFileIn: the file (" << fileName << ") format is invalid!"; + handleError( StkError::FILE_ERROR ); + } + format_ = *data; + + // Read the number of tracks. + if ( !file_.read( buffer, 2 ) ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap16((unsigned char *)&buffer); +#endif + if ( format_ == 0 && *data != 1 ) { + oStream_ << "MidiFileIn: invalid number of tracks (>1) for a file format = 0!"; + handleError( StkError::FILE_ERROR ); + } + nTracks_ = *data; + + // Read the beat division. + if ( !file_.read( buffer, 2 ) ) goto error; +#ifdef __LITTLE_ENDIAN__ + swap16((unsigned char *)&buffer); +#endif + division_ = (int) *data; + double tickrate; + usingTimeCode_ = false; + if ( *data & 0x8000 ) { + // Determine ticks per second from time-code formats. + signed char tmp = -(*data & 0xFF00)>>8; + tickrate = (double) tmp; + // If frames per second value is 29, it really should be 29.97. + if ( tickrate == 29.0 ) tickrate = 29.97; + tickrate *= (*data & 0x00FF); + usingTimeCode_ = true; + } + else { + tickrate = (double) (*data & 0x7FFF); // ticks per quarter note + } + + // Now locate the track offsets and lengths. If not using time + // code, we can initialize the "tick time" using a default tempo of + // 120 beats per minute. We will then check for tempo meta-events + // afterward. + unsigned int i; + for ( i=0; i event; + unsigned long value, count; + + // We need to temporarily change the usingTimeCode_ value here so + // that the getNextEvent() function doesn't try to check the tempo + // map (which we're creating here). + usingTimeCode_ = true; + count = getNextEvent( &event, 0 ); + while ( event.size() ) { + if ( ( event.size() == 6 ) && ( event[0] == 0xff ) && + ( event[1] == 0x51 ) && ( event[2] == 0x03 ) ) { + tempoEvent.count = count; + value = ( event[3] << 16 ) + ( event[4] << 8 ) + event[5]; + tempoEvent.tickSeconds = (double) (0.000001 * value / tickrate); + if ( count > tempoEvents_.back().count ) + tempoEvents_.push_back( tempoEvent ); + else + tempoEvents_.back() = tempoEvent; + } + count += getNextEvent( &event, 0 ); + } + rewindTrack( 0 ); + for ( unsigned int i=0; i= nTracks_ ) { + oStream_ << "MidiFileIn::getNextEvent: invalid track argument (" << track << ")."; + handleError( StkError::WARNING ); return; + } + + trackPointers_[track] = trackOffsets_[track]; + trackStatus_[track] = 0; + tickSeconds_[track] = tempoEvents_[0].tickSeconds; +} + +double MidiFileIn :: getTickSeconds( unsigned int track ) +{ + // Return the current tick value in seconds for the given track. + if ( track >= nTracks_ ) { + oStream_ << "MidiFileIn::getTickSeconds: invalid track argument (" << track << ")."; + handleError( StkError::WARNING ); return 0.0; + } + + return tickSeconds_[track]; +} + +unsigned long MidiFileIn :: getNextEvent( std::vector *event, unsigned int track ) +{ + // Fill the user-provided vector with the next event in the + // specified track (default = 0) and return the event delta time in + // ticks. This function assumes that the stored track pointer is + // positioned at the start of a track event. If the track has + // reached its end, the event vector size will be zero. + // + // If we have a format 0 or 2 file and we're not using timecode, we + // should check every meta-event for tempo changes and make + // appropriate updates to the tickSeconds_ parameter if so. + // + // If we have a format 1 file and we're not using timecode, keep a + // running sum of ticks for each track and update the tickSeconds_ + // parameter as needed based on the stored tempo map. + + event->clear(); + if ( track >= nTracks_ ) { + oStream_ << "MidiFileIn::getNextEvent: invalid track argument (" << track << ")."; + handleError( StkError::WARNING ); return 0; + } + + // Check for the end of the track. + if ( (trackPointers_[track] - trackOffsets_[track]) >= trackLengths_[track] ) + return 0; + + unsigned long ticks = 0, bytes = 0; + bool isTempoEvent = false; + + // Read the event delta time. + file_.seekg( trackPointers_[track], std::ios_base::beg ); + if ( !readVariableLength( &ticks ) ) goto error; + + // Parse the event stream to determine the event length. + unsigned char c; + if ( !file_.read( (char *)&c, 1 ) ) goto error; + switch ( c ) { + + case 0xFF: // A Meta-Event + unsigned long position; + trackStatus_[track] = 0; + event->push_back( c ); + if ( !file_.read( (char *)&c, 1 ) ) goto error; + event->push_back( c ); + if ( format_ != 1 && ( c == 0x51 ) ) isTempoEvent = true; + position = (unsigned long)file_.tellg(); + if ( !readVariableLength( &bytes ) ) goto error; + bytes += ( (unsigned long)file_.tellg() - position ); + file_.seekg( position, std::ios_base::beg ); + break; + + case 0xF0: + case 0xF7: // The start or continuation of a Sysex event + trackStatus_[track] = 0; + event->push_back( c ); + position = (unsigned long)file_.tellg(); + if ( !readVariableLength( &bytes ) ) goto error; + bytes += ( (unsigned long)file_.tellg() - position ); + file_.seekg( position, std::ios_base::beg ); + break; + + default: // Should be a MIDI channel event + if ( c & 0x80 ) { // MIDI status byte + if ( c > 0xF0 ) goto error; + trackStatus_[track] = c; + event->push_back( c ); + c &= 0xF0; + if ( (c == 0xC0) || (c == 0xD0) ) bytes = 1; + else bytes = 2; + } + else if ( trackStatus_[track] & 0x80 ) { // Running status + event->push_back( trackStatus_[track] ); + event->push_back( c ); + c = trackStatus_[track] & 0xF0; + if ( (c != 0xC0) && (c != 0xD0) ) bytes = 1; + } + else goto error; + + } + + // Read the rest of the event into the event vector. + unsigned long i; + for ( i=0; ipush_back( c ); + } + + if ( !usingTimeCode_ ) { + if ( isTempoEvent ) { + // Parse the tempo event and update tickSeconds_[track]. + double tickrate = (double) (division_ & 0x7FFF); + unsigned long value = ( event->at(3) << 16 ) + ( event->at(4) << 8 ) + event->at(5); + tickSeconds_[track] = (double) (0.000001 * value / tickrate); + } + + if ( format_ == 1 ) { + // Update track counter and check the tempo map. + trackCounters_[track] += ticks; + TempoChange tempoEvent = tempoEvents_[ trackTempoIndex_[track] ]; + if ( trackCounters_[track] >= tempoEvent.count && trackTempoIndex_[track] < tempoEvents_.size() - 1 ) { + trackTempoIndex_[track]++; + tickSeconds_[track] = tempoEvent.tickSeconds; + } + } + } + + // Save the current track pointer value. + trackPointers_[track] = (long)file_.tellg(); + + return ticks; + + error: + oStream_ << "MidiFileIn::getNextEvent: file read error!"; + handleError( StkError::FILE_ERROR ); + return 0; +} + +unsigned long MidiFileIn :: getNextMidiEvent( std::vector *midiEvent, unsigned int track ) +{ + // Fill the user-provided vector with the next MIDI event in the + // specified track (default = 0) and return the event delta time in + // ticks. Meta-Events preceeding this event are skipped and ignored. + if ( track >= nTracks_ ) { + oStream_ << "MidiFileIn::getNextMidiEvent: invalid track argument (" << track << ")."; + handleError( StkError::WARNING ); return 0; + } + + unsigned long ticks = getNextEvent( midiEvent, track ); + while ( midiEvent->size() && ( midiEvent->at(0) >= 0xF0 ) ) { + //for ( unsigned int i=0; isize(); i++ ) + //std::cout << "event byte = " << i << ", value = " << (int)midiEvent->at(i) << std::endl; + ticks = getNextEvent( midiEvent, track ); + } + + //for ( unsigned int i=0; isize(); i++ ) + //std::cout << "event byte = " << i << ", value = " << (int)midiEvent->at(i) << std::endl; + + return ticks; +} + +bool MidiFileIn :: readVariableLength( unsigned long *value ) +{ + // It is assumed that this function is called with the file read + // pointer positioned at the start of a variable-length value. The + // function returns "true" if the value is successfully parsed and + // "false" otherwise. + *value = 0; + char c; + + if ( !file_.read( &c, 1 ) ) return false; + *value = (unsigned long) c; + if ( *value & 0x80 ) { + *value &= 0x7f; + do { + if ( !file_.read( &c, 1 ) ) return false; + *value = ( *value << 7 ) + ( c & 0x7f ); + } while ( c & 0x80 ); + } + + return true; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Modal.cpp b/7.x/src/stk/src/Modal.cpp new file mode 100644 index 0000000..f096abd --- /dev/null +++ b/7.x/src/stk/src/Modal.cpp @@ -0,0 +1,169 @@ +/***************************************************/ +/*! \class Modal + \brief STK resonance model abstract base class. + + This class contains an excitation wavetable, + an envelope, an oscillator, and N resonances + (non-sweeping BiQuad filters), where N is set + during instantiation. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Modal.h" +#include + +namespace stk { + +Modal :: Modal( unsigned int modes ) + : nModes_(modes) +{ + if ( nModes_ == 0 ) { + oStream_ << "Modal: 'modes' argument to constructor is zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + // We don't make the excitation wave here yet, because we don't know + // what it's going to be. + + ratios_.resize( nModes_ ); + radii_.resize( nModes_ ); + filters_ = (BiQuad **) calloc( nModes_, sizeof(BiQuad *) ); + for (unsigned int i=0; isetEqualGainZeroes(); + } + + // Set some default values. + vibrato_.setFrequency( 6.0 ); + vibratoGain_ = 0.0; + directGain_ = 0.0; + masterGain_ = 1.0; + baseFrequency_ = 440.0; + + this->clear(); + + stickHardness_ = 0.5; + strikePosition_ = 0.561; +} + +Modal :: ~Modal( void ) +{ + for ( unsigned int i=0; iclear(); +} + +void Modal :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Modal::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + baseFrequency_ = frequency; + for ( unsigned int i=0; isetRatioAndRadius( i, ratios_[i], radii_[i] ); +} + +void Modal :: setRatioAndRadius( unsigned int modeIndex, StkFloat ratio, StkFloat radius ) +{ + if ( modeIndex >= nModes_ ) { + oStream_ << "Modal::setRatioAndRadius: modeIndex parameter is greater than number of modes!"; + handleError( StkError::WARNING ); return; + } + + StkFloat nyquist = Stk::sampleRate() / 2.0; + StkFloat temp; + + if ( ratio * baseFrequency_ < nyquist ) { + ratios_[modeIndex] = ratio; + } + else { + temp = ratio; + while (temp * baseFrequency_ > nyquist) temp *= 0.5; + ratios_[modeIndex] = temp; +#if defined(_STK_DEBUG_) + oStream_ << "Modal::setRatioAndRadius: aliasing would occur here ... correcting."; + handleError( StkError::DEBUG_PRINT ); +#endif + } + radii_[modeIndex] = radius; + if (ratio < 0) + temp = -ratio; + else + temp = ratio * baseFrequency_; + + filters_[modeIndex]->setResonance(temp, radius); +} + +void Modal :: setModeGain( unsigned int modeIndex, StkFloat gain ) +{ + if ( modeIndex >= nModes_ ) { + oStream_ << "Modal::setModeGain: modeIndex parameter is greater than number of modes!"; + handleError( StkError::WARNING ); return; + } + + filters_[modeIndex]->setGain( gain ); +} + +void Modal :: strike( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "Modal::strike: amplitude is out of range!"; + handleError( StkError::WARNING ); + } + + envelope_.setRate( 1.0 ); + envelope_.setTarget( amplitude ); + onepole_.setPole( 1.0 - amplitude ); + envelope_.tick(); + wave_->reset(); + + StkFloat temp; + for ( unsigned int i=0; isetResonance(temp, radii_[i]); + } +} + +void Modal :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->strike( amplitude ); + this->setFrequency( frequency ); +} + +void Modal :: noteOff( StkFloat amplitude ) +{ + // This calls damp, but inverts the meaning of amplitude (high + // amplitude means fast damping). + this->damp( 1.0 - (amplitude * 0.03) ); +} + +void Modal :: damp( StkFloat amplitude ) +{ + StkFloat temp; + for ( unsigned int i=0; isetResonance( temp, radii_[i]*amplitude ); + } +} + +} // stk namespace diff --git a/7.x/src/stk/src/ModalBar.cpp b/7.x/src/stk/src/ModalBar.cpp new file mode 100644 index 0000000..6274cb2 --- /dev/null +++ b/7.x/src/stk/src/ModalBar.cpp @@ -0,0 +1,182 @@ +/***************************************************/ +/*! \class ModalBar + \brief STK resonant bar instrument class. + + This class implements a number of different + struck bar instruments. It inherits from the + Modal class. + + Control Change Numbers: + - Stick Hardness = 2 + - Stick Position = 4 + - Vibrato Gain = 8 + - Vibrato Frequency = 11 + - Direct Stick Mix = 1 + - Volume = 128 + - Modal Presets = 16 + - Marimba = 0 + - Vibraphone = 1 + - Agogo = 2 + - Wood1 = 3 + - Reso = 4 + - Wood2 = 5 + - Beats = 6 + - Two Fixed = 7 + - Clump = 8 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "ModalBar.h" +#include "SKINImsg.h" +#include + +namespace stk { + +ModalBar :: ModalBar( void ) + : Modal() +{ + // Concatenate the STK rawwave path to the rawwave file + wave_ = new FileWvIn( (Stk::rawwavePath() + "marmstk1.raw").c_str(), true ); + wave_->setRate( 0.5 * 22050.0 / Stk::sampleRate() ); + + // Set the resonances for preset 0 (marimba). + this->setPreset( 0 ); +} + +ModalBar :: ~ModalBar( void ) +{ + delete wave_; +} + +void ModalBar :: setStickHardness( StkFloat hardness ) +{ + if ( hardness < 0.0 || hardness > 1.0 ) { + oStream_ << "ModalBar::setStickHardness: parameter is out of range!"; + handleError( StkError::WARNING ); return; + } + + stickHardness_ = hardness; + wave_->setRate( (0.25 * pow(4.0, stickHardness_) ) ); + masterGain_ = 0.1 + (1.8 * stickHardness_); +} + +void ModalBar :: setStrikePosition( StkFloat position ) +{ + if ( position < 0.0 || position > 1.0 ) { + oStream_ << "ModalBar::setStrikePosition: parameter is out of range!"; + handleError( StkError::WARNING ); return; + } + + strikePosition_ = position; + + // Hack only first three modes. + StkFloat temp2 = position * PI; + StkFloat temp = sin(temp2); + this->setModeGain(0, 0.12 * temp); + + temp = sin(0.05 + (3.9 * temp2)); + this->setModeGain(1, -0.03 * temp); + + temp = sin(-0.05 + (11 * temp2)); + this->setModeGain(2, 0.11 * temp); +} + +void ModalBar :: setPreset( int preset ) +{ + // Presets: + // First line: relative modal frequencies (negative number is + // a fixed mode that doesn't scale with frequency + // Second line: resonances of the modes + // Third line: mode volumes + // Fourth line: stickHardness, strikePosition, and direct stick + // gain (mixed directly into the output + static StkFloat presets[9][4][4] = { + {{1.0, 3.99, 10.65, -2443}, // Marimba + {0.9996, 0.9994, 0.9994, 0.999}, + {0.04, 0.01, 0.01, 0.008}, + {0.429688, 0.445312, 0.093750}}, + {{1.0, 2.01, 3.9, 14.37}, // Vibraphone + {0.99995, 0.99991, 0.99992, 0.9999}, + {0.025, 0.015, 0.015, 0.015 }, + {0.390625,0.570312,0.078125}}, + {{1.0, 4.08, 6.669, -3725.0}, // Agogo + {0.999, 0.999, 0.999, 0.999}, + {0.06, 0.05, 0.03, 0.02}, + {0.609375,0.359375,0.140625}}, + {{1.0, 2.777, 7.378, 15.377}, // Wood1 + {0.996, 0.994, 0.994, 0.99}, + {0.04, 0.01, 0.01, 0.008}, + {0.460938,0.375000,0.046875}}, + {{1.0, 2.777, 7.378, 15.377}, // Reso + {0.99996, 0.99994, 0.99994, 0.9999}, + {0.02, 0.005, 0.005, 0.004}, + {0.453125,0.250000,0.101562}}, + {{1.0, 1.777, 2.378, 3.377}, // Wood2 + {0.996, 0.994, 0.994, 0.99}, + {0.04, 0.01, 0.01, 0.008}, + {0.312500,0.445312,0.109375}}, + {{1.0, 1.004, 1.013, 2.377}, // Beats + {0.9999, 0.9999, 0.9999, 0.999}, + {0.02, 0.005, 0.005, 0.004}, + {0.398438,0.296875,0.070312}}, + {{1.0, 4.0, -1320.0, -3960.0}, // 2Fix + {0.9996, 0.999, 0.9994, 0.999}, + {0.04, 0.01, 0.01, 0.008}, + {0.453125,0.453125,0.070312}}, + {{1.0, 1.217, 1.475, 1.729}, // Clump + {0.999, 0.999, 0.999, 0.999}, + {0.03, 0.03, 0.03, 0.03 }, + {0.390625,0.570312,0.078125}}, + }; + + int temp = (preset % 9); + for (unsigned int i=0; isetRatioAndRadius(i, presets[temp][0][i], presets[temp][1][i]); + this->setModeGain(i, presets[temp][2][i]); + } + + this->setStickHardness(presets[temp][3][0]); + this->setStrikePosition(presets[temp][3][1]); + directGain_ = presets[temp][3][2]; + + if (temp == 1) // vibraphone + vibratoGain_ = 0.2; + else + vibratoGain_ = 0.0; +} + +void ModalBar :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "ModalBar::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_StickHardness_) // 2 + this->setStickHardness( normalizedValue ); + else if (number == __SK_StrikePosition_) // 4 + this->setStrikePosition( normalizedValue ); + else if (number == __SK_ProphesyRibbon_) // 16 + this->setPreset((int) value); + else if (number == __SK_Balance_) // 8 + vibratoGain_ = normalizedValue * 0.3; + else if (number == __SK_ModWheel_) // 1 + directGain_ = normalizedValue; + else if (number == __SK_ModFrequency_) // 11 + vibrato_.setFrequency( normalizedValue * 12.0 ); + else if (number == __SK_AfterTouch_Cont_) // 128 + envelope_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "ModalBar::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Modulate.cpp b/7.x/src/stk/src/Modulate.cpp new file mode 100644 index 0000000..c81eae5 --- /dev/null +++ b/7.x/src/stk/src/Modulate.cpp @@ -0,0 +1,49 @@ +/***************************************************/ +/*! \class Modulate + \brief STK periodic/random modulator. + + This class combines random and periodic + modulations to give a nice, natural human + modulation function. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Modulate.h" + +namespace stk { + +Modulate :: Modulate( void ) +{ + vibrato_.setFrequency( 6.0 ); + vibratoGain_ = 0.04; + + noiseRate_ = (unsigned int) ( 330.0 * Stk::sampleRate() / 22050.0 ); + noiseCounter_ = noiseRate_; + + randomGain_ = 0.05; + filter_.setPole( 0.999 ); + filter_.setGain( randomGain_ ); + + Stk::addSampleRateAlert( this ); +} + +Modulate :: ~Modulate( void ) +{ + Stk::removeSampleRateAlert( this ); +} + +void Modulate :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) + noiseRate_ = (unsigned int ) ( newRate * noiseRate_ / oldRate ); +} + +void Modulate :: setRandomGain( StkFloat gain ) +{ + randomGain_ = gain; + filter_.setGain( randomGain_ ); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Moog.cpp b/7.x/src/stk/src/Moog.cpp new file mode 100644 index 0000000..4451b21 --- /dev/null +++ b/7.x/src/stk/src/Moog.cpp @@ -0,0 +1,111 @@ +/***************************************************/ +/*! \class Moog + \brief STK moog-like swept filter sampling synthesis class. + + This instrument uses one attack wave, one + looped wave, and an ADSR envelope (inherited + from the Sampler class) and adds two sweepable + formant (FormSwep) filters. + + Control Change Numbers: + - Filter Q = 2 + - Filter Sweep Rate = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Gain = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Moog.h" +#include "SKINImsg.h" + +namespace stk { + +Moog :: Moog( void ) +{ + // Concatenate the STK rawwave path to the rawwave file + attacks_.push_back( new FileWvIn( (Stk::rawwavePath() + "mandpluk.raw").c_str(), true ) ); + loops_.push_back ( new FileLoop( (Stk::rawwavePath() + "impuls20.raw").c_str(), true ) ); + loops_.push_back ( new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ) ); // vibrato + loops_[1]->setFrequency( 6.122 ); + + filters_[0].setTargets( 0.0, 0.7 ); + filters_[1].setTargets( 0.0, 0.7 ); + + adsr_.setAllTimes( 0.001, 1.5, 0.6, 0.250 ); + filterQ_ = 0.85; + filterRate_ = 0.0001; + modDepth_ = 0.0; +} + +Moog :: ~Moog( void ) +{ +} + +void Moog :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Moog::setFrequency: parameter is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + baseFrequency_ = frequency; + StkFloat rate = attacks_[0]->getSize() * 0.01 * baseFrequency_ / Stk::sampleRate(); + attacks_[0]->setRate( rate ); + loops_[0]->setFrequency( baseFrequency_ ); +} + +void Moog :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + StkFloat temp; + + this->setFrequency( frequency ); + this->keyOn(); + attackGain_ = amplitude * 0.5; + loopGain_ = amplitude; + + temp = filterQ_ + 0.05; + filters_[0].setStates( 2000.0, temp ); + filters_[1].setStates( 2000.0, temp ); + + temp = filterQ_ + 0.099; + filters_[0].setTargets( frequency, temp ); + filters_[1].setTargets( frequency, temp ); + + filters_[0].setSweepRate( filterRate_ * 22050.0 / Stk::sampleRate() ); + filters_[1].setSweepRate( filterRate_ * 22050.0 / Stk::sampleRate() ); +} + +void Moog :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Moog::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_FilterQ_) // 2 + filterQ_ = 0.80 + ( 0.1 * normalizedValue ); + else if (number == __SK_FilterSweepRate_) // 4 + filterRate_ = normalizedValue * 0.0002; + else if (number == __SK_ModFrequency_) // 11 + this->setModulationSpeed( normalizedValue * 12.0 ); + else if (number == __SK_ModWheel_) // 1 + this->setModulationDepth( normalizedValue ); + else if (number == __SK_AfterTouch_Cont_) // 128 + adsr_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Moog::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/NRev.cpp b/7.x/src/stk/src/NRev.cpp new file mode 100644 index 0000000..63686c8 --- /dev/null +++ b/7.x/src/stk/src/NRev.cpp @@ -0,0 +1,119 @@ +/***************************************************/ +/*! \class NRev + \brief CCRMA's NRev reverberator class. + + This class takes a monophonic input signal and produces a stereo + output signal. It is derived from the CLM NRev function, which is + based on the use of networks of simple allpass and comb delay + filters. This particular arrangement consists of 6 comb filters + in parallel, followed by 3 allpass filters, a lowpass filter, and + another allpass in series, followed by two allpass filters in + parallel with corresponding right and left outputs. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "NRev.h" +#include + +namespace stk { + +NRev :: NRev( StkFloat T60 ) +{ + if ( T60 <= 0.0 ) { + oStream_ << "NRev::NRev: argument (" << T60 << ") must be positive!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + lastFrame_.resize( 1, 2, 0.0 ); // resize lastFrame_ for stereo output + + int lengths[15] = {1433, 1601, 1867, 2053, 2251, 2399, 347, 113, 37, 59, 53, 43, 37, 29, 19}; + double scaler = Stk::sampleRate() / 25641.0; + + int delay, i; + for ( i=0; i<15; i++ ) { + delay = (int) floor(scaler * lengths[i]); + if ( (delay & 1) == 0) delay++; + while ( !this->isPrime(delay) ) delay += 2; + lengths[i] = delay; + } + + for ( i=0; i<6; i++ ) { + combDelays_[i].setMaximumDelay( lengths[i] ); + combDelays_[i].setDelay( lengths[i] ); + combCoefficient_[i] = pow(10.0, (-3 * lengths[i] / (T60 * Stk::sampleRate()))); + } + + for ( i=0; i<8; i++ ) { + allpassDelays_[i].setMaximumDelay( lengths[i+6] ); + allpassDelays_[i].setDelay( lengths[i+6] ); + } + + this->setT60( T60 ); + allpassCoefficient_ = 0.7; + effectMix_ = 0.3; + this->clear(); +} + +void NRev :: clear() +{ + int i; + for (i=0; i<6; i++) combDelays_[i].clear(); + for (i=0; i<8; i++) allpassDelays_[i].clear(); + lastFrame_[0] = 0.0; + lastFrame_[1] = 0.0; + lowpassState_ = 0.0; +} + +void NRev :: setT60( StkFloat T60 ) +{ + if ( T60 <= 0.0 ) { + oStream_ << "NRev::setT60: argument (" << T60 << ") must be positive!"; + handleError( StkError::WARNING ); return; + } + + for ( int i=0; i<6; i++ ) + combCoefficient_[i] = pow(10.0, (-3.0 * combDelays_[i].getDelay() / (T60 * Stk::sampleRate()))); +} + +StkFrames& NRev :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() - 1 ) { + oStream_ << "NRev::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() - 1 ) { + oStream_ << "NRev::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i + +namespace stk { + +Noise :: Noise( unsigned int seed ) +{ + // Seed the random number generator + this->setSeed( seed ); +} + +void Noise :: setSeed( unsigned int seed ) +{ + if ( seed == 0 ) + srand( (unsigned int) time( NULL ) ); + else + srand( seed ); +} + +} // stk namespace + + diff --git a/7.x/src/stk/src/OnePole.cpp b/7.x/src/stk/src/OnePole.cpp new file mode 100644 index 0000000..bbdfa61 --- /dev/null +++ b/7.x/src/stk/src/OnePole.cpp @@ -0,0 +1,61 @@ +/***************************************************/ +/*! \class OnePole + \brief STK one-pole filter class. + + This class implements a one-pole digital filter. A method is + provided for setting the pole position along the real axis of the + z-plane while maintaining a constant peak filter gain. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "OnePole.h" + +namespace stk { + +OnePole :: OnePole( StkFloat thePole ) +{ + b_.resize( 1 ); + a_.resize( 2 ); + a_[0] = 1.0; + inputs_.resize( 1, 1, 0.0 ); + outputs_.resize( 2, 1, 0.0 ); + + this->setPole( thePole ); +} + +OnePole :: ~OnePole() +{ +} + +void OnePole :: setPole( StkFloat thePole ) +{ + if ( std::abs( thePole ) >= 1.0 ) { + oStream_ << "OnePole::setPole: argument (" << thePole << ") should be less than 1.0!"; + handleError( StkError::WARNING ); return; + } + + // Normalize coefficients for peak unity gain. + if ( thePole > 0.0 ) + b_[0] = (StkFloat) (1.0 - thePole); + else + b_[0] = (StkFloat) (1.0 + thePole); + + a_[1] = -thePole; +} + +void OnePole :: setCoefficients( StkFloat b0, StkFloat a1, bool clearState ) +{ + if ( std::abs( a1 ) >= 1.0 ) { + oStream_ << "OnePole::setCoefficients: a1 argument (" << a1 << ") should be less than 1.0!"; + handleError( StkError::WARNING ); return; + } + + b_[0] = b0; + a_[1] = a1; + + if ( clearState ) this->clear(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/OneZero.cpp b/7.x/src/stk/src/OneZero.cpp new file mode 100644 index 0000000..bf16c85 --- /dev/null +++ b/7.x/src/stk/src/OneZero.cpp @@ -0,0 +1,49 @@ +/***************************************************/ +/*! \class OneZero + \brief STK one-zero filter class. + + This class implements a one-zero digital filter. A method is + provided for setting the zero position along the real axis of the + z-plane while maintaining a constant filter gain. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "OneZero.h" +#include + +namespace stk { + +OneZero :: OneZero( StkFloat theZero ) +{ + b_.resize( 2 ); + inputs_.resize( 2, 1, 0.0 ); + + this->setZero( theZero ); +} + +OneZero :: ~OneZero( void ) +{ +} + +void OneZero :: setZero( StkFloat theZero ) +{ + // Normalize coefficients for unity gain. + if ( theZero > 0.0 ) + b_[0] = 1.0 / ((StkFloat) 1.0 + theZero); + else + b_[0] = 1.0 / ((StkFloat) 1.0 - theZero); + + b_[1] = -theZero * b_[0]; +} + +void OneZero :: setCoefficients( StkFloat b0, StkFloat b1, bool clearState ) +{ + b_[0] = b0; + b_[1] = b1; + + if ( clearState ) this->clear(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/PRCRev.cpp b/7.x/src/stk/src/PRCRev.cpp new file mode 100644 index 0000000..f2ecd21 --- /dev/null +++ b/7.x/src/stk/src/PRCRev.cpp @@ -0,0 +1,120 @@ +/***************************************************/ +/*! \class PRCRev + \brief Perry's simple reverberator class. + + This class is based on some of the famous + Stanford/CCRMA reverbs (NRev, KipRev), which + were based on the Chowning/Moorer/Schroeder + reverberators using networks of simple allpass + and comb delay filters. This class implements + two series allpass units and two parallel comb + filters. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "PRCRev.h" +#include + +namespace stk { + +PRCRev :: PRCRev( StkFloat T60 ) +{ + if ( T60 <= 0.0 ) { + oStream_ << "PRCRev::PRCRev: argument (" << T60 << ") must be positive!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + lastFrame_.resize( 1, 2, 0.0 ); // resize lastFrame_ for stereo output + + // Delay lengths for 44100 Hz sample rate. + int lengths[4]= {341, 613, 1557, 2137}; + double scaler = Stk::sampleRate() / 44100.0; + + // Scale the delay lengths if necessary. + int delay, i; + if ( scaler != 1.0 ) { + for (i=0; i<4; i++) { + delay = (int) floor(scaler * lengths[i]); + if ( (delay & 1) == 0) delay++; + while ( !this->isPrime(delay) ) delay += 2; + lengths[i] = delay; + } + } + + for ( i=0; i<2; i++ ) { + allpassDelays_[i].setMaximumDelay( lengths[i] ); + allpassDelays_[i].setDelay( lengths[i] ); + + combDelays_[i].setMaximumDelay( lengths[i+2] ); + combDelays_[i].setDelay( lengths[i+2] ); + } + + this->setT60( T60 ); + allpassCoefficient_ = 0.7; + effectMix_ = 0.5; + this->clear(); +} + +void PRCRev :: clear( void ) +{ + allpassDelays_[0].clear(); + allpassDelays_[1].clear(); + combDelays_[0].clear(); + combDelays_[1].clear(); + lastFrame_[0] = 0.0; + lastFrame_[1] = 0.0; +} + +void PRCRev :: setT60( StkFloat T60 ) +{ + if ( T60 <= 0.0 ) { + oStream_ << "PRCRev::setT60: argument (" << T60 << ") must be positive!"; + handleError( StkError::WARNING ); return; + } + + combCoefficient_[0] = pow(10.0, (-3.0 * combDelays_[0].getDelay() / (T60 * Stk::sampleRate()))); + combCoefficient_[1] = pow(10.0, (-3.0 * combDelays_[1].getDelay() / (T60 * Stk::sampleRate()))); +} + +StkFrames& PRCRev :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() - 1 ) { + oStream_ << "PRCRev::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() - 1 ) { + oStream_ << "PRCRev::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; i3--\ + 2-- + -->1-->Out + \endcode + + Control Change Numbers: + - Total Modulator Index = 2 + - Modulator Crossfade = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "PercFlut.h" + +namespace stk { + +PercFlut :: PercFlut( void ) + : FM() +{ + // Concatenate the STK rawwave path to the rawwave files + for ( unsigned int i=0; i<3; i++ ) + waves_[i] = new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ); + waves_[3] = new FileLoop( (Stk::rawwavePath() + "fwavblnk.raw").c_str(), true ); + + this->setRatio(0, 1.50 * 1.000); + this->setRatio(1, 3.00 * 0.995); + this->setRatio(2, 2.99 * 1.005); + this->setRatio(3, 6.00 * 0.997); + gains_[0] = fmGains_[99]; + gains_[1] = fmGains_[71]; + gains_[2] = fmGains_[93]; + gains_[3] = fmGains_[85]; + + adsr_[0]->setAllTimes( 0.05, 0.05, fmSusLevels_[14], 0.05); + adsr_[1]->setAllTimes( 0.02, 0.50, fmSusLevels_[13], 0.5); + adsr_[2]->setAllTimes( 0.02, 0.30, fmSusLevels_[11], 0.05); + adsr_[3]->setAllTimes( 0.02, 0.05, fmSusLevels_[13], 0.01); + + twozero_.setGain( 0.0 ); + modDepth_ = 0.005; +} + +PercFlut :: ~PercFlut( void ) +{ +} + +void PercFlut :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "PercFlut::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + baseFrequency_ = frequency; +} + +void PercFlut :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + gains_[0] = amplitude * fmGains_[99] * 0.5; + gains_[1] = amplitude * fmGains_[71] * 0.5; + gains_[2] = amplitude * fmGains_[93] * 0.5; + gains_[3] = amplitude * fmGains_[85] * 0.5; + this->setFrequency( frequency ); + this->keyOn(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Phonemes.cpp b/7.x/src/stk/src/Phonemes.cpp new file mode 100644 index 0000000..fa3d52b --- /dev/null +++ b/7.x/src/stk/src/Phonemes.cpp @@ -0,0 +1,292 @@ +/***************************************************/ +/*! \class Phonemes + \brief STK phonemes table. + + This class does nothing other than declare a + set of 32 static phoneme formant parameters + and provide access to those values. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Phonemes.h" +#include + +namespace stk { + +const char Phonemes :: phonemeNames[32][4] = + {"eee", "ihh", "ehh", "aaa", + "ahh", "aww", "ohh", "uhh", + "uuu", "ooo", "rrr", "lll", + "mmm", "nnn", "nng", "ngg", + "fff", "sss", "thh", "shh", + "xxx", "hee", "hoo", "hah", + "bbb", "ddd", "jjj", "ggg", + "vvv", "zzz", "thz", "zhh" + }; + +const StkFloat Phonemes :: phonemeGains[32][2] = + {{1.0, 0.0}, // eee + {1.0, 0.0}, // ihh + {1.0, 0.0}, // ehh + {1.0, 0.0}, // aaa + + {1.0, 0.0}, // ahh + {1.0, 0.0}, // aww + {1.0, 0.0}, // ohh + {1.0, 0.0}, // uhh + + {1.0, 0.0}, // uuu + {1.0, 0.0}, // ooo + {1.0, 0.0}, // rrr + {1.0, 0.0}, // lll + + {1.0, 0.0}, // mmm + {1.0, 0.0}, // nnn + {1.0, 0.0}, // nng + {1.0, 0.0}, // ngg + + {0.0, 0.7}, // fff + {0.0, 0.7}, // sss + {0.0, 0.7}, // thh + {0.0, 0.7}, // shh + + {0.0, 0.7}, // xxx + {0.0, 0.1}, // hee + {0.0, 0.1}, // hoo + {0.0, 0.1}, // hah + + {1.0, 0.1}, // bbb + {1.0, 0.1}, // ddd + {1.0, 0.1}, // jjj + {1.0, 0.1}, // ggg + + {1.0, 1.0}, // vvv + {1.0, 1.0}, // zzz + {1.0, 1.0}, // thz + {1.0, 1.0} // zhh + }; + +const StkFloat Phonemes :: phonemeParameters[32][4][3] = + {{ { 273, 0.996, 10}, // eee (beet) + {2086, 0.945, -16}, + {2754, 0.979, -12}, + {3270, 0.440, -17}}, + { { 385, 0.987, 10}, // ihh (bit) + {2056, 0.930, -20}, + {2587, 0.890, -20}, + {3150, 0.400, -20}}, + { { 515, 0.977, 10}, // ehh (bet) + {1805, 0.810, -10}, + {2526, 0.875, -10}, + {3103, 0.400, -13}}, + { { 773, 0.950, 10}, // aaa (bat) + {1676, 0.830, -6}, + {2380, 0.880, -20}, + {3027, 0.600, -20}}, + + { { 770, 0.950, 0}, // ahh (father) + {1153, 0.970, -9}, + {2450, 0.780, -29}, + {3140, 0.800, -39}}, + { { 637, 0.910, 0}, // aww (bought) + { 895, 0.900, -3}, + {2556, 0.950, -17}, + {3070, 0.910, -20}}, + { { 637, 0.910, 0}, // ohh (bone) NOTE:: same as aww (bought) + { 895, 0.900, -3}, + {2556, 0.950, -17}, + {3070, 0.910, -20}}, + { { 561, 0.965, 0}, // uhh (but) + {1084, 0.930, -10}, + {2541, 0.930, -15}, + {3345, 0.900, -20}}, + + { { 515, 0.976, 0}, // uuu (foot) + {1031, 0.950, -3}, + {2572, 0.960, -11}, + {3345, 0.960, -20}}, + { { 349, 0.986, -10}, // ooo (boot) + { 918, 0.940, -20}, + {2350, 0.960, -27}, + {2731, 0.950, -33}}, + { { 394, 0.959, -10}, // rrr (bird) + {1297, 0.780, -16}, + {1441, 0.980, -16}, + {2754, 0.950, -40}}, + { { 462, 0.990, +5}, // lll (lull) + {1200, 0.640, -10}, + {2500, 0.200, -20}, + {3000, 0.100, -30}}, + + { { 265, 0.987, -10}, // mmm (mom) + {1176, 0.940, -22}, + {2352, 0.970, -20}, + {3277, 0.940, -31}}, + { { 204, 0.980, -10}, // nnn (nun) + {1570, 0.940, -15}, + {2481, 0.980, -12}, + {3133, 0.800, -30}}, + { { 204, 0.980, -10}, // nng (sang) NOTE:: same as nnn + {1570, 0.940, -15}, + {2481, 0.980, -12}, + {3133, 0.800, -30}}, + { { 204, 0.980, -10}, // ngg (bong) NOTE:: same as nnn + {1570, 0.940, -15}, + {2481, 0.980, -12}, + {3133, 0.800, -30}}, + + { {1000, 0.300, 0}, // fff + {2800, 0.860, -10}, + {7425, 0.740, 0}, + {8140, 0.860, 0}}, + { {0, 0.000, 0}, // sss + {2000, 0.700, -15}, + {5257, 0.750, -3}, + {7171, 0.840, 0}}, + { { 100, 0.900, 0}, // thh + {4000, 0.500, -20}, + {5500, 0.500, -15}, + {8000, 0.400, -20}}, + { {2693, 0.940, 0}, // shh + {4000, 0.720, -10}, + {6123, 0.870, -10}, + {7755, 0.750, -18}}, + + { {1000, 0.300, -10}, // xxx NOTE:: Not Really Done Yet + {2800, 0.860, -10}, + {7425, 0.740, 0}, + {8140, 0.860, 0}}, + { { 273, 0.996, -40}, // hee (beet) (noisy eee) + {2086, 0.945, -16}, + {2754, 0.979, -12}, + {3270, 0.440, -17}}, + { { 349, 0.986, -40}, // hoo (boot) (noisy ooo) + { 918, 0.940, -10}, + {2350, 0.960, -17}, + {2731, 0.950, -23}}, + { { 770, 0.950, -40}, // hah (father) (noisy ahh) + {1153, 0.970, -3}, + {2450, 0.780, -20}, + {3140, 0.800, -32}}, + + { {2000, 0.700, -20}, // bbb NOTE:: Not Really Done Yet + {5257, 0.750, -15}, + {7171, 0.840, -3}, + {9000, 0.900, 0}}, + { { 100, 0.900, 0}, // ddd NOTE:: Not Really Done Yet + {4000, 0.500, -20}, + {5500, 0.500, -15}, + {8000, 0.400, -20}}, + { {2693, 0.940, 0}, // jjj NOTE:: Not Really Done Yet + {4000, 0.720, -10}, + {6123, 0.870, -10}, + {7755, 0.750, -18}}, + { {2693, 0.940, 0}, // ggg NOTE:: Not Really Done Yet + {4000, 0.720, -10}, + {6123, 0.870, -10}, + {7755, 0.750, -18}}, + + { {2000, 0.700, -20}, // vvv NOTE:: Not Really Done Yet + {5257, 0.750, -15}, + {7171, 0.840, -3}, + {9000, 0.900, 0}}, + { { 100, 0.900, 0}, // zzz NOTE:: Not Really Done Yet + {4000, 0.500, -20}, + {5500, 0.500, -15}, + {8000, 0.400, -20}}, + { {2693, 0.940, 0}, // thz NOTE:: Not Really Done Yet + {4000, 0.720, -10}, + {6123, 0.870, -10}, + {7755, 0.750, -18}}, + { {2693, 0.940, 0}, // zhh NOTE:: Not Really Done Yet + {4000, 0.720, -10}, + {6123, 0.870, -10}, + {7755, 0.750, -18}} + }; + +Phonemes :: Phonemes(void) +{ +} + +Phonemes :: ~Phonemes(void) +{ +} + +const char *Phonemes :: name( unsigned int index ) +{ + if ( index > 31 ) { + oStream_ << "Phonemes::name: index is greater than 31!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0; + } + return phonemeNames[index]; +} + +StkFloat Phonemes :: voiceGain( unsigned int index ) +{ + if ( index > 31 ) { + oStream_ << "Phonemes::voiceGain: index is greater than 31!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + return phonemeGains[index][0]; +} + +StkFloat Phonemes :: noiseGain( unsigned int index ) +{ + if ( index > 31 ) { + oStream_ << "Phonemes::noiseGain: index is greater than 31!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + return phonemeGains[index][1]; +} + +StkFloat Phonemes :: formantFrequency( unsigned int index, unsigned int partial ) +{ + if ( index > 31 ) { + oStream_ << "Phonemes::formantFrequency: index is greater than 31!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + if ( partial > 3 ) { + oStream_ << "Phonemes::formantFrequency: partial is greater than 3!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + return phonemeParameters[index][partial][0]; +} + +StkFloat Phonemes :: formantRadius( unsigned int index, unsigned int partial ) +{ + if ( index > 31 ) { + oStream_ << "Phonemes::formantRadius: index is greater than 31!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + if ( partial > 3 ) { + oStream_ << "Phonemes::formantRadius: partial is greater than 3!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + return phonemeParameters[index][partial][1]; +} + +StkFloat Phonemes :: formantGain( unsigned int index, unsigned int partial ) +{ + if ( index > 31 ) { + oStream_ << "Phonemes::formantGain: index is greater than 31!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + if ( partial > 3 ) { + oStream_ << "Phonemes::formantGain: partial is greater than 3!"; + handleError( oStream_.str(), StkError::WARNING ); + return 0.0; + } + return phonemeParameters[index][partial][2]; +} + +} // stk namespace diff --git a/7.x/src/stk/src/PitShift.cpp b/7.x/src/stk/src/PitShift.cpp new file mode 100644 index 0000000..eaead21 --- /dev/null +++ b/7.x/src/stk/src/PitShift.cpp @@ -0,0 +1,88 @@ +/***************************************************/ +/*! \class PitShift + \brief STK simple pitch shifter effect class. + + This class implements a simple pitch shifter + using delay lines. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "PitShift.h" +#include + +namespace stk { + +PitShift :: PitShift( void ) +{ + delayLength_ = maxDelay - 24; + halfLength_ = delayLength_ / 2; + delay_[0] = 12; + delay_[1] = maxDelay / 2; + + delayLine_[0].setMaximumDelay( maxDelay ); + delayLine_[0].setDelay( delay_[0] ); + delayLine_[1].setMaximumDelay( maxDelay ); + delayLine_[1].setDelay( delay_[1] ); + effectMix_ = 0.5; + rate_ = 1.0; +} + +void PitShift :: clear() +{ + delayLine_[0].clear(); + delayLine_[1].clear(); + lastFrame_[0] = 0.0; +} + +void PitShift :: setShift( StkFloat shift ) +{ + if ( shift < 1.0 ) { + rate_ = 1.0 - shift; + } + else if ( shift > 1.0 ) { + rate_ = 1.0 - shift; + } + else { + rate_ = 0.0; + delay_[0] = halfLength_ + 12; + } +} + +StkFrames& PitShift :: tick( StkFrames& frames, unsigned int channel ) +{ +#if defined(_STK_DEBUG_) + if ( channel >= frames.channels() ) { + oStream_ << "PitShift::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *samples = &frames[channel]; + unsigned int hop = frames.channels(); + for ( unsigned int i=0; i= iFrames.channels() || oChannel >= oFrames.channels() ) { + oStream_ << "PitShift::tick(): channel and StkFrames arguments are incompatible!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } +#endif + + StkFloat *iSamples = &iFrames[iChannel]; + StkFloat *oSamples = &oFrames[oChannel]; + unsigned int iHop = iFrames.channels(), oHop = oFrames.channels(); + for ( unsigned int i=0; isetFrequency( 220.0 ); +} + +Plucked :: ~Plucked( void ) +{ +} + +void Plucked :: clear( void ) +{ + delayLine_.clear(); + loopFilter_.clear(); + pickFilter_.clear(); +} + +void Plucked :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Plucked::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + // Delay = length - filter delay. + StkFloat delay = ( Stk::sampleRate() / frequency ) - loopFilter_.phaseDelay( frequency ); + delayLine_.setDelay( delay ); + + loopGain_ = 0.995 + (frequency * 0.000005); + if ( loopGain_ >= 1.0 ) loopGain_ = 0.99999; +} + +void Plucked :: pluck( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "Plucked::pluck: amplitude is out of range!"; + handleError( StkError::WARNING ); return; + } + + pickFilter_.setPole( 0.999 - (amplitude * 0.15) ); + pickFilter_.setGain( amplitude * 0.5 ); + for ( unsigned long i=0; isetFrequency( frequency ); + this->pluck( amplitude ); +} + +void Plucked :: noteOff( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "Plucked::noteOff: amplitude is out of range!"; + handleError( StkError::WARNING ); return; + } + + loopGain_ = 1.0 - amplitude; +} + +} // stk namespace diff --git a/7.x/src/stk/src/PoleZero.cpp b/7.x/src/stk/src/PoleZero.cpp new file mode 100644 index 0000000..2f2e821 --- /dev/null +++ b/7.x/src/stk/src/PoleZero.cpp @@ -0,0 +1,73 @@ +/***************************************************/ +/*! \class PoleZero + \brief STK one-pole, one-zero filter class. + + This class implements a one-pole, one-zero digital filter. A + method is provided for creating an allpass filter with a given + coefficient. Another method is provided to create a DC blocking + filter. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "PoleZero.h" + +namespace stk { + +PoleZero :: PoleZero() +{ + // Default setting for pass-through. + b_.resize( 2, 0.0 ); + a_.resize( 2, 0.0 ); + b_[0] = 1.0; + a_[0] = 1.0; + inputs_.resize( 2, 1, 0.0 ); + outputs_.resize( 2, 1, 0.0 ); +} + +PoleZero :: ~PoleZero() +{ +} + +void PoleZero :: setCoefficients( StkFloat b0, StkFloat b1, StkFloat a1, bool clearState ) +{ + if ( std::abs( a1 ) >= 1.0 ) { + oStream_ << "PoleZero::setCoefficients: a1 argument (" << a1 << ") should be less than 1.0!"; + handleError( StkError::WARNING ); return; + } + + b_[0] = b0; + b_[1] = b1; + a_[1] = a1; + + if ( clearState ) this->clear(); +} + +void PoleZero :: setAllpass( StkFloat coefficient ) +{ + if ( std::abs( coefficient ) >= 1.0 ) { + oStream_ << "PoleZero::setAllpass: argument (" << coefficient << ") makes filter unstable!"; + handleError( StkError::WARNING ); return; + } + + b_[0] = coefficient; + b_[1] = 1.0; + a_[0] = 1.0; // just in case + a_[1] = coefficient; +} + +void PoleZero :: setBlockZero( StkFloat thePole ) +{ + if ( std::abs( thePole ) >= 1.0 ) { + oStream_ << "PoleZero::setBlockZero: argument (" << thePole << ") makes filter unstable!"; + handleError( StkError::WARNING ); return; + } + + b_[0] = 1.0; + b_[1] = -1.0; + a_[0] = 1.0; // just in case + a_[1] = -thePole; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Recorder.cpp b/7.x/src/stk/src/Recorder.cpp new file mode 100644 index 0000000..8dc0eec --- /dev/null +++ b/7.x/src/stk/src/Recorder.cpp @@ -0,0 +1,345 @@ +/***************************************************/ +/*! \class Recorder + \brief A recorder / flute physical model. + + This class implements a physical model of a recorder / + flute instrument, based on the paper "Sound production + in recorderlike instruments. II. A simulation model." + by M.P. Verge, A. Hirschberg and R. Causse, Journal of + the Acoustical Society of America, 1997. + + Control Change Numbers: + - Softness = 2 + - Noise Gain = 4 + - Noise Cutoff = 16 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Breath Pressure = 128 + + by Mathias Bredholt, McGill University. + Formatted for STK by Gary Scavone, 2021. +*/ +/***************************************************/ + +#include "Recorder.h" +#include "SKINImsg.h" + +namespace stk { + +// Air constants +const stk::StkFloat rho = 1.2041; // density of air +const stk::StkFloat c0 = 343.21; // speed of sound in air + +// Flute constants +const stk::StkFloat lc = 0.02; // length of flue canal +const stk::StkFloat h = 0.001; // height of flue exit +const stk::StkFloat H = 0.02; // pipe diameter +const stk::StkFloat W = 4 * h; // width of mouth +const stk::StkFloat Sp = H * H; // cross-section of pipe +const stk::StkFloat Sm = W * H; // cross-section of mouth +const stk::StkFloat din = 0.0030; // end correction +const stk::StkFloat dout = 0.0063; // end correction +const stk::StkFloat dm = din + dout; // end correction of mouth +const stk::StkFloat dd = 0.0035; // acoustic distance between Q1 and Q2 +const stk::StkFloat rp = sqrt(Sp / stk::PI); +const stk::StkFloat b = 0.4 * h; // jet width + +// Calculation coefficients +const stk::StkFloat b2 = Sp / (rho * c0); + +Recorder :: Recorder() +{ + vibratoGain_ = 0.0; + noiseGain_ = 0.2; + breathCutoff_ = 0.0; + outputGain_ = 0.0; + psi_ = 1.0; + poutL_ = 0; + pout_ = 0; + poutm1_ = 0; + poutm2_ = 0; + pin_ = 0; + pinm1_ = 0; + pinm2_ = 0; + Uj_ = 0; + Ujm1_ = 0; + Qj_ = 0; + Qjm1_ = 0; + Qjm2_ = 0; + Q1_ = 0; + Q1m1_ = 0; + Q1m2_ = 0; + Qp_ = 0; + Qpm1_ = 0; + pm_ = 0; + + pinDelay_.tick( 0 ); + poutDelay_.tick( 0 ); + jetDelay_.tick( 0 ); + + jetDelay_.setDelay(200); + vibrato_.setFrequency(4); + + // Calculation coefficients ... would need to be recalculated if sample rate changes + StkFloat T = 1.0 / Stk::sampleRate(); + b1 = rho / (4.0 * PI * c0 * T * T); + b3 = dm * Sp / (T * Sm * c0); + b4 = rho * dout / (Sm * T); + + // Radiation loss filter + StkFloat A = rp * rp / (4 * c0 * c0 * T * T); + StkFloat B = 0.82 * rp / (c0*T); + StkFloat b_rad[3] = { 1 + A - B, B - 2 * A, A }; + StkFloat a_rad[3] = { A - B - 1, B - 2 * A, A }; + std::vector b_coeffs( &b_rad[0], &b_rad[0]+3 ); + std::vector a_coeffs( &a_rad[0], &a_rad[0]+3 ); + radiation_filter_.setCoefficients(b_coeffs, a_coeffs); + + // Visco-thermal loss filter + StkFloat b_visco[4] = { 0.83820223947141, -0.16888603248373, -0.64759781930259, 0.07424498608506 }; + StkFloat a_visco[4] = { 1.0, -0.33623476246554, -0.71257915055968, 0.14508304017256 }; + b_coeffs.clear(); + b_coeffs.assign( &b_visco[0], &b_visco[0]+4 ); + a_coeffs.clear(); + a_coeffs.assign( &a_visco[0], &a_visco[0]+4 ); + visco_in_filter_.setCoefficients(b_coeffs, a_coeffs); + visco_out_filter_.setCoefficients(b_coeffs, a_coeffs); + + setBreathCutoff( 500 ); + setFrequency( 880 ); +} + +Recorder :: ~Recorder( void ) +{ +} + +void Recorder :: clear( void ) +{ + pinDelay_.clear(); + poutDelay_.clear(); + jetDelay_.clear(); + radiation_filter_.clear(); + visco_in_filter_.clear(); + visco_out_filter_.clear(); + turbFilter_.clear(); +} + +void Recorder :: setFrequency( StkFloat val ) +{ +#if defined(_STK_DEBUG_) + if ( val <= 0.0 ) { + oStream_ << "Recorder::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat M = Stk::sampleRate() / val - 4 - 3; + pinDelay_.setDelay( M ); + poutDelay_.setDelay( M ); +} + +void Recorder :: setBlowPressure( StkFloat val ) +{ + maxPressure_ = val; +} + +void Recorder :: setVibratoGain( StkFloat val ) +{ + vibratoGain_ = val; +} + +void Recorder :: setVibratoFrequency( StkFloat val ) +{ + vibrato_.setFrequency( val ); +} + +void Recorder :: setNoiseGain( StkFloat val ) +{ + noiseGain_ = val; +} + +void Recorder :: setBreathCutoff( StkFloat val ) +{ + // The gain of this filter is quite high + breathCutoff_ = val; + StkFloat Q = 0.99; + StkFloat r = 2.0 * sin(PI * val / sampleRate()); + StkFloat q = 1.0 - r * Q; + StkFloat as[3] = { 1.0, r * r - q - 1, q }; + std::vector b_turb(1, r*r); + std::vector a_turb( &as[0], &as[0]+3 ); + turbFilter_.setCoefficients(b_turb, a_turb); +} + +void Recorder :: setSoftness( StkFloat val ) +{ + psi_ = val; +} + +void Recorder :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "Recorder::startBlowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setAttackRate( rate ); + //maxPressure_ = amplitude / (StkFloat) 0.8; + maxPressure_ = 35 * amplitude; + adsr_.keyOn(); +} + +void Recorder :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "Recorder::stopBlowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + adsr_.setReleaseRate( rate ); + adsr_.keyOff(); +} + +void Recorder :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->startBlowing( 1.1 + (amplitude * 0.20), amplitude * 0.02 ); + outputGain_ = amplitude / 40.0; +} + +void Recorder :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.02 ); +} + +void Recorder :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Recorder::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == 2) // 2 + psi_ = 2.0 * normalizedValue; + else if (number == 16) + setBreathCutoff( normalizedValue * 2000 ); + else if (number == __SK_NoiseLevel_) // 4 + noiseGain_ = normalizedValue; + else if (number == __SK_ModFrequency_) // 11 + vibrato_.setFrequency( normalizedValue * 12.0); + else if (number == __SK_ModWheel_) // 1 + vibratoGain_ = ( normalizedValue * 0.4 ); + else if (number == __SK_AfterTouch_Cont_) // 128 + maxPressure_ = 35.0 * normalizedValue; +#if defined(_STK_DEBUG_) + else { + oStream_ << "Recorder::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +StkFloat Recorder::tick( unsigned int ) +{ + // Read in from delay lines + pinm2_ = pinm1_; + pinm1_ = pin_; + pin_ = pinDelay_.lastOut(); + + poutm2_ = poutm1_; + poutm1_ = pout_; + poutL_ = poutDelay_.lastOut(); + + // Filter wave components for visco-thermal losses + pin_ = visco_in_filter_.tick(pin_); + poutL_ = visco_out_filter_.tick(poutL_); + + // Get input blow pressure + StkFloat pf = maxPressure_ * adsr_.tick() * (vibrato_.tick() * vibratoGain_ + (1 - vibratoGain_)); + + StkFloat T = 1.0 / sampleRate(); + + // Jet velocity at flue exit + Ujm1_ = Uj_; + Uj_ = Ujm1_ + T / (rho * lc) * (pf - pm_ - 0.5 * rho * Ujm1_ * Ujm1_); + + // Jet flow at flue exit + Qjm2_ = Qjm1_; + Qjm1_ = Qj_; + Qj_ = h * H * Uj_; + + // Jet drive + StkFloat Uj_steady = fmax(sqrt(2 * pf / rho), 0.1); + StkFloat fc_jet = 0.36 / W * Uj_steady; + StkFloat g_jet = 0.002004 * exp(-0.06046 * Uj_steady); + StkFloat r_jet = 0.95 - Uj_steady * 0.015; + StkFloat b0_jet = g_jet * (1 - r_jet * r_jet) / 2; + + // Calculate coefficients for resonant filter + StkFloat b_jet[3] = { b0_jet, 0, -b0_jet }; + StkFloat a_jet[3] = { 1, -2 * r_jet * cos(2 * PI * fc_jet * T), r_jet * r_jet }; + std::vector b_jetcoeffs( &b_jet[0], &b_jet[0]+3 ); + std::vector a_jetcoeffs( &a_jet[0], &a_jet[0]+3 ); + jetFilter_.setCoefficients( b_jetcoeffs, a_jetcoeffs ); + StkFloat eta = jetFilter_.tick(jetDelay_.lastOut()); + + // Calculate flow source Q1 + Q1m1_ = Q1_; + Q1_ = b * H * Uj_ * (1 + tanh(eta / (psi_ * b))); + + // Calculate pressure pulse modeling the jet drive + StkFloat pjd = -rho * dd / Sm * (Q1_ - Q1m1_) / T; + + // Vortex shedding + int Qp_sign = 0; + if (Qp_ < 0) Qp_sign = -1; + else if (Qp_ > 0) Qp_sign = 1; + + StkFloat pa = -0.5 * rho * (Qp_ / (0.6 * Sm)) * (Qp_ / (0.6 * Sm)) * Qp_sign; + + // Turbulence + StkFloat pt = turbFilter_.tick(noiseGain_ * turb_.tick() * 0.5 * rho * Uj_ * Uj_); + + // Pressure pulse delta p + StkFloat dp = pjd + pa + pt; + + // Calculate outgoing pressure pout + pout_ = ((b3 - b1 * b2 - 1) * pin_ + + (2 * b1 * b2 - b3) * (pinm1_ - poutm1_) + + b1 * b2 * (poutm2_ - pinm2_) - + b1 * (Qj_ - 2 * Qjm1_ + Qjm2_) + + b4 * (Qj_ - Qjm1_) + dp) / (1 - b1 * b2 + b3); + + // Flow in the pipe + Qpm1_ = Qp_; + Qp_ = Sp / (rho * c0) * (pout_ - pin_); + + // Mouth pressure + pm_ = pout_ + pin_ - dp + rho * din / Sm * (Qp_ - Qpm1_)/T; + + // Calculate transverse acoustic velocity + StkFloat Q1d = Q1_ - 0.5 * b * H * Uj_; + StkFloat Vac = 2.0 / PI * Qp_ / Sm - 0.38 * Q1d / Sm; + jetDelay_.tick(Vac); + + // Calculate new jet delay line length + //jet_.setDelay(fmin(W / (0.6 * Uj_steady) * sampleRate(), 200.0)); + jetDelay_.setDelay(fmin(W / (0.6 * Uj_steady * T), 200.0)); + + // Radiation loss filtering + StkFloat pin_L = radiation_filter_.tick(poutL_); + + // Write to delay lines + poutDelay_.tick(pout_); + pinDelay_.tick(pin_L); + + lastFrame_[0] = outputGain_ * (pout_ + pin_); + return lastFrame_[0]; + + //return (pout_0 + pin_0) * 0.01; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Resonate.cpp b/7.x/src/stk/src/Resonate.cpp new file mode 100644 index 0000000..3dc42fd --- /dev/null +++ b/7.x/src/stk/src/Resonate.cpp @@ -0,0 +1,113 @@ +/***************************************************/ +/*! \class Resonate + \brief STK noise driven formant filter. + + This instrument contains a noise source, which + excites a biquad resonance filter, with volume + controlled by an ADSR. + + Control Change Numbers: + - Resonance Frequency (0-Nyquist) = 2 + - Pole Radii = 4 + - Notch Frequency (0-Nyquist) = 11 + - Zero Radii = 1 + - Envelope Gain = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Resonate.h" +#include "SKINImsg.h" + +namespace stk { + +Resonate :: Resonate( void ) +{ + poleFrequency_ = 4000.0; + poleRadius_ = 0.95; + // Set the filter parameters. + filter_.setResonance( poleFrequency_, poleRadius_, true ); + zeroFrequency_ = 0.0; + zeroRadius_ = 0.0; +} + +Resonate :: ~Resonate( void ) +{ +} + +void Resonate :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + adsr_.setTarget( amplitude ); + this->keyOn(); + this->setResonance( frequency, poleRadius_ ); +} + +void Resonate :: noteOff( StkFloat amplitude ) +{ + this->keyOff(); +} + +void Resonate :: setResonance( StkFloat frequency, StkFloat radius ) +{ + if ( frequency < 0.0 ) { + oStream_ << "Resonate::setResonance: frequency parameter is less than zero!"; + handleError( StkError::WARNING ); return; + } + + if ( radius < 0.0 || radius >= 1.0 ) { + oStream_ << "Resonate::setResonance: radius parameter is out of range!"; + handleError( StkError::WARNING ); return; + } + + poleFrequency_ = frequency; + poleRadius_ = radius; + filter_.setResonance( poleFrequency_, poleRadius_, true ); +} + +void Resonate :: setNotch( StkFloat frequency, StkFloat radius ) +{ + if ( frequency < 0.0 ) { + oStream_ << "Resonate::setNotch: frequency parameter is less than zero ... setting to 0.0!"; + handleError( StkError::WARNING ); return; + } + + if ( radius < 0.0 ) { + oStream_ << "Resonate::setNotch: radius parameter is less than 0.0!"; + handleError( StkError::WARNING ); return; + } + + zeroFrequency_ = frequency; + zeroRadius_ = radius; + filter_.setNotch( zeroFrequency_, zeroRadius_ ); +} + +void Resonate :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Resonate::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == 2) // 2 + setResonance( normalizedValue * Stk::sampleRate() * 0.5, poleRadius_ ); + else if (number == 4) // 4 + setResonance( poleFrequency_, normalizedValue * 0.9999 ); + else if (number == 11) // 11 + this->setNotch( normalizedValue * Stk::sampleRate() * 0.5, zeroRadius_ ); + else if (number == 1) + this->setNotch( zeroFrequency_, normalizedValue ); + else if (number == __SK_AfterTouch_Cont_) // 128 + adsr_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Resonate::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Rhodey.cpp b/7.x/src/stk/src/Rhodey.cpp new file mode 100644 index 0000000..f1a415c --- /dev/null +++ b/7.x/src/stk/src/Rhodey.cpp @@ -0,0 +1,92 @@ +/***************************************************/ +/*! \class Rhodey + \brief STK Fender Rhodes-like electric piano FM + synthesis instrument. + + This class implements two simple FM Pairs + summed together, also referred to as algorithm + 5 of the TX81Z. + + \code + Algorithm 5 is : 4->3--\ + + --> Out + 2->1--/ + \endcode + + Control Change Numbers: + - Modulator Index One = 2 + - Crossfade of Outputs = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Rhodey.h" + +namespace stk { + +Rhodey :: Rhodey( void ) + : FM() +{ + // Concatenate the STK rawwave path to the rawwave files + for ( unsigned int i=0; i<3; i++ ) + waves_[i] = new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ); + waves_[3] = new FileLoop( (Stk::rawwavePath() + "fwavblnk.raw").c_str(), true ); + + this->setRatio(0, 1.0); + this->setRatio(1, 0.5); + this->setRatio(2, 1.0); + this->setRatio(3, 15.0); + + gains_[0] = fmGains_[99]; + gains_[1] = fmGains_[90]; + gains_[2] = fmGains_[99]; + gains_[3] = fmGains_[67]; + + adsr_[0]->setAllTimes( 0.001, 1.50, 0.0, 0.04); + adsr_[1]->setAllTimes( 0.001, 1.50, 0.0, 0.04); + adsr_[2]->setAllTimes( 0.001, 1.00, 0.0, 0.04); + adsr_[3]->setAllTimes( 0.001, 0.25, 0.0, 0.04); + + twozero_.setGain( 1.0 ); +} + +Rhodey :: ~Rhodey( void ) +{ +} + +void Rhodey :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Rhodey::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + baseFrequency_ = frequency * 2.0; + + for (unsigned int i=0; isetFrequency( baseFrequency_ * ratios_[i] ); +} + +void Rhodey :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + gains_[0] = amplitude * fmGains_[99]; + gains_[1] = amplitude * fmGains_[90]; + gains_[2] = amplitude * fmGains_[99]; + gains_[3] = amplitude * fmGains_[67]; + this->setFrequency( frequency ); + this->keyOn(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Sampler.cpp b/7.x/src/stk/src/Sampler.cpp new file mode 100644 index 0000000..f373b1f --- /dev/null +++ b/7.x/src/stk/src/Sampler.cpp @@ -0,0 +1,53 @@ +/***************************************************/ +/*! \class Sampler + \brief STK sampling synthesis abstract base class. + + This instrument provides an ADSR envelope, a one-pole filter, and + structures for an arbitrary number of attack and looped files. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Sampler.h" + +namespace stk { + +Sampler :: Sampler( void ) +{ + // We don't make the waves here yet, because + // we don't know what they will be. + baseFrequency_ = 440.0; + attackGain_ = 0.25; + loopGain_ = 0.25; +} + +Sampler :: ~Sampler( void ) +{ + unsigned int i; + for ( i=0; ireset(); + + // Start the envelope. + adsr_.keyOn(); + +} + +void Sampler :: keyOff( void ) +{ + adsr_.keyOff(); +} + +void Sampler :: noteOff( StkFloat amplitude ) +{ + this->keyOff(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Saxofony.cpp b/7.x/src/stk/src/Saxofony.cpp new file mode 100644 index 0000000..0877a54 --- /dev/null +++ b/7.x/src/stk/src/Saxofony.cpp @@ -0,0 +1,177 @@ +/***************************************************/ +/*! \class Saxofony + \brief STK faux conical bore reed instrument class. + + This class implements a "hybrid" digital + waveguide instrument that can generate a + variety of wind-like sounds. It has also been + referred to as the "blowed string" model. The + waveguide section is essentially that of a + string, with one rigid and one lossy + termination. The non-linear function is a + reed table. The string can be "blown" at any + point between the terminations, though just as + with strings, it is impossible to excite the + system at either end. If the excitation is + placed at the string mid-point, the sound is + that of a clarinet. At points closer to the + "bridge", the sound is closer to that of a + saxophone. See Scavone (2002) for more details. + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + Control Change Numbers: + - Reed Stiffness = 2 + - Reed Aperture = 26 + - Noise Gain = 4 + - Blow Position = 11 + - Vibrato Frequency = 29 + - Vibrato Gain = 1 + - Breath Pressure = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Saxofony.h" +#include "SKINImsg.h" + +namespace stk { + +Saxofony :: Saxofony( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "Saxofony::Saxofony: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long nDelays = (unsigned long) ( Stk::sampleRate() / lowestFrequency ); + delays_[0].setMaximumDelay( nDelays + 1 ); + delays_[1].setMaximumDelay( nDelays + 1 ); + + // Initialize blowing position to 0.2 of length. + position_ = 0.2; + + reedTable_.setOffset( 0.7 ); + reedTable_.setSlope( 0.3 ); + + vibrato_.setFrequency( 5.735 ); + + outputGain_ = 0.3; + noiseGain_ = 0.2; + vibratoGain_ = 0.1; + + this->setFrequency( 220.0 ); + this->clear(); +} + +Saxofony :: ~Saxofony( void ) +{ +} + +void Saxofony :: clear( void ) +{ + delays_[0].clear(); + delays_[1].clear(); + filter_.clear(); +} + +void Saxofony :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Saxofony::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + // Account for filter delay and one sample "lastOut" delay. + StkFloat delay = ( Stk::sampleRate() / frequency ) - filter_.phaseDelay( frequency ) - 1.0; + delays_[0].setDelay( (1.0-position_) * delay ); + delays_[1].setDelay( position_ * delay ); +} + +void Saxofony :: setBlowPosition( StkFloat position ) +{ + if ( position_ == position ) return; + + if ( position < 0.0 ) position_ = 0.0; + else if ( position > 1.0 ) position_ = 1.0; + else position_ = position; + + StkFloat totalDelay = delays_[0].getDelay(); + totalDelay += delays_[1].getDelay(); + + delays_[0].setDelay( (1.0-position_) * totalDelay ); + delays_[1].setDelay( position_ * totalDelay ); +} + +void Saxofony :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "Saxofony::startBlowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( rate ); + envelope_.setTarget( amplitude ); +} + +void Saxofony :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "Saxofony::stopBlowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( rate ); + envelope_.setTarget( 0.0 ); +} + +void Saxofony :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->startBlowing( 0.55 + (amplitude * 0.30), amplitude * 0.005 ); + outputGain_ = amplitude + 0.001; +} + +void Saxofony :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.01 ); +} + +void Saxofony :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Saxofony::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_ReedStiffness_) // 2 + reedTable_.setSlope( 0.1 + (0.4 * normalizedValue) ); + else if (number == __SK_NoiseLevel_) // 4 + noiseGain_ = ( normalizedValue * 0.4 ); + else if (number == 29) // 29 + vibrato_.setFrequency( normalizedValue * 12.0 ); + else if (number == __SK_ModWheel_) // 1 + vibratoGain_ = ( normalizedValue * 0.5 ); + else if (number == __SK_AfterTouch_Cont_) // 128 + envelope_.setValue( normalizedValue ); + else if (number == 11) // 11 + this->setBlowPosition( normalizedValue ); + else if (number == 26) // reed table offset + reedTable_.setOffset(0.4 + ( normalizedValue * 0.6)); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Saxofony::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Shakers.cpp b/7.x/src/stk/src/Shakers.cpp new file mode 100644 index 0000000..48ced91 --- /dev/null +++ b/7.x/src/stk/src/Shakers.cpp @@ -0,0 +1,729 @@ +/***************************************************/ +/*! \class Shakers + \brief PhISEM and PhOLIES class. + + PhISEM (Physically Informed Stochastic Event Modeling) is an + algorithmic approach for simulating collisions of multiple + independent sound producing objects. This class is a meta-model + that can simulate a Maraca, Sekere, Cabasa, Bamboo Wind Chimes, + Water Drops, Tambourine, Sleighbells, and a Guiro. + + PhOLIES (Physically-Oriented Library of Imitated Environmental + Sounds) is a similar approach for the synthesis of environmental + sounds. This class implements simulations of breaking sticks, + crunchy snow (or not), a wrench, sandpaper, and more. + + Control Change Numbers: + - Shake Energy = 2 + - System Decay = 4 + - Number Of Objects = 11 + - Resonance Frequency = 1 + - Shake Energy = 128 + - Instrument Selection = 1071 + - Maraca = 0 + - Cabasa = 1 + - Sekere = 2 + - Tambourine = 3 + - Sleigh Bells = 4 + - Bamboo Chimes = 5 + - Sand Paper = 6 + - Coke Can = 7 + - Sticks = 8 + - Crunch = 9 + - Big Rocks = 10 + - Little Rocks = 11 + - Next Mug = 12 + - Penny + Mug = 13 + - Nickle + Mug = 14 + - Dime + Mug = 15 + - Quarter + Mug = 16 + - Franc + Mug = 17 + - Peso + Mug = 18 + - Guiro = 19 + - Wrench = 20 + - Water Drops = 21 + - Tuned Bamboo Chimes = 22 + + by Perry R. Cook with updates by Gary Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Shakers.h" +#include "SKINImsg.h" + +namespace stk { + +// Maraca +const StkFloat MARACA_SOUND_DECAY = 0.95; +const StkFloat MARACA_SYSTEM_DECAY = 0.999; +const StkFloat MARACA_GAIN = 4.0; +const StkFloat MARACA_NUM_BEANS = 25; +const int MARACA_RESONANCES = 1; +const StkFloat MARACA_FREQUENCIES[MARACA_RESONANCES] = { 3200 }; +const StkFloat MARACA_RADII[MARACA_RESONANCES] = { 0.96 }; +const StkFloat MARACA_GAINS[MARACA_RESONANCES] = { 1.0 }; + +// Cabasa +const StkFloat CABASA_SOUND_DECAY = 0.96; +const StkFloat CABASA_SYSTEM_DECAY = 0.997; +const StkFloat CABASA_GAIN = 8.0; +const StkFloat CABASA_NUM_BEADS = 512; +const int CABASA_RESONANCES = 1; +const StkFloat CABASA_FREQUENCIES[CABASA_RESONANCES] = { 3000 }; +const StkFloat CABASA_RADII[CABASA_RESONANCES] = { 0.7 }; +const StkFloat CABASA_GAINS[CABASA_RESONANCES] = { 1.0 }; + +// Sekere +const StkFloat SEKERE_SOUND_DECAY = 0.96; +const StkFloat SEKERE_SYSTEM_DECAY = 0.999; +const StkFloat SEKERE_GAIN = 4.0; +const StkFloat SEKERE_NUM_BEANS = 64; +const int SEKERE_RESONANCES = 1; +const StkFloat SEKERE_FREQUENCIES[SEKERE_RESONANCES] = { 5500 }; +const StkFloat SEKERE_RADII[SEKERE_RESONANCES] = { 0.6 }; +const StkFloat SEKERE_GAINS[SEKERE_RESONANCES] = { 1.0 }; + +// Bamboo Wind Chimes +const StkFloat BAMBOO_SOUND_DECAY = 0.9; +const StkFloat BAMBOO_SYSTEM_DECAY = 0.9999; +const StkFloat BAMBOO_GAIN = 0.4; +const StkFloat BAMBOO_NUM_TUBES = 1.2; +const int BAMBOO_RESONANCES = 3; +const StkFloat BAMBOO_FREQUENCIES[BAMBOO_RESONANCES] = { 2800, 0.8 * 2800.0, 1.2 * 2800.0 }; +const StkFloat BAMBOO_RADII[BAMBOO_RESONANCES] = { 0.995, 0.995, 0.995 }; +const StkFloat BAMBOO_GAINS[BAMBOO_RESONANCES] = { 1.0, 1.0, 1.0 }; + +// Tambourine +const StkFloat TAMBOURINE_SOUND_DECAY = 0.95; +const StkFloat TAMBOURINE_SYSTEM_DECAY = 0.9985; +const StkFloat TAMBOURINE_GAIN = 1.0; +const StkFloat TAMBOURINE_NUM_TIMBRELS = 32; +const int TAMBOURINE_RESONANCES = 3; // Fixed shell + 2 moving cymbal resonances +const StkFloat TAMBOURINE_FREQUENCIES[TAMBOURINE_RESONANCES] = { 2300, 5600, 8100 }; +const StkFloat TAMBOURINE_RADII[TAMBOURINE_RESONANCES] = { 0.96, 0.99, 0.99 }; +const StkFloat TAMBOURINE_GAINS[TAMBOURINE_RESONANCES] = { 0.1, 0.8, 1.0 }; + +// Sleighbells +const StkFloat SLEIGH_SOUND_DECAY = 0.97; +const StkFloat SLEIGH_SYSTEM_DECAY = 0.9994; +const StkFloat SLEIGH_GAIN = 1.0; +const StkFloat SLEIGH_NUM_BELLS = 32; +const int SLEIGH_RESONANCES = 5; +const StkFloat SLEIGH_FREQUENCIES[SLEIGH_RESONANCES] = { 2500, 5300, 6500, 8300, 9800 }; +const StkFloat SLEIGH_RADII[SLEIGH_RESONANCES] = { 0.99, 0.99, 0.99, 0.99, 0.99 }; +const StkFloat SLEIGH_GAINS[SLEIGH_RESONANCES] = { 1.0, 1.0, 1.0, 0.5, 0.3 }; + +// Sandpaper +const StkFloat SANDPAPER_SOUND_DECAY = 0.999; +const StkFloat SANDPAPER_SYSTEM_DECAY = 0.999; +const StkFloat SANDPAPER_GAIN = 0.5; +const StkFloat SANDPAPER_NUM_GRAINS = 128; +const int SANDPAPER_RESONANCES = 1; +const StkFloat SANDPAPER_FREQUENCIES[SANDPAPER_RESONANCES] = { 4500 }; +const StkFloat SANDPAPER_RADII[SANDPAPER_RESONANCES] = { 0.6 }; +const StkFloat SANDPAPER_GAINS[SANDPAPER_RESONANCES] = { 1.0 }; + +// Cokecan +const StkFloat COKECAN_SOUND_DECAY = 0.97; +const StkFloat COKECAN_SYSTEM_DECAY = 0.999; +const StkFloat COKECAN_GAIN = 0.5; +const StkFloat COKECAN_NUM_PARTS = 48; +const int COKECAN_RESONANCES = 5; // Helmholtz + 4 metal resonances +const StkFloat COKECAN_FREQUENCIES[COKECAN_RESONANCES] = { 370, 1025, 1424, 2149, 3596 }; +const StkFloat COKECAN_RADII[COKECAN_RESONANCES] = { 0.99, 0.992, 0.992, 0.992, 0.992 }; +const StkFloat COKECAN_GAINS[COKECAN_RESONANCES] = { 1.0, 1.8, 1.8, 1.8, 1.8 }; + +// Tuned Bamboo Wind Chimes (Angklung) +const StkFloat ANGKLUNG_SOUND_DECAY = 0.95; +const StkFloat ANGKLUNG_SYSTEM_DECAY = 0.9999; +const StkFloat ANGKLUNG_GAIN = 0.5; +const StkFloat ANGKLUNG_NUM_TUBES = 1.2; +const int ANGKLUNG_RESONANCES = 7; +const StkFloat ANGKLUNG_FREQUENCIES[ANGKLUNG_RESONANCES] = { 1046.6, 1174.8, 1397.0, 1568, 1760, 2093.3, 2350 }; +const StkFloat ANGKLUNG_RADII[ANGKLUNG_RESONANCES] = { 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996 }; +const StkFloat ANGKLUNG_GAINS[ANGKLUNG_RESONANCES] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 }; + +// Guiro +const StkFloat GUIRO_SOUND_DECAY = 0.95; +const StkFloat GUIRO_GAIN = 0.4; +const StkFloat GUIRO_NUM_PARTS = 128; +const int GUIRO_RESONANCES = 2; +const StkFloat GUIRO_FREQUENCIES[GUIRO_RESONANCES] = { 2500, 4000 }; +const StkFloat GUIRO_RADII[GUIRO_RESONANCES] = { 0.97, 0.97 }; +const StkFloat GUIRO_GAINS[GUIRO_RESONANCES] = { 1.0, 1.0 }; + +// Wrench +const StkFloat WRENCH_SOUND_DECAY = 0.95; +const StkFloat WRENCH_GAIN = 0.4; +const StkFloat WRENCH_NUM_PARTS = 128; +const int WRENCH_RESONANCES = 2; +const StkFloat WRENCH_FREQUENCIES[WRENCH_RESONANCES] = { 3200, 8000 }; +const StkFloat WRENCH_RADII[WRENCH_RESONANCES] = { 0.99, 0.992 }; +const StkFloat WRENCH_GAINS[WRENCH_RESONANCES] = { 1.0, 1.0 }; + +// Water Drops +const StkFloat WATER_SOUND_DECAY = 0.95; +const StkFloat WATER_SYSTEM_DECAY = 0.996; +const StkFloat WATER_GAIN = 1.0; +const StkFloat WATER_NUM_SOURCES = 10; +const int WATER_RESONANCES = 3; +const StkFloat WATER_FREQUENCIES[WATER_RESONANCES] = { 450, 600, 750 }; +const StkFloat WATER_RADII[WATER_RESONANCES] = { 0.9985, 0.9985, 0.9985 }; +const StkFloat WATER_GAINS[WATER_RESONANCES] = { 1.0, 1.0, 1.0 }; + +// PhOLIES (Physically-Oriented Library of Imitated Environmental +// Sounds), Perry Cook, 1997-8 + +// Stix1 +const StkFloat STIX1_SOUND_DECAY = 0.96; +const StkFloat STIX1_SYSTEM_DECAY = 0.998; +const StkFloat STIX1_GAIN = 6.0; +const StkFloat STIX1_NUM_BEANS = 2; +const int STIX1_RESONANCES = 1; +const StkFloat STIX1_FREQUENCIES[STIX1_RESONANCES] = { 5500 }; +const StkFloat STIX1_RADII[STIX1_RESONANCES] = { 0.6 }; +const StkFloat STIX1_GAINS[STIX1_RESONANCES] = { 1.0 }; + +// Crunch1 +const StkFloat CRUNCH1_SOUND_DECAY = 0.95; +const StkFloat CRUNCH1_SYSTEM_DECAY = 0.99806; +const StkFloat CRUNCH1_GAIN = 4.0; +const StkFloat CRUNCH1_NUM_BEADS = 7; +const int CRUNCH1_RESONANCES = 1; +const StkFloat CRUNCH1_FREQUENCIES[CRUNCH1_RESONANCES] = { 800 }; +const StkFloat CRUNCH1_RADII[CRUNCH1_RESONANCES] = { 0.95 }; +const StkFloat CRUNCH1_GAINS[CRUNCH1_RESONANCES] = { 1.0 }; + +// Nextmug + Coins +const StkFloat NEXTMUG_SOUND_DECAY = 0.97; +const StkFloat NEXTMUG_SYSTEM_DECAY = 0.9995; +const StkFloat NEXTMUG_GAIN = 0.8; +const StkFloat NEXTMUG_NUM_PARTS = 3; +const int NEXTMUG_RESONANCES = 4; +const StkFloat NEXTMUG_FREQUENCIES[NEXTMUG_RESONANCES] = { 2123, 4518, 8856, 10753 }; +const StkFloat NEXTMUG_RADII[NEXTMUG_RESONANCES] = { 0.997, 0.997, 0.997, 0.997 }; +const StkFloat NEXTMUG_GAINS[NEXTMUG_RESONANCES] = { 1.0, 0.8, 0.6, 0.4 }; + +const int COIN_RESONANCES = 3; +const StkFloat PENNY_FREQUENCIES[COIN_RESONANCES] = { 11000, 5200, 3835 }; +const StkFloat PENNY_RADII[COIN_RESONANCES] = { 0.999, 0.999, 0.999 }; +const StkFloat PENNY_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 }; + +const StkFloat NICKEL_FREQUENCIES[COIN_RESONANCES] = { 5583, 9255, 9805 }; +const StkFloat NICKEL_RADII[COIN_RESONANCES] = { 0.9992, 0.9992, 0.9992 }; +const StkFloat NICKEL_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 }; + +const StkFloat DIME_FREQUENCIES[COIN_RESONANCES] = { 4450, 4974, 9945 }; +const StkFloat DIME_RADII[COIN_RESONANCES] = { 0.9993, 0.9993, 0.9993 }; +const StkFloat DIME_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 }; + +const StkFloat QUARTER_FREQUENCIES[COIN_RESONANCES] = { 1708, 8863, 9045 }; +const StkFloat QUARTER_RADII[COIN_RESONANCES] = { 0.9995, 0.9995, 0.9995 }; +const StkFloat QUARTER_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 }; + +const StkFloat FRANC_FREQUENCIES[COIN_RESONANCES] = { 5583, 11010, 1917 }; +const StkFloat FRANC_RADII[COIN_RESONANCES] = { 0.9995, 0.9995, 0.9995 }; +const StkFloat FRANC_GAINS[COIN_RESONANCES] = { 0.7, 0.4, 0.3 }; + +const StkFloat PESO_FREQUENCIES[COIN_RESONANCES] = { 7250, 8150, 10060 }; +const StkFloat PESO_RADII[COIN_RESONANCES] = { 0.9996, 0.9996, 0.9996 }; +const StkFloat PESO_GAINS[COIN_RESONANCES] = { 1.0, 1.2, 0.7 }; + +// Big Gravel +const StkFloat BIGROCKS_SOUND_DECAY = 0.98; +const StkFloat BIGROCKS_SYSTEM_DECAY = 0.9965; +const StkFloat BIGROCKS_GAIN = 4.0; +const StkFloat BIGROCKS_NUM_PARTS = 23; +const int BIGROCKS_RESONANCES = 1; +const StkFloat BIGROCKS_FREQUENCIES[BIGROCKS_RESONANCES] = { 6460 }; +const StkFloat BIGROCKS_RADII[BIGROCKS_RESONANCES] = { 0.932 }; +const StkFloat BIGROCKS_GAINS[BIGROCKS_RESONANCES] = { 1.0 }; + +// Little Gravel +const StkFloat LITTLEROCKS_SOUND_DECAY = 0.98; +const StkFloat LITTLEROCKS_SYSTEM_DECAY = 0.99586; +const StkFloat LITTLEROCKS_GAIN = 4.0; +const StkFloat LITTLEROCKS_NUM_PARTS = 1600; +const int LITTLEROCKS_RESONANCES = 1; +const StkFloat LITTLEROCKS_FREQUENCIES[LITTLEROCKS_RESONANCES] = { 9000 }; +const StkFloat LITTLEROCKS_RADII[LITTLEROCKS_RESONANCES] = { 0.843 }; +const StkFloat LITTLEROCKS_GAINS[LITTLEROCKS_RESONANCES] = { 1.0 }; + +Shakers :: Shakers( int type ) +{ + shakerType_ = -1; + this->setType( type ); +} + +void Shakers :: setType( int type ) +{ + if ( shakerType_ == type ) return; + varyFactor_ = 0.0; + shakerType_ = type; + if ( type == 1 ) { // Cabasa + nResonances_ = CABASA_RESONANCES; + filters_.resize( nResonances_ ); + baseFrequencies_.resize( nResonances_ ); + baseRadii_.resize( nResonances_ ); + doVaryFrequency_.resize( nResonances_ ); + baseObjects_ = CABASA_NUM_BEADS; + for ( unsigned int i=0; i 11 && type < 19 ) { // Nextmug + nResonances_ = NEXTMUG_RESONANCES; + if ( type > 12 ) // mug + coin + nResonances_ += COIN_RESONANCES; + filters_.resize( nResonances_ ); + baseFrequencies_.resize( nResonances_ ); + baseRadii_.resize( nResonances_ ); + doVaryFrequency_.resize( nResonances_ ); + baseObjects_ = NEXTMUG_NUM_PARTS; + for ( int i=0; isetType( noteNumber ); + + shakeEnergy_ += amplitude * MAX_SHAKE * 0.1; + if ( shakeEnergy_ > MAX_SHAKE ) shakeEnergy_ = MAX_SHAKE; + if ( shakerType_==19 || shakerType_==20 ) ratchetCount_ += 1; +} + +void Shakers :: noteOff( StkFloat amplitude ) +{ + shakeEnergy_ = 0.0; + if ( shakerType_==19 || shakerType_==20 ) ratchetCount_ = 0; +} + +void Shakers :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Shakers::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if ( number == __SK_Breath_ || number == __SK_AfterTouch_Cont_ ) { // 2 or 128 ... energy + if ( shakerType_ == 19 || shakerType_ == 20 ) { + if ( lastRatchetValue_ < 0.0 ) ratchetCount_++; + else ratchetCount_ = (int) fabs(value - lastRatchetValue_); + ratchetDelta_ = baseRatchetDelta_ * ratchetCount_; + lastRatchetValue_ = (int) value; + } + else { + shakeEnergy_ += normalizedValue * MAX_SHAKE * 0.1; + if ( shakeEnergy_ > MAX_SHAKE ) shakeEnergy_ = MAX_SHAKE; + } + } + else if ( number == __SK_ModFrequency_ ) { // 4 ... decay + systemDecay_ = baseDecay_ + ( 2.0 * (normalizedValue - 0.5) * decayScale_ * (1.0 - baseDecay_) ); + } + else if ( number == __SK_FootControl_ ) { // 11 ... number of objects + nObjects_ = (StkFloat) ( 2.0 * normalizedValue * baseObjects_ ) + 1.1; + currentGain_ = log( nObjects_ ) * baseGain_ / nObjects_; + } + else if ( number == __SK_ModWheel_ ) { // 1 ... resonance frequency + for ( unsigned int i=0; isetType( type ); + } +#if defined(_STK_DEBUG_) + else { + oStream_ << "Shakers::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Simple.cpp b/7.x/src/stk/src/Simple.cpp new file mode 100644 index 0000000..69fc83d --- /dev/null +++ b/7.x/src/stk/src/Simple.cpp @@ -0,0 +1,105 @@ +/***************************************************/ +/*! \class Simple + \brief STK wavetable/noise instrument. + + This class combines a looped wave, a + noise source, a biquad resonance filter, + a one-pole filter, and an ADSR envelope + to create some interesting sounds. + + Control Change Numbers: + - Filter Pole Position = 2 + - Noise/Pitched Cross-Fade = 4 + - Envelope Rate = 11 + - Gain = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Simple.h" +#include "SKINImsg.h" + +namespace stk { + +Simple :: Simple( void ) +{ + // Concatenate the STK rawwave path to the rawwave file + loop_ = new FileLoop( (Stk::rawwavePath() + "impuls10.raw").c_str(), true ); + + filter_.setPole( 0.5 ); + baseFrequency_ = 440.0; + setFrequency( baseFrequency_ ); + loopGain_ = 0.5; +} + +Simple :: ~Simple( void ) +{ + delete loop_; +} + +void Simple :: keyOn( void ) +{ + adsr_.keyOn(); +} + +void Simple :: keyOff( void ) +{ + adsr_.keyOff(); +} + +void Simple :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->keyOn(); + this->setFrequency( frequency ); + filter_.setGain( amplitude ); +} +void Simple :: noteOff( StkFloat amplitude ) +{ + this->keyOff(); +} + +void Simple :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Simple::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + biquad_.setResonance( frequency, 0.98, true ); + loop_->setFrequency( frequency ); +} + +void Simple :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Simple::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_Breath_) // 2 + filter_.setPole( 0.99 * (1.0 - (normalizedValue * 2.0)) ); + else if (number == __SK_NoiseLevel_) // 4 + loopGain_ = normalizedValue; + else if (number == __SK_ModFrequency_) { // 11 + normalizedValue /= 0.2 * Stk::sampleRate(); + adsr_.setAttackRate( normalizedValue ); + adsr_.setDecayRate( normalizedValue ); + adsr_.setReleaseRate( normalizedValue ); + } + else if (number == __SK_AfterTouch_Cont_) // 128 + adsr_.setTarget( normalizedValue ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "Simple::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/SineWave.cpp b/7.x/src/stk/src/SineWave.cpp new file mode 100644 index 0000000..c362968 --- /dev/null +++ b/7.x/src/stk/src/SineWave.cpp @@ -0,0 +1,78 @@ +/***************************************************/ +/*! \class SineWave + \brief STK sinusoid oscillator class. + + This class computes and saves a static sine "table" that can be + shared by multiple instances. It has an interface similar to the + WaveLoop class but inherits from the Generator class. Output + values are computed using linear interpolation. + + The "table" length, set in SineWave.h, is 2048 samples by default. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "SineWave.h" +#include + +namespace stk { + +StkFrames SineWave :: table_; + +SineWave :: SineWave( void ) + : time_(0.0), rate_(1.0), phaseOffset_(0.0) +{ + if ( table_.empty() ) { + table_.resize( TABLE_SIZE + 1, 1 ); + StkFloat temp = 1.0 / TABLE_SIZE; + for ( unsigned long i=0; i<=TABLE_SIZE; i++ ) + table_[i] = sin( TWO_PI * i * temp ); + } + + Stk::addSampleRateAlert( this ); +} + +SineWave :: ~SineWave() +{ + Stk::removeSampleRateAlert( this ); +} + +void SineWave :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) + this->setRate( oldRate * rate_ / newRate ); +} + +void SineWave :: reset( void ) +{ + time_ = 0.0; + lastFrame_[0] = 0; +} + +void SineWave :: setFrequency( StkFloat frequency ) +{ + // This is a looping frequency. + this->setRate( TABLE_SIZE * frequency / Stk::sampleRate() ); +} + +void SineWave :: addTime( StkFloat time ) +{ + // Add an absolute time in samples. + time_ += time; +} + +void SineWave :: addPhase( StkFloat phase ) +{ + // Add a time in cycles (one cycle = TABLE_SIZE). + time_ += TABLE_SIZE * phase; +} + +void SineWave :: addPhaseOffset( StkFloat phaseOffset ) +{ + // Add a phase offset relative to any previous offset value. + time_ += ( phaseOffset - phaseOffset_ ) * TABLE_SIZE; + phaseOffset_ = phaseOffset; +} + +} // stk namespace diff --git a/7.x/src/stk/src/SingWave.cpp b/7.x/src/stk/src/SingWave.cpp new file mode 100644 index 0000000..6d80770 --- /dev/null +++ b/7.x/src/stk/src/SingWave.cpp @@ -0,0 +1,53 @@ +/***************************************************/ +/*! \class SingWave + \brief STK "singing" looped soundfile class. + + This class loops a specified soundfile and modulates it both + periodically and randomly to produce a pitched musical sound, like + a simple voice or violin. In general, it is not be used alone + because of "munchkinification" effects from pitch shifting. + Within STK, it is used as an excitation source for other + instruments. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "SingWave.h" + +namespace stk { + +SingWave :: SingWave( std::string fileName, bool raw ) +{ + // An exception could be thrown here. + wave_.openFile( fileName, raw ); + + rate_ = 1.0; + sweepRate_ = 0.001; + + modulator_.setVibratoRate( 6.0 ); + modulator_.setVibratoGain( 0.04 ); + modulator_.setRandomGain( 0.005 ); + + this->setFrequency( 75.0 ); + pitchEnvelope_.setRate( 1.0 ); + this->tick(); + this->tick(); + pitchEnvelope_.setRate( sweepRate_ * rate_ ); +} + +SingWave :: ~SingWave() +{ +} + +void SingWave :: setFrequency( StkFloat frequency ) +{ + StkFloat temp = rate_; + rate_ = wave_.getSize() * frequency / Stk::sampleRate(); + temp -= rate_; + if ( temp < 0) temp = -temp; + pitchEnvelope_.setTarget( rate_ ); + pitchEnvelope_.setRate( sweepRate_ * temp ); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Sitar.cpp b/7.x/src/stk/src/Sitar.cpp new file mode 100644 index 0000000..ab5f405 --- /dev/null +++ b/7.x/src/stk/src/Sitar.cpp @@ -0,0 +1,95 @@ +/***************************************************/ +/*! \class Sitar + \brief STK sitar string model class. + + This class implements a sitar plucked string + physical model based on the Karplus-Strong + algorithm. + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + There exist at least two patents, assigned to + Stanford, bearing the names of Karplus and/or + Strong. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Sitar.h" + +namespace stk { + +Sitar :: Sitar( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "Sitar::Sitar: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long length = (unsigned long) ( Stk::sampleRate() / lowestFrequency + 1 ); + delayLine_.setMaximumDelay( length ); + delay_ = 0.5 * length; + delayLine_.setDelay( delay_ ); + targetDelay_ = delay_; + + loopFilter_.setZero( 0.01 ); + loopGain_ = 0.999; + + envelope_.setAllTimes( 0.001, 0.04, 0.0, 0.5 ); + this->clear(); +} + +Sitar :: ~Sitar( void ) +{ +} + +void Sitar :: clear( void ) +{ + delayLine_.clear(); + loopFilter_.clear(); +} + +void Sitar :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Sitar::setFrequency: parameter is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + targetDelay_ = (Stk::sampleRate() / frequency); + // Do not modulate the delay line with noise here: doing so injects energy + // on every frequency change and can make the sitar build up clipped samples + // over time (csound/plugins#4). The noise excitation is applied in tick(). + delay_ = targetDelay_; + delayLine_.setDelay( delay_ ); + loopGain_ = 0.995 + (frequency * 0.0000005); + if ( loopGain_ > 0.9995 ) loopGain_ = 0.9995; +} + +void Sitar :: pluck( StkFloat amplitude ) +{ + envelope_.keyOn(); +} + +void Sitar :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->pluck( amplitude ); + amGain_ = 0.1 * amplitude; +} + +void Sitar :: noteOff( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "Sitar::noteOff: amplitude is out of range!"; + handleError( StkError::WARNING ); return; + } + + loopGain_ = (StkFloat) 1.0 - amplitude; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Skini.cpp b/7.x/src/stk/src/Skini.cpp new file mode 100644 index 0000000..aec29a5 --- /dev/null +++ b/7.x/src/stk/src/Skini.cpp @@ -0,0 +1,228 @@ +/***************************************************/ +/*! \class Skini + \brief STK SKINI parsing class + + This class parses SKINI formatted text + messages. It can be used to parse individual + messages or it can be passed an entire file. + The SKINI specification is Perry's and his + alone, but it's all text so it shouldn't be too + hard to figure out. + + SKINI (Synthesis toolKit Instrument Network + Interface) is like MIDI, but allows for + floating-point control changes, note numbers, + etc. The following example causes a sharp + middle C to be played with a velocity of 111.132: + + noteOn 60.01 111.132 + + See also SKINI.txt. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Skini.h" +#include "SKINItbl.h" +#include +#include + +namespace stk { + +Skini :: Skini() +{ +} + +Skini :: ~Skini() +{ +} + +bool Skini :: setFile( std::string fileName ) +{ + if ( file_.is_open() ) { + oStream_ << "Skini::setFile: already reaading a file!"; + handleError( StkError::WARNING ); + return false; + } + + file_.open( fileName.c_str() ); + if ( !file_ ) { + oStream_ << "Skini::setFile: unable to open file (" << fileName << ")"; + handleError( StkError::WARNING ); + return false; + } + + return true; +} + +long Skini :: nextMessage( Message& message ) +{ + if ( !file_.is_open() ) return 0; + + std::string line; + bool done = false; + while ( !done ) { + + // Read a line from the file and skip over invalid messages. + if ( std::getline( file_, line ).eof() ) { + oStream_ << "// End of Score. Thanks for using SKINI!!"; + handleError( StkError::STATUS ); + file_.close(); + message.type = 0; + done = true; + } + else if ( parseString( line, message ) > 0 ) done = true; + } + + return message.type; +} + +void Skini :: tokenize( const std::string& str, + std::vector& tokens, + const std::string& delimiters ) +{ + // Skip delimiters at beginning. + std::string::size_type lastPos = str.find_first_not_of(delimiters, 0); + // Find first "non-delimiter". + std::string::size_type pos = str.find_first_of(delimiters, lastPos); + + while (std::string::npos != pos || std::string::npos != lastPos) { + // Found a token, add it to the vector. + tokens.push_back(str.substr(lastPos, pos - lastPos)); + // Skip delimiters. Note the "not_of" + lastPos = str.find_first_not_of(delimiters, pos); + // Find next "non-delimiter" + pos = str.find_first_of(delimiters, lastPos); + } +} + +long Skini :: parseString( std::string& line, Message& message ) +{ + message.type = 0; + if ( line.empty() ) return message.type; + + // Check for comment lines. + std::string::size_type lastPos = line.find_first_not_of(" ,\t", 0); + std::string::size_type pos = line.find_first_of("/", lastPos); + if ( std::string::npos != pos ) { + oStream_ << "// Comment Line: " << line; + handleError( StkError::STATUS ); + return message.type; + } + + // Tokenize the string. + std::vector tokens; + this->tokenize( line, tokens, " ,\t"); + + // Valid SKINI messages must have at least three fields (type, time, + // and channel). + if ( tokens.size() < 3 ) return message.type; + + // Determine message type. + int iSkini = 0; + while ( iSkini < __SK_MaxMsgTypes_ ) { + if ( tokens[0] == skini_msgs[iSkini].messageString ) break; + iSkini++; + } + + if ( iSkini >= __SK_MaxMsgTypes_ ) { + oStream_ << "Skini::parseString: couldn't parse this line:\n " << line; + handleError( StkError::WARNING ); + return message.type; + } + + // Found the type. + message.type = skini_msgs[iSkini].type; + + // Parse time field. + if ( tokens[1][0] == '=' ) { + tokens[1].erase( tokens[1].begin() ); + if ( tokens[1].empty() ) { + oStream_ << "Skini::parseString: couldn't parse time field in line:\n " << line; + handleError( StkError::WARNING ); + return message.type = 0; + } + message.time = (StkFloat) -atof( tokens[1].c_str() ); + } + else + message.time = (StkFloat) atof( tokens[1].c_str() ); + + // Parse the channel field. + message.channel = atoi( tokens[2].c_str() ); + + // Parse the remaining fields (maximum of 2 more). + int iValue = 0; + unsigned int iToken = iValue + 3; //rgh: MIDI extension argument counts are different from regular MIDI + long dataType = skini_msgs[iSkini].data2; + while ( dataType != NOPE ) { + +// if ( tokens.size() <= (unsigned int) (iValue+3) ) { //rgh: test iToken rather than always testing iValue+3 +// if (tokens.size() <= iToken) { //rgh: iToken only tests it more tokens are to be consumed (SK_INT, SK_DBL, SK_STR) + if ((tokens.size() <= iToken) && (dataType < 0)) { //Don't fail if remaining iValues come from skini_msgs[] rather than tokens[]. + oStream_ << "Skini::parseString: inconsistency between type table and parsed line:\n " << line; + handleError( StkError::WARNING ); + return message.type = 0; + } + + switch ( dataType ) { + + case SK_INT: + message.intValues[iValue] = atoi( tokens[iToken].c_str() ); //rgh: use new index + message.floatValues[iValue] = (StkFloat) message.intValues[iValue]; + ++iToken; //rgh: increment token index and value index (below) + break; + + case SK_DBL: + message.floatValues[iValue] = atof( tokens[iToken].c_str() ); //rgh: use new index + message.intValues[iValue] = (long) message.floatValues[iValue]; + ++iToken; //rgh: increment token index and value index (below) + break; + + case SK_STR: // Must be the last field. + message.remainder = tokens[iToken]; //rgh: use new index + return message.type; + + default: // MIDI extension message + message.intValues[iValue] = dataType; + message.floatValues[iValue] = (StkFloat) message.intValues[iValue]; + //iValue--; //rgh: iValue must increment even when iToken does not; resetting iValue only works sometimes + } + + if ( ++iValue == 1 ) + dataType = skini_msgs[iSkini].data3; + else + dataType = NOPE; + } + + return message.type; +} + +std::string Skini :: whatsThisType(long type) +{ + std::string typeString; + + for ( int i=0; i<__SK_MaxMsgTypes_; i++ ) { + if ( type == skini_msgs[i].type ) { + typeString = skini_msgs[i].messageString; + break; + } + } + return typeString; +} + +std::string Skini :: whatsThisController( long number ) +{ + std::string controller; + + for ( int i=0; i<__SK_MaxMsgTypes_; i++) { + if ( skini_msgs[i].type == __SK_ControlChange_ && + number == skini_msgs[i].data2) { + controller = skini_msgs[i].messageString; + break; + } + } + return controller; +} + +} // stk namespace diff --git a/7.x/src/stk/src/Sphere.cpp b/7.x/src/stk/src/Sphere.cpp new file mode 100644 index 0000000..90b2a14 --- /dev/null +++ b/7.x/src/stk/src/Sphere.cpp @@ -0,0 +1,50 @@ +/***************************************************/ +/*! \class Sphere + \brief STK sphere class. + + This class implements a spherical ball with + radius, mass, position, and velocity parameters. + + by Perry R. Cook, 1995--2021. +*/ +/***************************************************/ + +#include "Sphere.h" +#include + +namespace stk { + +Vector3D* Sphere::getRelativePosition( Vector3D* position ) +{ + workingVector_.setXYZ(position->getX() - position_.getX(), + position->getY() - position_.getY(), + position->getZ() - position_.getZ()); + return &workingVector_; +}; + +StkFloat Sphere::getVelocity( Vector3D* velocity ) +{ + velocity->setXYZ( velocity_.getX(), velocity_.getY(), velocity_.getZ() ); + return velocity_.getLength(); +}; + +StkFloat Sphere::isInside( Vector3D *position ) +{ + // Return directed distance from aPosition to spherical boundary ( < + // 0 if inside). + StkFloat distance; + Vector3D *tempVector; + + tempVector = this->getRelativePosition( position ); + distance = tempVector->getLength(); + return distance - radius_; +}; + +void Sphere::addVelocity(StkFloat x, StkFloat y, StkFloat z) +{ + velocity_.setX(velocity_.getX() + x); + velocity_.setY(velocity_.getY() + y); + velocity_.setZ(velocity_.getZ() + z); +} + +} // stk namespace diff --git a/7.x/src/stk/src/StifKarp.cpp b/7.x/src/stk/src/StifKarp.cpp new file mode 100644 index 0000000..c8a4881 --- /dev/null +++ b/7.x/src/stk/src/StifKarp.cpp @@ -0,0 +1,181 @@ +/***************************************************/ +/*! \class StifKarp + \brief STK plucked stiff string instrument. + + This class implements a simple plucked string + algorithm (Karplus Strong) with enhancements + (Jaffe-Smith, Smith, and others), including + string stiffness and pluck position controls. + The stiffness is modeled with allpass filters. + + This is a digital waveguide model, making its + use possibly subject to patents held by + Stanford University, Yamaha, and others. + + Control Change Numbers: + - Pickup Position = 4 + - String Sustain = 11 + - String Stretch = 1 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "StifKarp.h" +#include "SKINImsg.h" +#include + +namespace stk { + +StifKarp :: StifKarp( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "StifKarp::StifKarp: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + unsigned long nDelays = (unsigned long) ( Stk::sampleRate() / lowestFrequency ); + delayLine_.setMaximumDelay( nDelays + 1 ); + combDelay_.setMaximumDelay( nDelays + 1 ); + + pluckAmplitude_ = 0.3; + pickupPosition_ = 0.4; + + stretching_ = 0.9999; + baseLoopGain_ = 0.995; + loopGain_ = 0.999; + + this->clear(); + this->setFrequency( 220.0 ); +} + +StifKarp :: ~StifKarp( void ) +{ +} + +void StifKarp :: clear( void ) +{ + delayLine_.clear(); + combDelay_.clear(); + filter_.clear(); +} + +void StifKarp :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "StifKarp::setFrequency: parameter is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + lastFrequency_ = frequency; + lastLength_ = Stk::sampleRate() / lastFrequency_; + StkFloat delay = lastLength_ - 0.5; + delayLine_.setDelay( delay ); + + loopGain_ = baseLoopGain_ + (frequency * 0.000005); + if (loopGain_ >= 1.0) loopGain_ = 0.99999; + + setStretch(stretching_); + + combDelay_.setDelay( 0.5 * pickupPosition_ * lastLength_ ); +} + +void StifKarp :: setStretch( StkFloat stretch ) +{ + stretching_ = stretch; + StkFloat coefficient; + StkFloat freq = lastFrequency_ * 2.0; + StkFloat dFreq = ( (0.5 * Stk::sampleRate()) - freq ) * 0.25; + StkFloat temp = 0.5 + (stretch * 0.5); + if ( temp > 0.99999 ) temp = 0.99999; + for ( int i=0; i<4; i++ ) { + coefficient = temp * temp; + biquad_[i].setA2( coefficient ); + biquad_[i].setB0( coefficient ); + biquad_[i].setB2( 1.0 ); + + coefficient = -2.0 * temp * cos(TWO_PI * freq / Stk::sampleRate()); + biquad_[i].setA1( coefficient ); + biquad_[i].setB1( coefficient ); + + freq += dFreq; + } +} + +void StifKarp :: setPickupPosition( StkFloat position ) { + + if ( position < 0.0 || position > 1.0 ) { + oStream_ << "StifKarp::setPickupPosition: parameter is out of range!"; + handleError( StkError::WARNING ); return; + } + + // Set the pick position, which puts zeroes at position * length. + pickupPosition_ = position; + combDelay_.setDelay( 0.5 * pickupPosition_ * lastLength_ ); +} + +void StifKarp :: setBaseLoopGain( StkFloat aGain ) +{ + baseLoopGain_ = aGain; + loopGain_ = baseLoopGain_ + (lastFrequency_ * 0.000005); + if ( loopGain_ > 0.99999 ) loopGain_ = (StkFloat) 0.99999; +} + +void StifKarp :: pluck( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "StifKarp::pluck: amplitude is out of range!"; + handleError( StkError::WARNING ); return; + } + + pluckAmplitude_ = amplitude; + for ( unsigned long i=0; itick() * pluckAmplitude_) ); + } +} + +void StifKarp :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->pluck( amplitude ); +} + +void StifKarp :: noteOff( StkFloat amplitude ) +{ + if ( amplitude < 0.0 || amplitude > 1.0 ) { + oStream_ << "StifKarp::noteOff: amplitude is out of range!"; + handleError( StkError::WARNING ); return; + } + + loopGain_ = (1.0 - amplitude) * 0.5; +} + +void StifKarp :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Clarinet::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_PickPosition_) // 4 + this->setPickupPosition( normalizedValue ); + else if (number == __SK_StringDamping_) // 11 + this->setBaseLoopGain( 0.97 + (normalizedValue * 0.03) ); + else if (number == __SK_StringDetune_) // 1 + this->setStretch( 0.9 + (0.1 * (1.0 - normalizedValue)) ); +#if defined(_STK_DEBUG_) + else { + oStream_ << "StifKarp::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Stk.cpp b/7.x/src/stk/src/Stk.cpp new file mode 100644 index 0000000..e080415 --- /dev/null +++ b/7.x/src/stk/src/Stk.cpp @@ -0,0 +1,401 @@ +/***************************************************/ +/*! \class Stk + \brief STK base class + + Nearly all STK classes inherit from this class. + The global sample rate can be queried and + modified via Stk. In addition, this class + provides error handling and byte-swapping + functions. + + The Synthesis ToolKit in C++ (STK) is a set of open source audio + signal processing and algorithmic synthesis classes written in the + C++ programming language. STK was designed to facilitate rapid + development of music synthesis and audio processing software, with + an emphasis on cross-platform functionality, realtime control, + ease of use, and educational example code. STK currently runs + with realtime support (audio and MIDI) on Linux, Macintosh OS X, + and Windows computer platforms. Generic, non-realtime support has + been tested under NeXTStep, Sun, and other platforms and should + work with any standard C++ compiler. + + STK WWW site: http://ccrma.stanford.edu/software/stk/ + + The Synthesis ToolKit in C++ (STK) + Copyright (c) 1995--2021 Perry R. Cook and Gary P. Scavone + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + Any person wishing to distribute modifications to the Software is + asked to send the modifications to the original developer so that + they can be incorporated into the canonical version. This is, + however, not a binding provision of this license. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ +/***************************************************/ + +#include "Stk.h" +#include + +namespace stk { + +StkFloat Stk :: srate_ = (StkFloat) SRATE; +std::string Stk :: rawwavepath_ = RAWWAVE_PATH; +const Stk::StkFormat Stk :: STK_SINT8 = 0x1; +const Stk::StkFormat Stk :: STK_SINT16 = 0x2; +const Stk::StkFormat Stk :: STK_SINT24 = 0x4; +const Stk::StkFormat Stk :: STK_SINT32 = 0x8; +const Stk::StkFormat Stk :: STK_FLOAT32 = 0x10; +const Stk::StkFormat Stk :: STK_FLOAT64 = 0x20; +bool Stk :: showWarnings_ = true; +bool Stk :: printErrors_ = true; +std::vector Stk :: alertList_; +std::ostringstream Stk :: oStream_; + +Stk :: Stk( void ) + : ignoreSampleRateChange_(false) +{ +} + +Stk :: ~Stk( void ) +{ +} + +void Stk :: setSampleRate( StkFloat rate ) +{ + if ( rate > 0.0 && rate != srate_ ) { + StkFloat oldRate = srate_; + srate_ = rate; + + for ( unsigned int i=0; isampleRateChanged( srate_, oldRate ); + } +} + +void Stk :: sampleRateChanged( StkFloat /*newRate*/, StkFloat /*oldRate*/ ) +{ + // This function should be reimplemented in classes that need to + // make internal variable adjustments in response to a global sample + // rate change. +} + +void Stk :: addSampleRateAlert( Stk *ptr ) +{ + for ( unsigned int i=0; i +#elif defined(__OS_WINDOWS__) + #include +#endif + +void Stk :: sleep(unsigned long milliseconds) +{ +#if defined(__OS_WINDOWS__) + Sleep((DWORD) milliseconds); +#elif (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__)) + usleep( (unsigned long) (milliseconds * 1000.0) ); +#endif +} + +void Stk :: handleError( StkError::Type type ) const +{ + handleError( oStream_.str(), type ); + oStream_.str( std::string() ); // reset the ostringstream buffer +} + +void Stk :: handleError( const char *message, StkError::Type type ) +{ + std::string msg( message ); + handleError( msg, type ); +} + +void Stk :: handleError( std::string message, StkError::Type type ) +{ + if ( type == StkError::WARNING || type == StkError::STATUS ) { + if ( !showWarnings_ ) return; + std::cerr << '\n' << message << '\n' << std::endl; + } + else if (type == StkError::DEBUG_PRINT) { +#if defined(_STK_DEBUG_) + std::cerr << '\n' << message << '\n' << std::endl; +#endif + } + else { + if ( printErrors_ ) { + // Print error message before throwing. + std::cerr << '\n' << message << '\n' << std::endl; + } + throw StkError(message, type); + } +} + +// +// StkFrames definitions +// + +StkFrames :: StkFrames( unsigned int nFrames, unsigned int nChannels ) + : data_( 0 ), nFrames_( nFrames ), nChannels_( nChannels ) +{ + size_ = nFrames_ * nChannels_; + bufferSize_ = size_; + + if ( size_ > 0 ) { + data_ = (StkFloat *) calloc( size_, sizeof( StkFloat ) ); +#if defined(_STK_DEBUG_) + if ( data_ == NULL ) { + std::string error = "StkFrames: memory allocation error in constructor!"; + Stk::handleError( error, StkError::MEMORY_ALLOCATION ); + } +#endif + } + + dataRate_ = Stk::sampleRate(); +} + +StkFrames :: StkFrames( const StkFloat& value, unsigned int nFrames, unsigned int nChannels ) + : data_( 0 ), nFrames_( nFrames ), nChannels_( nChannels ) +{ + size_ = nFrames_ * nChannels_; + bufferSize_ = size_; + if ( size_ > 0 ) { + data_ = (StkFloat *) malloc( size_ * sizeof( StkFloat ) ); +#if defined(_STK_DEBUG_) + if ( data_ == NULL ) { + std::string error = "StkFrames: memory allocation error in constructor!"; + Stk::handleError( error, StkError::MEMORY_ALLOCATION ); + } +#endif + for ( long i=0; i<(long)size_; i++ ) data_[i] = value; + } + + dataRate_ = Stk::sampleRate(); +} + +StkFrames :: ~StkFrames() +{ + if ( data_ ) free( data_ ); +} + +StkFrames :: StkFrames( const StkFrames& f ) + : data_(0), size_(0), bufferSize_(0) +{ + resize( f.frames(), f.channels() ); + dataRate_ = Stk::sampleRate(); + for ( unsigned int i=0; i bufferSize_ ) { + if ( data_ ) free( data_ ); + data_ = (StkFloat *) malloc( size_ * sizeof( StkFloat ) ); +#if defined(_STK_DEBUG_) + if ( data_ == NULL ) { + std::string error = "StkFrames::resize: memory allocation error!"; + Stk::handleError( error, StkError::MEMORY_ALLOCATION ); + } +#endif + bufferSize_ = size_; + } +} + +void StkFrames :: resize( size_t nFrames, unsigned int nChannels, StkFloat value ) +{ + this->resize( nFrames, nChannels ); + + for ( size_t i=0; i channels() - 1) { + std::ostringstream error; + error << "StkFrames::getChannel invalid sourceChannel (" << sourceChannel << ")"; + Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT); + } + if (destinationChannel > destinationFrames.channels() - 1) { + std::ostringstream error; + error << "StkFrames::getChannel invalid destinationChannel (" << destinationChannel << ")"; + Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT ); + } + if (destinationFrames.frames() < frames()) { + std::ostringstream error; + error << "StkFrames::getChannel destination.frames() < frames()"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS); + } +#endif + int sourceHop = nChannels_; + int destinationHop = destinationFrames.nChannels_; + for (unsigned int i = sourceChannel, j= destinationChannel; + i < nFrames_ * nChannels_; + i+=sourceHop,j+=destinationHop) + { + destinationFrames[j] = data_[i]; + } + return destinationFrames; + +} + +void StkFrames::setChannel(unsigned int destinationChannel, const stk::StkFrames &sourceFrames,unsigned int sourceChannel) +{ +#if defined(_STK_DEBUG_) + if (sourceChannel > sourceFrames.channels() - 1) { + std::ostringstream error; + error << "StkFrames::setChannel invalid sourceChannel (" << sourceChannel << ")"; + Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT); + } + if (destinationChannel > channels() - 1) { + std::ostringstream error; + error << "StkFrames::setChannel invalid channel (" << destinationChannel << ")"; + Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT ); + } + if (sourceFrames.frames() != frames()) { + std::ostringstream error; + error << "StkFrames::setChannel sourceFrames.frames() != frames()"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS); + } +#endif + unsigned int sourceHop = sourceFrames.nChannels_; + unsigned int destinationHop = nChannels_; + for (unsigned int i = destinationChannel,j = sourceChannel; + i < nFrames_ * nChannels_; + i+=destinationHop,j+=sourceHop) + { + data_[i] = sourceFrames[j]; + } +} + +StkFloat StkFrames :: interpolate( StkFloat frame, unsigned int channel ) const +{ +#if defined(_STK_DEBUG_) + if ( frame < 0.0 || frame > (StkFloat) ( nFrames_ - 1 ) || channel >= nChannels_ ) { + std::ostringstream error; + error << "StkFrames::interpolate: invalid frame (" << frame << ") or channel (" << channel << ") value!"; + Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); + } +#endif + + size_t iIndex = ( size_t ) frame; // integer part of index + StkFloat output, alpha = frame - (StkFloat) iIndex; // fractional part of index + + iIndex = iIndex * nChannels_ + channel; + output = data_[ iIndex ]; + if ( alpha > 0.0 ) + output += ( alpha * ( data_[ iIndex + nChannels_ ] - output ) ); + + return output; +} + +} // stk namespace diff --git a/7.x/src/stk/src/TapDelay.cpp b/7.x/src/stk/src/TapDelay.cpp new file mode 100644 index 0000000..49bca6a --- /dev/null +++ b/7.x/src/stk/src/TapDelay.cpp @@ -0,0 +1,87 @@ +/***************************************************/ +/*! \class TapDelay + \brief STK non-interpolating tapped delay line class. + + This class implements a non-interpolating digital delay-line with + an arbitrary number of output "taps". If the maximum length and + tap delays are not specified during instantiation, a fixed maximum + length of 4095 and a single tap delay of zero is set. + + A non-interpolating delay line is typically used in fixed + delay-length applications, such as for reverberation. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "TapDelay.h" + +namespace stk { + +TapDelay :: TapDelay( std::vector taps, unsigned long maxDelay ) +{ + // Writing before reading allows delays from 0 to length-1. + // If we want to allow a delay of maxDelay, we need a + // delayline of length = maxDelay+1. + if ( maxDelay < 1 ) { + oStream_ << "TapDelay::TapDelay: maxDelay must be > 0!\n"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + for ( unsigned int i=0; i maxDelay ) { + oStream_ << "TapDelay::TapDelay: maxDelay must be > than all tap delay values!\n"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + } + + if ( ( maxDelay + 1 ) > inputs_.size() ) + inputs_.resize( maxDelay + 1, 1, 0.0 ); + + inPoint_ = 0; + this->setTapDelays( taps ); +} + +TapDelay :: ~TapDelay() +{ +} + +void TapDelay :: setMaximumDelay( unsigned long delay ) +{ + if ( delay < inputs_.size() ) return; + + for ( unsigned int i=0; i taps ) +{ + for ( unsigned int i=0; i inputs_.size() - 1 ) { // The value is too big. + oStream_ << "TapDelay::setTapDelay: argument (" << taps[i] << ") greater than maximum!\n"; + handleError( StkError::WARNING ); return; + } + } + + if ( taps.size() != outPoint_.size() ) { + outPoint_.resize( taps.size() ); + delays_.resize( taps.size() ); + lastFrame_.resize( 1, (unsigned int)taps.size(), 0.0 ); + } + + for ( unsigned int i=0; i= taps[i] ) outPoint_[i] = inPoint_ - taps[i]; + else outPoint_[i] = inputs_.size() + inPoint_ - taps[i]; + delays_[i] = taps[i]; + } +} + +} // stk namespace + diff --git a/7.x/src/stk/src/TubeBell.cpp b/7.x/src/stk/src/TubeBell.cpp new file mode 100644 index 0000000..83eac78 --- /dev/null +++ b/7.x/src/stk/src/TubeBell.cpp @@ -0,0 +1,78 @@ +/***************************************************/ +/*! \class TubeBell + \brief STK tubular bell (orchestral chime) FM + synthesis instrument. + + This class implements two simple FM Pairs + summed together, also referred to as algorithm + 5 of the TX81Z. + + \code + Algorithm 5 is : 4->3--\ + + --> Out + 2->1--/ + \endcode + + Control Change Numbers: + - Modulator Index One = 2 + - Crossfade of Outputs = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "TubeBell.h" + +namespace stk { + +TubeBell :: TubeBell( void ) + : FM() +{ + // Concatenate the STK rawwave path to the rawwave files + for ( unsigned int i=0; i<3; i++ ) + waves_[i] = new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ); + waves_[3] = new FileLoop( (Stk::rawwavePath() + "fwavblnk.raw").c_str(), true ); + + this->setRatio(0, 1.0 * 0.995); + this->setRatio(1, 1.414 * 0.995); + this->setRatio(2, 1.0 * 1.005); + this->setRatio(3, 1.414 * 1.000); + + gains_[0] = fmGains_[94]; + gains_[1] = fmGains_[76]; + gains_[2] = fmGains_[99]; + gains_[3] = fmGains_[71]; + + adsr_[0]->setAllTimes( 0.005, 4.0, 0.0, 0.04); + adsr_[1]->setAllTimes( 0.005, 4.0, 0.0, 0.04); + adsr_[2]->setAllTimes( 0.001, 2.0, 0.0, 0.04); + adsr_[3]->setAllTimes( 0.004, 4.0, 0.0, 0.04); + + twozero_.setGain( 0.5 ); + vibrato_.setFrequency( 2.0 ); +} + +TubeBell :: ~TubeBell( void ) +{ +} + +void TubeBell :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + gains_[0] = amplitude * fmGains_[94]; + gains_[1] = amplitude * fmGains_[76]; + gains_[2] = amplitude * fmGains_[99]; + gains_[3] = amplitude * fmGains_[71]; + this->setFrequency( frequency ); + this->keyOn(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/Twang.cpp b/7.x/src/stk/src/Twang.cpp new file mode 100644 index 0000000..17f0925 --- /dev/null +++ b/7.x/src/stk/src/Twang.cpp @@ -0,0 +1,103 @@ +/***************************************************/ +/*! \class Twang + \brief STK enhanced plucked string class. + + This class implements an enhanced plucked-string + physical model, a la Jaffe-Smith, Smith, + Karjalainen and others. It includes a comb + filter to simulate pluck position. The tick() + function takes an input sample, which is added + to the delayline input. This can be used to + implement commuted synthesis (if the input + samples are derived from the impulse response of + a body filter) or feedback (as in an electric + guitar model). + + This is a digital waveguide model, making its + use possibly subject to patents held by Stanford + University, Yamaha, and others. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Twang.h" + +namespace stk { + +Twang :: Twang( StkFloat lowestFrequency ) +{ + if ( lowestFrequency <= 0.0 ) { + oStream_ << "Twang::Twang: argument is less than or equal to zero!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + this->setLowestFrequency( lowestFrequency ); + + std::vector coefficients( 2, 0.5 ); + loopFilter_.setCoefficients( coefficients ); + + loopGain_ = 0.995; + pluckPosition_ = 0.4; + this->setFrequency( 220.0 ); +} + +void Twang :: clear( void ) +{ + delayLine_.clear(); + combDelay_.clear(); + loopFilter_.clear(); + lastOutput_ = 0.0; +} + +void Twang :: setLowestFrequency( StkFloat frequency ) +{ + unsigned long nDelays = (unsigned long) ( Stk::sampleRate() / frequency ); + delayLine_.setMaximumDelay( nDelays + 1 ); + combDelay_.setMaximumDelay( nDelays + 1 ); +} + +void Twang :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Twang::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + frequency_ = frequency; + // Delay = length - filter delay. + StkFloat delay = ( Stk::sampleRate() / frequency ) - loopFilter_.phaseDelay( frequency ); + delayLine_.setDelay( delay ); + + this->setLoopGain( loopGain_ ); + + // Set the pluck position, which puts zeroes at position * length. + combDelay_.setDelay( 0.5 * pluckPosition_ * delay ); +} + +void Twang :: setLoopGain( StkFloat loopGain ) +{ + if ( loopGain < 0.0 || loopGain >= 1.0 ) { + oStream_ << "Twang::setLoopGain: parameter is out of range!"; + handleError( StkError::WARNING ); return; + } + + loopGain_ = loopGain; + StkFloat gain = loopGain_ + (frequency_ * 0.000005); + if ( gain >= 1.0 ) gain = 0.99999; + loopFilter_.setGain( gain ); +} + +void Twang :: setPluckPosition( StkFloat position ) +{ + if ( position < 0.0 || position > 1.0 ) { + oStream_ << "Twang::setPluckPosition: argument (" << position << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + + pluckPosition_ = position; +} + +} // stk namespace diff --git a/7.x/src/stk/src/TwoPole.cpp b/7.x/src/stk/src/TwoPole.cpp new file mode 100644 index 0000000..8964a1b --- /dev/null +++ b/7.x/src/stk/src/TwoPole.cpp @@ -0,0 +1,76 @@ +/***************************************************/ +/*! \class TwoPole + \brief STK two-pole filter class. + + This class implements a two-pole digital filter. A method is + provided for creating a resonance in the frequency response while + maintaining a nearly constant filter gain. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "TwoPole.h" +#include + +namespace stk { + +TwoPole :: TwoPole( void ) +{ + b_.resize( 1 ); + a_.resize( 3 ); + inputs_.resize( 1, 1, 0.0 ); + outputs_.resize( 3, 1, 0.0 ); + b_[0] = 1.0; + a_[0] = 1.0; + + Stk::addSampleRateAlert( this ); +} + +TwoPole :: ~TwoPole() +{ + Stk::removeSampleRateAlert( this ); +} + +void TwoPole :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) { + oStream_ << "TwoPole::sampleRateChanged: you may need to recompute filter coefficients!"; + handleError( StkError::WARNING ); + } +} + +void TwoPole :: setResonance( StkFloat frequency, StkFloat radius, bool normalize ) +{ +#if defined(_STK_DEBUG_) + if ( frequency < 0.0 || frequency > 0.5 * Stk::sampleRate() ) { + oStream_ << "TwoPole::setResonance: frequency argument (" << frequency << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + if ( radius < 0.0 || radius >= 1.0 ) { + oStream_ << "TwoPole::setResonance: radius argument (" << radius << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + a_[2] = radius * radius; + a_[1] = (StkFloat) -2.0 * radius * cos(TWO_PI * frequency / Stk::sampleRate()); + + if ( normalize ) { + // Normalize the filter gain ... not terribly efficient. + StkFloat real = 1 - radius + (a_[2] - radius) * cos(TWO_PI * 2 * frequency / Stk::sampleRate()); + StkFloat imag = (a_[2] - radius) * sin(TWO_PI * 2 * frequency / Stk::sampleRate()); + b_[0] = sqrt( pow(real, 2) + pow(imag, 2) ); + } +} + +void TwoPole :: setCoefficients( StkFloat b0, StkFloat a1, StkFloat a2, bool clearState ) +{ + b_[0] = b0; + a_[1] = a1; + a_[2] = a2; + + if ( clearState ) this->clear(); +} + +} // stk namespace diff --git a/7.x/src/stk/src/TwoZero.cpp b/7.x/src/stk/src/TwoZero.cpp new file mode 100644 index 0000000..8742bf4 --- /dev/null +++ b/7.x/src/stk/src/TwoZero.cpp @@ -0,0 +1,74 @@ +/***************************************************/ +/*! \class TwoZero + \brief STK two-zero filter class. + + This class implements a two-zero digital filter. A method is + provided for creating a "notch" in the frequency response while + maintaining a constant filter gain. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "TwoZero.h" +#include + +namespace stk { + +TwoZero :: TwoZero( void ) +{ + b_.resize( 3, 0.0 ); + inputs_.resize( 3, 1, 0.0 ); + b_[0] = 1.0; + + Stk::addSampleRateAlert( this ); +} + +TwoZero :: ~TwoZero() +{ + Stk::removeSampleRateAlert( this ); +} + +void TwoZero :: sampleRateChanged( StkFloat newRate, StkFloat oldRate ) +{ + if ( !ignoreSampleRateChange_ ) { + oStream_ << "TwoZero::sampleRateChanged: you may need to recompute filter coefficients!"; + handleError( StkError::WARNING ); + } +} + +void TwoZero :: setCoefficients( StkFloat b0, StkFloat b1, StkFloat b2, bool clearState ) +{ + b_[0] = b0; + b_[1] = b1; + b_[2] = b2; + + if ( clearState ) this->clear(); +} + +void TwoZero :: setNotch( StkFloat frequency, StkFloat radius ) +{ +#if defined(_STK_DEBUG_) + if ( frequency < 0.0 || frequency > 0.5 * Stk::sampleRate() ) { + oStream_ << "TwoZero::setNotch: frequency argument (" << frequency << ") is out of range!"; + handleError( StkError::WARNING ); return; + } + if ( radius < 0.0 ) { + oStream_ << "TwoZero::setNotch: radius argument (" << radius << ") is negative!"; + handleError( StkError::WARNING ); return; + } +#endif + + b_[2] = radius * radius; + b_[1] = -2.0 * radius * cos(TWO_PI * frequency / Stk::sampleRate()); + + // Normalize the filter gain. + if ( b_[1] > 0.0 ) // Maximum at z = 0. + b_[0] = 1.0 / ( 1.0 + b_[1] + b_[2] ); + else // Maximum at z = -1. + b_[0] = 1.0 / ( 1.0 - b_[1] + b_[2] ); + b_[1] *= b_[0]; + b_[2] *= b_[0]; +} + +} // stk namespace diff --git a/7.x/src/stk/src/VoicForm.cpp b/7.x/src/stk/src/VoicForm.cpp new file mode 100644 index 0000000..ef1b5d0 --- /dev/null +++ b/7.x/src/stk/src/VoicForm.cpp @@ -0,0 +1,189 @@ +/***************************************************/ +/*! \class VoicForm + \brief Four formant synthesis instrument. + + This instrument contains an excitation singing + wavetable (looping wave with random and + periodic vibrato, smoothing on frequency, + etc.), excitation noise, and four sweepable + complex resonances. + + Measured formant data is included, and enough + data is there to support either parallel or + cascade synthesis. In the floating point case + cascade synthesis is the most natural so + that's what you'll find here. + + Control Change Numbers: + - Voiced/Unvoiced Mix = 2 + - Vowel/Phoneme Selection = 4 + - Vibrato Frequency = 11 + - Vibrato Gain = 1 + - Loudness (Spectral Tilt) = 128 + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "VoicForm.h" +#include "Phonemes.h" +#include "SKINImsg.h" +#include +#include + +namespace stk { + +VoicForm :: VoicForm( void ) : Instrmnt() +{ + // Concatenate the STK rawwave path to the rawwave file + voiced_ = new SingWave( (Stk::rawwavePath() + "impuls20.raw").c_str(), true ); + voiced_->setGainRate( 0.001 ); + voiced_->setGainTarget( 0.0 ); + + for ( int i=0; i<4; i++ ) + filters_[i].setSweepRate( 0.001 ); + + onezero_.setZero( -0.9 ); + onepole_.setPole( 0.9 ); + + noiseEnv_.setRate( 0.001 ); + noiseEnv_.setTarget( 0.0 ); + + this->setPhoneme( "eee" ); + this->clear(); +} + +VoicForm :: ~VoicForm( void ) +{ + delete voiced_; +} + +void VoicForm :: clear( void ) +{ + onezero_.clear(); + onepole_.clear(); + for ( int i=0; i<4; i++ ) { + filters_[i].clear(); + } +} + +void VoicForm :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "VoicForm::setFrequency: parameter is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + voiced_->setFrequency( frequency ); +} + +bool VoicForm :: setPhoneme( const char *phoneme ) +{ + bool found = false; + unsigned int i = 0; + while( i < 32 && !found ) { + if ( !strcmp( Phonemes::name(i), phoneme ) ) { + found = true; + filters_[0].setTargets( Phonemes::formantFrequency(i, 0), Phonemes::formantRadius(i, 0), pow(10.0, Phonemes::formantGain(i, 0 ) / 20.0) ); + filters_[1].setTargets( Phonemes::formantFrequency(i, 1), Phonemes::formantRadius(i, 1), pow(10.0, Phonemes::formantGain(i, 1 ) / 20.0) ); + filters_[2].setTargets( Phonemes::formantFrequency(i, 2), Phonemes::formantRadius(i, 2), pow(10.0, Phonemes::formantGain(i, 2 ) / 20.0) ); + filters_[3].setTargets( Phonemes::formantFrequency(i, 3), Phonemes::formantRadius(i, 3), pow(10.0, Phonemes::formantGain(i, 3 ) / 20.0) ); + this->setVoiced( Phonemes::voiceGain( i ) ); + this->setUnVoiced( Phonemes::noiseGain( i ) ); + } + i++; + } + + if ( !found ) { + oStream_ << "VoicForm::setPhoneme: phoneme " << phoneme << " not found!"; + handleError( StkError::WARNING ); + } + + return found; +} + +void VoicForm :: setFilterSweepRate( unsigned int whichOne, StkFloat rate ) +{ + if ( whichOne > 3 ) { + oStream_ << "VoicForm::setFilterSweepRate: filter select argument outside range 0-3!"; + handleError( StkError::WARNING ); return; + } + + filters_[whichOne].setSweepRate(rate); +} + +void VoicForm :: quiet( void ) +{ + voiced_->noteOff(); + noiseEnv_.setTarget( 0.0 ); +} + +void VoicForm :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + voiced_->setGainTarget( amplitude ); + onepole_.setPole( 0.97 - (amplitude * 0.2) ); +} + +void VoicForm :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "VoicForm::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if (number == __SK_Breath_) { // 2 + this->setVoiced( 1.0 - normalizedValue ); + this->setUnVoiced( 0.01 * normalizedValue ); + } + else if (number == __SK_FootControl_) { // 4 + StkFloat temp = 0.0; + unsigned int i = (int) value; + if (i < 32) { + temp = 0.9; + } + else if (i < 64) { + i -= 32; + temp = 1.0; + } + else if (i < 96) { + i -= 64; + temp = 1.1; + } + else if (i < 128) { + i -= 96; + temp = 1.2; + } + else if (i == 128) { + i = 0; + temp = 1.4; + } + filters_[0].setTargets( temp * Phonemes::formantFrequency(i, 0), Phonemes::formantRadius(i, 0), pow(10.0, Phonemes::formantGain(i, 0 ) / 20.0) ); + filters_[1].setTargets( temp * Phonemes::formantFrequency(i, 1), Phonemes::formantRadius(i, 1), pow(10.0, Phonemes::formantGain(i, 1 ) / 20.0) ); + filters_[2].setTargets( temp * Phonemes::formantFrequency(i, 2), Phonemes::formantRadius(i, 2), pow(10.0, Phonemes::formantGain(i, 2 ) / 20.0) ); + filters_[3].setTargets( temp * Phonemes::formantFrequency(i, 3), Phonemes::formantRadius(i, 3), pow(10.0, Phonemes::formantGain(i, 3 ) / 20.0) ); + this->setVoiced( Phonemes::voiceGain( i ) ); + this->setUnVoiced( Phonemes::noiseGain( i ) ); + } + else if (number == __SK_ModFrequency_) // 11 + voiced_->setVibratoRate( normalizedValue * 12.0); // 0 to 12 Hz + else if (number == __SK_ModWheel_) // 1 + voiced_->setVibratoGain( normalizedValue * 0.2); + else if (number == __SK_AfterTouch_Cont_) { // 128 + this->setVoiced( normalizedValue ); + onepole_.setPole( 0.97 - ( normalizedValue * 0.2) ); + } +#if defined(_STK_DEBUG_) + else { + oStream_ << "VoicForm::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Voicer.cpp b/7.x/src/stk/src/Voicer.cpp new file mode 100644 index 0000000..543cffb --- /dev/null +++ b/7.x/src/stk/src/Voicer.cpp @@ -0,0 +1,224 @@ +/***************************************************/ +/*! \class Voicer + \brief STK voice manager class. + + This class can be used to manage a group of STK instrument + classes. Individual voices can be controlled via unique note + tags. Instrument groups can be controlled by group number. + + A previously constructed STK instrument class is linked with a + voice manager using the addInstrument() function. An optional + group number argument can be specified to the addInstrument() + function as well (default group = 0). The voice manager does not + delete any instrument instances ... it is the responsibility of + the user to allocate and deallocate all instruments. + + The tick() function returns the mix of all sounding voices. Each + noteOn returns a unique tag (credits to the NeXT MusicKit), so you + can send control changes to specific voices within an ensemble. + Alternately, control changes can be sent to all voices in a given + group. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Voicer.h" +#include + +namespace stk { + +Voicer :: Voicer( StkFloat decayTime ) +{ + if ( decayTime < 0.0 ) { + oStream_ << "Voicer::Voicer: argument (" << decayTime << ") must be positive!"; + handleError( StkError::FUNCTION_ARGUMENT ); + } + + tags_ = 23456; + muteTime_ = (int) ( decayTime * Stk::sampleRate() ); + lastFrame_.resize( 1, 1, 0.0 ); +} + +void Voicer :: addInstrument( Instrmnt *instrument, int group ) +{ + Voicer::Voice voice; + voice.instrument = instrument; + voice.group = group; + voice.noteNumber = -1; + voices_.push_back( voice ); + + // Check output channels and resize lastFrame_ if necessary. + if ( instrument->channelsOut() > lastFrame_.channels() ) { + unsigned int startChannel = lastFrame_.channels(); + lastFrame_.resize( 1, instrument->channelsOut() ); + for ( unsigned int i=startChannel; i::iterator i; + for ( i=voices_.begin(); i!=voices_.end(); ++i ) { + if ( (*i).instrument != instrument ) continue; + voices_.erase( i ); + found = true; + break; + } + + if ( found ) { + // Check output channels and resize lastFrame_ if necessary. + unsigned int maxChannels = 1; + for ( i=voices_.begin(); i!=voices_.end(); ++i ) { + if ( (*i).instrument->channelsOut() > maxChannels ) maxChannels = (*i).instrument->channelsOut(); + } + if ( maxChannels < lastFrame_.channels() ) + lastFrame_.resize( 1, maxChannels ); + } + else { + oStream_ << "Voicer::removeInstrument: instrument pointer not found in current voices!"; + handleError( StkError::WARNING ); + } +} + +long Voicer :: noteOn(StkFloat noteNumber, StkFloat amplitude, int group ) +{ + unsigned int i; + StkFloat frequency = (StkFloat) 220.0 * pow( 2.0, (noteNumber - 57.0) / 12.0 ); + for ( i=0; inoteOn( frequency, amplitude * ONE_OVER_128 ); + voices_[i].sounding = 1; + return voices_[i].tag; + } + } + + // All voices are sounding, so interrupt the oldest voice. + int voice = -1; + for ( i=0; i= 0 ) { + voices_[voice].tag = tags_++; + voices_[voice].group = group; + voices_[voice].noteNumber = noteNumber; + voices_[voice].frequency = frequency; + voices_[voice].instrument->noteOn( frequency, amplitude * ONE_OVER_128 ); + voices_[voice].sounding = 1; + return voices_[voice].tag; + } + + return -1; +} + +void Voicer :: noteOff( StkFloat noteNumber, StkFloat amplitude, int group ) +{ + for ( unsigned int i=0; inoteOff( amplitude * ONE_OVER_128 ); + voices_[i].sounding = -muteTime_; + } + } +} + +void Voicer :: noteOff( long tag, StkFloat amplitude ) +{ + for ( unsigned int i=0; inoteOff( amplitude * ONE_OVER_128 ); + voices_[i].sounding = -muteTime_; + break; + } + } +} + +void Voicer :: setFrequency( StkFloat noteNumber, int group ) +{ + StkFloat frequency = (StkFloat) 220.0 * pow( 2.0, (noteNumber - 57.0) / 12.0 ); + for ( unsigned int i=0; isetFrequency( frequency ); + } + } +} + +void Voicer :: setFrequency( long tag, StkFloat noteNumber ) +{ + StkFloat frequency = (StkFloat) 220.0 * pow( 2.0, (noteNumber - 57.0) / 12.0 ); + for ( unsigned int i=0; isetFrequency( frequency ); + break; + } + } +} + +void Voicer :: pitchBend( StkFloat value, int group ) +{ + StkFloat pitchScaler; + if ( value < 8192.0 ) + pitchScaler = pow( 0.5, (8192.0-value) / 8192.0 ); + else + pitchScaler = pow( 2.0, (value-8192.0) / 8192.0 ); + for ( unsigned int i=0; isetFrequency( (StkFloat) (voices_[i].frequency * pitchScaler) ); + } +} + +void Voicer :: pitchBend( long tag, StkFloat value ) +{ + StkFloat pitchScaler; + if ( value < 8192.0 ) + pitchScaler = pow( 0.5, (8192.0-value) / 8192.0 ); + else + pitchScaler = pow( 2.0, (value-8192.0) / 8192.0 ); + for ( unsigned int i=0; isetFrequency( (StkFloat) (voices_[i].frequency * pitchScaler) ); + break; + } + } +} + +void Voicer :: controlChange( int number, StkFloat value, int group ) +{ + for ( unsigned int i=0; icontrolChange( number, value ); + } +} + +void Voicer :: controlChange( long tag, int number, StkFloat value ) +{ + for ( unsigned int i=0; icontrolChange( number, value ); + break; + } + } +} + +void Voicer :: silence( void ) +{ + for ( unsigned int i=0; i 0 ) + voices_[i].instrument->noteOff( 0.5 ); + } +} + +} // stk namespace diff --git a/7.x/src/stk/src/Whistle.cpp b/7.x/src/stk/src/Whistle.cpp new file mode 100644 index 0000000..636861e --- /dev/null +++ b/7.x/src/stk/src/Whistle.cpp @@ -0,0 +1,256 @@ +/***************************************************/ +/*! \Class Whistle + \brief STK police/referee whistle instrument class. + + This class implements a hybrid physical/spectral + model of a police whistle (a la Cook). + + Control Change Numbers: + - Noise Gain = 4 + - Fipple Modulation Frequency = 11 + - Fipple Modulation Gain = 1 + - Blowing Frequency Modulation = 2 + - Volume = 128 + + by Perry R. Cook 1995--2021. +*/ +/***************************************************/ + +#include "Whistle.h" +#include "SKINImsg.h" +#include + +namespace stk { + +const int CAN_RADIUS = 100; +const int PEA_RADIUS = 30; +const int BUMP_RADIUS = 5; + +const StkFloat NORM_CAN_LOSS = 0.97; +//const StkFloat SLOW_CAN_LOSS = 0.90; +const StkFloat GRAVITY = 20.0; + +const StkFloat NORM_TICK_SIZE = 0.004; +//const StkFloat SLOW_TICK_SIZE = 0.0001; + +const StkFloat ENV_RATE = 0.001; + +Whistle :: Whistle( void ) +{ + sine_.setFrequency( 2800.0 ); + + can_.setRadius( CAN_RADIUS ); + can_.setPosition(0, 0, 0); // set can location + can_.setVelocity(0, 0, 0); // and the velocity + + onepole_.setPole(0.95); // 0.99 + + bumper_.setRadius( BUMP_RADIUS ); + bumper_.setPosition(0.0, CAN_RADIUS-BUMP_RADIUS, 0); + bumper_.setPosition(0.0, CAN_RADIUS-BUMP_RADIUS, 0); + + pea_.setRadius( PEA_RADIUS ); + pea_.setPosition(0, CAN_RADIUS/2, 0); + pea_.setVelocity(35, 15, 0); + + envelope_.setRate( ENV_RATE ); + envelope_.keyOn(); + + fippleFreqMod_ = 0.5; + fippleGainMod_ = 0.5; + blowFreqMod_ = 0.25; + noiseGain_ = 0.125; + baseFrequency_ = 2000; + + tickSize_ = NORM_TICK_SIZE; + canLoss_ = NORM_CAN_LOSS; + + subSample_ = 1; + subSampCount_ = subSample_; +} + +Whistle :: ~Whistle( void ) +{ +#ifdef WHISTLE_ANIMATION + printf("Exit, Whistle bye bye!!\n"); +#endif +} + +void Whistle :: clear( void ) +{ +} + +void Whistle :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Whistle::setFrequency: parameter is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + baseFrequency_ = frequency * 4; // the whistle is a transposing instrument +} + +void Whistle :: startBlowing( StkFloat amplitude, StkFloat rate ) +{ + if ( amplitude <= 0.0 || rate <= 0.0 ) { + oStream_ << "Whistle::startBlowing: one or more arguments is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( ENV_RATE ); + envelope_.setTarget( amplitude ); +} + +void Whistle :: stopBlowing( StkFloat rate ) +{ + if ( rate <= 0.0 ) { + oStream_ << "Whistle::stopBlowing: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } + + envelope_.setRate( rate ); + envelope_.keyOff(); +} + +void Whistle :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + this->setFrequency( frequency ); + this->startBlowing( amplitude*2.0 ,amplitude * 0.2 ); +} + +void Whistle :: noteOff( StkFloat amplitude ) +{ + this->stopBlowing( amplitude * 0.02 ); +} + +int frameCount = 0; + +StkFloat Whistle :: tick( unsigned int ) +{ + StkFloat soundMix, tempFreq; + StkFloat envOut = 0, temp, temp1, temp2, tempX, tempY; + double phi, cosphi, sinphi; + double gain = 0.5, mod = 0.0; + + if ( --subSampCount_ <= 0 ) { + tempVectorP_ = pea_.getPosition(); + subSampCount_ = subSample_; + temp = bumper_.isInside( tempVectorP_ ); +#ifdef WHISTLE_ANIMATION + frameCount += 1; + if ( frameCount >= (1470 / subSample_) ) { + frameCount = 0; + printf("%f %f %f\n",tempVectorP_->getX(),tempVectorP_->getY(),envOut); + fflush(stdout); + } +#endif + envOut = envelope_.tick(); + + if (temp < (BUMP_RADIUS + PEA_RADIUS)) { + tempX = envOut * tickSize_ * 2000 * noise_.tick(); + tempY = -envOut * tickSize_ * 1000 * (1.0 + noise_.tick()); + pea_.addVelocity( tempX, tempY, 0 ); + pea_.tick( tickSize_ ); + } + + mod = exp(-temp * 0.01); // exp. distance falloff of fipple/pea effect + temp = onepole_.tick(mod); // smooth it a little + gain = (1.0 - (fippleGainMod_*0.5)) + (2.0 * fippleGainMod_ * temp); + gain *= gain; // squared distance/gain + // tempFreq = 1.0 // Normalized Base Freq + // + (fippleFreqMod_ * 0.25) - (fippleFreqMod_ * temp) // fippleModulation + // - (blowFreqMod_) + (blowFreqMod_ * envOut); // blowingModulation + // short form of above + tempFreq = 1.0 + fippleFreqMod_*(0.25-temp) + blowFreqMod_*(envOut-1.0); + tempFreq *= baseFrequency_; + + sine_.setFrequency(tempFreq); + + tempVectorP_ = pea_.getPosition(); + temp = can_.isInside(tempVectorP_); + temp = -temp; // We know (hope) it's inside, just how much?? + if (temp < (PEA_RADIUS * 1.25)) { + pea_.getVelocity( &tempVector_ ); // This is the can/pea collision + tempX = tempVectorP_->getX(); // calculation. Could probably + tempY = tempVectorP_->getY(); // simplify using tables, etc. + phi = -atan2(tempY,tempX); + + cosphi = cos(phi); + sinphi = sin(phi); + temp1 = (cosphi*tempVector_.getX()) - (sinphi*tempVector_.getY()); + temp2 = (sinphi*tempVector_.getX()) + (cosphi*tempVector_.getY()); + temp1 = -temp1; + tempX = (cosphi*temp1) + (sinphi*temp2); + tempY = (-sinphi*temp1) + (cosphi*temp2); + pea_.setVelocity(tempX, tempY, 0); + pea_.tick(tickSize_); + pea_.setVelocity( tempX*canLoss_, tempY*canLoss_, 0 ); + pea_.tick(tickSize_); + } + + temp = tempVectorP_->getLength(); + if (temp > 0.01) { + tempX = tempVectorP_->getX(); + tempY = tempVectorP_->getY(); + phi = atan2( tempY, tempX ); + phi += 0.3 * temp / CAN_RADIUS; + cosphi = cos(phi); + sinphi = sin(phi); + tempX = 3.0 * temp * cosphi; + tempY = 3.0 * temp * sinphi; + } + else { + tempX = 0.0; + tempY = 0.0; + } + + temp = (0.9 + 0.1*subSample_*noise_.tick()) * envOut * 0.6 * tickSize_; + pea_.addVelocity( temp * tempX, (temp*tempY) - (GRAVITY*tickSize_), 0 ); + pea_.tick( tickSize_ ); + + // bumper_.tick(0.0); + } + + temp = envOut * envOut * gain / 2; + soundMix = temp * ( sine_.tick() + ( noiseGain_*noise_.tick() ) ); + lastFrame_[0] = 0.20 * soundMix; // should probably do one-zero filter here + + return lastFrame_[0]; +} + +void Whistle :: controlChange( int number, StkFloat value ) +{ +#if defined(_STK_DEBUG_) + if ( Stk::inRange( value, 0.0, 128.0 ) == false ) { + oStream_ << "Whistle::controlChange: value (" << value << ") is out of range!"; + handleError( StkError::WARNING ); return; + } +#endif + + StkFloat normalizedValue = value * ONE_OVER_128; + if ( number == __SK_NoiseLevel_ ) // 4 + noiseGain_ = 0.25 * normalizedValue; + else if ( number == __SK_ModFrequency_ ) // 11 + fippleFreqMod_ = normalizedValue; + else if ( number == __SK_ModWheel_ ) // 1 + fippleGainMod_ = normalizedValue; + else if ( number == __SK_AfterTouch_Cont_ ) // 128 + envelope_.setTarget( normalizedValue * 2.0 ); + else if ( number == __SK_Breath_ ) // 2 + blowFreqMod_ = normalizedValue * 0.5; + else if ( number == __SK_Sustain_ ) { // 64 + subSample_ = (int) value; + if ( subSample_ < 1.0 ) subSample_ = 1; + envelope_.setRate( ENV_RATE / subSample_ ); + } +#if defined(_STK_DEBUG_) + else { + oStream_ << "Whistle::controlChange: undefined control number (" << number << ")!"; + handleError( StkError::WARNING ); + } +#endif +} + +} // stk namespace diff --git a/7.x/src/stk/src/Wurley.cpp b/7.x/src/stk/src/Wurley.cpp new file mode 100644 index 0000000..6842539 --- /dev/null +++ b/7.x/src/stk/src/Wurley.cpp @@ -0,0 +1,94 @@ +/***************************************************/ +/*! \class Wurley + \brief STK Wurlitzer electric piano FM + synthesis instrument. + + This class implements two simple FM Pairs + summed together, also referred to as algorithm + 5 of the TX81Z. + + \code + Algorithm 5 is : 4->3--\ + + --> Out + 2->1--/ + \endcode + + Control Change Numbers: + - Modulator Index One = 2 + - Crossfade of Outputs = 4 + - LFO Speed = 11 + - LFO Depth = 1 + - ADSR 2 & 4 Target = 128 + + The basic Chowning/Stanford FM patent expired + in 1995, but there exist follow-on patents, + mostly assigned to Yamaha. If you are of the + type who should worry about this (making + money) worry away. + + by Perry R. Cook and Gary P. Scavone, 1995--2021. +*/ +/***************************************************/ + +#include "Wurley.h" + +namespace stk { + +Wurley :: Wurley( void ) + : FM() +{ + // Concatenate the STK rawwave path to the rawwave files + for ( unsigned int i=0; i<3; i++ ) + waves_[i] = new FileLoop( (Stk::rawwavePath() + "sinewave.raw").c_str(), true ); + waves_[3] = new FileLoop( (Stk::rawwavePath() + "fwavblnk.raw").c_str(), true ); + + this->setRatio(0, 1.0); + this->setRatio(1, 4.0); + this->setRatio(2, -510.0); + this->setRatio(3, -510.0); + + gains_[0] = fmGains_[99]; + gains_[1] = fmGains_[82]; + gains_[2] = fmGains_[92]; + gains_[3] = fmGains_[68]; + + adsr_[0]->setAllTimes( 0.001, 1.50, 0.0, 0.04); + adsr_[1]->setAllTimes( 0.001, 1.50, 0.0, 0.04); + adsr_[2]->setAllTimes( 0.001, 0.25, 0.0, 0.04); + adsr_[3]->setAllTimes( 0.001, 0.15, 0.0, 0.04); + + twozero_.setGain( 2.0 ); + vibrato_.setFrequency( 8.0 ); +} + +Wurley :: ~Wurley( void ) +{ +} + +void Wurley :: setFrequency( StkFloat frequency ) +{ +#if defined(_STK_DEBUG_) + if ( frequency <= 0.0 ) { + oStream_ << "Wurley::setFrequency: argument is less than or equal to zero!"; + handleError( StkError::WARNING ); return; + } +#endif + + baseFrequency_ = frequency; + waves_[0]->setFrequency( baseFrequency_ * ratios_[0]); + waves_[1]->setFrequency( baseFrequency_ * ratios_[1]); + waves_[2]->setFrequency( ratios_[2] ); // Note here a 'fixed resonance'. + waves_[3]->setFrequency( ratios_[3] ); +} + +void Wurley :: noteOn( StkFloat frequency, StkFloat amplitude ) +{ + gains_[0] = amplitude * fmGains_[99]; + gains_[1] = amplitude * fmGains_[82]; + gains_[2] = amplitude * fmGains_[82]; + gains_[3] = amplitude * fmGains_[68]; + this->setFrequency( frequency ); + this->keyOn(); +} + +} // stk namespace diff --git a/7.x/src/stk/stkOpcodes.cpp b/7.x/src/stk/stkOpcodes.cpp new file mode 100644 index 0000000..87df13a --- /dev/null +++ b/7.x/src/stk/stkOpcodes.cpp @@ -0,0 +1,610 @@ +/* + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ +/* + * CSOUND 7 OPCODES FOR PERRY COOK'S SYNTHESIS TOOLKIT IN C++ (STK) INSTRUMENT + * + * This code is copyright (C) 2005 by Michael Gogins. It is licensed under the + * same terms as the Synthesis Toolkit in C++ by Perry R. Cook and Gary P. + * Scavone. + * + * The STK sources are bundled in this directory (include/, src/ and + * rawwaves/) so that a patched copy is always used, independent of any system + * or package-manager STK installation. The rawwaves path defaults to the + * installed location (DEFAULT_RAWWAVE_PATH) and can be overridden with the + * RAWWAVE_PATH environment variable. + * + * All these opcodes are named "STK" + the STK classname, + * e.g. "STKBowed" for the Bowed instrument. + * + * All the STK opcodes have the same signature: + * + * aout STKName ifrequency igain {kcontroller0, kvalue1,...,kcontroller7, + * kvalue7} + * + * They take a frequency in Hertz and a gain parameter in the range [0, 1], + * plus up to eight optional krate controller-value pairs, and return an arate + * signal that should be more or less in the range [-1, +1]. + * See the STK class documentation to determine the controller numbers + * used by each instrument. + */ + +/* Standard library headers must be included before any STK or Csound headers so + that STK's and Csound's "PI" do not clash with the standard library. */ +#include +#include +#include +#include +#include +#include + +#include "BandedWG.h" +#include "BeeThree.h" +#include "BlowBotl.h" +#include "BlowHole.h" +#include "Bowed.h" +#include "Brass.h" +#include "Clarinet.h" +#include "Drummer.h" +#include "FMVoices.h" +#include "Flute.h" +#include "HevyMetl.h" +#include "Mandolin.h" +#include "Stk.h" +#include "ModalBar.h" +#include "Moog.h" +#include "PercFlut.h" +#include "Plucked.h" +#include "Resonate.h" +#include "Rhodey.h" +#include "Saxofony.h" +#include "Shakers.h" +#include "Simple.h" +#include "Sitar.h" +#include "StifKarp.h" +#include "TubeBell.h" +#include "VoicForm.h" +#include "Whistle.h" +#include "Wurley.h" + +extern "C" { +#include +} + +#include "OpcodeBase.hpp" + +using namespace stk; +using namespace csound; +using namespace std; + +template +class STKInstrumentAdapter : public OpcodeBase> { +public: + // Outputs. + cs_float *aoutput; + // Inputs. + cs_float *ifrequency; + cs_float *igain; + cs_float *kcontroller0; + cs_float *kvalue0; + cs_float *kcontroller1; + cs_float *kvalue1; + cs_float *kcontroller2; + cs_float *kvalue2; + cs_float *kcontroller3; + cs_float *kvalue3; + cs_float *kcontroller4; + cs_float *kvalue4; + cs_float *kcontroller5; + cs_float *kvalue5; + cs_float *kcontroller6; + cs_float *kvalue6; + cs_float *kcontroller7; + cs_float *kvalue7; + // State. + T *instrument; + bool released; + cs_float oldkcontroller0; + cs_float oldkvalue0; + cs_float oldkcontroller1; + cs_float oldkvalue1; + cs_float oldkcontroller2; + cs_float oldkvalue2; + cs_float oldkcontroller3; + cs_float oldkvalue3; + cs_float oldkcontroller4; + cs_float oldkvalue4; + cs_float oldkcontroller5; + cs_float oldkvalue5; + cs_float oldkcontroller6; + cs_float oldkvalue6; + cs_float oldkcontroller7; + cs_float oldkvalue7; + STKInstrumentAdapter() : instrument(0) {} + int32_t init(CSOUND *csound) { + if (!instrument) { + Stk::setSampleRate((StkFloat)this->opds.insdshead->esr); + instrument = new T(); + } + instrument->noteOn(*ifrequency, *igain); + released = false; + oldkcontroller0 = -1.0; + oldkvalue0 = -1.0; + oldkcontroller1 = -1.0; + oldkvalue1 = -1.0; + oldkcontroller2 = -1.0; + oldkvalue2 = -1.0; + oldkcontroller3 = -1.0; + oldkvalue3 = -1.0; + oldkcontroller4 = -1.0; + oldkvalue4 = -1.0; + oldkcontroller5 = -1.0; + oldkvalue5 = -1.0; + oldkcontroller6 = -1.0; + oldkvalue6 = -1.0; + oldkcontroller7 = -1.0; + oldkvalue7 = -1.0; + return OK; + } + int32_t kontrol(CSOUND *csound) { + if (!released) { + if (*kcontroller0 != oldkcontroller0 || *kvalue0 != oldkvalue0) { + instrument->controlChange(static_cast(*kcontroller0), *kvalue0); + oldkcontroller0 = *kcontroller0; + oldkvalue0 = *kvalue0; + } + if (*kcontroller1 != oldkcontroller1 || *kvalue1 != oldkvalue1) { + instrument->controlChange(static_cast(*kcontroller1), *kvalue1); + oldkcontroller1 = *kcontroller1; + oldkvalue1 = *kvalue1; + } + if (*kcontroller2 != oldkcontroller2 || *kvalue2 != oldkvalue2) { + instrument->controlChange(static_cast(*kcontroller2), *kvalue2); + oldkcontroller2 = *kcontroller2; + oldkvalue2 = *kvalue2; + } + if (*kcontroller3 != oldkcontroller3 || *kvalue3 != oldkvalue3) { + instrument->controlChange(static_cast(*kcontroller3), *kvalue3); + oldkcontroller3 = *kcontroller3; + oldkvalue3 = *kvalue3; + } + if (*kcontroller4 != oldkcontroller4 || *kvalue4 != oldkvalue4) { + instrument->controlChange(static_cast(*kcontroller4), *kvalue4); + oldkcontroller4 = *kcontroller4; + oldkvalue4 = *kvalue4; + } + if (*kcontroller5 != oldkcontroller5 || *kvalue5 != oldkvalue5) { + instrument->controlChange(static_cast(*kcontroller5), *kvalue5); + oldkcontroller5 = *kcontroller5; + oldkvalue5 = *kvalue5; + } + if (*kcontroller6 != oldkcontroller6 || *kvalue6 != oldkvalue6) { + instrument->controlChange(static_cast(*kcontroller6), *kvalue6); + oldkcontroller6 = *kcontroller6; + oldkvalue6 = *kvalue6; + } + if (*kcontroller7 != oldkcontroller7 || *kvalue7 != oldkvalue7) { + instrument->controlChange(static_cast(*kcontroller7), *kvalue7); + oldkcontroller7 = *kcontroller7; + oldkvalue7 = *kvalue7; + } + } + uint32_t offset = this->kperiodOffset(); + uint32_t end = this->kperiodEnd(); + uint32_t nsmps = this->ksmps(); + for (uint32_t i = 0; i < offset; i++) { + aoutput[i] = 0; + } + if (!released) { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = instrument->tick(); + } + } else { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = 0; + } + } + for (uint32_t i = end; i < nsmps; i++) { + aoutput[i] = 0; + } + return OK; + } + int32_t deinit(CSOUND *csound) { + if (instrument) { + delete instrument; + instrument = 0; + } + return OK; + } + static int32_t deinit_(CSOUND *csound, void *opcode) { + return reinterpret_cast *>(opcode)->deinit(csound); + } +}; + +template +class STKInstrumentAdapter1 : public OpcodeBase> { +public: + // Outputs. + cs_float *aoutput; + // Inputs. + cs_float *ifrequency; + cs_float *igain; + cs_float *kcontroller0; + cs_float *kvalue0; + cs_float *kcontroller1; + cs_float *kvalue1; + cs_float *kcontroller2; + cs_float *kvalue2; + cs_float *kcontroller3; + cs_float *kvalue3; + cs_float *kcontroller4; + cs_float *kvalue4; + cs_float *kcontroller5; + cs_float *kvalue5; + cs_float *kcontroller6; + cs_float *kvalue6; + cs_float *kcontroller7; + cs_float *kvalue7; + // State. + T *instrument; + bool released; + cs_float oldkcontroller0; + cs_float oldkvalue0; + cs_float oldkcontroller1; + cs_float oldkvalue1; + cs_float oldkcontroller2; + cs_float oldkvalue2; + cs_float oldkcontroller3; + cs_float oldkvalue3; + cs_float oldkcontroller4; + cs_float oldkvalue4; + cs_float oldkcontroller5; + cs_float oldkvalue5; + cs_float oldkcontroller6; + cs_float oldkvalue6; + cs_float oldkcontroller7; + cs_float oldkvalue7; + STKInstrumentAdapter1() : instrument(0) {} + int32_t init(CSOUND *csound) { + if (!instrument) { + Stk::setSampleRate((StkFloat)this->opds.insdshead->esr); + instrument = new T((StkFloat)10.0); + } + instrument->noteOn(*ifrequency, *igain); + released = false; + oldkcontroller0 = -1.0; + oldkvalue0 = -1.0; + oldkcontroller1 = -1.0; + oldkvalue1 = -1.0; + oldkcontroller2 = -1.0; + oldkvalue2 = -1.0; + oldkcontroller3 = -1.0; + oldkvalue3 = -1.0; + oldkcontroller4 = -1.0; + oldkvalue4 = -1.0; + oldkcontroller5 = -1.0; + oldkvalue5 = -1.0; + oldkcontroller6 = -1.0; + oldkvalue6 = -1.0; + oldkcontroller7 = -1.0; + oldkvalue7 = -1.0; + return OK; + } + int32_t kontrol(CSOUND *csound) { + if (!released) { + if (*kcontroller0 != oldkcontroller0 || *kvalue0 != oldkvalue0) { + instrument->controlChange(static_cast(*kcontroller0), *kvalue0); + oldkcontroller0 = *kcontroller0; + oldkvalue0 = *kvalue0; + } + if (*kcontroller1 != oldkcontroller1 || *kvalue1 != oldkvalue1) { + instrument->controlChange(static_cast(*kcontroller1), *kvalue1); + oldkcontroller1 = *kcontroller1; + oldkvalue1 = *kvalue1; + } + if (*kcontroller2 != oldkcontroller2 || *kvalue2 != oldkvalue2) { + instrument->controlChange(static_cast(*kcontroller2), *kvalue2); + oldkcontroller2 = *kcontroller2; + oldkvalue2 = *kvalue2; + } + if (*kcontroller3 != oldkcontroller3 || *kvalue3 != oldkvalue3) { + instrument->controlChange(static_cast(*kcontroller3), *kvalue3); + oldkcontroller3 = *kcontroller3; + oldkvalue3 = *kvalue3; + } + if (*kcontroller4 != oldkcontroller4 || *kvalue4 != oldkvalue4) { + instrument->controlChange(static_cast(*kcontroller4), *kvalue4); + oldkcontroller4 = *kcontroller4; + oldkvalue4 = *kvalue4; + } + if (*kcontroller5 != oldkcontroller5 || *kvalue5 != oldkvalue5) { + instrument->controlChange(static_cast(*kcontroller5), *kvalue5); + oldkcontroller5 = *kcontroller5; + oldkvalue5 = *kvalue5; + } + if (*kcontroller6 != oldkcontroller6 || *kvalue6 != oldkvalue6) { + instrument->controlChange(static_cast(*kcontroller6), *kvalue6); + oldkcontroller6 = *kcontroller6; + oldkvalue6 = *kvalue6; + } + if (*kcontroller7 != oldkcontroller7 || *kvalue7 != oldkvalue7) { + instrument->controlChange(static_cast(*kcontroller7), *kvalue7); + oldkcontroller7 = *kcontroller7; + oldkvalue7 = *kvalue7; + } + } + uint32_t offset = this->kperiodOffset(); + uint32_t end = this->kperiodEnd(); + uint32_t nsmps = this->ksmps(); + for (uint32_t i = 0; i < offset; i++) { + aoutput[i] = 0; + } + if (!released) { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = instrument->tick(); + } + } else { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = 0; + } + } + for (uint32_t i = end; i < nsmps; i++) { + aoutput[i] = 0; + } + return OK; + } + int32_t deinit(CSOUND *csound) { + if (instrument) { + delete instrument; + instrument = 0; + } + return OK; + } + static int32_t deinit_(CSOUND *csound, void *opcode) { + return reinterpret_cast *>(opcode)->deinit(csound); + } +}; + +extern "C" { +OENTRY oentries[] = { + { + (char *)"STKBandedWG", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKBeeThree", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKBlowBotl", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKBlowHole", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKBowed", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKBrass", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKClarinet", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKDrummer", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKFlute", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKFMVoices", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKHevyMetl", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKMandolin", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKModalBar", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKMoog", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKPercFlut", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKPlucked", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKResonate", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKRhodey", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKSaxofony", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKShakers", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKSimple", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKSitar", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKStifKarp", sizeof(STKInstrumentAdapter1), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter1::init_, + (SUBR)STKInstrumentAdapter1::kontrol_, + (SUBR)STKInstrumentAdapter1::deinit_, 0, 0, + }, + { + (char *)"STKTubeBell", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKVoicForm", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKWhistle", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + (char *)"STKWurley", sizeof(STKInstrumentAdapter), 0, + (char *)"a", (char *)"iiJJJJJJJJJJJJJJJJ", + (SUBR)STKInstrumentAdapter::init_, + (SUBR)STKInstrumentAdapter::kontrol_, + (SUBR)STKInstrumentAdapter::deinit_, 0, 0, + }, + { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }}; +} + +PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { return 0; } + +PUBLIC int32_t csoundModuleInit(CSOUND *csound) { + const char *path = csound->GetEnv(csound, "RAWWAVE_PATH"); +#ifdef DEFAULT_RAWWAVE_PATH + if (path == NULL || strlen(path) == 0) + path = DEFAULT_RAWWAVE_PATH; +#endif + if (path == NULL || strlen(path) == 0) { + if (UNLIKELY(csound->GetDebug(csound))) + csound->Warning(csound, + "%s", Str("STK opcodes not available: define environment " + "variable RAWWAVE_PATH\n(points " + "to rawwaves directory) to use STK opcodes.")); + return 0; + } else { + Stk::setRawwavePath(path); + } + int32_t status = 0; + for (OENTRY *ep = &oentries[0]; ep->opname; ep++) { + status |= csound->AppendOpcode( + csound, ep->opname, ep->dsblksiz, ep->flags, ep->outypes, ep->intypes, + (int32_t (*)(CSOUND *, void *))ep->init, + (int32_t (*)(CSOUND *, void *))ep->perf, + (int32_t (*)(CSOUND *, void *))ep->deinit); + } + return status; +} + +PUBLIC int32_t csoundModuleDestroy(CSOUND *csound) { return 0; } + +PUBLIC int32_t csoundModuleInfo(void) { return CSOUND_MODULE_INFO; } From 40b8db1987af1d6aaae06e671009bfaf4b8a5486 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Tue, 13 Oct 2026 09:45:26 +0100 Subject: [PATCH 46/72] Stage STK rawwaves with the correct .raw extension --- .github/workflows/plugins_build_7.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 5316a50..82f160b 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -119,7 +119,7 @@ jobs: build/src/OpenCL/*.so \ build/src/stk/*.so package/ mkdir -p package/rawwaves - cp 7.x/src/stk/rawwaves/*.wav package/rawwaves/ + cp 7.x/src/stk/rawwaves/*.raw package/rawwaves/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -225,7 +225,7 @@ jobs: build/src/OpenCL/*.dylib \ build/src/stk/*.dylib package/ mkdir -p package/rawwaves - cp 7.x/src/stk/rawwaves/*.wav package/rawwaves/ + cp 7.x/src/stk/rawwaves/*.raw package/rawwaves/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -327,7 +327,7 @@ jobs: } $rawwaves = Join-Path $package 'rawwaves' New-Item -ItemType Directory -Force -Path $rawwaves | Out-Null - Copy-Item '7.x\src\stk\rawwaves\*.wav' -Destination $rawwaves + Copy-Item '7.x\src\stk\rawwaves\*.raw' -Destination $rawwaves - name: Upload plugins uses: actions/upload-artifact@v4 From ef0c14e5f91d09fe227b6c19fd3563981a1059c4 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Tue, 13 Oct 2026 11:58:01 +0100 Subject: [PATCH 47/72] Add CodeRabbit config excluding vendored STK sources --- .coderabbit.yaml | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .coderabbit.yaml diff --git a/.coderabbit.yaml b/.coderabbit.yaml new file mode 100644 index 0000000..dbc8cc7 --- /dev/null +++ b/.coderabbit.yaml @@ -0,0 +1,5 @@ +reviews: + path_filters: + - "!7.x/src/stk/src/**" + - "!7.x/src/stk/include/**" + - "!7.x/src/stk/rawwaves/**" From d2e2057e20870fa44ab48bc00bd4a54d563781d4 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Tue, 13 Oct 2026 12:13:03 +0100 Subject: [PATCH 48/72] Fix STK adapter issues - Correct kperiodEnd() in OpcodeBase to return the end index (ksmps - ksmps_no_end). - Catch StkError from instrument construction and return via csound->InitError. --- 7.x/src/stk/OpcodeBase.hpp | 14 ++------------ 7.x/src/stk/stkOpcodes.cpp | 14 ++++++++++---- 2 files changed, 12 insertions(+), 16 deletions(-) diff --git a/7.x/src/stk/OpcodeBase.hpp b/7.x/src/stk/OpcodeBase.hpp index 49a724f..f0e3843 100644 --- a/7.x/src/stk/OpcodeBase.hpp +++ b/7.x/src/stk/OpcodeBase.hpp @@ -199,12 +199,7 @@ namespace csound { } uint32_t kperiodEnd() const { - uint32_t end = opds.insdshead->ksmps_no_end; - if (end) { - return end; - } else { - return ksmps(); - } + return ksmps() - opds.insdshead->ksmps_no_end; } uint32_t ksmps() const { @@ -325,12 +320,7 @@ namespace csound { } uint32_t kperiodEnd() const { - uint32_t end = opds.insdshead->ksmps_no_end; - if (end) { - return end; - } else { - return ksmps(); - } + return ksmps() - opds.insdshead->ksmps_no_end; } uint32_t ksmps() const { diff --git a/7.x/src/stk/stkOpcodes.cpp b/7.x/src/stk/stkOpcodes.cpp index 87df13a..0f721fd 100644 --- a/7.x/src/stk/stkOpcodes.cpp +++ b/7.x/src/stk/stkOpcodes.cpp @@ -138,8 +138,11 @@ class STKInstrumentAdapter : public OpcodeBase> { STKInstrumentAdapter() : instrument(0) {} int32_t init(CSOUND *csound) { if (!instrument) { - Stk::setSampleRate((StkFloat)this->opds.insdshead->esr); - instrument = new T(); + try { + instrument = new T(); + } catch (StkError &e) { + return csound->InitError(csound, "STK: %s", e.getMessage().c_str()); + } } instrument->noteOn(*ifrequency, *igain); released = false; @@ -282,8 +285,11 @@ class STKInstrumentAdapter1 : public OpcodeBase> { STKInstrumentAdapter1() : instrument(0) {} int32_t init(CSOUND *csound) { if (!instrument) { - Stk::setSampleRate((StkFloat)this->opds.insdshead->esr); - instrument = new T((StkFloat)10.0); + try { + instrument = new T((StkFloat)10.0); + } catch (StkError &e) { + return csound->InitError(csound, "STK: %s", e.getMessage().c_str()); + } } instrument->noteOn(*ifrequency, *igain); released = false; From 23c397d662640d1278551cc9e9d2593b13d998bd Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Tue, 13 Oct 2026 12:24:06 +0100 Subject: [PATCH 49/72] Fix STK rawwaves staging path in CI Stage rawwaves under package/stk/rawwaves to match DEFAULT_RAWWAVE_PATH (/stk/rawwaves) so release packages find them without requiring RAWWAVE_PATH. --- .github/workflows/plugins_build_7.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 82f160b..4d2ca45 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -118,8 +118,8 @@ jobs: build/src/py/*.so \ build/src/OpenCL/*.so \ build/src/stk/*.so package/ - mkdir -p package/rawwaves - cp 7.x/src/stk/rawwaves/*.raw package/rawwaves/ + mkdir -p package/stk/rawwaves + cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -224,8 +224,8 @@ jobs: build/src/py/*.dylib \ build/src/OpenCL/*.dylib \ build/src/stk/*.dylib package/ - mkdir -p package/rawwaves - cp 7.x/src/stk/rawwaves/*.raw package/rawwaves/ + mkdir -p package/stk/rawwaves + cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -325,7 +325,7 @@ jobs: if (Test-Path $vcpkgBin) { Copy-Item (Join-Path $vcpkgBin '*.dll') -Destination $package -ErrorAction SilentlyContinue } - $rawwaves = Join-Path $package 'rawwaves' + $rawwaves = Join-Path $package 'stk/rawwaves' New-Item -ItemType Directory -Force -Path $rawwaves | Out-Null Copy-Item '7.x\src\stk\rawwaves\*.raw' -Destination $rawwaves From cdc51c0842aa17c78a284b64d059cfb4e6950730 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Tue, 13 Oct 2026 20:27:30 +0300 Subject: [PATCH 50/72] feat(wasm): scaffold @csound/plugins npm package --- .github/workflows/plugins_wasm.yml | 51 +++ .gitignore | 5 + 7.x/CMakeLists.txt | 20 +- 7.x/cmake/Modules/FindCSOUND.cmake | 8 +- 7.x/cmake/WasmPlugins.cmake | 37 ++ README.md | 3 + THIRD_PARTY.md | 20 + index.d.ts | 6 + index.js | 6 + package-lock.json | 569 +++++++++++++++++++++++++++++ package.json | 39 ++ wasm/README.md | 72 ++++ wasm/default.nix | 107 ++++++ wasm/nixpkgs.nix | 5 + wasm/scripts/build-runtime.sh | 24 ++ wasm/scripts/build.sh | 24 ++ wasm/tests/runtime.test.js | 117 ++++++ 17 files changed, 1110 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/plugins_wasm.yml create mode 100644 7.x/cmake/WasmPlugins.cmake create mode 100644 THIRD_PARTY.md create mode 100644 index.d.ts create mode 100644 index.js create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 wasm/README.md create mode 100644 wasm/default.nix create mode 100644 wasm/nixpkgs.nix create mode 100644 wasm/scripts/build-runtime.sh create mode 100644 wasm/scripts/build.sh create mode 100644 wasm/tests/runtime.test.js diff --git a/.github/workflows/plugins_wasm.yml b/.github/workflows/plugins_wasm.yml new file mode 100644 index 0000000..c9b7f3f --- /dev/null +++ b/.github/workflows/plugins_wasm.yml @@ -0,0 +1,51 @@ +name: Csound 7 WASM plugins + +on: + pull_request: + branches: [develop] + push: + branches: [develop] + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + package: + runs-on: ubuntu-latest + timeout-minutes: 60 + steps: + - uses: actions/checkout@v7.0.1 + # csound/csound#3416 must land and ship before this package can publish. + - uses: actions/checkout@v7.0.1 + with: + repository: csound/csound + ref: dfe33946847fd2fe5fe04948d9ae44ba320c5390 + path: .csound + - uses: actions/setup-node@v6 + with: + node-version: 22 + cache: npm + - uses: cachix/install-nix-action@v31.11.1 + - uses: cachix/cachix-action@v17 + with: + name: csound + - name: Install JS dependencies + run: npm ci + - name: Build WASM plugins with CMake and Nix + run: npm run build + - name: Build the required Csound runtime + run: | + npm run build:runtime + echo "CSOUND_BROWSER_URL=file://$GITHUB_WORKSPACE/.csound/platform/wasm-wasi/browser/dist/csound.js" >> "$GITHUB_ENV" + - name: Test and pack + run: npm pack + - uses: actions/upload-artifact@v7.0.1 + with: + name: csound-plugins-npm + path: csound-plugins-*.tgz + if-no-files-found: error diff --git a/.gitignore b/.gitignore index b80e235..d91c3aa 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,8 @@ build dist csound6-plugins-win_x86_64-* +node_modules/ +result* +*.tgz +.csound/ +.wasm-dist.*/ diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index ed75642..10e1bd2 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -34,6 +34,12 @@ endif() project(Csound-plugins) +string(TOUPPER "${CMAKE_SYSTEM_NAME}" CMAKE_SYSTEM_NAME_UPPER) +if(CMAKE_SYSTEM_NAME_UPPER STREQUAL "WASI") + set(WASM ON) + include(cmake/WasmPlugins.cmake) +endif() + if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") set(CMAKE_COMPILER_IS_CLANG 1) endif() @@ -50,6 +56,9 @@ find_package(CSOUND 7.0) if(NOT CSOUND_FOUND) message(FATAL_ERROR "Csound 7.0 or newer is required") endif() +if(WASM AND NOT CSOUND_VERSION_MAJOR EQUAL 7) + message(FATAL_ERROR "WASM plugins require the Csound 7 SDK") +endif() include(TestBigEndian) include(CheckFunctionExists) @@ -163,7 +172,9 @@ if(LINUX) endif() # plugin install directories (CS_USER_PLUGIN on MacOs/Windows) -if(USE_DOUBLE) +if(WASM) + set(PLUGIN_INSTALL_DIR "lib") +elseif(USE_DOUBLE) message(STATUS "Building with 64-bit floats") if(APPLE) set(PLUGIN_INSTALL_DIR "$ENV{HOME}/Library/csound/${APIVERSION}/plugins64") @@ -232,7 +243,11 @@ endfunction(check_deps) # NB - this was moved here as it needs some VARS defined above # for setting up the framework function(make_plugin libname srcs) - if(APPLE) + if(WASM) + # CMake does not model WASI side modules as shared libraries. + add_executable(${libname} ${srcs}) + configure_wasm_plugin(${libname}) + elseif(APPLE) add_library(${libname} SHARED ${srcs}) else() add_library(${libname} MODULE ${srcs}) @@ -245,6 +260,7 @@ function(make_plugin libname srcs) endwhile() install(TARGETS ${libname} + RUNTIME DESTINATION "${PLUGIN_INSTALL_DIR}" LIBRARY DESTINATION "${PLUGIN_INSTALL_DIR}" ARCHIVE DESTINATION "${PLUGIN_INSTALL_DIR}" ) endfunction(make_plugin) diff --git a/7.x/cmake/Modules/FindCSOUND.cmake b/7.x/cmake/Modules/FindCSOUND.cmake index 66232fe..a0dec67 100644 --- a/7.x/cmake/Modules/FindCSOUND.cmake +++ b/7.x/cmake/Modules/FindCSOUND.cmake @@ -82,8 +82,14 @@ include(FindPackageHandleStandardArgs) # handle the QUIETLY and REQUIRED arguments and set CSOUND_FOUND to TRUE # if all listed variables are TRUE and the version satisfies the request +if(WASM) + # Side modules call the browser engine through its API table. + set(_csound_required_vars CSOUND_INCLUDE_DIR) +else() + set(_csound_required_vars CSOUND_LIBRARY CSOUND_INCLUDE_DIR) +endif() find_package_handle_standard_args(CSOUND - REQUIRED_VARS CSOUND_LIBRARY CSOUND_INCLUDE_DIR + REQUIRED_VARS ${_csound_required_vars} VERSION_VAR CSOUND_VERSION ) diff --git a/7.x/cmake/WasmPlugins.cmake b/7.x/cmake/WasmPlugins.cmake new file mode 100644 index 0000000..280f685 --- /dev/null +++ b/7.x/cmake/WasmPlugins.cmake @@ -0,0 +1,37 @@ +# Match platform/wasm-wasi/src/plugin_example*.nix in csound/csound. +set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) +set(USE_COMPILER_OPTIMIZATIONS OFF CACHE BOOL "" FORCE) +set(REQUIRE_PTHREADS OFF CACHE BOOL "" FORCE) +set(USE_DOUBLE ON CACHE BOOL "" FORCE) +execute_process(COMMAND ${CMAKE_C_COMPILER} --print-libgcc-file-name + OUTPUT_VARIABLE WASM_BUILTINS OUTPUT_STRIP_TRAILING_WHITESPACE + COMMAND_ERROR_IS_FATAL ANY) + +function(configure_wasm_plugin target) + set_target_properties(${target} PROPERTIES SUFFIX ".wasm") + target_compile_features(${target} PRIVATE c_std_11) + target_compile_definitions(${target} PRIVATE + USE_DOUBLE=1 _WASI_EMULATED_SIGNAL _WASI_EMULATED_MMAN) + target_compile_options(${target} PRIVATE + -fPIC "SHELL:-mllvm -wasm-enable-sjlj" + "$<$:-std=gnu11>" + "$<$:-fno-exceptions;-nostdinc++>" + "$<$:-isystem${WASM_CXX_INCLUDE_DIR}>") + target_link_options(${target} PRIVATE + -shared -nostdlib -nostartfiles + "LINKER:-Bsymbolic" + "LINKER:--experimental-pic" + "LINKER:--no-entry" + "LINKER:--import-table" + "LINKER:--import-memory" + "LINKER:--allow-undefined" + "LINKER:--export=__wasm_call_ctors" + "LINKER:--export-if-defined=__wasm_apply_data_relocs" + "LINKER:--export-if-defined=csound_opcode_init" + "LINKER:--export-if-defined=csoundModuleInfo" + "LINKER:--export-if-defined=csoundModuleInit" + "LINKER:--export-if-defined=csoundModuleCreate" + "LINKER:--export-if-defined=csoundModuleDestroy") + target_link_libraries(${target} PRIVATE + "${WASM_LIBCXX}" "${WASM_LIBC}" "${WASM_SETJMP}" "${WASM_BUILTINS}") +endfunction() diff --git a/README.md b/README.md index 457805f..7be5104 100644 --- a/README.md +++ b/README.md @@ -7,6 +7,9 @@ plugins. The tree is currently organised by major Csound versions. Full and beta releases are available and build artefacts are also accessible from the actions tab. +The Csound 7 WASM package, `@csound/plugins`, uses Nix and CMake. See the +[build, test, and npm release notes](wasm/README.md). + NB: Csound 6.x is EOL. It is likely that plugins for that version will be removed from the develop and main branch after the first full release. In that case, we will keep the code solely in the csound6 branch. diff --git a/THIRD_PARTY.md b/THIRD_PARTY.md new file mode 100644 index 0000000..9b8d546 --- /dev/null +++ b/THIRD_PARTY.md @@ -0,0 +1,20 @@ +# Third-party code in the WASM package + +The plugins use the LGPL-2.1-or-later license in `LICENSE`. Their source and +copyright notices live under [`7.x/src`](https://github.com/csound/plugins/tree/develop/7.x/src). +The package also contains code from these libraries: + +| Library | Used by | License notices | +| --- | --- | --- | +| Eigen | Chua | `dist/licenses/eigen/` | +| GMM++ (GetFEM) | Linear algebra | `dist/licenses/gmm.txt`; LGPL-3.0-or-later with the exception in the headers | +| libpng | Image | `dist/licenses/libpng.txt` | +| zlib | Image | `dist/licenses/zlib.txt` | +| wasi-libc, musl, cloudlibc, musl-fts | C runtime | `dist/licenses/wasi-libc/` | +| LLVM libc++, libc++abi, compiler-rt | C++ runtime and compiler support | `dist/licenses/libcxx.txt`, `libcxxabi.txt`, `compiler-rt.txt` | + +The Nix build copies these notices from the source used to build each library. +[`wasm/nixpkgs.nix`](https://github.com/csound/plugins/blob/develop/wasm/nixpkgs.nix) +pins their source versions. The GMM++ headers live in this repository. The build +uses upstream CMake and make options for static PIC libraries; it adds no source +patches. `wasm/default.nix` records those options. diff --git a/index.d.ts b/index.d.ts new file mode 100644 index 0000000..92dc222 --- /dev/null +++ b/index.d.ts @@ -0,0 +1,6 @@ +/** Asset URLs for Csound 7's `withPlugins` option. */ +export declare const plugins: Readonly<{ + chua: string; + image: string; + linearAlgebra: string; +}>; diff --git a/index.js b/index.js new file mode 100644 index 0000000..312756a --- /dev/null +++ b/index.js @@ -0,0 +1,6 @@ +/** Asset URLs for Csound 7's `withPlugins` option. */ +export const plugins = Object.freeze({ + chua: new URL("./dist/chua.wasm", import.meta.url).href, + image: new URL("./dist/image.wasm", import.meta.url).href, + linearAlgebra: new URL("./dist/linear_algebra.wasm", import.meta.url).href, +}); diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..168efd8 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,569 @@ +{ + "name": "@csound/plugins", + "version": "7.0.0-beta.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@csound/plugins", + "version": "7.0.0-beta.0", + "license": "LGPL-2.1-or-later", + "devDependencies": { + "@csound/browser": "7.0.0-beta38", + "@csound/wasm-bin": "7.0.0-beta28" + }, + "engines": { + "node": ">=22.13.0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.29.10", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.10.tgz", + "integrity": "sha512-NpugTzbKgGrNe45Ui32cN8vCFFMxVtP/9rtfwv0nP5FRDAjvYBxJcLVpYA9mr1jxP6cnIT7x9LUzuDTbWYYNRA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@csound/browser": { + "version": "7.0.0-beta38", + "resolved": "https://registry.npmjs.org/@csound/browser/-/browser-7.0.0-beta38.tgz", + "integrity": "sha512-Q64BnO6VMjpPNJgP9VZzfTVKB3VAuN/zfIfqyUSFCjsY2SPw3KUqfpU+e1NxWt8VZEkNvSF23OjqCzR40kqgUg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "eventemitter3": "^5.0.4", + "google-closure-compiler": "20260923.0.0", + "google-closure-library": "^20230802.0.0", + "pako": "^3.0.2", + "ramda": "^0.32.0", + "rimraf": "^6.1.3", + "standardized-audio-context": "^25.3.77", + "text-encoding-shim": "^1.0.5", + "unmute-ios-audio": "^3.3.0", + "web-midi-api": "^2.4.0" + }, + "engines": { + "node": ">=22.13.0" + } + }, + "node_modules/@csound/wasm-bin": { + "version": "7.0.0-beta28", + "resolved": "https://registry.npmjs.org/@csound/wasm-bin/-/wasm-bin-7.0.0-beta28.tgz", + "integrity": "sha512-HjXP+1XbjiYYRRZGc3EnuBSjP6zFjhFqnR0rk8XK9XOyI/rk+35eqPk49r3PwRgyISlB+pnmHiRKMsP8In4K8w==", + "dev": true, + "license": "LGPL-2.1" + }, + "node_modules/automation-events": { + "version": "7.1.19", + "resolved": "https://registry.npmjs.org/automation-events/-/automation-events-7.1.19.tgz", + "integrity": "sha512-cD+TLhJTI0q4AI3ktd353lrGZiVa9AchowSDzQzzGjSoYe22js4vlS32VUtWuaulghi1Yq0KYNWKk9wWuGymPA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.29.2", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=18.2.0" + } + }, + "node_modules/b4a": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.9.0.tgz", + "integrity": "sha512-dpfcF9fDNR6++cthXR67iyhgqWy9CBouAvIWhIntzBG6cvK/cnIPiZQjBwi/ZqjjBEDGfoNDtmB0kTjroOJ3pQ==", + "dev": true, + "license": "Apache-2.0", + "peerDependencies": { + "react-native-b4a": "*" + }, + "peerDependenciesMeta": { + "react-native-b4a": { + "optional": true + } + } + }, + "node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/bare-events": { + "version": "2.9.2", + "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.9.2.tgz", + "integrity": "sha512-AIPKioV7/Y/8KfZ3AAhjPJxLLbY49S64Ym5DakZlUg75qQiTgUq9hEJoEwa4eUezPUlXRy/i5NpsKvo9jgKmoA==", + "dev": true, + "license": "Apache-2.0", + "peerDependencies": { + "bare-abort-controller": "*" + }, + "peerDependenciesMeta": { + "bare-abort-controller": { + "optional": true + } + } + }, + "node_modules/brace-expansion": { + "version": "5.0.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz", + "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/chalk": { + "version": "5.6.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", + "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/clone": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz", + "integrity": "sha512-3Pe/CF1Nn94hyhIYpjtiLhdCoEoz0DqQ+988E9gmeEdQZlojxnOb74wctFyuwWQHzqyf9X7C7MG8juUpqBJT8w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/eventemitter3": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz", + "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/events-universal": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz", + "integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "bare-events": "^2.7.0" + } + }, + "node_modules/fast-fifo": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz", + "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/google-closure-compiler": { + "version": "20260923.0.0", + "resolved": "https://registry.npmjs.org/google-closure-compiler/-/google-closure-compiler-20260923.0.0.tgz", + "integrity": "sha512-45HDxy12r6D6E4nLqB/ae7qzX37x+qHYjIMX7ozYJcAeJoWx8EKxNHTP//1I+Phu62ZPW2CgLe5nq0R6xGHsDA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "chalk": "^2.0.0 || ^3.0.0 || ^4.0.0 || ^5.0.0 <5.6.1 || ^5.6.2 >5.6.1", + "google-closure-compiler-java": "^20260923.0.0", + "minimist": "^1.0.0", + "vinyl": "^3.0.1", + "vinyl-sourcemaps-apply": "^0.2.0" + }, + "bin": { + "google-closure-compiler": "cli.js" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "google-closure-compiler-linux": "^20260923.0.0", + "google-closure-compiler-linux-arm64": "^20260923.0.0", + "google-closure-compiler-macos": "^20260923.0.0", + "google-closure-compiler-windows": "^20260923.0.0" + } + }, + "node_modules/google-closure-compiler-java": { + "version": "20260923.0.0", + "resolved": "https://registry.npmjs.org/google-closure-compiler-java/-/google-closure-compiler-java-20260923.0.0.tgz", + "integrity": "sha512-ySzXGXao466rqU1Bpkl/DrE7D8fo/dxkHsN1EnZ5mzr5uEM533FP16+yM6jZfAbjOcWEc48y1LzY2yFhMBsn4w==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/google-closure-compiler-linux": { + "version": "20260923.0.0", + "resolved": "https://registry.npmjs.org/google-closure-compiler-linux/-/google-closure-compiler-linux-20260923.0.0.tgz", + "integrity": "sha512-dO0M/kFl1U2/IPphilHmA/tUshrJ9p9TBYbqXbeaFYs0/yo/515f3qoRelGwc/EC5LB9+X1aHwiiwd+9DK1+9g==", + "cpu": [ + "x32", + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/google-closure-compiler-linux-arm64": { + "version": "20260923.0.0", + "resolved": "https://registry.npmjs.org/google-closure-compiler-linux-arm64/-/google-closure-compiler-linux-arm64-20260923.0.0.tgz", + "integrity": "sha512-BeuzHqu9s408xTkIuYymC+dTSOMiQvmQVGhxXkrM0SAy/aE4/Vjn6M3jRfDu4kNdzoPj3f7lbiegS20pZq/wFA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/google-closure-compiler-macos": { + "version": "20260923.0.0", + "resolved": "https://registry.npmjs.org/google-closure-compiler-macos/-/google-closure-compiler-macos-20260923.0.0.tgz", + "integrity": "sha512-MnpLL5puaSU3fJtfe9DytNfPwMXQA73AqsYM0BrVlAfshKaW2I5fb11oizGbKUNcVRW5Pd9x+60rKePdTl57rQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/google-closure-compiler-windows": { + "version": "20260923.0.0", + "resolved": "https://registry.npmjs.org/google-closure-compiler-windows/-/google-closure-compiler-windows-20260923.0.0.tgz", + "integrity": "sha512-+yMoYGT0mre78YZe1RoQc4DLj7SSC423quXdslHogKXT6aXjLeP7+yPhpbBPo4ayikrGuNA3WVsoeCa/OjuAXA==", + "cpu": [ + "x32", + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/google-closure-library": { + "version": "20230802.0.0", + "resolved": "https://registry.npmjs.org/google-closure-library/-/google-closure-library-20230802.0.0.tgz", + "integrity": "sha512-h2lBEX2tjWwfR+dhFukGER15vKY+4cA3nRqwKSOsBdyizlOxTAHOWbEYiGnMoom3/SrVeQ5uG0eKsbxQ3wbsxA==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/jazz-midi": { + "version": "1.7.9", + "resolved": "https://registry.npmjs.org/jazz-midi/-/jazz-midi-1.7.9.tgz", + "integrity": "sha512-c8c4BBgwxdsIr1iVm53nadCrtH7BUlnX3V95ciK/gbvXN/ndE5+POskBalXgqlc/r9p2XUbdLTrgrC6fou5p9w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/jzz": { + "version": "1.9.6", + "resolved": "https://registry.npmjs.org/jzz/-/jzz-1.9.6.tgz", + "integrity": "sha512-J7ENLhXwfm2BNDKRUrL8eKtPhUS/CtMBpiafxQHDBcOWSocLhearDKEdh+ylnZFcr5OXWTed0gj6l/txeQA9vg==", + "dev": true, + "license": "MIT", + "dependencies": { + "jazz-midi": "^1.7.9" + } + }, + "node_modules/lru-cache": { + "version": "11.5.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz", + "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/minimatch": { + "version": "10.2.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz", + "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.8" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "dev": true, + "license": "BlueOak-1.0.0" + }, + "node_modules/pako": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/pako/-/pako-3.0.2.tgz", + "integrity": "sha512-uBv6IT2aT1A78iU6dpNEbf6+CyhlV/6g9JlJs9kpgjFGFhruIICVRysF/W0SLzXg5+hCl+KroH7e4YUyfEmgLg==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/puzrin" + }, + { + "type": "github", + "url": "https://github.com/sponsors/nodeca" + } + ], + "license": "(MIT AND Zlib)" + }, + "node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/ramda": { + "version": "0.32.0", + "resolved": "https://registry.npmjs.org/ramda/-/ramda-0.32.0.tgz", + "integrity": "sha512-GQWAHhxhxWBWA8oIBr1XahFVjQ9Fic6MK9ikijfd4TZHfE2+urfk+irVlR5VOn48uwMgM+loRRBJd6Yjsbc0zQ==", + "dev": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/ramda" + } + }, + "node_modules/remove-trailing-separator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "integrity": "sha512-/hS+Y0u3aOfIETiaiirUFwDBDzmXPvO+jAfKTitUngIPzdKc6Z0LoFjM/CK5PL4C+eKwHohlHAb6H0VFfmmUsw==", + "dev": true, + "license": "ISC" + }, + "node_modules/replace-ext": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-2.0.0.tgz", + "integrity": "sha512-UszKE5KVK6JvyD92nzMn9cDapSk6w/CaFZ96CnmDMUqH9oowfxF/ZjRITD25H4DnOQClLA4/j7jLGXXLVKxAug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/rimraf": { + "version": "6.1.3", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-6.1.3.tgz", + "integrity": "sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "glob": "^13.0.3", + "package-json-from-dist": "^1.0.1" + }, + "bin": { + "rimraf": "dist/esm/bin.mjs" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/standardized-audio-context": { + "version": "25.3.77", + "resolved": "https://registry.npmjs.org/standardized-audio-context/-/standardized-audio-context-25.3.77.tgz", + "integrity": "sha512-Ki9zNz6pKcC5Pi+QPjPyVsD9GwJIJWgryji0XL9cAJXMGyn+dPOf6Qik1AHei0+UNVcc4BOCa0hWLBzlwqsW/A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.25.6", + "automation-events": "^7.0.9", + "tslib": "^2.7.0" + } + }, + "node_modules/streamx": { + "version": "2.28.1", + "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.28.1.tgz", + "integrity": "sha512-zEzXb0s5Cds7tqMH6rhZ05lcJydCWiQPEwiNngVqzsxCc962vLY4Uw+mW7od8kDH258k2Uz/JrOkdIAAhSh9VA==", + "dev": true, + "license": "MIT", + "dependencies": { + "events-universal": "^1.0.0", + "fast-fifo": "^1.3.2", + "text-decoder": "^1.1.0" + } + }, + "node_modules/teex": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/teex/-/teex-1.0.1.tgz", + "integrity": "sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "streamx": "^2.12.5" + } + }, + "node_modules/text-decoder": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.7.tgz", + "integrity": "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "b4a": "^1.6.4" + } + }, + "node_modules/text-encoding-shim": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/text-encoding-shim/-/text-encoding-shim-1.0.5.tgz", + "integrity": "sha512-H7yYW+jRn4yhu60ygZ2f/eMhXPITRt4QSUTKzLm+eCaDsdX8avmgWpmtmHAzesjBVUTAypz9odu5RKUjX5HNYA==", + "dev": true, + "license": "MIT" + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, + "license": "0BSD" + }, + "node_modules/unmute-ios-audio": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/unmute-ios-audio/-/unmute-ios-audio-3.3.0.tgz", + "integrity": "sha512-MmoCOrsS2gn3wLT2tT+hF56Q4V4kksIKn2LHrwAtX6umzQwQHDWSh1slMzH+0WuxTZ62s3w8/wsfIII1FQ7ACg==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/vinyl": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-3.0.1.tgz", + "integrity": "sha512-0QwqXteBNXgnLCdWdvPQBX6FXRHtIH3VhJPTd5Lwn28tJXc34YqSCWUmkOvtJHBmB3gGoPtrOKk3Ts8/kEZ9aA==", + "dev": true, + "license": "MIT", + "dependencies": { + "clone": "^2.1.2", + "remove-trailing-separator": "^1.1.0", + "replace-ext": "^2.0.0", + "teex": "^1.0.1" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/vinyl-sourcemaps-apply": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz", + "integrity": "sha512-+oDh3KYZBoZC8hfocrbrxbLUeaYtQK7J5WU5Br9VqWqmCll3tFJqKp97GC9GmMsVIL0qnx2DgEDVxdo5EZ5sSw==", + "dev": true, + "license": "ISC", + "dependencies": { + "source-map": "^0.5.1" + } + }, + "node_modules/web-midi-api": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/web-midi-api/-/web-midi-api-2.4.0.tgz", + "integrity": "sha512-tTfLdxa5LpOP1NgWByV458iYKgSLhlsIwqCpfbcJuyjProNtuf5UnX97K4JNyuQCqkR+6thQAIsk2BOMSrKaCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "jzz": "^1.9.5" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..4717023 --- /dev/null +++ b/package.json @@ -0,0 +1,39 @@ +{ + "name": "@csound/plugins", + "version": "7.0.0-beta.0", + "private": true, + "description": "Csound 7 opcode plugins for WebAssembly", + "type": "module", + "license": "LGPL-2.1-or-later", + "repository": { + "type": "git", + "url": "git+https://github.com/csound/plugins.git" + }, + "bugs": { + "url": "https://github.com/csound/plugins/issues" + }, + "homepage": "https://github.com/csound/plugins", + "publishConfig": { + "access": "public" + }, + "engines": { + "node": ">=22.13.0" + }, + "files": ["dist", "index.js", "index.d.ts", "LICENSE", "THIRD_PARTY.md", "wasm/README.md"], + "exports": { + ".": { "types": "./index.d.ts", "import": "./index.js" }, + "./dist/*": "./dist/*", + "./package.json": "./package.json" + }, + "scripts": { + "build": "bash wasm/scripts/build.sh", + "build:runtime": "bash wasm/scripts/build-runtime.sh", + "test": "node --test wasm/tests/*.test.js", + "prepack": "npm test" + }, + "devDependencies": { + "@csound/browser": "7.0.0-beta38", + "@csound/wasm-bin": "7.0.0-beta28" + }, + "keywords": ["csound", "audio", "plugins", "wasm", "wasi", "webassembly"] +} diff --git a/wasm/README.md b/wasm/README.md new file mode 100644 index 0000000..af4a19d --- /dev/null +++ b/wasm/README.md @@ -0,0 +1,72 @@ +# @csound/plugins + +WASM opcode plugins for the double-precision Csound 7 browser engine. + +This first package includes Chua (`chuap`), image, and linear algebra. This build +disables STK, FluidSynth, HDF5, Python, WebSockets, device, and GPU plugins. +Csound 6 is not supported. + +## Runtime dependency + +This draft depends on [csound/csound#3416](https://github.com/csound/csound/pull/3416). +`@csound/browser@7.0.0-beta38` cannot load these plugins. CI builds the upstream +commit in that PR and tests against it. The package stays private until a browser +release includes those changes. + +## Use + +With a compatible browser build: + +```js +import { Csound } from "@csound/browser"; +import { plugins } from "@csound/plugins"; + +const csound = await Csound({ withPlugins: [plugins.chua, plugins.image] }); +``` + +The exports are asset URL strings. Bundlers must copy the WASM files referenced +by `new URL(..., import.meta.url)`. You can also serve files from +`@csound/plugins/dist/` yourself and pass their URLs to `withPlugins`. + +## Build and test + +Install Nix and Node.js 22.13 or newer, then run: + +```sh +npm ci +npm run build +``` + +Nix pins the toolchain and builds the existing `7.x` CMake targets with Ninja. +Dependencies use static PIC builds. The C runtime imports the engine's allocator; +it does not link its own heap. C++ plugins use libc++ without C++ exceptions. +The SDK comes from the locked `@csound/wasm-bin` +package. To use another Csound 7 SDK, set `CSOUND_PLUGIN_SDK` to an absolute archive +path. Set `NIX_SYSTEM=x86_64-linux` when using a Linux remote builder from macOS. + +Until the upstream browser changes ship, check out their commit and build it +with the helper. It also supplies Java through Nix for the browser compiler: + +```sh +git clone https://github.com/csound/csound.git .csound +git -C .csound checkout dfe33946847fd2fe5fe04948d9ae44ba320c5390 +npm run build:runtime +export CSOUND_BROWSER_URL="file://$PWD/.csound/platform/wasm-wasi/browser/dist/csound.js" +npm test +npm pack +``` + +You can pass an existing Csound checkout to `npm run build:runtime -- /path/to/csound`. +`CSOUND_BROWSER_URL` also accepts the absolute file URL of a built browser bundle. +Without it, tests use the locked npm browser package. Tests load all plugins +together, render Chua, compute a vector norm, and save and reload a PNG through +the WASI filesystem. Packing runs the tests and includes the WASM files and their +license notices. + +## First npm release + +After the upstream fix ships, update the browser and WASM SDK pins and lockfile, +remove the temporary runtime checkout/build from CI, and run the checks against +the published browser package. Remove `private` from `package.json`, set the +package version, and run `npm publish --tag beta --access public` from a clean +build. No workflow publishes this package yet. diff --git a/wasm/default.nix b/wasm/default.nix new file mode 100644 index 0000000..229265c --- /dev/null +++ b/wasm/default.nix @@ -0,0 +1,107 @@ +{ system ? builtins.currentSystem +, pkgs ? import (import ./nixpkgs.nix) { inherit system; } +, csoundSdkArchive ? null +}: +let + wasi = pkgs.pkgsCross.wasi32.clangStdenv; + libc = pkgs.pkgsCross.wasi32.wasilibc.overrideAttrs (old: { + NIX_CFLAGS_COMPILE = (old.NIX_CFLAGS_COMPILE or []) ++ [ "-fPIC" ]; + # Use the engine's allocator. wasi-libc also skips its fixed symbol list + # for this mode; PIC adds imports absent from that non-PIC list. + makeFlags = (old.makeFlags or []) ++ [ "MALLOC_IMPL=none" ]; + preFixup = ""; + dontStrip = true; + }); + libcxx = pkgs.pkgsCross.wasi32.llvmPackages.libcxx.overrideAttrs (old: { + cmakeFlags = old.cmakeFlags ++ [ + "-DCMAKE_POSITION_INDEPENDENT_CODE=ON" + "-DLIBCXX_ENABLE_FILESYSTEM=ON" + ]; + dontStrip = true; + }); + lock = builtins.fromJSON (builtins.readFile ../package-lock.json); + wasmBin = lock.packages."node_modules/@csound/wasm-bin"; + sdkArchive = if csoundSdkArchive == null then null else builtins.path { + path = csoundSdkArchive; + name = "csound-plugin-sdk.tar.gz"; + }; + sdk = pkgs.runCommand "csound-wasm-plugin-sdk-${wasmBin.version}" {} '' + mkdir -p $out + ${if csoundSdkArchive == null then '' + tar -xzf ${pkgs.fetchurl { url = wasmBin.resolved; hash = wasmBin.integrity; }} + tar -xzf package/lib/csound-plugin-sdk.tar.gz --strip-components=1 -C $out + '' else '' + tar -xzf ${sdkArchive} --strip-components=1 -C $out + ''} + ''; + zlib = wasi.mkDerivation { + pname = "zlib-wasm-pic"; + inherit (pkgs.zlib) version src; + nativeBuildInputs = [ pkgs.cmake pkgs.ninja ]; + cmakeFlags = [ "-DCMAKE_POSITION_INDEPENDENT_CODE=ON" "-DCMAKE_INSTALL_LIBDIR=lib" "-DZLIB_BUILD_EXAMPLES=OFF" ]; + dontStrip = true; + }; + libpng = wasi.mkDerivation { + pname = "libpng-wasm-pic"; + inherit (pkgs.libpng) version src; + nativeBuildInputs = [ pkgs.cmake pkgs.ninja ]; + buildInputs = [ zlib ]; + cmakeFlags = [ + "-DUNIX=ON" + "-DCMAKE_POSITION_INDEPENDENT_CODE=ON" + "-DCMAKE_INSTALL_LIBDIR=lib" + "-DPNG_SHARED=OFF" "-DPNG_STATIC=ON" "-DPNG_TESTS=OFF" "-DPNG_TOOLS=OFF" + "-DZLIB_LIBRARY=${zlib}/lib/libzlibstatic.a" + ]; + NIX_CFLAGS_COMPILE = [ "-mllvm" "-wasm-enable-sjlj" ]; + dontStrip = true; + }; +in wasi.mkDerivation { + pname = "csound-plugins-wasm"; + version = (builtins.fromJSON (builtins.readFile ../package.json)).version; + src = pkgs.lib.cleanSource ../7.x; + nativeBuildInputs = [ pkgs.cmake pkgs.ninja ]; + buildInputs = [ libpng zlib ]; + dontStrip = true; + cmakeFlags = [ + "-DCMAKE_POLICY_VERSION_MINIMUM=3.5" + "-DCMAKE_BUILD_TYPE=Release" + "-DCSOUND_INCLUDE_DIR=${sdk}/include/csound" + "-DWASM_LIBC=${libc}/lib/libc.a" + "-DWASM_SETJMP=${libc}/lib/libsetjmp.a" + "-DWASM_LIBCXX=${libcxx}/lib/libc++.a" + "-DWASM_CXX_INCLUDE_DIR=${libcxx.dev}/include/c++/v1" + "-DEIGEN3_INCLUDE_DIR=${pkgs.eigen}/include/eigen3" + "-DZLIB_LIBRARY=${zlib}/lib/libzlibstatic.a" + "-DPNG_LIBRARY=${libpng}/lib/libpng.a" + "-DBUILD_CHUA_OPCODES=ON" + "-DBUILD_IMAGE_OPCODES=ON" + "-DBUILD_LINEAR_ALGEBRA_OPCODES=ON" + "-DBUILD_STK_OPCODES=OFF" + "-DBUILD_FLUID_OPCODES=OFF" + "-DBUILD_HDF5_OPCODES=OFF" + "-DBUILD_WEBSOCKET_OPCODE=OFF" + "-DBUILD_PYTHON_OPCODES=OFF" + "-DBUILD_WIIMOTE_OPCODES=OFF" + "-DBUILD_P5GLOVE_OPCODES=OFF" + "-DBUILD_CUDA_OPCODES=OFF" + "-DBUILD_OPENCL_OPCODES=OFF" + ]; + postInstall = '' + mkdir -p $out/share/licenses/wasi-libc $out/share/licenses/eigen + cp ${libc.src}/LICENSE* $out/share/licenses/wasi-libc/ + cp ${libc.src}/libc-top-half/musl/COPYRIGHT $out/share/licenses/wasi-libc/musl.txt + cp ${libc.src}/libc-bottom-half/cloudlibc/LICENSE $out/share/licenses/wasi-libc/cloudlibc.txt + cp ${libc.src}/fts/musl-fts/COPYING $out/share/licenses/wasi-libc/musl-fts.txt + cp ${libcxx.src}/libcxx/LICENSE.TXT $out/share/licenses/libcxx.txt + cp ${libcxx.src}/libcxxabi/LICENSE.TXT $out/share/licenses/libcxxabi.txt + cp ${pkgs.pkgsCross.wasi32.llvmPackages.compiler-rt.src}/compiler-rt/LICENSE.TXT $out/share/licenses/compiler-rt.txt + cp ${pkgs.eigen.src}/COPYING* $out/share/licenses/eigen/ + sed -n '1,/^=*[*][/]$/p' ${../7.x/src/linear_algebra/gmm/gmm.h} > $out/share/licenses/gmm.txt + tar -xOf ${pkgs.libpng.src} libpng-${pkgs.libpng.version}/LICENSE > $out/share/licenses/libpng.txt + tar -xOf ${pkgs.zlib.src} zlib-${pkgs.zlib.version}/LICENSE > $out/share/licenses/zlib.txt + for plugin in chua image linear_algebra; do + test -s "$out/lib/$plugin.wasm" + done + ''; +} diff --git a/wasm/nixpkgs.nix b/wasm/nixpkgs.nix new file mode 100644 index 0000000..89b6f90 --- /dev/null +++ b/wasm/nixpkgs.nix @@ -0,0 +1,5 @@ +# Keep in sync with csound/csound's platform/wasm-wasi/scripts/nixpkgs-pin.sh. +builtins.fetchTarball { + url = "https://github.com/NixOS/nixpkgs/archive/4db2c220f32fd162658ed1b7bb2f46a82996ddbe.tar.gz"; + sha256 = "08b1k0zrbal2if94bph2ap9f73zlplsh05a65jbdkp5ipycmg92s"; +} diff --git a/wasm/scripts/build-runtime.sh b/wasm/scripts/build-runtime.sh new file mode 100644 index 0000000..f720307 --- /dev/null +++ b/wasm/scripts/build-runtime.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +set -euo pipefail +cd "$(dirname "$0")/../.." + +# Temporary until the runtime changes ship in @csound/browser and @csound/wasm-bin. +csound_source=$(cd "${1:-.csound}" && pwd) +args=(-o result-browser --argstr moduleKind browser) +if [[ -n "${NIX_SYSTEM:-}" ]]; then + args+=(--argstr system "$NIX_SYSTEM") +fi +nixpkgs=$(nix-instantiate --eval --strict --json wasm/nixpkgs.nix | node -e \ + 'let input=""; process.stdin.on("data", c => input += c); process.stdin.on("end", () => console.log(JSON.parse(input)));') +nix-build "$csound_source/platform/wasm-wasi/src/csound.nix" -I "nixpkgs=$nixpkgs" "${args[@]}" + +browser_dir="$csound_source/platform/wasm-wasi/browser" +npm ci --prefix "$browser_dir" +for file in csound.wasm csound.wasm.z; do + install -m 644 "result-browser/lib/$file" "$browser_dir/node_modules/@csound/wasm-bin/lib/$file" +done +export CSOUND_BROWSER_BUILD_DIR="$browser_dir" +# Expand the exported path in the shell that Nix starts. +# shellcheck disable=SC2016 +nix-shell -I "nixpkgs=$nixpkgs" -p jdk21 --run \ + 'npm run build:prod --prefix "$CSOUND_BROWSER_BUILD_DIR"' diff --git a/wasm/scripts/build.sh b/wasm/scripts/build.sh new file mode 100644 index 0000000..22c5070 --- /dev/null +++ b/wasm/scripts/build.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +set -euo pipefail +cd "$(dirname "$0")/../.." + +args=(--show-trace -o result-wasm) +if [[ -n "${NIX_SYSTEM:-}" ]]; then + args+=(--argstr system "$NIX_SYSTEM") +fi +if [[ -n "${CSOUND_PLUGIN_SDK:-}" ]]; then + args+=(--argstr csoundSdkArchive "$CSOUND_PLUGIN_SDK") +fi +nix-build wasm/default.nix "${args[@]}" +staging=$(mktemp -d .wasm-dist.XXXXXX) +trap 'rm -rf "$staging"' EXIT +for plugin in chua image linear_algebra; do + install -m 644 "result-wasm/lib/$plugin.wasm" "$staging/$plugin.wasm" +done +cp -R result-wasm/share/licenses "$staging/licenses" +chmod -R u+w "$staging/licenses" +if [[ -d dist ]]; then + chmod -R u+w dist +fi +rm -rf dist +mv "$staging" dist diff --git a/wasm/tests/runtime.test.js b/wasm/tests/runtime.test.js new file mode 100644 index 0000000..7c990ac --- /dev/null +++ b/wasm/tests/runtime.test.js @@ -0,0 +1,117 @@ +import assert from "node:assert/strict"; +import { readFile } from "node:fs/promises"; +import test from "node:test"; +import { plugins } from "../../index.js"; + +// The in-process browser API needs these names, but no audio device or DOM. +globalThis.self = globalThis; +globalThis.window = globalThis; +const { libcsound } = await import(process.env.CSOUND_BROWSER_URL || "@csound/browser/dist/csound.js"); + +const binaries = await Promise.all(Object.values(plugins).map((url) => readFile(new URL(url)))); + +const document = (body) => ` + +-n -d -m0 + + +sr = 48000 +ksmps = 32 +nchnls = 1 +0dbfs = 1 +instr 1 +${body} +endin + + +i 1 0 0.02 +e + +`; + +async function run(body, check, withPlugins = binaries) { + const errors = []; + const originalError = console.error; + console.error = (...args) => errors.push(args.join(" ")); + let api; + try { + api = await libcsound({ withPlugins }); + } finally { + console.error = originalError; + } + assert.deepEqual(errors, [], "every plugin must load without missing imports"); + assert.ok(api.csoundGetVersion() >= 7000 && api.csoundGetVersion() < 8000); + assert.equal(api.csoundGetSizeOfMYFLT(), 8); + const csound = api.csoundCreate(); + try { + assert.equal(api.csoundCompileCSD(csound, document(body)), 0); + assert.equal(api.csoundStart(csound), 0); + let peak = 0; + let blocks = 0; + while (api.csoundPerformKsmps(csound) === 0) { + const samples = new Float64Array(api.getMemory().buffer, api.csoundGetSpout(csound), 32); + for (const sample of samples) { + assert.ok(Number.isFinite(sample), "audio samples must be finite"); + peak = Math.max(peak, Math.abs(sample)); + } + assert.ok(++blocks < 100, "score must finish"); + } + assert.ok(blocks > 0); + await check(api, csound, peak); + } finally { + api.csoundDestroy(csound); + } +} + +test("all plugins are WASI side modules", async () => { + for (const bytes of binaries) { + const module = await WebAssembly.compile(bytes); + const imports = WebAssembly.Module.imports(module); + const exports = WebAssembly.Module.exports(module); + assert.ok(WebAssembly.Module.customSections(module, "dylink.0").length > 0); + assert.ok(imports.some(({ kind, name }) => kind === "memory" && name === "memory")); + assert.ok(imports.some(({ kind }) => kind === "table")); + assert.ok(exports.some(({ name }) => name === "__wasm_call_ctors")); + assert.ok(exports.some(({ name }) => ["csoundModuleInit", "csound_opcode_init"].includes(name))); + assert.ok(!exports.some(({ name }) => name === "_start")); + } +}); + +test("chua produces finite, nonzero audio alongside the other plugins", async () => { + await run(` + a1, a2, a3 chuap 0.018, 0, 1e-7, 1/1500, -0.0008, -0.0005, 1, 1e-8, 0, 0, 0.1, 1e-5 + out a3 * 0.1 + `, (_, __, peak) => assert.ok(peak > 0)); +}); + +test("linear algebra computes a vector norm", async () => { + await run(` + iv la_i_vr_create 2 + iv la_i_vr_set 0, 3 + iv la_i_vr_set 1, 4 + inorm la_i_norm_euclid_vr iv + chnset inorm, "norm" + `, (api, csound) => assert.equal(api.csoundGetControlChannel(csound, "norm"), 5)); +}); + +test("image writes and reads a PNG through the WASI filesystem", async () => { + await run(` + ih imagecreate 2, 3 + imagesetpixel ih, 0, 0, 1, 0, 0 + imagesave ih, "roundtrip.png" + iload imageload "roundtrip.png" + iw, ihgt imagesize iload + kred, kgreen, kblue imagegetpixel iload, 0, 0 + chnset iw, "width" + chnset ihgt, "height" + chnset kred, "red" + chnset kgreen, "green" + `, async (api, csound) => { + assert.equal(api.csoundGetControlChannel(csound, "width"), 2); + assert.equal(api.csoundGetControlChannel(csound, "height"), 3); + assert.equal(api.csoundGetControlChannel(csound, "red"), 1); + assert.equal(api.csoundGetControlChannel(csound, "green"), 0); + const bytes = await api.readFile(csound, "roundtrip.png"); + assert.deepEqual([...bytes.slice(0, 8)], [137, 80, 78, 71, 13, 10, 26, 10]); + }); +}); From 0ace7f0c2d063a07c296eab9437d4ad1d5be14a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Tue, 13 Oct 2026 22:22:43 +0300 Subject: [PATCH 51/72] chore(wasm): use reviewed plugin runtime --- .github/workflows/plugins_wasm.yml | 2 +- wasm/README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/plugins_wasm.yml b/.github/workflows/plugins_wasm.yml index c9b7f3f..7c9b9ce 100644 --- a/.github/workflows/plugins_wasm.yml +++ b/.github/workflows/plugins_wasm.yml @@ -24,7 +24,7 @@ jobs: - uses: actions/checkout@v7.0.1 with: repository: csound/csound - ref: dfe33946847fd2fe5fe04948d9ae44ba320c5390 + ref: aed14beaa392dfe9c12270abd9cd63e57651be06 path: .csound - uses: actions/setup-node@v6 with: diff --git a/wasm/README.md b/wasm/README.md index af4a19d..02d8077 100644 --- a/wasm/README.md +++ b/wasm/README.md @@ -49,7 +49,7 @@ with the helper. It also supplies Java through Nix for the browser compiler: ```sh git clone https://github.com/csound/csound.git .csound -git -C .csound checkout dfe33946847fd2fe5fe04948d9ae44ba320c5390 +git -C .csound checkout aed14beaa392dfe9c12270abd9cd63e57651be06 npm run build:runtime export CSOUND_BROWSER_URL="file://$PWD/.csound/platform/wasm-wasi/browser/dist/csound.js" npm test From e0b46747f16d7a943d2cec55825c884f618ecd80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Tue, 13 Oct 2026 23:34:21 +0300 Subject: [PATCH 52/72] build(wasm): use released SDK and enable Cachix --- .github/workflows/plugins_build.yml | 4 +- .github/workflows/plugins_build_7.yml | 38 +++++------ .github/workflows/plugins_wasm.yml | 14 ++--- package-lock.json | 8 +-- package.json | 25 ++++++-- wasm/README.md | 91 ++++++++++++++++++--------- wasm/runtime.json | 3 + wasm/scripts/build-runtime.sh | 27 +++++--- wasm/shell.nix | 4 ++ 9 files changed, 137 insertions(+), 77 deletions(-) create mode 100644 wasm/runtime.json create mode 100644 wasm/shell.nix diff --git a/.github/workflows/plugins_build.yml b/.github/workflows/plugins_build.yml index afcbb88..2f81107 100644 --- a/.github/workflows/plugins_build.yml +++ b/.github/workflows/plugins_build.yml @@ -27,7 +27,7 @@ jobs: steps: - name: Checkout Source Code - uses: actions/checkout@v1 + uses: actions/checkout@v7.0.1 with: fetch-depth: 1 submodules: true @@ -86,7 +86,7 @@ jobs: run: iscc /o. .\installer\win64\Installer.iss - name: Upload installer - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7.0.2 with: name: Csound_win_x64-${{env.CSOUND_VERSION}}.${{github.run_number}}-plugins-installer path: ./csound6-plugins-win_x86_64-*.exe diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 4d2ca45..a0ec586 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -33,7 +33,7 @@ jobs: release: ${{ steps.check_pr.outputs.has_label }} steps: - name: Checkout source - uses: actions/checkout@v4 + uses: actions/checkout@v7.0.1 with: fetch-depth: 0 @@ -61,7 +61,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout source - uses: actions/checkout@v4 + uses: actions/checkout@v7.0.1 - name: Install Csound build dependencies run: | @@ -76,7 +76,7 @@ jobs: - name: Cache Csound install id: cache-csound - uses: actions/cache@v4 + uses: actions/cache@v6.1.0 with: path: ~/csound-install key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} @@ -122,7 +122,7 @@ jobs: cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ - name: Upload plugins - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7.0.2 with: name: csound7-plugins-linux path: package/ @@ -134,7 +134,7 @@ jobs: runs-on: macos-latest steps: - name: Checkout source - uses: actions/checkout@v4 + uses: actions/checkout@v7.0.1 - name: Install Csound build dependencies env: @@ -151,7 +151,7 @@ jobs: run: 7.x/vcpkg/bootstrap-vcpkg.sh -disableMetrics - name: Cache vcpkg binary cache - uses: actions/cache@v4 + uses: actions/cache@v6.1.0 with: path: vcpkg-cache key: vcpkg-macos-${{ github.run_id }} @@ -159,7 +159,7 @@ jobs: - name: Cache Csound install id: cache-csound - uses: actions/cache@v4 + uses: actions/cache@v6.1.0 with: path: ~/csound-install key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} @@ -228,7 +228,7 @@ jobs: cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ - name: Upload plugins - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7.0.2 with: name: csound7-plugins-macos path: package/ @@ -243,7 +243,7 @@ jobs: shell: pwsh steps: - name: Checkout source - uses: actions/checkout@v4 + uses: actions/checkout@v7.0.1 - name: Install Csound build dependencies run: choco install -y winflexbison3 @@ -255,7 +255,7 @@ jobs: - name: Cache Csound install id: cache-csound - uses: actions/cache@v4 + uses: actions/cache@v6.1.0 with: path: ${{ runner.temp }}\csound-install key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} @@ -271,7 +271,7 @@ jobs: run: .\7.x\vcpkg\bootstrap-vcpkg.bat -disableMetrics - name: Cache vcpkg binary cache - uses: actions/cache@v4 + uses: actions/cache@v6.1.0 with: path: ${{ github.workspace }}\vcpkg-cache key: vcpkg-windows-${{ github.run_id }} @@ -330,7 +330,7 @@ jobs: Copy-Item '7.x\src\stk\rawwaves\*.raw' -Destination $rawwaves - name: Upload plugins - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7.0.2 with: name: csound7-plugins-windows path: package/ @@ -344,7 +344,7 @@ jobs: image: nvidia/cuda:12.4.1-devel-ubuntu22.04 steps: - name: Checkout source - uses: actions/checkout@v4 + uses: actions/checkout@v7.0.1 - name: Install build dependencies run: | @@ -360,7 +360,7 @@ jobs: - name: Cache Csound install id: cache-csound - uses: actions/cache@v4 + uses: actions/cache@v6.1.0 with: path: /csound-install key: csound-cuda-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} @@ -403,7 +403,7 @@ jobs: cp build/src/CUDA/*.so package/ - name: Upload plugins - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7.0.2 with: name: csound7-plugins-linux-cuda path: package/ @@ -418,25 +418,25 @@ jobs: contents: write steps: - name: Download Linux plugins - uses: actions/download-artifact@v4 + uses: actions/download-artifact@v8.0.2 with: name: csound7-plugins-linux path: release/linux - name: Download Linux CUDA plugins - uses: actions/download-artifact@v4 + uses: actions/download-artifact@v8.0.2 with: name: csound7-plugins-linux-cuda path: release/linux - name: Download macOS plugins - uses: actions/download-artifact@v4 + uses: actions/download-artifact@v8.0.2 with: name: csound7-plugins-macos path: release/macos - name: Download Windows plugins - uses: actions/download-artifact@v4 + uses: actions/download-artifact@v8.0.2 with: name: csound7-plugins-windows path: release/windows diff --git a/.github/workflows/plugins_wasm.yml b/.github/workflows/plugins_wasm.yml index 7c9b9ce..9206e43 100644 --- a/.github/workflows/plugins_wasm.yml +++ b/.github/workflows/plugins_wasm.yml @@ -20,13 +20,7 @@ jobs: timeout-minutes: 60 steps: - uses: actions/checkout@v7.0.1 - # csound/csound#3416 must land and ship before this package can publish. - - uses: actions/checkout@v7.0.1 - with: - repository: csound/csound - ref: aed14beaa392dfe9c12270abd9cd63e57651be06 - path: .csound - - uses: actions/setup-node@v6 + - uses: actions/setup-node@v7.1.0 with: node-version: 22 cache: npm @@ -34,17 +28,19 @@ jobs: - uses: cachix/cachix-action@v17 with: name: csound + authToken: ${{ secrets.CACHIX_AUTH_TOKEN }} + skipPush: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository }} - name: Install JS dependencies run: npm ci - name: Build WASM plugins with CMake and Nix run: npm run build - - name: Build the required Csound runtime + - name: Build the browser wrapper with the released engine run: | npm run build:runtime echo "CSOUND_BROWSER_URL=file://$GITHUB_WORKSPACE/.csound/platform/wasm-wasi/browser/dist/csound.js" >> "$GITHUB_ENV" - name: Test and pack run: npm pack - - uses: actions/upload-artifact@v7.0.1 + - uses: actions/upload-artifact@v7.0.2 with: name: csound-plugins-npm path: csound-plugins-*.tgz diff --git a/package-lock.json b/package-lock.json index 168efd8..ad26568 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10,7 +10,7 @@ "license": "LGPL-2.1-or-later", "devDependencies": { "@csound/browser": "7.0.0-beta38", - "@csound/wasm-bin": "7.0.0-beta28" + "@csound/wasm-bin": "7.0.0-beta29" }, "engines": { "node": ">=22.13.0" @@ -49,9 +49,9 @@ } }, "node_modules/@csound/wasm-bin": { - "version": "7.0.0-beta28", - "resolved": "https://registry.npmjs.org/@csound/wasm-bin/-/wasm-bin-7.0.0-beta28.tgz", - "integrity": "sha512-HjXP+1XbjiYYRRZGc3EnuBSjP6zFjhFqnR0rk8XK9XOyI/rk+35eqPk49r3PwRgyISlB+pnmHiRKMsP8In4K8w==", + "version": "7.0.0-beta29", + "resolved": "https://registry.npmjs.org/@csound/wasm-bin/-/wasm-bin-7.0.0-beta29.tgz", + "integrity": "sha512-OfrrLaS+h6Br7S9XaJWK9tBxj1JgPRxEySYx2XyZjgAnt+UIn9Dm8H2qBSJUJgBWIT2KBmFCyw4fcdcwtGGyOg==", "dev": true, "license": "LGPL-2.1" }, diff --git a/package.json b/package.json index 4717023..356b59b 100644 --- a/package.json +++ b/package.json @@ -19,9 +19,19 @@ "engines": { "node": ">=22.13.0" }, - "files": ["dist", "index.js", "index.d.ts", "LICENSE", "THIRD_PARTY.md", "wasm/README.md"], + "files": [ + "dist", + "index.js", + "index.d.ts", + "LICENSE", + "THIRD_PARTY.md", + "wasm/README.md" + ], "exports": { - ".": { "types": "./index.d.ts", "import": "./index.js" }, + ".": { + "types": "./index.d.ts", + "import": "./index.js" + }, "./dist/*": "./dist/*", "./package.json": "./package.json" }, @@ -33,7 +43,14 @@ }, "devDependencies": { "@csound/browser": "7.0.0-beta38", - "@csound/wasm-bin": "7.0.0-beta28" + "@csound/wasm-bin": "7.0.0-beta29" }, - "keywords": ["csound", "audio", "plugins", "wasm", "wasi", "webassembly"] + "keywords": [ + "csound", + "audio", + "plugins", + "wasm", + "wasi", + "webassembly" + ] } diff --git a/wasm/README.md b/wasm/README.md index 02d8077..b765fdc 100644 --- a/wasm/README.md +++ b/wasm/README.md @@ -8,10 +8,14 @@ Csound 6 is not supported. ## Runtime dependency -This draft depends on [csound/csound#3416](https://github.com/csound/csound/pull/3416). -`@csound/browser@7.0.0-beta38` cannot load these plugins. CI builds the upstream -commit in that PR and tests against it. The package stays private until a browser -release includes those changes. +The engine and plugin SDK come from the released `@csound/wasm-bin` version in +[package-lock.json](../package-lock.json). The browser loader changes have +[merged upstream](https://github.com/csound/csound/pull/3416), but still need a +release of `@csound/browser`. + +Until then, `npm run build:runtime` fetches the wrapper source pinned in +[runtime.json](runtime.json) and builds it with the released engine. CI uses the +same helper. The package stays private until the published browser can load it. ## Use @@ -28,45 +32,74 @@ The exports are asset URL strings. Bundlers must copy the WASM files referenced by `new URL(..., import.meta.url)`. You can also serve files from `@csound/plugins/dist/` yourself and pass their URLs to `withPlugins`. +To use `--opcode-lib`, write the plugin to Csound's virtual filesystem before +compiling your CSD. This does not need `withPlugins`: + +```js +const csound = await Csound(); +const response = await fetch(plugins.image); +if (!response.ok) throw new Error(`Plugin download failed: ${response.status}`); +await csound.fs.writeFile("/image.wasm", new Uint8Array(await response.arrayBuffer())); +await csound.setOption("--opcode-lib=/image.wasm"); +await csound.compileCSD(csd); +``` + +You can also put the option in ``. Its path refers to the virtual +filesystem, not a URL. + ## Build and test -Install Nix and Node.js 22.13 or newer, then run: +Install Nix and a Node.js version that meets [package.json](../package.json)'s +`engines` requirement, then run: ```sh npm ci npm run build +npm run build:runtime +export CSOUND_BROWSER_URL="file://$PWD/.csound/platform/wasm-wasi/browser/dist/csound.js" +npm test +npm pack ``` Nix pins the toolchain and builds the existing `7.x` CMake targets with Ninja. Dependencies use static PIC builds. The C runtime imports the engine's allocator; it does not link its own heap. C++ plugins use libc++ without C++ exceptions. -The SDK comes from the locked `@csound/wasm-bin` -package. To use another Csound 7 SDK, set `CSOUND_PLUGIN_SDK` to an absolute archive -path. Set `NIX_SYSTEM=x86_64-linux` when using a Linux remote builder from macOS. +To use another Csound 7 SDK, set `CSOUND_PLUGIN_SDK` to an absolute archive path. +Set `NIX_SYSTEM=x86_64-linux` when using a Linux remote builder from macOS. -Until the upstream browser changes ship, check out their commit and build it -with the helper. It also supplies Java through Nix for the browser compiler: +The runtime helper supplies Java through [shell.nix](shell.nix). It builds only +the JavaScript wrapper; it does not rebuild the engine. For work on the loader, +pass an existing Csound checkout to +`npm run build:runtime -- /path/to/csound` and point `CSOUND_BROWSER_URL` at that +checkout's built `platform/wasm-wasi/browser/dist/csound.js` file. -```sh -git clone https://github.com/csound/csound.git .csound -git -C .csound checkout aed14beaa392dfe9c12270abd9cd63e57651be06 -npm run build:runtime -export CSOUND_BROWSER_URL="file://$PWD/.csound/platform/wasm-wasi/browser/dist/csound.js" -npm test -npm pack -``` +Without `CSOUND_BROWSER_URL`, tests use the locked npm browser package. Tests load +all plugins together, render Chua, compute a vector norm, and save and reload a +PNG through the WASI filesystem. Packing runs the tests and includes the WASM +files and their license notices. + +## Updating dependencies + +Keep version pins in these files, rather than copying them into commands or docs: + +- [package.json](../package.json) and [package-lock.json](../package-lock.json): + update npm dependencies with `npm install --save-dev --save-exact @`. + The Nix build reads the SDK version, URL, and hash from the lockfile. +- [runtime.json](runtime.json): the temporary browser wrapper source revision. + The helper fetches it for both local builds and CI. +- [nixpkgs.nix](nixpkgs.nix): the Nix toolchain revision and hash, shared by the + plugin build and the wrapper build shell. -You can pass an existing Csound checkout to `npm run build:runtime -- /path/to/csound`. -`CSOUND_BROWSER_URL` also accepts the absolute file URL of a built browser bundle. -Without it, tests use the locked npm browser package. Tests load all plugins -together, render Chua, compute a vector norm, and save and reload a PNG through -the WASI filesystem. Packing runs the tests and includes the WASM files and their -license notices. +After an update, run the build, test, and pack commands above. The WASM workflow +uses the `csound` Cachix cache and uploads builds when `CACHIX_AUTH_TOKEN` is +available. Fork PRs read from the cache without the secret. Native builds use +GitHub Actions caches. ## First npm release -After the upstream fix ships, update the browser and WASM SDK pins and lockfile, -remove the temporary runtime checkout/build from CI, and run the checks against -the published browser package. Remove `private` from `package.json`, set the -package version, and run `npm publish --tag beta --access public` from a clean -build. No workflow publishes this package yet. +Once the browser loader ships, update `@csound/browser` and the lockfile, then +run the checks against that published package without `CSOUND_BROWSER_URL`. +Remove the temporary runtime build step, helper, source pin, and Java shell. +Remove `private` from `package.json`, set the package version, and run +`npm publish --tag beta --access public` from a clean build. No workflow publishes +this package yet. diff --git a/wasm/runtime.json b/wasm/runtime.json new file mode 100644 index 0000000..b90aa56 --- /dev/null +++ b/wasm/runtime.json @@ -0,0 +1,3 @@ +{ + "revision": "aed14beaa392dfe9c12270abd9cd63e57651be06" +} diff --git a/wasm/scripts/build-runtime.sh b/wasm/scripts/build-runtime.sh index f720307..19f8ad5 100644 --- a/wasm/scripts/build-runtime.sh +++ b/wasm/scripts/build-runtime.sh @@ -2,23 +2,30 @@ set -euo pipefail cd "$(dirname "$0")/../.." -# Temporary until the runtime changes ship in @csound/browser and @csound/wasm-bin. -csound_source=$(cd "${1:-.csound}" && pwd) -args=(-o result-browser --argstr moduleKind browser) -if [[ -n "${NIX_SYSTEM:-}" ]]; then - args+=(--argstr system "$NIX_SYSTEM") +# Temporary until the loader changes ship in @csound/browser. Use the released +# engine from this project's lockfile; only the JavaScript wrapper needs a build. +wasm_bin_dir="$PWD/node_modules/@csound/wasm-bin/lib" +if [[ $# -eq 0 ]]; then + revision=$(node -p 'require("./wasm/runtime.json").revision') + csound_source="$PWD/.csound" + if [[ ! -d "$csound_source" ]]; then + git init --quiet "$csound_source" + fi + if [[ "$(git -C "$csound_source" rev-parse HEAD 2>/dev/null || true)" != "$revision" ]]; then + git -C "$csound_source" fetch --depth 1 https://github.com/csound/csound.git "$revision" + git -C "$csound_source" checkout --detach "$revision" + fi +else + csound_source=$(cd "$1" && pwd) fi -nixpkgs=$(nix-instantiate --eval --strict --json wasm/nixpkgs.nix | node -e \ - 'let input=""; process.stdin.on("data", c => input += c); process.stdin.on("end", () => console.log(JSON.parse(input)));') -nix-build "$csound_source/platform/wasm-wasi/src/csound.nix" -I "nixpkgs=$nixpkgs" "${args[@]}" browser_dir="$csound_source/platform/wasm-wasi/browser" npm ci --prefix "$browser_dir" for file in csound.wasm csound.wasm.z; do - install -m 644 "result-browser/lib/$file" "$browser_dir/node_modules/@csound/wasm-bin/lib/$file" + install -m 644 "$wasm_bin_dir/$file" "$browser_dir/node_modules/@csound/wasm-bin/lib/$file" done export CSOUND_BROWSER_BUILD_DIR="$browser_dir" # Expand the exported path in the shell that Nix starts. # shellcheck disable=SC2016 -nix-shell -I "nixpkgs=$nixpkgs" -p jdk21 --run \ +nix-shell wasm/shell.nix --run \ 'npm run build:prod --prefix "$CSOUND_BROWSER_BUILD_DIR"' diff --git a/wasm/shell.nix b/wasm/shell.nix new file mode 100644 index 0000000..89fb8b2 --- /dev/null +++ b/wasm/shell.nix @@ -0,0 +1,4 @@ +{ pkgs ? import (import ./nixpkgs.nix) {} }: +pkgs.mkShell { + packages = [ pkgs.jdk21 ]; +} From 59771ad442b8e11be30dc3e7f7f910b66d7dec00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Tue, 13 Oct 2026 23:49:07 +0300 Subject: [PATCH 53/72] build(wasm): test against published browser runtime --- .github/workflows/plugins_wasm.yml | 4 --- package-lock.json | 8 +++--- package.json | 3 +-- wasm/README.md | 42 ++++++++++-------------------- wasm/runtime.json | 3 --- wasm/scripts/build-runtime.sh | 31 ---------------------- wasm/shell.nix | 4 --- 7 files changed, 19 insertions(+), 76 deletions(-) delete mode 100644 wasm/runtime.json delete mode 100644 wasm/scripts/build-runtime.sh delete mode 100644 wasm/shell.nix diff --git a/.github/workflows/plugins_wasm.yml b/.github/workflows/plugins_wasm.yml index 9206e43..4469308 100644 --- a/.github/workflows/plugins_wasm.yml +++ b/.github/workflows/plugins_wasm.yml @@ -34,10 +34,6 @@ jobs: run: npm ci - name: Build WASM plugins with CMake and Nix run: npm run build - - name: Build the browser wrapper with the released engine - run: | - npm run build:runtime - echo "CSOUND_BROWSER_URL=file://$GITHUB_WORKSPACE/.csound/platform/wasm-wasi/browser/dist/csound.js" >> "$GITHUB_ENV" - name: Test and pack run: npm pack - uses: actions/upload-artifact@v7.0.2 diff --git a/package-lock.json b/package-lock.json index ad26568..1f9e10f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,7 +9,7 @@ "version": "7.0.0-beta.0", "license": "LGPL-2.1-or-later", "devDependencies": { - "@csound/browser": "7.0.0-beta38", + "@csound/browser": "7.0.0-beta39", "@csound/wasm-bin": "7.0.0-beta29" }, "engines": { @@ -27,9 +27,9 @@ } }, "node_modules/@csound/browser": { - "version": "7.0.0-beta38", - "resolved": "https://registry.npmjs.org/@csound/browser/-/browser-7.0.0-beta38.tgz", - "integrity": "sha512-Q64BnO6VMjpPNJgP9VZzfTVKB3VAuN/zfIfqyUSFCjsY2SPw3KUqfpU+e1NxWt8VZEkNvSF23OjqCzR40kqgUg==", + "version": "7.0.0-beta39", + "resolved": "https://registry.npmjs.org/@csound/browser/-/browser-7.0.0-beta39.tgz", + "integrity": "sha512-/POVGpLfRrQ3kVjCPBp5bTnfYgMUQRCUHtrAilwSjrlRMQbQvQw3qjtcNbwTAxdY6uhppbpy7GbUAU2kl+OHug==", "dev": true, "license": "Apache-2.0", "dependencies": { diff --git a/package.json b/package.json index 356b59b..5242717 100644 --- a/package.json +++ b/package.json @@ -37,12 +37,11 @@ }, "scripts": { "build": "bash wasm/scripts/build.sh", - "build:runtime": "bash wasm/scripts/build-runtime.sh", "test": "node --test wasm/tests/*.test.js", "prepack": "npm test" }, "devDependencies": { - "@csound/browser": "7.0.0-beta38", + "@csound/browser": "7.0.0-beta39", "@csound/wasm-bin": "7.0.0-beta29" }, "keywords": [ diff --git a/wasm/README.md b/wasm/README.md index b765fdc..72ce0e8 100644 --- a/wasm/README.md +++ b/wasm/README.md @@ -8,18 +8,14 @@ Csound 6 is not supported. ## Runtime dependency -The engine and plugin SDK come from the released `@csound/wasm-bin` version in -[package-lock.json](../package-lock.json). The browser loader changes have -[merged upstream](https://github.com/csound/csound/pull/3416), but still need a -release of `@csound/browser`. - -Until then, `npm run build:runtime` fetches the wrapper source pinned in -[runtime.json](runtime.json) and builds it with the released engine. CI uses the -same helper. The package stays private until the published browser can load it. +Builds use the plugin SDK from `@csound/wasm-bin`, and tests use the published +`@csound/browser` runtime. [package.json](../package.json) and +[package-lock.json](../package-lock.json) record the versions used together. ## Use -With a compatible browser build: +Use a compatible `@csound/browser` release, such as the version pinned in +[package.json](../package.json): ```js import { Csound } from "@csound/browser"; @@ -55,8 +51,6 @@ Install Nix and a Node.js version that meets [package.json](../package.json)'s ```sh npm ci npm run build -npm run build:runtime -export CSOUND_BROWSER_URL="file://$PWD/.csound/platform/wasm-wasi/browser/dist/csound.js" npm test npm pack ``` @@ -67,16 +61,11 @@ it does not link its own heap. C++ plugins use libc++ without C++ exceptions. To use another Csound 7 SDK, set `CSOUND_PLUGIN_SDK` to an absolute archive path. Set `NIX_SYSTEM=x86_64-linux` when using a Linux remote builder from macOS. -The runtime helper supplies Java through [shell.nix](shell.nix). It builds only -the JavaScript wrapper; it does not rebuild the engine. For work on the loader, -pass an existing Csound checkout to -`npm run build:runtime -- /path/to/csound` and point `CSOUND_BROWSER_URL` at that -checkout's built `platform/wasm-wasi/browser/dist/csound.js` file. - -Without `CSOUND_BROWSER_URL`, tests use the locked npm browser package. Tests load -all plugins together, render Chua, compute a vector norm, and save and reload a -PNG through the WASI filesystem. Packing runs the tests and includes the WASM -files and their license notices. +Tests load all plugins together, render Chua, compute a vector norm, and save and +reload a PNG through the WASI filesystem. Packing runs the tests and includes +the WASM files and their license notices. For work on the browser loader, +`CSOUND_BROWSER_URL` can point to an absolute file URL of a local browser bundle; +leave it unset to test the published package as CI does. ## Updating dependencies @@ -85,10 +74,8 @@ Keep version pins in these files, rather than copying them into commands or docs - [package.json](../package.json) and [package-lock.json](../package-lock.json): update npm dependencies with `npm install --save-dev --save-exact @`. The Nix build reads the SDK version, URL, and hash from the lockfile. -- [runtime.json](runtime.json): the temporary browser wrapper source revision. - The helper fetches it for both local builds and CI. - [nixpkgs.nix](nixpkgs.nix): the Nix toolchain revision and hash, shared by the - plugin build and the wrapper build shell. + plugin build and its static dependencies. After an update, run the build, test, and pack commands above. The WASM workflow uses the `csound` Cachix cache and uploads builds when `CACHIX_AUTH_TOKEN` is @@ -97,9 +84,8 @@ GitHub Actions caches. ## First npm release -Once the browser loader ships, update `@csound/browser` and the lockfile, then -run the checks against that published package without `CSOUND_BROWSER_URL`. -Remove the temporary runtime build step, helper, source pin, and Java shell. -Remove `private` from `package.json`, set the package version, and run +Run the build, test, and pack commands against the published browser package +with `CSOUND_BROWSER_URL` unset. When ready to publish, remove `private` from +`package.json`, set the package version with `npm version`, and run `npm publish --tag beta --access public` from a clean build. No workflow publishes this package yet. diff --git a/wasm/runtime.json b/wasm/runtime.json deleted file mode 100644 index b90aa56..0000000 --- a/wasm/runtime.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "revision": "aed14beaa392dfe9c12270abd9cd63e57651be06" -} diff --git a/wasm/scripts/build-runtime.sh b/wasm/scripts/build-runtime.sh deleted file mode 100644 index 19f8ad5..0000000 --- a/wasm/scripts/build-runtime.sh +++ /dev/null @@ -1,31 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail -cd "$(dirname "$0")/../.." - -# Temporary until the loader changes ship in @csound/browser. Use the released -# engine from this project's lockfile; only the JavaScript wrapper needs a build. -wasm_bin_dir="$PWD/node_modules/@csound/wasm-bin/lib" -if [[ $# -eq 0 ]]; then - revision=$(node -p 'require("./wasm/runtime.json").revision') - csound_source="$PWD/.csound" - if [[ ! -d "$csound_source" ]]; then - git init --quiet "$csound_source" - fi - if [[ "$(git -C "$csound_source" rev-parse HEAD 2>/dev/null || true)" != "$revision" ]]; then - git -C "$csound_source" fetch --depth 1 https://github.com/csound/csound.git "$revision" - git -C "$csound_source" checkout --detach "$revision" - fi -else - csound_source=$(cd "$1" && pwd) -fi - -browser_dir="$csound_source/platform/wasm-wasi/browser" -npm ci --prefix "$browser_dir" -for file in csound.wasm csound.wasm.z; do - install -m 644 "$wasm_bin_dir/$file" "$browser_dir/node_modules/@csound/wasm-bin/lib/$file" -done -export CSOUND_BROWSER_BUILD_DIR="$browser_dir" -# Expand the exported path in the shell that Nix starts. -# shellcheck disable=SC2016 -nix-shell wasm/shell.nix --run \ - 'npm run build:prod --prefix "$CSOUND_BROWSER_BUILD_DIR"' diff --git a/wasm/shell.nix b/wasm/shell.nix deleted file mode 100644 index 89fb8b2..0000000 --- a/wasm/shell.nix +++ /dev/null @@ -1,4 +0,0 @@ -{ pkgs ? import (import ./nixpkgs.nix) {} }: -pkgs.mkShell { - packages = [ pkgs.jdk21 ]; -} From 70ead80f7e5de814efa13bc77dc07c38bd736007 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Wed, 14 Oct 2026 00:03:46 +0300 Subject: [PATCH 54/72] ci(wasm): disable checkout credential persistence --- .github/workflows/plugins_wasm.yml | 2 ++ wasm/tests/runtime.test.js | 5 +++++ 2 files changed, 7 insertions(+) diff --git a/.github/workflows/plugins_wasm.yml b/.github/workflows/plugins_wasm.yml index 4469308..c783d6d 100644 --- a/.github/workflows/plugins_wasm.yml +++ b/.github/workflows/plugins_wasm.yml @@ -20,6 +20,8 @@ jobs: timeout-minutes: 60 steps: - uses: actions/checkout@v7.0.1 + with: + persist-credentials: false - uses: actions/setup-node@v7.1.0 with: node-version: 22 diff --git a/wasm/tests/runtime.test.js b/wasm/tests/runtime.test.js index 7c990ac..783c3c9 100644 --- a/wasm/tests/runtime.test.js +++ b/wasm/tests/runtime.test.js @@ -29,6 +29,11 @@ e `; +/** + * Load plugin bytes into Csound 7 and render the given instrument body. + * Call check with the API, Csound instance, and peak sample magnitude before + * destroying the instance. + */ async function run(body, check, withPlugins = binaries) { const errors = []; const originalError = console.error; From 383321809aa5ac880bed26bb2fe48aa543b61b4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Wed, 14 Oct 2026 10:56:17 +0300 Subject: [PATCH 55/72] feat(wasm): bundle STK instruments and raw waves --- 7.x/cmake/WasmPlugins.cmake | 7 ++++- 7.x/src/stk/CMakeLists.txt | 39 +++++++++++++++++++++--- 7.x/src/stk/EmbedRawwaves.cmake | 21 +++++++++++++ 7.x/src/stk/stkOpcodes.cpp | 54 +++++++++++++++++++++++++++++++-- THIRD_PARTY.md | 10 +++--- index.d.ts | 1 + index.js | 1 + wasm/README.md | 23 ++++++++++---- wasm/default.nix | 38 +++++++++++++++++++++-- wasm/libunwind/CMakeLists.txt | 12 ++++++++ wasm/scripts/build.sh | 2 +- wasm/tests/runtime.test.js | 51 ++++++++++++++++++++++++++++++- 12 files changed, 235 insertions(+), 24 deletions(-) create mode 100644 7.x/src/stk/EmbedRawwaves.cmake create mode 100644 wasm/libunwind/CMakeLists.txt diff --git a/7.x/cmake/WasmPlugins.cmake b/7.x/cmake/WasmPlugins.cmake index 280f685..541f6c4 100644 --- a/7.x/cmake/WasmPlugins.cmake +++ b/7.x/cmake/WasmPlugins.cmake @@ -15,8 +15,13 @@ function(configure_wasm_plugin target) target_compile_options(${target} PRIVATE -fPIC "SHELL:-mllvm -wasm-enable-sjlj" "$<$:-std=gnu11>" - "$<$:-fno-exceptions;-nostdinc++>" + "$<$:-nostdinc++>" "$<$:-isystem${WASM_CXX_INCLUDE_DIR}>") + if(WASM_CXX_EXCEPTIONS) + target_compile_options(${target} PRIVATE "$<$:-fwasm-exceptions>") + else() + target_compile_options(${target} PRIVATE "$<$:-fno-exceptions>") + endif() target_link_options(${target} PRIVATE -shared -nostdlib -nostartfiles "LINKER:-Bsymbolic" diff --git a/7.x/src/stk/CMakeLists.txt b/7.x/src/stk/CMakeLists.txt index caa1d4c..bd809aa 100644 --- a/7.x/src/stk/CMakeLists.txt +++ b/7.x/src/stk/CMakeLists.txt @@ -1,4 +1,5 @@ option(BUILD_STK_OPCODES "Build the stk opcodes" ON) +option(STK_EMBED_RAWWAVES "Embed STK's raw-wave files in the plugin" ${WASM}) # The STK sources are bundled under this directory (include/, src/ and # rawwaves/) so that a patched copy is always built, independent of any system @@ -8,20 +9,48 @@ if(BUILD_STK_OPCODES) file(GLOB stk_srcs "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp") list(APPEND stk_srcs "${CMAKE_CURRENT_SOURCE_DIR}/stkOpcodes.cpp") + if(WASM) + if(NOT WASM_LIBCXX_EXCEPTIONS OR NOT WASM_CXX_EXCEPTIONS_INCLUDE_DIR OR NOT WASM_LIBUNWIND) + message(FATAL_ERROR "STK needs the WASM C++ exception runtime and unwinder") + endif() + set(WASM_CXX_EXCEPTIONS ON) + set(WASM_LIBCXX "${WASM_LIBCXX_EXCEPTIONS}") + set(WASM_CXX_INCLUDE_DIR "${WASM_CXX_EXCEPTIONS_INCLUDE_DIR}") + endif() make_plugin(stkops "${stk_srcs}") + if(WASM) + target_link_libraries(stkops PRIVATE "${WASM_LIBUNWIND}") + endif() target_include_directories(stkops PRIVATE ${CSOUND_INCLUDE_DIRS} "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/src") target_compile_definitions(stkops PRIVATE BUILD_PLUGINS) + if(STK_EMBED_RAWWAVES) + file(GLOB rawwaves CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/rawwaves/*.raw") + set(embedded_waves "${CMAKE_CURRENT_BINARY_DIR}/stk_rawwaves.inc") + add_custom_command(OUTPUT "${embedded_waves}" + COMMAND ${CMAKE_COMMAND} + "-DRAWWAVE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/rawwaves" + "-DOUTPUT_FILE=${embedded_waves}" + -P "${CMAKE_CURRENT_SOURCE_DIR}/EmbedRawwaves.cmake" + DEPENDS ${rawwaves} "${CMAKE_CURRENT_SOURCE_DIR}/EmbedRawwaves.cmake" + VERBATIM) + target_sources(stkops PRIVATE "${embedded_waves}") + target_include_directories(stkops PRIVATE "${CMAKE_CURRENT_BINARY_DIR}") + target_compile_definitions(stkops PRIVATE STK_EMBED_RAWWAVES) + endif() + # Install the rawwaves used by the STK instruments and make them the # default raw wave path; the RAWWAVE_PATH environment variable overrides it. - install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/rawwaves" - DESTINATION "${PLUGIN_INSTALL_DIR}/stk") - if(PLUGIN_INSTALL_DIR) - target_compile_definitions(stkops PRIVATE - DEFAULT_RAWWAVE_PATH="${PLUGIN_INSTALL_DIR}/stk/rawwaves") + if(NOT STK_EMBED_RAWWAVES) + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/rawwaves" + DESTINATION "${PLUGIN_INSTALL_DIR}/stk") + if(PLUGIN_INSTALL_DIR) + target_compile_definitions(stkops PRIVATE + DEFAULT_RAWWAVE_PATH="${PLUGIN_INSTALL_DIR}/stk/rawwaves") + endif() endif() message(STATUS "Building STK opcodes") diff --git a/7.x/src/stk/EmbedRawwaves.cmake b/7.x/src/stk/EmbedRawwaves.cmake new file mode 100644 index 0000000..78204d2 --- /dev/null +++ b/7.x/src/stk/EmbedRawwaves.cmake @@ -0,0 +1,21 @@ +# Generate byte arrays from the bundled files; no decoder is needed at runtime. +file(GLOB waves "${RAWWAVE_DIR}/*.raw") +list(SORT waves) +file(WRITE "${OUTPUT_FILE}" "// Generated by EmbedRawwaves.cmake.\n") +set(entries "") +foreach(wave IN LISTS waves) + get_filename_component(name "${wave}" NAME) + string(MAKE_C_IDENTIFIER "${name}" symbol) + file(READ "${wave}" bytes HEX) + string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," bytes "${bytes}") + file(APPEND "${OUTPUT_FILE}" "static const unsigned char ${symbol}[] = {${bytes}};\n") + string(APPEND entries " {\"${name}\", ${symbol}, sizeof(${symbol})},\n") +endforeach() +file(APPEND "${OUTPUT_FILE}" " +static const struct { + const char *name; + const unsigned char *bytes; + size_t size; +} stkRawwaves[] = { +${entries}}; +") diff --git a/7.x/src/stk/stkOpcodes.cpp b/7.x/src/stk/stkOpcodes.cpp index 0f721fd..d672079 100644 --- a/7.x/src/stk/stkOpcodes.cpp +++ b/7.x/src/stk/stkOpcodes.cpp @@ -25,9 +25,10 @@ * * The STK sources are bundled in this directory (include/, src/ and * rawwaves/) so that a patched copy is always used, independent of any system - * or package-manager STK installation. The rawwaves path defaults to the - * installed location (DEFAULT_RAWWAVE_PATH) and can be overridden with the - * RAWWAVE_PATH environment variable. + * or package-manager STK installation. STK_EMBED_RAWWAVES stages the bundled + * samples at module initialization; otherwise the rawwaves path defaults to + * the installed location (DEFAULT_RAWWAVE_PATH). The RAWWAVE_PATH environment + * variable overrides either default. * * All these opcodes are named "STK" + the STK classname, * e.g. "STKBowed" for the Bowed instrument. @@ -53,6 +54,16 @@ #include #include +#ifdef STK_EMBED_RAWWAVES +#include +#ifdef _WIN32 +#include +#else +#include +#endif +#include "stk_rawwaves.inc" +#endif + #include "BandedWG.h" #include "BeeThree.h" #include "BlowBotl.h" @@ -584,8 +595,45 @@ OENTRY oentries[] = { PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { return 0; } +#ifdef STK_EMBED_RAWWAVES +// Keep STK's file reader unchanged by staging the embedded bytes at module init. +static bool writeEmbeddedRawwaves(CSOUND *csound, const char *directory) { +#ifdef _WIN32 + const int result = _mkdir(directory); +#else + const int result = mkdir(directory, 0700); +#endif + if (result != 0 && errno != EEXIST) { + csound->Message(csound, "STK: cannot create raw-wave directory %s\n", directory); + return false; + } + for (const auto &wave : stkRawwaves) { + const std::string filename = std::string(directory) + "/" + wave.name; + FILE *file = fopen(filename.c_str(), "wb"); + if (!file) { + csound->Message(csound, "STK: cannot open embedded raw wave %s\n", filename.c_str()); + return false; + } + const bool written = fwrite(wave.bytes, 1, wave.size, file) == wave.size; + const int closed = fclose(file); + if (!written || closed != 0) { + csound->Message(csound, "STK: cannot write embedded raw wave %s\n", filename.c_str()); + return false; + } + } + return true; +} +#endif + PUBLIC int32_t csoundModuleInit(CSOUND *csound) { const char *path = csound->GetEnv(csound, "RAWWAVE_PATH"); +#ifdef STK_EMBED_RAWWAVES + if (path == NULL || strlen(path) == 0) { + path = ".csound-stk-rawwaves"; + if (!writeEmbeddedRawwaves(csound, path)) + return NOTOK; + } +#endif #ifdef DEFAULT_RAWWAVE_PATH if (path == NULL || strlen(path) == 0) path = DEFAULT_RAWWAVE_PATH; diff --git a/THIRD_PARTY.md b/THIRD_PARTY.md index 9b8d546..6e94339 100644 --- a/THIRD_PARTY.md +++ b/THIRD_PARTY.md @@ -10,11 +10,13 @@ The package also contains code from these libraries: | GMM++ (GetFEM) | Linear algebra | `dist/licenses/gmm.txt`; LGPL-3.0-or-later with the exception in the headers | | libpng | Image | `dist/licenses/libpng.txt` | | zlib | Image | `dist/licenses/zlib.txt` | +| STK and its raw-wave samples | STK instruments | `dist/licenses/stk.txt` | | wasi-libc, musl, cloudlibc, musl-fts | C runtime | `dist/licenses/wasi-libc/` | -| LLVM libc++, libc++abi, compiler-rt | C++ runtime and compiler support | `dist/licenses/libcxx.txt`, `libcxxabi.txt`, `compiler-rt.txt` | +| LLVM libc++, libc++abi, libunwind, compiler-rt | C++ runtime and compiler support | `dist/licenses/libcxx.txt`, `libcxxabi.txt`, `libunwind.txt`, `compiler-rt.txt` | The Nix build copies these notices from the source used to build each library. [`wasm/nixpkgs.nix`](https://github.com/csound/plugins/blob/develop/wasm/nixpkgs.nix) -pins their source versions. The GMM++ headers live in this repository. The build -uses upstream CMake and make options for static PIC libraries; it adds no source -patches. `wasm/default.nix` records those options. +pins their source versions. The GMM++ headers and STK sources and samples live +in this repository. The build uses upstream CMake and make options for static +PIC libraries, plus a small CMake target for LLVM's WASM unwinder; it adds no +source patches. `wasm/default.nix` records those options. diff --git a/index.d.ts b/index.d.ts index 92dc222..d1c4647 100644 --- a/index.d.ts +++ b/index.d.ts @@ -3,4 +3,5 @@ export declare const plugins: Readonly<{ chua: string; image: string; linearAlgebra: string; + stk: string; }>; diff --git a/index.js b/index.js index 312756a..d8963c5 100644 --- a/index.js +++ b/index.js @@ -3,4 +3,5 @@ export const plugins = Object.freeze({ chua: new URL("./dist/chua.wasm", import.meta.url).href, image: new URL("./dist/image.wasm", import.meta.url).href, linearAlgebra: new URL("./dist/linear_algebra.wasm", import.meta.url).href, + stk: new URL("./dist/stkops.wasm", import.meta.url).href, }); diff --git a/wasm/README.md b/wasm/README.md index 72ce0e8..5a361cf 100644 --- a/wasm/README.md +++ b/wasm/README.md @@ -2,8 +2,8 @@ WASM opcode plugins for the double-precision Csound 7 browser engine. -This first package includes Chua (`chuap`), image, and linear algebra. This build -disables STK, FluidSynth, HDF5, Python, WebSockets, device, and GPU plugins. +This package includes Chua (`chuap`), image, linear algebra, and STK. This build +disables FluidSynth, HDF5, Python, WebSockets, device, and GPU plugins. Csound 6 is not supported. ## Runtime dependency @@ -24,6 +24,12 @@ import { plugins } from "@csound/plugins"; const csound = await Csound({ withPlugins: [plugins.chua, plugins.image] }); ``` +Use `plugins.stk` to load the STK instruments. Its single `stkops.wasm` file +contains all bundled raw-wave samples. At initialization, the plugin writes +them to Csound's virtual filesystem and sets its wave path. No extra downloads +or `RAWWAVE_PATH` setup are needed. An explicit `RAWWAVE_PATH` overrides the +embedded samples; that directory must already contain the files STK needs. + The exports are asset URL strings. Bundlers must copy the WASM files referenced by `new URL(..., import.meta.url)`. You can also serve files from `@csound/plugins/dist/` yourself and pass their URLs to `withPlugins`. @@ -57,13 +63,18 @@ npm pack Nix pins the toolchain and builds the existing `7.x` CMake targets with Ninja. Dependencies use static PIC builds. The C runtime imports the engine's allocator; -it does not link its own heap. C++ plugins use libc++ without C++ exceptions. +it does not link its own heap. STK uses a separate libc++ build with C++ exceptions +and a static WASM unwinder. Other C++ plugins keep exceptions disabled. +CMake's `STK_EMBED_RAWWAVES` option embeds the samples and defaults to on for WASM. +Native builds keep using the installed raw-wave directory by default. To use another Csound 7 SDK, set `CSOUND_PLUGIN_SDK` to an absolute archive path. Set `NIX_SYSTEM=x86_64-linux` when using a Linux remote builder from macOS. -Tests load all plugins together, render Chua, compute a vector norm, and save and -reload a PNG through the WASI filesystem. Packing runs the tests and includes -the WASM files and their license notices. For work on the browser loader, +Tests load all plugins together, render Chua and STK, compute a vector norm, and +save and reload a PNG through the WASI filesystem. STK tests also cover loading +it alone, overriding its wave path, and catching a missing-sample error. +Packing runs the tests and includes the WASM files and their license notices. +For work on the browser loader, `CSOUND_BROWSER_URL` can point to an absolute file URL of a local browser bundle; leave it unset to test the published package as CI does. diff --git a/wasm/default.nix b/wasm/default.nix index 229265c..9b7353a 100644 --- a/wasm/default.nix +++ b/wasm/default.nix @@ -4,6 +4,13 @@ }: let wasi = pkgs.pkgsCross.wasi32.clangStdenv; + # Nix's WASI wrapper otherwise forces -fno-exceptions after CMake's flags. + # Let each target select its exception mode instead. + wasiCxx = pkgs.overrideCC wasi (wasi.cc.override (old: { + nixSupport = old.nixSupport // { + cc-cflags = builtins.filter (flag: flag != "-fno-exceptions") old.nixSupport.cc-cflags; + }; + })); libc = pkgs.pkgsCross.wasi32.wasilibc.overrideAttrs (old: { NIX_CFLAGS_COMPILE = (old.NIX_CFLAGS_COMPILE or []) ++ [ "-fPIC" ]; # Use the engine's allocator. wasi-libc also skips its fixed symbol list @@ -19,6 +26,26 @@ let ]; dontStrip = true; }); + libunwindSource = pkgs.pkgsCross.wasi32.llvmPackages.libunwind.src; + libunwind = wasi.mkDerivation { + pname = "libunwind-wasm-pic"; + inherit (libcxx) version; + src = ./libunwind; + nativeBuildInputs = [ pkgs.cmake pkgs.ninja ]; + cmakeFlags = [ "-DLIBUNWIND_SOURCE_DIR=${libunwindSource}/libunwind" ]; + dontStrip = true; + }; + libcxxExceptions = (libcxx.override { stdenv = wasiCxx; }).overrideAttrs (old: { + pname = "libcxx-wasm-exceptions"; + cmakeFlags = old.cmakeFlags ++ [ + "-DLIBCXX_ENABLE_EXCEPTIONS=ON" + "-DLIBCXX_ADDITIONAL_LIBRARIES=" + "-DLIBCXXABI_ENABLE_EXCEPTIONS=ON" + ]; + preConfigure = (old.preConfigure or "") + '' + cmakeFlagsArray+=("-DCMAKE_CXX_FLAGS=-fexceptions -fwasm-exceptions -I${libunwindSource}/libunwind/include") + ''; + }); lock = builtins.fromJSON (builtins.readFile ../package-lock.json); wasmBin = lock.packages."node_modules/@csound/wasm-bin"; sdkArchive = if csoundSdkArchive == null then null else builtins.path { @@ -56,7 +83,7 @@ let NIX_CFLAGS_COMPILE = [ "-mllvm" "-wasm-enable-sjlj" ]; dontStrip = true; }; -in wasi.mkDerivation { +in wasiCxx.mkDerivation { pname = "csound-plugins-wasm"; version = (builtins.fromJSON (builtins.readFile ../package.json)).version; src = pkgs.lib.cleanSource ../7.x; @@ -71,13 +98,16 @@ in wasi.mkDerivation { "-DWASM_SETJMP=${libc}/lib/libsetjmp.a" "-DWASM_LIBCXX=${libcxx}/lib/libc++.a" "-DWASM_CXX_INCLUDE_DIR=${libcxx.dev}/include/c++/v1" + "-DWASM_LIBCXX_EXCEPTIONS=${libcxxExceptions}/lib/libc++.a" + "-DWASM_CXX_EXCEPTIONS_INCLUDE_DIR=${libcxxExceptions.dev}/include/c++/v1" + "-DWASM_LIBUNWIND=${libunwind}/lib/libunwind.a" "-DEIGEN3_INCLUDE_DIR=${pkgs.eigen}/include/eigen3" "-DZLIB_LIBRARY=${zlib}/lib/libzlibstatic.a" "-DPNG_LIBRARY=${libpng}/lib/libpng.a" "-DBUILD_CHUA_OPCODES=ON" "-DBUILD_IMAGE_OPCODES=ON" "-DBUILD_LINEAR_ALGEBRA_OPCODES=ON" - "-DBUILD_STK_OPCODES=OFF" + "-DBUILD_STK_OPCODES=ON" "-DBUILD_FLUID_OPCODES=OFF" "-DBUILD_HDF5_OPCODES=OFF" "-DBUILD_WEBSOCKET_OPCODE=OFF" @@ -95,12 +125,14 @@ in wasi.mkDerivation { cp ${libc.src}/fts/musl-fts/COPYING $out/share/licenses/wasi-libc/musl-fts.txt cp ${libcxx.src}/libcxx/LICENSE.TXT $out/share/licenses/libcxx.txt cp ${libcxx.src}/libcxxabi/LICENSE.TXT $out/share/licenses/libcxxabi.txt + cp ${libunwindSource}/libunwind/LICENSE.TXT $out/share/licenses/libunwind.txt + cp ${../7.x/src/stk/LICENSE} $out/share/licenses/stk.txt cp ${pkgs.pkgsCross.wasi32.llvmPackages.compiler-rt.src}/compiler-rt/LICENSE.TXT $out/share/licenses/compiler-rt.txt cp ${pkgs.eigen.src}/COPYING* $out/share/licenses/eigen/ sed -n '1,/^=*[*][/]$/p' ${../7.x/src/linear_algebra/gmm/gmm.h} > $out/share/licenses/gmm.txt tar -xOf ${pkgs.libpng.src} libpng-${pkgs.libpng.version}/LICENSE > $out/share/licenses/libpng.txt tar -xOf ${pkgs.zlib.src} zlib-${pkgs.zlib.version}/LICENSE > $out/share/licenses/zlib.txt - for plugin in chua image linear_algebra; do + for plugin in chua image linear_algebra stkops; do test -s "$out/lib/$plugin.wasm" done ''; diff --git a/wasm/libunwind/CMakeLists.txt b/wasm/libunwind/CMakeLists.txt new file mode 100644 index 0000000..5e79ec6 --- /dev/null +++ b/wasm/libunwind/CMakeLists.txt @@ -0,0 +1,12 @@ +cmake_minimum_required(VERSION 3.16) +project(CsoundWasmUnwind C) + +# LLVM 21's main build also selects assembly files that do not support WASM. +# The VM unwinds the stack; this source supplies the C++ exception interface. +add_library(unwind STATIC "${LIBUNWIND_SOURCE_DIR}/src/Unwind-wasm.c") +set_target_properties(unwind PROPERTIES POSITION_INDEPENDENT_CODE ON) +target_compile_features(unwind PRIVATE c_std_11) +target_compile_options(unwind PRIVATE -fwasm-exceptions) +target_compile_definitions(unwind PRIVATE _LIBUNWIND_HIDE_SYMBOLS) +target_include_directories(unwind PRIVATE "${LIBUNWIND_SOURCE_DIR}/include") +install(TARGETS unwind ARCHIVE DESTINATION lib) diff --git a/wasm/scripts/build.sh b/wasm/scripts/build.sh index 22c5070..87afa3c 100644 --- a/wasm/scripts/build.sh +++ b/wasm/scripts/build.sh @@ -12,7 +12,7 @@ fi nix-build wasm/default.nix "${args[@]}" staging=$(mktemp -d .wasm-dist.XXXXXX) trap 'rm -rf "$staging"' EXIT -for plugin in chua image linear_algebra; do +for plugin in chua image linear_algebra stkops; do install -m 644 "result-wasm/lib/$plugin.wasm" "$staging/$plugin.wasm" done cp -R result-wasm/share/licenses "$staging/licenses" diff --git a/wasm/tests/runtime.test.js b/wasm/tests/runtime.test.js index 783c3c9..b7ca0f6 100644 --- a/wasm/tests/runtime.test.js +++ b/wasm/tests/runtime.test.js @@ -31,10 +31,11 @@ e /** * Load plugin bytes into Csound 7 and render the given instrument body. + * Run prepare before compilation to set options or supply files. * Call check with the API, Csound instance, and peak sample magnitude before * destroying the instance. */ -async function run(body, check, withPlugins = binaries) { +async function run(body, check, withPlugins = binaries, prepare = () => {}) { const errors = []; const originalError = console.error; console.error = (...args) => errors.push(args.join(" ")); @@ -49,6 +50,7 @@ async function run(body, check, withPlugins = binaries) { assert.equal(api.csoundGetSizeOfMYFLT(), 8); const csound = api.csoundCreate(); try { + await prepare(api, csound); assert.equal(api.csoundCompileCSD(csound, document(body)), 0); assert.equal(api.csoundStart(csound), 0); let peak = 0; @@ -89,6 +91,53 @@ test("chua produces finite, nonzero audio alongside the other plugins", async () `, (_, __, peak) => assert.ok(peak > 0)); }); +for (const instrument of ["STKMandolin", "STKModalBar", "STKBeeThree", "STKDrummer"]) { + test(`${instrument} renders with embedded waves alongside the other plugins`, async () => { + await run(` + a1 ${instrument} 220, 0.5 + out a1 + `, (_, __, peak) => assert.ok(peak > 0)); + }); +} + +test("STK loads on its own without a raw-wave path or extra files", async () => { + const stk = await readFile(new URL(plugins.stk)); + await run("a1 STKMandolin 220, 0.5\nout a1", (_, __, peak) => assert.ok(peak > 0), [stk]); +}); + +test("RAWWAVE_PATH uses caller-supplied samples without overwriting them", async () => { + const silentWave = new Uint8Array(512); + await run("a1 STKModalBar 220, 0.5\nout a1", async (api, csound, peak) => { + assert.equal(peak, 0); + assert.deepEqual(await api.readFile(csound, "/custom-waves/marmstk1.raw"), silentWave); + }, binaries, async (api, csound) => { + await api.writeFile(csound, "/custom-waves/marmstk1.raw", silentWave); + assert.equal(api.csoundSetOption(csound, "--env:RAWWAVE_PATH=/custom-waves"), 0); + }); +}); + +test("STK reports a missing sample through Csound instead of throwing out of WASM", async () => { + const api = await libcsound({ withPlugins: binaries }); + const csound = api.csoundCreate(); + const messages = []; + const originalLog = console.log; + console.log = (...args) => messages.push(args.join(" ")); + try { + assert.equal(api.csoundSetOption(csound, "--env:RAWWAVE_PATH=/missing-stk-waves"), 0); + assert.equal(api.csoundCompileCSD(csound, document("a1 STKMandolin 220, 0.5\nout a1")), 0); + assert.equal(api.csoundStart(csound), 0); + let result = 0; + for (let block = 0; block < 100 && result === 0; block++) { + result = api.csoundPerformKsmps(csound); + } + assert.notEqual(result, 0, "the failed score must finish"); + assert.ok(messages.some((message) => message.includes("STK: FileRead::open")), messages.join("\n")); + } finally { + api.csoundDestroy(csound); + console.log = originalLog; + } +}); + test("linear algebra computes a vector norm", async () => { await run(` iv la_i_vr_create 2 From 68b2cba55de8c9ee3b55ec76bab7b930c42911b2 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Wed, 14 Oct 2026 09:45:24 +0100 Subject: [PATCH 56/72] Add Faust opcodes for Csound 7 Port the faustcsound opcodes (faustgen, faustcompile, faustaudio, faustdsp, faustplay, faustctl) from 6.x to the Csound 7 plugin API. - Use cs_float/FAUSTFLOAT, the new OENTRY deinit field, and csoundModuleInit registration. - Add a CMake build supporting both a dynamic libfaust and a static libfaustwithllvm archive (-DFAUST_STATIC=ON) with symbol hiding. - Install and auto-locate the Faust standard library so import("stdfaust.lib") works without a separate Faust install. - Add CI steps to download the Faust release binaries and build/stage the plugin and stdlib on Linux, macOS and Windows. --- .github/workflows/plugins_build_7.yml | 106 ++- 7.x/CMakeLists.txt | 1 + 7.x/cmake/Modules/FindFAUST.cmake | 109 ++- 7.x/src/faustcsound/CMakeLists.txt | 57 ++ 7.x/src/faustcsound/README.md | 72 ++ 7.x/src/faustcsound/faustcsound.exports | 4 + 7.x/src/faustcsound/faustgen.cpp | 1121 +++++++++++++++++++++++ 7 files changed, 1435 insertions(+), 35 deletions(-) create mode 100644 7.x/src/faustcsound/CMakeLists.txt create mode 100644 7.x/src/faustcsound/README.md create mode 100644 7.x/src/faustcsound/faustcsound.exports create mode 100644 7.x/src/faustcsound/faustgen.cpp diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 4d2ca45..b86907e 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -20,6 +20,7 @@ on: env: CSOUND_VERSION: 7.0.0-beta.18 + FAUST_VERSION: 2.88.0 VCPKG_BINARY_SOURCES: "clear;files,${{ github.workspace }}/vcpkg-cache,readwrite" jobs: @@ -71,7 +72,7 @@ jobs: libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ libeigen3-dev libfluidsynth-dev libpng-dev \ libwebsockets-dev libuv1-dev libhdf5-dev \ - ocl-icd-opencl-dev \ + ocl-icd-opencl-dev libtinfo-dev \ flex bison - name: Cache Csound install @@ -94,16 +95,45 @@ jobs: cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(nproc)" cmake --install "$RUNNER_TEMP/csound-build" + - name: Cache Faust + id: cache-faust + uses: actions/cache@v4 + with: + path: ~/faust + key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} + + - name: Install Faust + if: steps.cache-faust.outputs.cache-hit != 'true' + run: | + mkdir -p "$HOME/faust" + curl -sL -o "$RUNNER_TEMP/libfaust.zip" \ + "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/libfaust-ubuntu-x86_64.zip" + curl -sL -o "$RUNNER_TEMP/faust-src.tar.gz" \ + "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/faust-$FAUST_VERSION.tar.gz" + unzip -q "$RUNNER_TEMP/libfaust.zip" -d "$HOME/faust" + tar xzf "$RUNNER_TEMP/faust-src.tar.gz" -C "$RUNNER_TEMP" \ + "faust-$FAUST_VERSION/architecture" "faust-$FAUST_VERSION/libraries" + mv "$RUNNER_TEMP/faust-$FAUST_VERSION/architecture" "$HOME/faust/include" + mv "$RUNNER_TEMP/faust-$FAUST_VERSION/libraries" "$HOME/faust/stdlib" + rm -f "$RUNNER_TEMP/libfaust.zip" "$RUNNER_TEMP/faust-src.tar.gz" + - name: Configure plugin build run: | echo "CSOUND_INCLUDE_DIR_HINT=$HOME/csound-install/include/csound" >> "$GITHUB_ENV" echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/lib" >> "$GITHUB_ENV" + echo "FAUST_INCLUDE_DIR_HINT=$HOME/faust/include" >> "$GITHUB_ENV" + echo "FAUST_LIB_DIR_HINT=$HOME/faust/lib" >> "$GITHUB_ENV" + echo "FAUST_STDLIB_DIR_HINT=$HOME/faust/stdlib" >> "$GITHUB_ENV" - name: Build plugins run: | cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ + -DFAUST_STATIC=ON \ -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ - -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" + -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" \ + -DFAUST_INCLUDE_DIR_HINT="$FAUST_INCLUDE_DIR_HINT" \ + -DFAUST_LIB_DIR_HINT="$FAUST_LIB_DIR_HINT" \ + -DFAUST_STDLIB_DIR_HINT="$FAUST_STDLIB_DIR_HINT" cmake --build build --parallel "$(nproc)" - name: Stage plugins @@ -118,8 +148,11 @@ jobs: build/src/py/*.so \ build/src/OpenCL/*.so \ build/src/stk/*.so package/ + cp build/src/faustcsound/*.so package/ mkdir -p package/stk/rawwaves cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ + mkdir -p package/faust + cp -R "$HOME/faust/stdlib/." package/faust/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -192,6 +225,33 @@ jobs: cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(sysctl -n hw.ncpu)" cmake --install "$RUNNER_TEMP/csound-build" + - name: Cache Faust + id: cache-faust + uses: actions/cache@v4 + with: + path: ~/faust + key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} + + - name: Install Faust + if: steps.cache-faust.outputs.cache-hit != 'true' + run: | + if [ "$(uname -m)" = "arm64" ]; then + asset="Faust-$FAUST_VERSION-arm64.dmg" + else + asset="Faust-$FAUST_VERSION-x64.dmg" + fi + curl -sL -o "$RUNNER_TEMP/faust.dmg" \ + "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/$asset" + mkdir -p "$HOME/faust" "$RUNNER_TEMP/faust_dmg" + hdiutil attach "$RUNNER_TEMP/faust.dmg" \ + -mountpoint "$RUNNER_TEMP/faust_dmg" -nobrowse -quiet + root=$(dirname "$(find "$RUNNER_TEMP/faust_dmg" -maxdepth 2 -type d -name include | head -1)") + cp -R "$root/include" "$HOME/faust/include" + cp -R "$root/lib" "$HOME/faust/lib" + cp -R "$root/share/faust" "$HOME/faust/stdlib" + hdiutil detach "$RUNNER_TEMP/faust_dmg" -quiet + rm -f "$RUNNER_TEMP/faust.dmg" + - name: Configure plugin build run: | framework="$HOME/csound-install/Frameworks/CsoundLib64.framework" @@ -202,14 +262,21 @@ jobs: echo "CSOUND_INCLUDE_DIR_HINT=$headers" >> "$GITHUB_ENV" echo "CSOUND_FRAMEWORK_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" + echo "FAUST_INCLUDE_DIR_HINT=$HOME/faust/include" >> "$GITHUB_ENV" + echo "FAUST_LIB_DIR_HINT=$HOME/faust/lib" >> "$GITHUB_ENV" + echo "FAUST_STDLIB_DIR_HINT=$HOME/faust/stdlib" >> "$GITHUB_ENV" - name: Build plugins run: | cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ -DUSE_VCPKG=ON \ + -DFAUST_STATIC=ON \ -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ -DCSOUND_FRAMEWORK_DIR_HINT="$CSOUND_FRAMEWORK_DIR_HINT" \ - -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" + -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" \ + -DFAUST_INCLUDE_DIR_HINT="$FAUST_INCLUDE_DIR_HINT" \ + -DFAUST_LIB_DIR_HINT="$FAUST_LIB_DIR_HINT" \ + -DFAUST_STDLIB_DIR_HINT="$FAUST_STDLIB_DIR_HINT" cmake --build build --parallel "$(sysctl -n hw.ncpu)" - name: Stage plugins @@ -224,8 +291,11 @@ jobs: build/src/py/*.dylib \ build/src/OpenCL/*.dylib \ build/src/stk/*.dylib package/ + cp build/src/faustcsound/*.dylib package/ mkdir -p package/stk/rawwaves cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ + mkdir -p package/faust + cp -R "$HOME/faust/stdlib/." package/faust/ - name: Upload plugins uses: actions/upload-artifact@v4 @@ -294,6 +364,23 @@ jobs: cmake --build csound-build --config Release --parallel cmake --install csound-build --config Release + - name: Cache Faust + id: cache-faust + uses: actions/cache@v4 + with: + path: ~/faust + key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} + + - name: Install Faust + if: steps.cache-faust.outputs.cache-hit != 'true' + run: | + $faustDir = Join-Path $env:USERPROFILE 'faust' + New-Item -ItemType Directory -Force -Path $faustDir | Out-Null + curl.exe -sL -o "$env:RUNNER_TEMP\faust.exe" ` + "https://github.com/grame-cncm/faust/releases/download/$env:FAUST_VERSION/Faust-$env:FAUST_VERSION-win64.exe" + & 'C:\Program Files\7-Zip\7z.exe' x "$env:RUNNER_TEMP\faust.exe" "-o$faustDir" -y | Out-Null + Remove-Item "$env:RUNNER_TEMP\faust.exe" + - name: Configure plugin build run: | $install = Join-Path $env:RUNNER_TEMP 'csound-install' @@ -305,13 +392,21 @@ jobs: if (-not $lib) { throw "csound64.lib not found under $install" } "CSOUND_INCLUDE_DIR_HINT=$($header.DirectoryName)" >> $env:GITHUB_ENV "CSOUND_LIBRARY_DIR_HINT=$($lib.DirectoryName)" >> $env:GITHUB_ENV + $faustDir = Join-Path $env:USERPROFILE 'faust' + "FAUST_INCLUDE_DIR_HINT=$faustDir\include" >> $env:GITHUB_ENV + "FAUST_LIB_DIR_HINT=$faustDir\lib" >> $env:GITHUB_ENV + "FAUST_STDLIB_DIR_HINT=$faustDir\share\faust" >> $env:GITHUB_ENV - name: Build plugins run: | cmake -S 7.x -B build -A x64 ` -DUSE_VCPKG=ON ` + -DFAUST_STATIC=ON ` -DCSOUND_INCLUDE_DIR_HINT="$env:CSOUND_INCLUDE_DIR_HINT" ` - -DCSOUND_LIBRARY_DIR_HINT="$env:CSOUND_LIBRARY_DIR_HINT" + -DCSOUND_LIBRARY_DIR_HINT="$env:CSOUND_LIBRARY_DIR_HINT" ` + -DFAUST_INCLUDE_DIR_HINT="$env:FAUST_INCLUDE_DIR_HINT" ` + -DFAUST_LIB_DIR_HINT="$env:FAUST_LIB_DIR_HINT" ` + -DFAUST_STDLIB_DIR_HINT="$env:FAUST_STDLIB_DIR_HINT" cmake --build build --config Release --parallel - name: Stage plugins @@ -328,6 +423,9 @@ jobs: $rawwaves = Join-Path $package 'stk/rawwaves' New-Item -ItemType Directory -Force -Path $rawwaves | Out-Null Copy-Item '7.x\src\stk\rawwaves\*.raw' -Destination $rawwaves + $faustOut = Join-Path $package 'faust' + New-Item -ItemType Directory -Force -Path $faustOut | Out-Null + Copy-Item "$env:USERPROFILE\faust\share\faust\*" -Destination $faustOut -Recurse - name: Upload plugins uses: actions/upload-artifact@v4 diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index ed75642..91b2f6a 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -314,3 +314,4 @@ add_subdirectory(./src/p5glove) add_subdirectory(./src/CUDA) add_subdirectory(./src/OpenCL) add_subdirectory(./src/stk) +add_subdirectory(./src/faustcsound) diff --git a/7.x/cmake/Modules/FindFAUST.cmake b/7.x/cmake/Modules/FindFAUST.cmake index d1d329e..a14dc99 100644 --- a/7.x/cmake/Modules/FindFAUST.cmake +++ b/7.x/cmake/Modules/FindFAUST.cmake @@ -1,6 +1,11 @@ # Find Faust2 include(FindPackageHandleStandardArgs) +# When ON, link against the self-contained static library that bundles LLVM +# (libfaustwithllvm on Linux/macOS, libfaustwithllvm.lib on Windows). This +# produces a plugin with no runtime dependency on libfaust. +option(FAUST_STATIC "Link against a static libfaust that bundles LLVM" OFF) + find_path(FAUST_INCLUDE_DIR faust/dsp/llvm-dsp.h HINTS C:/Program Files/Faust/include/ @@ -10,49 +15,91 @@ find_path(FAUST_INCLUDE_DIR faust/dsp/llvm-dsp.h "${FAUST_INCLUDE_DIR_HINT}" ) -find_library(FAUST_LIBRARY - NAMES - libfaust.so - libfaust.dylib - faust.dll - faust - libfaust +if(FAUST_STATIC) + find_library(FAUST_LIBRARY + NAMES + libfaustwithllvm.lib + libfaustwithllvm.a + faustwithllvm + HINTS + "${FAUST_LIB_DIR_HINT}" + ) +else() + find_library(FAUST_LIBRARY + NAMES + libfaust.so + libfaust.dylib + faust.dll + faust + libfaust + HINTS + "${FAUST_LIB_DIR_HINT}" + ) +endif() + +# Locate the Faust standard library (containing stdfaust.lib). It is shipped +# as share/faust in the binary packages and as libraries/ in the source tree. +find_path(FAUST_STDLIB_DIR stdfaust.lib HINTS - "${FAUST_LIB_DIR_HINT}" + "${FAUST_STDLIB_DIR_HINT}" + "${FAUST_LIB_DIR_HINT}/../share/faust" + "${FAUST_INCLUDE_DIR_HINT}/../share/faust" + "${FAUST_LIB_DIR_HINT}/../libraries" + "${FAUST_INCLUDE_DIR_HINT}/../libraries" + "${FAUST_INCLUDE_DIR_HINT}/../share/faust" ) find_package_handle_standard_args(FAUST FAUST_INCLUDE_DIR FAUST_LIBRARY) if(FAUST_FOUND) - set(FAUST_LIBRARIES ${FAUST_LIBRARY}) set(FAUST_INCLUDE_DIRS ${FAUST_INCLUDE_DIR}) - if("${FAUST_LIBRARY}" MATCHES ".*\\.a") - # This is a static build of faust, hence - # we have to add all the LLVM flags... + if(FAUST_STATIC) + # libfaustwithllvm bundles LLVM, so only platform libraries are needed. + if(WIN32) + set(FAUST_LIBRARIES ${FAUST_LIBRARY} + ws2_32 crypt32 dbghelp ole32 shell32 psapi bcrypt + version uuid user32 advapi32 ntdll) + elseif(APPLE) + set(FAUST_LIBRARIES ${FAUST_LIBRARY} z) + else() + set(_faust_syslibs dl pthread z) + find_library(FAUST_TINFO_LIBRARY NAMES tinfo ncurses) + if(FAUST_TINFO_LIBRARY) + list(APPEND _faust_syslibs ${FAUST_TINFO_LIBRARY}) + endif() + set(FAUST_LIBRARIES ${FAUST_LIBRARY} ${_faust_syslibs}) + endif() + else() + set(FAUST_LIBRARIES ${FAUST_LIBRARY}) - find_program(LLVM_CONFIG llvm-config - HINTS - /usr/bin - /usr/local/bin - /usr/local/opt/llvm/bin - ) + if("${FAUST_LIBRARY}" MATCHES ".*\\.a") + # This is a static build of faust without LLVM, hence + # we have to add all the LLVM flags... - if(NOT LLVM_CONFIG) - message(WARNING "Using a static Faust library requires LLVM tooling to be present in the path.") - UNSET(FAUST_FOUND) - else() - exec_program(${LLVM_CONFIG} ARGS --includedir OUTPUT_VARIABLE LLVM_DIR) - exec_program(${LLVM_CONFIG} ARGS --libs OUTPUT_VARIABLE LLVM_LIBS) - exec_program(${LLVM_CONFIG} ARGS --version OUTPUT_VARIABLE LLVM_VERSION) - exec_program(${LLVM_CONFIG} ARGS --ldflags OUTPUT_VARIABLE LLVM_LDFLAGS) + find_program(LLVM_CONFIG llvm-config + HINTS + /usr/bin + /usr/local/bin + /usr/local/opt/llvm/bin + ) - set(LLVM_VERSION LLVM_${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR}) + if(NOT LLVM_CONFIG) + message(WARNING "Using a static Faust library requires LLVM tooling to be present in the path.") + UNSET(FAUST_FOUND) + else() + exec_program(${LLVM_CONFIG} ARGS --includedir OUTPUT_VARIABLE LLVM_DIR) + exec_program(${LLVM_CONFIG} ARGS --libs OUTPUT_VARIABLE LLVM_LIBS) + exec_program(${LLVM_CONFIG} ARGS --version OUTPUT_VARIABLE LLVM_VERSION) + exec_program(${LLVM_CONFIG} ARGS --ldflags OUTPUT_VARIABLE LLVM_LDFLAGS) - find_package(OpenSSL REQUIRED) - set(FAUST_LIBRARIES ${FAUST_LIBRARIES} dl ${OPENSSL_LIBRARIES} ncurses z ${LLVM_LDFLAGS} ${LLVM_LIBS} ) - endif() - endif() + set(LLVM_VERSION LLVM_${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR}) + + find_package(OpenSSL REQUIRED) + set(FAUST_LIBRARIES ${FAUST_LIBRARIES} dl ${OPENSSL_LIBRARIES} ncurses z ${LLVM_LDFLAGS} ${LLVM_LIBS} ) + endif() + endif() + endif() else() set(FAUST_LIBRARIES) set(FAUST_INCLUDE_DIRS) diff --git a/7.x/src/faustcsound/CMakeLists.txt b/7.x/src/faustcsound/CMakeLists.txt new file mode 100644 index 0000000..70b8e07 --- /dev/null +++ b/7.x/src/faustcsound/CMakeLists.txt @@ -0,0 +1,57 @@ +# Build faustcsound opcodes +option(BUILD_FAUST_OPCODES "Build the Faust opcodes" ON) + +find_package(FAUST) +check_deps(BUILD_FAUST_OPCODES FAUST_FOUND) + +if(BUILD_FAUST_OPCODES AND FAUST_FOUND) + message(STATUS "Faust library: ${FAUST_LIBRARY}") + + make_plugin(faustcsound faustgen.cpp) + + target_include_directories(faustcsound PRIVATE + ${CSOUND_INCLUDE_DIRS} + ${FAUST_INCLUDE_DIR}) + target_compile_definitions(faustcsound PRIVATE "-DFAUSTFLOAT=cs_float") + + if(PTHREAD_LIBRARY) + target_compile_definitions(faustcsound PRIVATE "-DHAVE_PTHREAD") + endif() + + target_link_libraries(faustcsound + ${FAUST_LIBRARIES} + ${PTHREAD_LIBRARY} + ${CMAKE_DL_LIBS}) + + if(APPLE) + set_target_properties(faustcsound PROPERTIES + INSTALL_RPATH_USE_LINK_PATH TRUE + ) + endif() + + if(FAUST_STATIC) + # libfaustwithllvm bundles LLVM; without this the plugin would export + # the hundreds of thousands of LLVM/Faust symbols from the archive. + if(APPLE) + set_target_properties(faustcsound PROPERTIES LINK_FLAGS + "-Wl,-exported_symbols_list,${CMAKE_CURRENT_SOURCE_DIR}/faustcsound.exports") + elseif(UNIX) + set_target_properties(faustcsound PROPERTIES LINK_FLAGS + "-Wl,--exclude-libs,ALL") + endif() + endif() + + # Install the Faust standard library next to the plugin and point the + # plugin at it, so programs using import("stdfaust.lib") work without a + # separate Faust installation. + if(FAUST_STDLIB_DIR) + message(STATUS "Faust standard library: ${FAUST_STDLIB_DIR}") + install(DIRECTORY "${FAUST_STDLIB_DIR}/" + DESTINATION "${PLUGIN_INSTALL_DIR}/faust") + target_compile_definitions(faustcsound PRIVATE + "DEFAULT_FAUST_LIB_PATH=\"${PLUGIN_INSTALL_DIR}/faust\"") + else() + message(WARNING "Faust standard library (stdfaust.lib) not found; " + "set FAUST_STDLIB_DIR_HINT to enable import(\"stdfaust.lib\")") + endif() +endif() diff --git a/7.x/src/faustcsound/README.md b/7.x/src/faustcsound/README.md new file mode 100644 index 0000000..aef59eb --- /dev/null +++ b/7.x/src/faustcsound/README.md @@ -0,0 +1,72 @@ +Faust opcodes +======= + +These opcodes embed the [Faust](https://faust.grame.fr/) compiler and DSP +runtime into Csound: + +* `faustgen` - compiles and runs a single Faust program +* `faustcompile` - compiles a Faust program, returning a handle +* `faustaudio` - creates a DSP instance from a compiled program +* `faustdsp` - creates a DSP instance (no audio outputs) from a compiled program +* `faustplay` - runs an existing DSP instance with explicit inputs/outputs +* `faustctl` - sets the value of a control of a DSP instance + +Building +-------- + +To build the Faust opcodes you need the Faust library (headers and +`libfaust`), which can be downloaded as a binary package from + or built from source +(which also requires libcrypto and LLVM). + +When using the pre-built binary packages the following CMake variables +are important: + +* `FAUST_INCLUDE_DIR_HINT` - the `include` directory of the package + (contains `faust/dsp/llvm-dsp.h`). +* `FAUST_LIB_DIR_HINT` - the `lib` directory of the package. +* `FAUST_STDLIB_DIR_HINT` - the directory containing `stdfaust.lib` + (`share/faust` in the binary packages, `libraries` in the source tree). +* `FAUST_STATIC` - when `ON`, link against the self-contained + `libfaustwithllvm` archive, which bundles LLVM so the plugin has no + runtime dependency on `libfaust`. This produces a much larger plugin. + +For example, if Faust 2.88.0 is placed in the top-level user directory: + +``` +cmake .. -DFAUST_INCLUDE_DIR_HINT=$HOME/faust-2.88.0/include \ + -DFAUST_LIB_DIR_HINT=$HOME/faust-2.88.0/lib \ + -DFAUST_STDLIB_DIR_HINT=$HOME/faust-2.88.0/share/faust \ + -DFAUST_STATIC=ON +``` + +Without `FAUST_STATIC` the plugin is linked to `libfaust` dynamically and +`libfaust` must be locatable at runtime (the build sets an rpath to the +library directory by default). With `FAUST_STATIC=ON` the LLVM/Faust +symbols are linked in and hidden, so only the opcode entry points are +exported. + +The Faust standard library is installed next to the plugin (in a `faust` +subdirectory of the plugin directory) and the plugin looks for it there, +so `import("stdfaust.lib")` works without a separate Faust installation. +Set `FAUST_LIB_PATH` to override this, e.g. + +``` +export FAUST_LIB_PATH=$HOME/faust-2.88.0/share/faust +``` + +Faust programs that use the standard library (e.g. `os.osc`) need +`import("stdfaust.lib");`. + +Notes on the Csound 7 port +-------------------------- + +* `MYFLT` was replaced by `cs_float` and `FAUSTFLOAT` is defined to + `cs_float`, so the plugin always matches the Csound sample type. +* Opcode cleanup uses the `OENTRY` `deinit` field instead of the removed + `RegisterDeinitCallback`; `faustcompile` still uses a reset callback so + that compiled factories outlive the compiling instrument. +* `CreateThread2` was removed from the Csound API, so the `istacksize` + argument of `faustcompile` is now accepted but ignored. `faustgen` + compiles synchronously on the calling (init) thread, and asynchronous + `faustcompile` uses the default thread stack size. diff --git a/7.x/src/faustcsound/faustcsound.exports b/7.x/src/faustcsound/faustcsound.exports new file mode 100644 index 0000000..663cc21 --- /dev/null +++ b/7.x/src/faustcsound/faustcsound.exports @@ -0,0 +1,4 @@ +_csoundModuleCreate +_csoundModuleInit +_csoundModuleDestroy +_csoundModuleInfo diff --git a/7.x/src/faustcsound/faustgen.cpp b/7.x/src/faustcsound/faustgen.cpp new file mode 100644 index 0000000..7d85066 --- /dev/null +++ b/7.x/src/faustcsound/faustgen.cpp @@ -0,0 +1,1121 @@ +/* faustgen.cpp + + Copyright (c) Victor Lazzarini, 2013 + + This file is part of Csound. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA + + Faust Csound opcodes + + These four opcodes allow Faust to be embedded in Csound code: + + faustcompile: compiles a Faust program + faustaudio: creates a DSP instance from a compiled Faust program + (any number of instances from a single compiled program are + allowed) + faustctl: sets the value of a given control of a Faust DSP instance + + faustgen: compiles and creates a single DSP instance from a Faust program + (convenient for one-off Faust programs) + +*/ +#include "csdl.h" +#ifndef FAUSTFLOAT +#define FAUSTFLOAT cs_float +#endif +#include "faust/dsp/llvm-dsp.h" +#include "faust/gui/UI.h" +#include +#include +#ifdef _WIN32 +#include +#else +#include +#include +#endif + +#define MAXARG 40 + +static int dir_exists(const char *p) { +#ifdef _WIN32 + DWORD a = GetFileAttributesA(p); + return (a != INVALID_FILE_ATTRIBUTES && (a & FILE_ATTRIBUTE_DIRECTORY)); +#else + struct stat st; + return (stat(p, &st) == 0 && S_ISDIR(st.st_mode)); +#endif +} + +static void get_plugin_dir(char *out, size_t n) { + out[0] = '\0'; +#ifdef _WIN32 + HMODULE hm = NULL; + GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | + GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, + (LPCSTR)&get_plugin_dir, &hm); + GetModuleFileNameA(hm, out, (DWORD)n); +#else + Dl_info info; + if (dladdr((void *)&get_plugin_dir, &info) && info.dli_fname) + snprintf(out, n, "%s", info.dli_fname); +#endif + char *slash = strrchr(out, '/'); +#ifdef _WIN32 + char *bslash = strrchr(out, '\\'); + if (!slash || (bslash && bslash > slash)) + slash = bslash; +#endif + if (slash) + *slash = '\0'; +} + +static void set_faust_lib_path(const char *path) { +#ifdef _WIN32 + _putenv_s("FAUST_LIB_PATH", path); +#else + setenv("FAUST_LIB_PATH", path, 1); +#endif +} + +/* Locate the Faust standard library directory so that programs using + import("stdfaust.lib") work without a separate Faust installation. A + user-provided FAUST_LIB_PATH always takes precedence; otherwise we look + for a "faust" directory next to the plugin, then fall back to the path + configured at build time. */ +static void setup_faust_path(CSOUND *csound) { + const char *env = getenv("FAUST_LIB_PATH"); + if (env != NULL && env[0] != '\0') + return; + char dir[4096], cand[4096]; + get_plugin_dir(dir, sizeof(dir)); + if (dir[0] != '\0') { + snprintf(cand, sizeof(cand), "%s/faust", dir); + if (dir_exists(cand)) { + set_faust_lib_path(cand); + return; + } + } +#ifdef DEFAULT_FAUST_LIB_PATH + if (dir_exists(DEFAULT_FAUST_LIB_PATH)) { + set_faust_lib_path(DEFAULT_FAUST_LIB_PATH); + return; + } +#endif + (void)csound; +} + +/** + * Faust controls class for Csound + * + **/ +class controls : public UI { + + struct ctl { + FAUSTFLOAT *zone; + char label[65]; + cs_float min, max; + ctl *nxt; + } anchor; + + void addctl(const char *label, FAUSTFLOAT *zone, FAUSTFLOAT min, + FAUSTFLOAT max) { + ctl *pctl = &anchor; + while (pctl->nxt) + pctl = pctl->nxt; + pctl->nxt = new ctl; + pctl = pctl->nxt; + strncpy(pctl->label, label, 63); + pctl->label[63] = '\n'; pctl->label[64] = '\0'; + pctl->zone = zone; + pctl->min = min; + pctl->max = max; + pctl->nxt = NULL; + } + +public: + controls() { + anchor.nxt = NULL; + anchor.label[0] = '\0'; + } + ~controls() { + ctl *pctl = &anchor, *tmp; + pctl = pctl->nxt; + while (pctl) { + tmp = pctl; + pctl = pctl->nxt; + delete tmp; + } + } + + virtual void openTabBox(const char *label){}; + virtual void openHorizontalBox(const char *label){}; + virtual void openVerticalBox(const char *label){}; + virtual void closeBox(){}; + + virtual void addSoundfile(const char *label, const char *filename, + Soundfile **sf_zone){}; + + virtual void addButton(const char *label, FAUSTFLOAT *zone) { + addctl(label, zone, 0, 0); + } + virtual void addCheckButton(const char *label, FAUSTFLOAT *zone) { + addctl(label, zone, 0, 0); + } + virtual void addVerticalSlider(const char *label, FAUSTFLOAT *zone, + FAUSTFLOAT init, FAUSTFLOAT min, + FAUSTFLOAT max, FAUSTFLOAT step) { + addctl(label, zone, min, max); + } + virtual void addHorizontalSlider(const char *label, FAUSTFLOAT *zone, + FAUSTFLOAT init, FAUSTFLOAT min, + FAUSTFLOAT max, FAUSTFLOAT step) { + addctl(label, zone, min, max); + } + virtual void addNumEntry(const char *label, FAUSTFLOAT *zone, FAUSTFLOAT init, + FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) { + addctl(label, zone, min, max); + } + virtual void addHorizontalBargraph(const char *label, FAUSTFLOAT *zone, + FAUSTFLOAT min, FAUSTFLOAT max){}; + virtual void addVerticalBargraph(const char *label, FAUSTFLOAT *zone, + FAUSTFLOAT min, FAUSTFLOAT max){}; + + FAUSTFLOAT *getZone(char *label) { + ctl *pctl = &anchor; + pctl = pctl->nxt; + while (pctl) { + if (strcmp(pctl->label, label) == 0) + break; + pctl = pctl->nxt; + } + if (pctl) + return pctl->zone; + else + return NULL; + } + cs_float getMax(char *label) { + ctl *pctl = &anchor; + pctl = pctl->nxt; + while (pctl) { + if (strcmp(pctl->label, label) == 0) + break; + pctl = pctl->nxt; + } + if (pctl) + return pctl->max; + else + return 0; + } + cs_float getMin(char *label) { + ctl *pctl = &anchor; + pctl = pctl->nxt; + while (pctl) { + if (strcmp(pctl->label, label) == 0) + break; + pctl = pctl->nxt; + } + if (pctl) + return pctl->min; + else + return 0; + } +}; + +/** + * Faust object handle + * + **/ +struct faustobj { + void *obj; + controls *ctls; + faustobj *nxt; + uint64_t cnt; +}; + +/** + * Faust compile opcode + + usage: + ihandle faustcompile Scode, Sargs[,iasync, istacksize] + + ihandle - handle to compiled code + Scode - Faust program + Sargs - Faust compiler args + istacksize - compiler stack size in megabytes (default 1MB). NOTE: this + argument is accepted for backwards compatibility but is currently ignored, + as the Csound 7 threading API no longer supports setting the stack size. + iasync - async operation (1 = on, 0 = off) default to 1 +**/ +struct faustcompile { + OPDS h; + cs_float *hptr; + STRINGDAT *code; + STRINGDAT *args; + cs_float *async; + cs_float *stacksize; + cs_float *extra; + llvm_dsp_factory *factory; + void *thread; + void *lock; +}; + +char **parse_cmd(CSOUND *csound, char *str, int32_t *argc) { + char **argv; + int32_t i = 0, n = 0, end = strlen(str); + while (str[i] == ' ') + i++; + if (str[i] != '\0') + *argc = 1; + while (str[i] != '\0') { + if (str[i] == ' ') { + while (str[++i] == ' ') + ; + if (str[i] == '\0') + break; + (*argc)++; + } + i++; + } + argv = (char **)csound->Calloc(csound, sizeof(char *) * (*argc)); + i = 0; + while (str[i] == ' ') + i++; + for (n = 0; n < *argc && i < end; n++) { + argv[n] = &(str[i]); + while (str[++i] != ' ' && i < end) + ; + if (i >= end) + break; + str[i] = '\0'; + while (str[++i] == ' ' && i < end) + ; + } + return argv; +} + +int32_t delete_faustcompile(CSOUND *csound, void *p) { + + faustcompile *pp = ((faustcompile *)p); + faustobj *fobj, *prv, **pfobj; + if (pp->thread) + csound->JoinThread(pp->thread); + pfobj = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); + if(pfobj != NULL) { + fobj = *pfobj; + prv = fobj; + while (fobj != NULL) { + if (fobj->obj == (void *)pp->factory) { + prv->nxt = fobj->nxt; + break; + } + prv = fobj; + fobj = fobj->nxt; + } + if (fobj != NULL) { + if (*pfobj == fobj) + *pfobj = fobj->nxt; + deleteDSPFactory(pp->factory); + csound->Free(csound, fobj); + } + } + csound->DestroyMutex(pp->lock); + return OK; +} + +struct hdata { + faustcompile *p; + CSOUND *csound; +}; + +void *init_faustcompile_thread(void *pp) { + + faustcompile *p = ((hdata *)pp)->p; + faustobj **pffactory, *ffactory; + CSOUND *csound = ((hdata *)pp)->csound; + llvm_dsp_factory *factory; + int32_t argc = 0; + std::string err_msg; + char *cmd = (char *) csound->Calloc(csound, p->args->size + 9); + char *ccode = csound->Strdup(csound, p->code->data); + char *extra; + cs_float test = *p->extra; + strcpy(cmd, p->args->data); +#ifdef USE_DOUBLE + strcat(cmd, " -double"); +#endif + const char **argv = (const char **) parse_cmd(csound, cmd, &argc); + const char *varname = "::factory"; + + if(test) + extra = ((STRINGDAT *) p->extra)->data; + else + extra = (char *) ""; + + // Need to protect this + csound->LockMutex((void *) p->lock); + factory = createDSPFactoryFromString("faustop", (const char *) ccode, + argc, argv, extra, err_msg, 3); + csound->UnlockMutex((void *) p->lock); + + if (factory == NULL) { + csound->Message(csound, Str("\nFaust compilation problem:\nline %s\n"), + err_msg.c_str()); + *(p->hptr) = FL(-2.0); // error code. + csound->Free(csound, argv); + csound->Free(csound, cmd); + csound->Free(csound, ccode); + csound->Free(csound, pp); + return NULL; + } + + pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); + if (pffactory == NULL) { + csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); + pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); + ffactory = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + ffactory->obj = factory; + ffactory->nxt = NULL; + ffactory->cnt = 0ul; + *pffactory = ffactory; + } else { + ffactory = *pffactory; + while (ffactory->nxt) { + ffactory = ffactory->nxt; + } + ffactory->nxt = (faustobj *) csound->Calloc(csound, sizeof(faustobj)); + ffactory->nxt->cnt = ffactory->cnt+1ul; + ffactory = ffactory->nxt; + ffactory->obj = factory; + } + p->factory = factory; + if(p->hptr) + *p->hptr = FL(ffactory->cnt); + csound->Free(csound, argv); + csound->Free(csound, cmd); + csound->Free(csound, ccode); + csound->Free(csound, pp); + + return NULL; +} + +static uintptr_t init_faustcompile_thread_runner(void *pp) { + init_faustcompile_thread(pp); + return 0; +} + +int32_t init_faustcompile(CSOUND *csound, faustcompile *p) { + hdata *data = (hdata *)csound->Malloc(csound, sizeof(hdata)); + data->csound = csound; + data->p = p; + *p->hptr = -1.0; + p->lock = csound->Create_Mutex(0); + p->thread = NULL; + + if(!(int)*p->async) { + /* synchronous compilation, run on the calling thread (large stack) */ + init_faustcompile_thread(data); + } else { + p->thread = csound->CreateThread(init_faustcompile_thread_runner, data); + } + /* Factory cleanup is deferred to reset, so that instruments using the + compiled factory are not affected when the compiling instrument ends. */ + csound->RegisterResetCallback(csound, p, delete_faustcompile); + return OK; +} + +struct faustdsp { + OPDS h; + cs_float *ohptr; + cs_float *code; /* faust compiled code handle */ + llvm_dsp *engine; /* faust DSP */ + llvm_dsp_factory *factory; /* DSP factory */ +}; + +/* deinit function + delete faust dsp objects +*/ +int32_t delete_faustdsp(CSOUND *csound, void *p) { + faustdsp *pp = (faustdsp *)p; + faustobj *fobj, *prv, **pfobj; + pfobj = (faustobj **)csound->QueryGlobalVariable(csound, "::dsp"); + if (pfobj != NULL) { + fobj = *pfobj; + prv = fobj; + while (fobj != NULL) { + if (fobj->obj == (void *)pp->engine) { + prv->nxt = fobj->nxt; + break; + } + prv = fobj; + fobj = fobj->nxt; + } + if (fobj != NULL) { + if (*pfobj == fobj) + *pfobj = fobj->nxt; + csound->Free(csound, fobj); + delete pp->engine; + } else + csound->Warning(csound, Str("could not find DSP %p for deletion"), + pp->engine); + } + if (pp->factory) + deleteDSPFactory(pp->factory); + + return OK; +} + +int32_t init_faustdsp(CSOUND *csound, faustdsp *p) { + int32_t factory; + faustobj *fobj, **fobjp, **pfdsp, *fdsp; + llvm_dsp *dsp; + controls *ctls = new controls(); + const char *varname = "::dsp"; + int timout = 0; + while (*((cs_float *)p->code) == -1.0) { + csound->Sleep(1); + timout++; + if(timout > 1000) { + return csound->InitError( + csound, "%s", Str("Faust code was not ready. Try compiling it \n" + "in a separate instrument prior to running it here\n")); + } + } + + factory = (int32_t)*((cs_float *)p->code); + + if (factory == -2) + return csound->InitError( + csound, "%s", Str("Faust code did not compile properly.\n" + "Check above messages for Faust compiler errors\n")); + + fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); + if (fobjp == NULL) + return csound->InitError(csound, "%s", Str("no factory available\n")); + fobj = *fobjp; + while ((int32_t)fobj->cnt != factory) { + fobj = fobj->nxt; + if (fobj == NULL) + return csound->InitError(csound, Str("factory not found %d\n"), + (int32_t)factory); + } + + dsp = ((llvm_dsp_factory *)fobj->obj)->createDSPInstance(); + if (dsp == NULL) + return csound->InitError(csound, "%s", Str("Faust instantiation problem\n")); + + dsp->buildUserInterface(ctls); + pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); + if (pfdsp == NULL) { + csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); + pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); + fdsp = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->obj = dsp; + fdsp->ctls = ctls; + fdsp->nxt = NULL; + fdsp->cnt = 0; + *pfdsp = fdsp; + } else { + fdsp = *pfdsp; + if (fdsp != NULL) { + while (fdsp->nxt) { + fdsp = fdsp->nxt; + } + fdsp->nxt = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->nxt->cnt = fdsp->cnt + 1; + fdsp = fdsp->nxt; + fdsp->obj = dsp; + fdsp->ctls = ctls; + } else { + fdsp = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->obj = dsp; + fdsp->ctls = ctls; + fdsp->nxt = NULL; + fdsp->cnt = 0; + *pfdsp = fdsp; + } + } + + p->factory = NULL; // this opcode does not own the factory + p->engine = (llvm_dsp *)fdsp->obj; + p->engine->init((int)csound->GetEngineSr(csound)); + *p->ohptr = (cs_float)fdsp->cnt; + return OK; + +} + +struct faustplay { + OPDS h; + cs_float *outs[MAXARG]; /* outputs */ + cs_float *inst; + cs_float *ins[VARGMAX]; /* inputs */ + llvm_dsp *engine; /* faust DSP */ + llvm_dsp_factory *factory; /* DSP factory */ + AUXCH memin; + AUXCH memout; +}; + + +int32_t init_faustplay(CSOUND *csound, faustplay *p) { + faustobj *fobj, **fobjp; + const OPARMS *parms = csound->GetOParms(csound); + int32_t instance = (int32_t)*p->inst; + + fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::dsp"); + if (fobjp == NULL) + return csound->InitError(csound, "%s", Str("no dsp instances available\n")); + fobj = *fobjp; + + while ((int32_t)fobj->cnt != instance) { + fobj = fobj->nxt; + if (fobj == NULL) + return csound->InitError(csound, Str("dsp instance not found %d\n"), + (int32_t)*p->inst); + } + + p->engine = (llvm_dsp *)fobj->obj; + p->engine->init((int)csound->GetEngineSr(csound)); + + if (p->engine->getNumInputs() != p->INOCOUNT - 1) { + delete p->engine; + return csound->InitError(csound, "%s", Str("wrong number of input args\n")); + } + if (p->engine->getNumOutputs() != p->OUTOCOUNT) { + delete p->engine; + return csound->InitError(csound, "%s", Str("wrong number of output args\n")); + } + + /* memory for sampAccurate offsets */ + if (parms->sampleAccurate) { + size_t size; + size = p->engine->getNumInputs() * sizeof(cs_float *); + if (p->memin.auxp == NULL || p->memin.size < size) + csound->AuxAlloc(csound, size, &p->memin); + size = p->engine->getNumOutputs() * sizeof(cs_float *); + if (p->memout.auxp == NULL || p->memout.size < size) + csound->AuxAlloc(csound, size, &p->memout); + } + + return OK; +} + +int32_t perf_faustplay(CSOUND *csound, faustplay *p) { + int32_t nsmps = CS_KSMPS, i; + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + cs_float **in_tmp = (cs_float **)p->memin.auxp; + cs_float **out_tmp = (cs_float **)p->memout.auxp; + + if (UNLIKELY(early)) { + for (i = 0; i < p->OUTOCOUNT - 1; i++) + memset(p->outs[i], '\0', nsmps * sizeof(cs_float)); + nsmps -= early; + } + if (UNLIKELY(offset)) { + /* offset pointers, save current pos */ + for (i = 0; i < p->OUTOCOUNT; i++) { + memset(p->outs[i], '\0', nsmps * sizeof(cs_float)); + out_tmp[i] = p->outs[i]; + p->outs[i] = &(p->outs[i][offset]); + } + for (i = 0; i < p->INOCOUNT - 1; i++) { + in_tmp[i] = p->ins[i]; + p->ins[i] = &(p->ins[i][offset]); + } + nsmps -= offset; + } + + p->engine->compute(nsmps, p->ins, p->outs); + + if (UNLIKELY(offset)) { + /* restore pos */ + for (i = 0; i < p->OUTOCOUNT; i++) + p->outs[i] = out_tmp[i]; + for (i = 0; i < p->INOCOUNT - 1; i++) + p->ins[i] = in_tmp[i]; + } + return OK; +} + + +/** + * faustgen and faustaudio opcodes + + usage: + ihandle[,asig1,...] faustgen Scode[,ain1,...] + ihandle[,asig1,...] faustaudio ifactory,[,ain1,...] + + Scode - Faust program + ifactory - handle pointing to compiled code from faustcompile + asig1 ... - audio outputs from Faust program + ain1 ... - audio inputs to Faust program + + ihandle - handle identifying this Faust DSP instance + +**/ +struct faustgen { + OPDS h; + cs_float *ohptr; + cs_float *outs[MAXARG]; /* outputs */ + STRINGDAT *code; /* faust code as string */ + cs_float *ins[VARGMAX]; /* inputs */ + llvm_dsp *engine; /* faust DSP */ + llvm_dsp_factory *factory; /* DSP factory */ + controls *ctls; + AUXCH memin; + AUXCH memout; +}; + +struct hdata2 { + faustgen *p; + CSOUND *csound; +}; + + +/* deinit function + delete faust objects +*/ +int32_t delete_faustgen(CSOUND *csound, void *p) { + faustgen *pp = (faustgen *)p; + faustobj *fobj, *prv, **pfobj; + if((pfobj = (faustobj **)csound->QueryGlobalVariable(csound, "::dsp")) + != NULL) { + fobj = *pfobj; + prv = fobj; + while (fobj != NULL) { + if (fobj->obj == (void *)pp->engine) { + prv->nxt = fobj->nxt; + break; + } + prv = fobj; + fobj = fobj->nxt; + } + if (fobj != NULL) { + if (*pfobj == fobj) + *pfobj = fobj->nxt; + csound->Free(csound, fobj); + delete pp->ctls; + delete pp->engine; + } + } + if (pp->factory) + deleteDSPFactory(pp->factory); + + return OK; +} + + +int32_t init_faustaudio(CSOUND *csound, faustgen *p) { + int32_t factory; + const OPARMS *parms = csound->GetOParms(csound); + faustobj *fobj, **fobjp, **pfdsp, *fdsp; + llvm_dsp *dsp; + controls *ctls = new controls(); + const char *varname = "::dsp"; + int timout = 0; + while (*((cs_float *)p->code) == -1.0) { + csound->Sleep(1); + timout++; + if(timout > 1000) { + return csound->InitError( + csound, "%s", Str("Faust code was not ready. Try compiling it \n" + "in a separate instrument prior to running it here\n")); + } + } + + + factory = (int32_t)*((cs_float *)p->code); + + if (factory == -2) + return csound->InitError( + csound, "%s", Str("Faust code did not compile properly.\n" + "Check above messages for Faust compiler errors\n")); + + fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); + if (fobjp == NULL) + return csound->InitError(csound, "%s", Str("no factory available\n")); + fobj = *fobjp; + while ((int32_t)fobj->cnt != factory) { + fobj = fobj->nxt; + if (fobj == NULL) + return csound->InitError(csound, Str("factory not found %d\n"), + (int32_t)factory); + } + + dsp = ((llvm_dsp_factory *)fobj->obj)->createDSPInstance(); + if (dsp == NULL) + return csound->InitError(csound, "%s", Str("Faust instantiation problem\n")); + + dsp->buildUserInterface(ctls); + pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); + if (pfdsp == NULL) { + csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); + pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); + fdsp = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->obj = dsp; + fdsp->ctls = ctls; + fdsp->nxt = NULL; + fdsp->cnt = 0; + *pfdsp = fdsp; + } else { + fdsp = *pfdsp; + if (fdsp != NULL) { + while (fdsp->nxt) { + fdsp = fdsp->nxt; + } + fdsp->nxt = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->nxt->cnt = fdsp->cnt + 1; + fdsp = fdsp->nxt; + fdsp->obj = dsp; + fdsp->ctls = ctls; + } else { + fdsp = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->obj = dsp; + fdsp->ctls = ctls; + fdsp->nxt = NULL; + fdsp->cnt = 0; + *pfdsp = fdsp; + } + } + + p->factory = NULL; // this opcode does not own the factory + p->engine = (llvm_dsp *)fdsp->obj; + p->engine->init((int)csound->GetEngineSr(csound)); + + if (p->engine->getNumInputs() != p->INOCOUNT - 1) { + delete p->engine; + p->engine = NULL; + return csound->InitError(csound, "%s", Str("wrong number of input args\n")); + } + if (p->engine->getNumOutputs() != p->OUTOCOUNT - 1) { + delete p->engine; + p->engine = NULL; + return csound->InitError(csound, "%s", Str("wrong number of output args\n")); + } + + /* memory for sampAccurate offsets */ + if (parms->sampleAccurate) { + size_t size; + size = p->engine->getNumInputs() * sizeof(cs_float *); + if (p->memin.auxp == NULL || p->memin.size < size) + csound->AuxAlloc(csound, size, &p->memin); + size = p->engine->getNumOutputs() * sizeof(cs_float *); + if (p->memout.auxp == NULL || p->memout.size < size) + csound->AuxAlloc(csound, size, &p->memout); + } + + p->ctls = ctls; + *p->ohptr = (cs_float)fdsp->cnt; + return OK; +} + +void *init_faustgen_thread(void *pp) { + CSOUND *csound = ((hdata2 *)pp)->csound; + faustgen *p = ((hdata2 *)pp)->p; + const OPARMS *parms = csound->GetOParms(csound); + std::string err_msg; +#ifdef USE_DOUBLE + int32_t argc = 4; + const char *argv[] = {"-vec", "-lv", " 1", "-double"}; +#else + int32_t argc = 3; + const char *argv[] = {"-vec", "-lv", " 1"}; +#endif + faustobj **pfdsp, *fdsp; + llvm_dsp *dsp; + controls *ctls = new controls(); + const char *varname = "::dsp"; + p->engine = NULL; + p->factory = createDSPFactoryFromString( + "faustop", (const char *)p->code->data, argc, argv, "", err_msg, 3); + if (p->factory == NULL) { + csound->InitError(csound, Str("Faust compilation problem: %s\n"), + err_msg.c_str()); + csound->Free(csound, pp); + return NULL; + } + + dsp = p->factory->createDSPInstance(); + if (dsp == NULL) { + csound->InitError(csound, "%s", + Str("Faust instantiation problem\n")); + csound->Free(csound, pp); + return NULL; + } + + dsp->buildUserInterface(ctls); + + pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); + if (pfdsp == NULL || *pfdsp == NULL) { + csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); + pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); + fdsp = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->obj = dsp; + fdsp->ctls = ctls; + fdsp->nxt = NULL; + fdsp->cnt = 0; + *pfdsp = fdsp; + } else { + fdsp = *pfdsp; + while (fdsp->nxt) { + fdsp = fdsp->nxt; + } + fdsp->nxt = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fdsp->nxt->cnt = fdsp->cnt++; + fdsp = fdsp->nxt; + fdsp->obj = dsp; + fdsp->ctls = ctls; + } + + p->engine = dsp; + dsp->init((int)csound->GetEngineSr(csound)); + if (p->engine->getNumInputs() != p->INOCOUNT - 1) { + csound->InitError(csound, "%s", Str("wrong number of input args\n")); + delete p->engine; + deleteDSPFactory(p->factory); + p->factory = NULL; + p->engine = NULL; + csound->Free(csound, pp); + return NULL; + } + if (p->engine->getNumOutputs() != p->OUTOCOUNT - 1) { + csound->InitError(csound, + Str("wrong number of output args: need %d had %d\n"), + p->engine->getNumOutputs(), + p->OUTOCOUNT - 1); + delete p->engine; + deleteDSPFactory(p->factory); + csound->Free(csound, pp); + p->engine = NULL; + p->factory = NULL; + return NULL; + } + + /* memory for sampAccurate offsets */ + if (parms->sampleAccurate) { + size_t size; + size = p->engine->getNumInputs() * sizeof(cs_float *); + if (p->memin.auxp == NULL || p->memin.size < size) + csound->AuxAlloc(csound, size, &p->memin); + size = p->engine->getNumOutputs() * sizeof(cs_float *); + if (p->memout.auxp == NULL || p->memout.size < size) + csound->AuxAlloc(csound, size, &p->memout); + } + p->ctls = ctls; + *p->ohptr = (cs_float)fdsp->cnt; + csound->Free(csound, pp); + return NULL; +} + +int32_t init_faustgen(CSOUND *csound, faustgen *p) { + hdata2 *data = (hdata2 *)csound->Malloc(csound, sizeof(hdata2)); + data->csound = csound; + data->p = p; + /* Compile synchronously on the calling thread, which has a large stack; + the original code also joined the worker thread immediately. */ + init_faustgen_thread(data); + return OK; +} + +int32_t perf_faust(CSOUND *csound, faustgen *p) { + int32_t nsmps = CS_KSMPS, i; + uint32_t offset = p->h.insdshead->ksmps_offset; + uint32_t early = p->h.insdshead->ksmps_no_end; + cs_float **in_tmp = (cs_float **)p->memin.auxp; + cs_float **out_tmp = (cs_float **)p->memout.auxp; + + if (UNLIKELY(early)) { + for (i = 0; i < p->OUTOCOUNT - 1; i++) + memset(p->outs[i], '\0', nsmps * sizeof(cs_float)); + nsmps -= early; + } + if (UNLIKELY(offset)) { + /* offset pointers, save current pos */ + for (i = 0; i < p->OUTOCOUNT - 1; i++) { + memset(p->outs[i], '\0', nsmps * sizeof(cs_float)); + out_tmp[i] = p->outs[i]; + p->outs[i] = &(p->outs[i][offset]); + } + for (i = 0; i < p->INOCOUNT - 1; i++) { + in_tmp[i] = p->ins[i]; + p->ins[i] = &(p->ins[i][offset]); + } + nsmps -= offset; + } + + p->engine->compute(nsmps, p->ins, p->outs); + + if (UNLIKELY(offset)) { + /* restore pos -- could be memcpy? */ + for (i = 0; i < p->OUTOCOUNT - 1; i++) + p->outs[i] = out_tmp[i]; + for (i = 0; i < p->INOCOUNT - 1; i++) + p->ins[i] = in_tmp[i]; + } + return OK; +} + +#define MAXPARAM 128 + +/** + * faustctl opcode + + usage: + faustctl idsp, Slabel, kval[, Slabel1, kval1 ...] + + idsp - handle from an existing Faust DSP instance + Slabel - name of control (in Faust program) + kval - value to be sent to control + +**/ +struct faustctl { + OPDS h; + cs_float *inst; + STRINGDAT *label; + cs_float *val; + cs_float *extraparam[MAXPARAM]; + FAUSTFLOAT *zone; + cs_float min, max; + cs_float minextra[MAXPARAM/2], maxextra[MAXPARAM/2]; + FAUSTFLOAT *zonextra[MAXPARAM/2]; +}; + +int32_t init_faustctl(CSOUND *csound, faustctl *p) { + + faustobj *fobj, **fobjp; + int32_t instance = (int32_t)*p->inst; + + /* checks that extra parameter count is even */ + if((p->INOCOUNT - 3)%2) + return csound->InitError(csound, "unbalanced parameter count \n"); + + fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::dsp"); + if (fobjp == NULL) + return csound->InitError(csound, "%s", Str("no dsp instances available\n")); + fobj = *fobjp; + + while ((int32_t)fobj->cnt != instance) { + fobj = fobj->nxt; + if (fobj == NULL) + return csound->InitError(csound, Str("dsp instance not found %d\n"), + (int32_t)*p->inst); + } + + p->zone = fobj->ctls->getZone(p->label->data); + if (p->zone == NULL) + return csound->InitError(csound, Str("dsp control %s not found\n"), + p->label->data); + p->max = fobj->ctls->getMax(p->label->data); + p->min = fobj->ctls->getMin(p->label->data); + { + cs_float val = *p->val; + if (p->min != p->max) + val = val < p->min ? p->min : (val > p->max ? p->max : val); + *p->zone = val; + } + + + /* implementation of extra optional parameters */ + for(int n = 0; n < p->INOCOUNT - 3; n+=2) { + char *name = ((STRINGDAT *)p->extraparam[n])->data; + p->zonextra[n/2] = fobj->ctls->getZone(name); + if (p->zonextra[n/2] == NULL) + return csound->InitError(csound, Str("dsp control %s not found\n"), + name); + p->maxextra[n/2] = fobj->ctls->getMax(name); + p->minextra[n/2] = fobj->ctls->getMin(name); + { + cs_float val = *(p->extraparam[n+1]); + cs_float min = p->minextra[n/2]; + cs_float max = p->maxextra[n/2]; + if (min != max) + val = val < min ? min : (val > max ? max : val); + *(p->zonextra[n/2]) = val; + } + } + + return OK; +} + +int32_t perf_faustctl(CSOUND *csound, faustctl *p) { + cs_float val = *p->val; + if (p->min != p->max) + val = val < p->min ? p->min : (val > p->max ? p->max : val); + *p->zone = val; + + /* implementation of extra optional parameters */ + for(int n = 0; n < p->INOCOUNT - 3; n+=2) { + cs_float val = *(p->extraparam[n+1]); + cs_float min = p->minextra[n/2]; + cs_float max = p->maxextra[n/2]; + if (min != max) + val = val < min ? min : (val > max ? max : val); + *(p->zonextra[n/2]) = val; + } + return OK; +} + +#define S(x) sizeof(x) + +static OENTRY localops[] = { + {(char *)"faustgen", S(faustgen), 0, + (char *)"immmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm", (char *)"SM", + (SUBR)init_faustgen, (SUBR)perf_faust, (SUBR)delete_faustgen, NULL, 0}, + {(char *)"faustcompile", S(faustcompile), 0, (char *)"i", (char *)"SSppo", + (SUBR)init_faustcompile, NULL, NULL, NULL, 0}, + {(char *)"faustaudio", S(faustgen), 0, + (char *)"immmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm", (char *)"iM", + (SUBR)init_faustaudio, (SUBR)perf_faust, (SUBR)delete_faustgen, NULL, 0}, + {(char *)"faustdsp", S(faustdsp), 0, + (char *)"i", (char *)"i", + (SUBR)init_faustdsp, NULL, (SUBR)delete_faustdsp, NULL, 0}, + {(char *)"faustplay", S(faustplay), 0, + (char *)"mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm", (char *)"iM", + (SUBR)init_faustplay, (SUBR)perf_faustplay, NULL, NULL, 0}, + {(char *)"faustctl.i", S(faustgen), 0, (char *)"", (char *)"iSiN", + (SUBR)init_faustctl, NULL, NULL, NULL, 0}, + {(char *)"faustctl.k ", S(faustgen), 0, (char *)"", (char *)"iSkN", + (SUBR)init_faustctl, (SUBR)perf_faustctl, NULL, NULL, 0}, + {NULL, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, 0}}; + +PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { + (void)csound; + return 0; +} + +PUBLIC int32_t csoundModuleInit(CSOUND *csound) { + int32_t err = 0; + OENTRY *ep = (OENTRY *)&(localops[0]); + setup_faust_path(csound); + while (ep->opname != NULL) { + err |= csound->AppendOpcode(csound, + ep->opname, ep->dsblksiz, ep->flags, + ep->outypes, ep->intypes, + (int32_t (*)(CSOUND *, void *))ep->init, + (int32_t (*)(CSOUND *, void *))ep->perf, + (int32_t (*)(CSOUND *, void *))ep->deinit); + ep++; + } + return err; +} + +PUBLIC int32_t csoundModuleDestroy(CSOUND *csound) { + (void)csound; + return 0; +} + +PUBLIC int32_t csoundModuleInfo(void) { + return CSOUND_MODULE_INFO; +} From 97a6a187c38325741373ce8685ed54ba1b00e5c8 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Wed, 14 Oct 2026 10:54:28 +0100 Subject: [PATCH 57/72] Address review findings in Faust opcodes for Csound 7 - faustgen: terminate control label strings with NUL instead of newline - faustcompile: pass the LLVM target as a real string argument, with overloads for the 4- and 5-argument forms; guard factory creation and the shared factory/DSP registries with a mutex - faustdsp: free the controls object on deletion - faustplay: null-check the DSP registry, validate channel counts before using the engine, do not re-initialise or delete the borrowed engine, and clear all outputs on the early-exit path - faustaudio/faustgen: validate channel counts before registering the DSP instance, and fix the instance counter increment - faustcompile: fix a crash at teardown caused by the reset callback and the asynchronous compilation thread referring to per-note opcode memory; keep their state in a persistent heap object and snapshot the code, args and target before spawning the thread --- 7.x/src/faustcsound/faustgen.cpp | 317 +++++++++++++++++++------------ 1 file changed, 192 insertions(+), 125 deletions(-) diff --git a/7.x/src/faustcsound/faustgen.cpp b/7.x/src/faustcsound/faustgen.cpp index 7d85066..041e16d 100644 --- a/7.x/src/faustcsound/faustgen.cpp +++ b/7.x/src/faustcsound/faustgen.cpp @@ -40,6 +40,7 @@ #include "faust/gui/UI.h" #include #include +#include #ifdef _WIN32 #include #else @@ -49,6 +50,12 @@ #define MAXARG 40 +/* Faust factory creation and the shared factory/DSP registries are not + thread-safe, so all factories are created and all registry lists are + updated while holding this lock. It is shared by every opcode instance, + including the asynchronous faustcompile threads. */ +static std::mutex faust_registry_mutex; + static int dir_exists(const char *p) { #ifdef _WIN32 DWORD a = GetFileAttributesA(p); @@ -138,7 +145,7 @@ class controls : public UI { pctl->nxt = new ctl; pctl = pctl->nxt; strncpy(pctl->label, label, 63); - pctl->label[63] = '\n'; pctl->label[64] = '\0'; + pctl->label[63] = '\0'; pctl->label[64] = '\0'; pctl->zone = zone; pctl->min = min; pctl->max = max; @@ -249,15 +256,16 @@ struct faustobj { * Faust compile opcode usage: - ihandle faustcompile Scode, Sargs[,iasync, istacksize] + ihandle faustcompile Scode, Sargs[,iasync, istacksize[,Starget]] ihandle - handle to compiled code Scode - Faust program Sargs - Faust compiler args istacksize - compiler stack size in megabytes (default 1MB). NOTE: this - argument is accepted for backwards compatibility but is currently ignored, - as the Csound 7 threading API no longer supports setting the stack size. + argument is accepted for backwards compatibility but is currently ignored, + as the Csound 7 threading API no longer supports setting the stack size. iasync - async operation (1 = on, 0 = off) default to 1 + Starget - optional LLVM target string (empty selects the native target) **/ struct faustcompile { OPDS h; @@ -266,10 +274,17 @@ struct faustcompile { STRINGDAT *args; cs_float *async; cs_float *stacksize; - cs_float *extra; + STRINGDAT *target; /* optional LLVM target string */ +}; + +/* Persistent state for a compiled factory. The asynchronous compilation + thread and the reset callback must not refer to the per-note faustcompile + opcode, whose memory is released as soon as the instrument that runs + faustcompile ends. */ +struct faustcompile_state { + CSOUND *csound; llvm_dsp_factory *factory; void *thread; - void *lock; }; char **parse_cmd(CSOUND *csound, char *str, int32_t *argc) { @@ -308,105 +323,118 @@ char **parse_cmd(CSOUND *csound, char *str, int32_t *argc) { int32_t delete_faustcompile(CSOUND *csound, void *p) { - faustcompile *pp = ((faustcompile *)p); + faustcompile_state *st = ((faustcompile_state *)p); faustobj *fobj, *prv, **pfobj; - if (pp->thread) - csound->JoinThread(pp->thread); - pfobj = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); - if(pfobj != NULL) { - fobj = *pfobj; - prv = fobj; - while (fobj != NULL) { - if (fobj->obj == (void *)pp->factory) { - prv->nxt = fobj->nxt; - break; - } + if (st->thread) + csound->JoinThread(st->thread); + { + std::lock_guard guard(faust_registry_mutex); + pfobj = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); + if(pfobj != NULL) { + fobj = *pfobj; prv = fobj; - fobj = fobj->nxt; - } - if (fobj != NULL) { - if (*pfobj == fobj) - *pfobj = fobj->nxt; - deleteDSPFactory(pp->factory); - csound->Free(csound, fobj); + while (fobj != NULL) { + if (fobj->obj == (void *)st->factory) { + prv->nxt = fobj->nxt; + break; + } + prv = fobj; + fobj = fobj->nxt; + } + if (fobj != NULL) { + if (*pfobj == fobj) + *pfobj = fobj->nxt; + deleteDSPFactory(st->factory); + csound->Free(csound, fobj); + } } } - csound->DestroyMutex(pp->lock); + csound->Free(csound, st); return OK; } struct hdata { - faustcompile *p; CSOUND *csound; + char *code; + char *args; + char *target; + cs_float *hptr; + faustcompile_state *state; }; void *init_faustcompile_thread(void *pp) { - faustcompile *p = ((hdata *)pp)->p; + hdata *hd = (hdata *)pp; faustobj **pffactory, *ffactory; - CSOUND *csound = ((hdata *)pp)->csound; + CSOUND *csound = hd->csound; llvm_dsp_factory *factory; int32_t argc = 0; std::string err_msg; - char *cmd = (char *) csound->Calloc(csound, p->args->size + 9); - char *ccode = csound->Strdup(csound, p->code->data); - char *extra; - cs_float test = *p->extra; - strcpy(cmd, p->args->data); + size_t alen = hd->args ? strlen(hd->args) : 0; + char *cmd = (char *) csound->Calloc(csound, alen + 9); + const char *ccode = hd->code; + const char *target = hd->target ? hd->target : ""; + if (alen) + strcpy(cmd, hd->args); #ifdef USE_DOUBLE strcat(cmd, " -double"); #endif const char **argv = (const char **) parse_cmd(csound, cmd, &argc); const char *varname = "::factory"; - if(test) - extra = ((STRINGDAT *) p->extra)->data; - else - extra = (char *) ""; - - // Need to protect this - csound->LockMutex((void *) p->lock); - factory = createDSPFactoryFromString("faustop", (const char *) ccode, - argc, argv, extra, err_msg, 3); - csound->UnlockMutex((void *) p->lock); + { + std::lock_guard guard(faust_registry_mutex); + factory = createDSPFactoryFromString("faustop", ccode, + argc, argv, target, err_msg, 3); + hd->state->factory = factory; + } if (factory == NULL) { csound->Message(csound, Str("\nFaust compilation problem:\nline %s\n"), err_msg.c_str()); - *(p->hptr) = FL(-2.0); // error code. + if (hd->hptr) + *(hd->hptr) = FL(-2.0); // error code. csound->Free(csound, argv); csound->Free(csound, cmd); - csound->Free(csound, ccode); - csound->Free(csound, pp); + csound->Free(csound, hd->code); + csound->Free(csound, hd->args); + if (hd->target) + csound->Free(csound, hd->target); + csound->Free(csound, hd); return NULL; } - pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); - if (pffactory == NULL) { - csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); + { + std::lock_guard guard(faust_registry_mutex); pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); - ffactory = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); - ffactory->obj = factory; - ffactory->nxt = NULL; - ffactory->cnt = 0ul; - *pffactory = ffactory; - } else { - ffactory = *pffactory; - while (ffactory->nxt) { + if (pffactory == NULL) { + csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); + pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); + ffactory = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + ffactory->obj = factory; + ffactory->nxt = NULL; + ffactory->cnt = 0ul; + *pffactory = ffactory; + } else { + ffactory = *pffactory; + while (ffactory->nxt) { + ffactory = ffactory->nxt; + } + ffactory->nxt = (faustobj *) csound->Calloc(csound, sizeof(faustobj)); + ffactory->nxt->cnt = ffactory->cnt+1ul; ffactory = ffactory->nxt; + ffactory->obj = factory; } - ffactory->nxt = (faustobj *) csound->Calloc(csound, sizeof(faustobj)); - ffactory->nxt->cnt = ffactory->cnt+1ul; - ffactory = ffactory->nxt; - ffactory->obj = factory; } - p->factory = factory; - if(p->hptr) - *p->hptr = FL(ffactory->cnt); + if(hd->hptr) + *hd->hptr = FL(ffactory->cnt); csound->Free(csound, argv); csound->Free(csound, cmd); - csound->Free(csound, ccode); - csound->Free(csound, pp); + csound->Free(csound, hd->code); + csound->Free(csound, hd->args); + if (hd->target) + csound->Free(csound, hd->target); + csound->Free(csound, hd); return NULL; } @@ -417,22 +445,37 @@ static uintptr_t init_faustcompile_thread_runner(void *pp) { } int32_t init_faustcompile(CSOUND *csound, faustcompile *p) { + faustcompile_state *st = + (faustcompile_state *)csound->Malloc(csound, sizeof(faustcompile_state)); + st->csound = csound; + st->factory = NULL; + st->thread = NULL; + + /* Snapshot everything the asynchronous thread needs, so that it never + touches the per-note opcode memory (which is freed when this instrument + ends). */ hdata *data = (hdata *)csound->Malloc(csound, sizeof(hdata)); data->csound = csound; - data->p = p; + data->code = csound->Strdup(csound, p->code->data); + data->args = csound->Strdup(csound, p->args ? p->args->data : ""); + data->target = NULL; + if (p->INOCOUNT > 4 && p->target != NULL && p->target->data != NULL) + data->target = csound->Strdup(csound, p->target->data); + data->hptr = p->hptr; + data->state = st; + *p->hptr = -1.0; - p->lock = csound->Create_Mutex(0); - p->thread = NULL; if(!(int)*p->async) { /* synchronous compilation, run on the calling thread (large stack) */ init_faustcompile_thread(data); } else { - p->thread = csound->CreateThread(init_faustcompile_thread_runner, data); + st->thread = csound->CreateThread(init_faustcompile_thread_runner, data); } /* Factory cleanup is deferred to reset, so that instruments using the - compiled factory are not affected when the compiling instrument ends. */ - csound->RegisterResetCallback(csound, p, delete_faustcompile); + compiled factory are not affected when the compiling instrument ends. + The callback owns the persistent state, not the opcode. */ + csound->RegisterResetCallback(csound, st, delete_faustcompile); return OK; } @@ -465,6 +508,7 @@ int32_t delete_faustdsp(CSOUND *csound, void *p) { if (fobj != NULL) { if (*pfobj == fobj) *pfobj = fobj->nxt; + delete fobj->ctls; csound->Free(csound, fobj); delete pp->engine; } else @@ -504,13 +548,16 @@ int32_t init_faustdsp(CSOUND *csound, faustdsp *p) { fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); if (fobjp == NULL) return csound->InitError(csound, "%s", Str("no factory available\n")); - fobj = *fobjp; - while ((int32_t)fobj->cnt != factory) { - fobj = fobj->nxt; - if (fobj == NULL) - return csound->InitError(csound, Str("factory not found %d\n"), - (int32_t)factory); + fobj = NULL; + { + std::lock_guard guard(faust_registry_mutex); + fobj = *fobjp; + while (fobj != NULL && (int32_t)fobj->cnt != factory) + fobj = fobj->nxt; } + if (fobj == NULL) + return csound->InitError(csound, Str("factory not found %d\n"), + (int32_t)factory); dsp = ((llvm_dsp_factory *)fobj->obj)->createDSPInstance(); if (dsp == NULL) @@ -577,6 +624,8 @@ int32_t init_faustplay(CSOUND *csound, faustplay *p) { if (fobjp == NULL) return csound->InitError(csound, "%s", Str("no dsp instances available\n")); fobj = *fobjp; + if (fobj == NULL) + return csound->InitError(csound, "%s", Str("no dsp instances available\n")); while ((int32_t)fobj->cnt != instance) { fobj = fobj->nxt; @@ -586,14 +635,17 @@ int32_t init_faustplay(CSOUND *csound, faustplay *p) { } p->engine = (llvm_dsp *)fobj->obj; - p->engine->init((int)csound->GetEngineSr(csound)); + /* The engine is owned and initialised by the opcode that created it + (faustdsp, faustaudio or faustgen), so it is neither re-initialised nor + deleted here; doing so would reset its state and invalidate the + registry. */ if (p->engine->getNumInputs() != p->INOCOUNT - 1) { - delete p->engine; + p->engine = NULL; return csound->InitError(csound, "%s", Str("wrong number of input args\n")); } if (p->engine->getNumOutputs() != p->OUTOCOUNT) { - delete p->engine; + p->engine = NULL; return csound->InitError(csound, "%s", Str("wrong number of output args\n")); } @@ -619,7 +671,7 @@ int32_t perf_faustplay(CSOUND *csound, faustplay *p) { cs_float **out_tmp = (cs_float **)p->memout.auxp; if (UNLIKELY(early)) { - for (i = 0; i < p->OUTOCOUNT - 1; i++) + for (i = 0; i < p->OUTOCOUNT; i++) memset(p->outs[i], '\0', nsmps * sizeof(cs_float)); nsmps -= early; } @@ -746,18 +798,34 @@ int32_t init_faustaudio(CSOUND *csound, faustgen *p) { fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); if (fobjp == NULL) return csound->InitError(csound, "%s", Str("no factory available\n")); - fobj = *fobjp; - while ((int32_t)fobj->cnt != factory) { - fobj = fobj->nxt; - if (fobj == NULL) - return csound->InitError(csound, Str("factory not found %d\n"), - (int32_t)factory); + fobj = NULL; + { + std::lock_guard guard(faust_registry_mutex); + fobj = *fobjp; + while (fobj != NULL && (int32_t)fobj->cnt != factory) + fobj = fobj->nxt; } + if (fobj == NULL) + return csound->InitError(csound, Str("factory not found %d\n"), + (int32_t)factory); dsp = ((llvm_dsp_factory *)fobj->obj)->createDSPInstance(); if (dsp == NULL) return csound->InitError(csound, "%s", Str("Faust instantiation problem\n")); + /* Validate the channel counts before publishing the instance, so that an + invalid DSP is never left reachable through the ::dsp registry. */ + if (dsp->getNumInputs() != p->INOCOUNT - 1) { + delete ctls; + delete dsp; + return csound->InitError(csound, "%s", Str("wrong number of input args\n")); + } + if (dsp->getNumOutputs() != p->OUTOCOUNT - 1) { + delete ctls; + delete dsp; + return csound->InitError(csound, "%s", Str("wrong number of output args\n")); + } + dsp->buildUserInterface(ctls); pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); if (pfdsp == NULL) { @@ -794,17 +862,6 @@ int32_t init_faustaudio(CSOUND *csound, faustgen *p) { p->engine = (llvm_dsp *)fdsp->obj; p->engine->init((int)csound->GetEngineSr(csound)); - if (p->engine->getNumInputs() != p->INOCOUNT - 1) { - delete p->engine; - p->engine = NULL; - return csound->InitError(csound, "%s", Str("wrong number of input args\n")); - } - if (p->engine->getNumOutputs() != p->OUTOCOUNT - 1) { - delete p->engine; - p->engine = NULL; - return csound->InitError(csound, "%s", Str("wrong number of output args\n")); - } - /* memory for sampAccurate offsets */ if (parms->sampleAccurate) { size_t size; @@ -838,8 +895,11 @@ void *init_faustgen_thread(void *pp) { controls *ctls = new controls(); const char *varname = "::dsp"; p->engine = NULL; - p->factory = createDSPFactoryFromString( - "faustop", (const char *)p->code->data, argc, argv, "", err_msg, 3); + { + std::lock_guard guard(faust_registry_mutex); + p->factory = createDSPFactoryFromString( + "faustop", (const char *)p->code->data, argc, argv, "", err_msg, 3); + } if (p->factory == NULL) { csound->InitError(csound, Str("Faust compilation problem: %s\n"), err_msg.c_str()); @@ -857,6 +917,30 @@ void *init_faustgen_thread(void *pp) { dsp->buildUserInterface(ctls); + /* Validate the channel counts before publishing the instance, so that an + invalid DSP is never left reachable through the ::dsp registry. */ + if (dsp->getNumInputs() != p->INOCOUNT - 1) { + csound->InitError(csound, "%s", Str("wrong number of input args\n")); + delete ctls; + delete dsp; + deleteDSPFactory(p->factory); + p->factory = NULL; + csound->Free(csound, pp); + return NULL; + } + if (dsp->getNumOutputs() != p->OUTOCOUNT - 1) { + csound->InitError(csound, + Str("wrong number of output args: need %d had %d\n"), + dsp->getNumOutputs(), + p->OUTOCOUNT - 1); + delete ctls; + delete dsp; + deleteDSPFactory(p->factory); + p->factory = NULL; + csound->Free(csound, pp); + return NULL; + } + pfdsp = (faustobj **)csound->QueryGlobalVariable(csound, varname); if (pfdsp == NULL || *pfdsp == NULL) { csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); @@ -873,7 +957,7 @@ void *init_faustgen_thread(void *pp) { fdsp = fdsp->nxt; } fdsp->nxt = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); - fdsp->nxt->cnt = fdsp->cnt++; + fdsp->nxt->cnt = fdsp->cnt + 1; fdsp = fdsp->nxt; fdsp->obj = dsp; fdsp->ctls = ctls; @@ -881,27 +965,6 @@ void *init_faustgen_thread(void *pp) { p->engine = dsp; dsp->init((int)csound->GetEngineSr(csound)); - if (p->engine->getNumInputs() != p->INOCOUNT - 1) { - csound->InitError(csound, "%s", Str("wrong number of input args\n")); - delete p->engine; - deleteDSPFactory(p->factory); - p->factory = NULL; - p->engine = NULL; - csound->Free(csound, pp); - return NULL; - } - if (p->engine->getNumOutputs() != p->OUTOCOUNT - 1) { - csound->InitError(csound, - Str("wrong number of output args: need %d had %d\n"), - p->engine->getNumOutputs(), - p->OUTOCOUNT - 1); - delete p->engine; - deleteDSPFactory(p->factory); - csound->Free(csound, pp); - p->engine = NULL; - p->factory = NULL; - return NULL; - } /* memory for sampAccurate offsets */ if (parms->sampleAccurate) { @@ -1005,6 +1068,8 @@ int32_t init_faustctl(CSOUND *csound, faustctl *p) { if (fobjp == NULL) return csound->InitError(csound, "%s", Str("no dsp instances available\n")); fobj = *fobjp; + if (fobj == NULL) + return csound->InitError(csound, "%s", Str("no dsp instances available\n")); while ((int32_t)fobj->cnt != instance) { fobj = fobj->nxt; @@ -1073,7 +1138,9 @@ static OENTRY localops[] = { {(char *)"faustgen", S(faustgen), 0, (char *)"immmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm", (char *)"SM", (SUBR)init_faustgen, (SUBR)perf_faust, (SUBR)delete_faustgen, NULL, 0}, - {(char *)"faustcompile", S(faustcompile), 0, (char *)"i", (char *)"SSppo", + {(char *)"faustcompile", S(faustcompile), 0, (char *)"i", (char *)"SSpp", + (SUBR)init_faustcompile, NULL, NULL, NULL, 0}, + {(char *)"faustcompile", S(faustcompile), 0, (char *)"i", (char *)"SSppS", (SUBR)init_faustcompile, NULL, NULL, NULL, 0}, {(char *)"faustaudio", S(faustgen), 0, (char *)"immmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm", (char *)"iM", From 4e20eedb7340e312c68ca96bc8f2d449b0b2f21e Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Wed, 14 Oct 2026 11:01:31 +0100 Subject: [PATCH 58/72] Fix standard header include order in faustgen.cpp Including after csdl.h pulled in after Csound's interlocks.h had defined macros such as _CR and TR, which clash with identifiers used by in libstdc++ and the MSVC STL. Include the C++ standard headers before csdl.h. --- 7.x/src/faustcsound/faustgen.cpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/7.x/src/faustcsound/faustgen.cpp b/7.x/src/faustcsound/faustgen.cpp index 041e16d..623f9e5 100644 --- a/7.x/src/faustcsound/faustgen.cpp +++ b/7.x/src/faustcsound/faustgen.cpp @@ -32,15 +32,19 @@ (convenient for one-off Faust programs) */ +/* The C++ standard headers must be included before "csdl.h": the latter pulls + in Csound's "interlocks.h", which defines short generic macros such as + _CR and TR that clash with identifiers used inside (reached via + ) in both libstdc++ and the MSVC STL. */ +#include +#include +#include #include "csdl.h" #ifndef FAUSTFLOAT #define FAUSTFLOAT cs_float #endif #include "faust/dsp/llvm-dsp.h" #include "faust/gui/UI.h" -#include -#include -#include #ifdef _WIN32 #include #else From efbeb90324ef34e88319b8f379e8fd13b9976f4a Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Wed, 14 Oct 2026 11:13:50 +0100 Subject: [PATCH 59/72] Use a separate mutex for Faust factory compilation Serialising createDSPFactoryFromString with the registry mutex allowed a long async LLVM compile to block factory lookups on the performance thread in faustdsp/faustaudio, defeating the purpose of asynchronous compilation. Add faust_compile_mutex for factory creation and keep faust_registry_mutex for the short ::factory list operations. --- 7.x/src/faustcsound/faustgen.cpp | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/7.x/src/faustcsound/faustgen.cpp b/7.x/src/faustcsound/faustgen.cpp index 623f9e5..a3d5530 100644 --- a/7.x/src/faustcsound/faustgen.cpp +++ b/7.x/src/faustcsound/faustgen.cpp @@ -54,10 +54,15 @@ #define MAXARG 40 -/* Faust factory creation and the shared factory/DSP registries are not - thread-safe, so all factories are created and all registry lists are - updated while holding this lock. It is shared by every opcode instance, - including the asynchronous faustcompile threads. */ +/* Faust/LLVM factory creation is not thread-safe, so all calls to + createDSPFactoryFromString are serialised by this lock. It is deliberately + separate from the registry lock: a compilation can take a long time, and + holding the registry lock for its duration would stall factory lookups + (and thus the performance thread) in faustdsp/faustaudio. */ +static std::mutex faust_compile_mutex; + +/* Protects the shared ::factory and ::dsp registry lists. Held only for the + short operations that read or modify those lists. */ static std::mutex faust_registry_mutex; static int dir_exists(const char *p) { @@ -387,11 +392,11 @@ void *init_faustcompile_thread(void *pp) { const char *varname = "::factory"; { - std::lock_guard guard(faust_registry_mutex); + std::lock_guard guard(faust_compile_mutex); factory = createDSPFactoryFromString("faustop", ccode, argc, argv, target, err_msg, 3); - hd->state->factory = factory; } + hd->state->factory = factory; if (factory == NULL) { csound->Message(csound, Str("\nFaust compilation problem:\nline %s\n"), @@ -900,7 +905,7 @@ void *init_faustgen_thread(void *pp) { const char *varname = "::dsp"; p->engine = NULL; { - std::lock_guard guard(faust_registry_mutex); + std::lock_guard guard(faust_compile_mutex); p->factory = createDSPFactoryFromString( "faustop", (const char *)p->code->data, argc, argv, "", err_msg, 3); } From 4a5353b89449de1a934455ffaafcc42cf34f9ef5 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Wed, 14 Oct 2026 11:19:55 +0100 Subject: [PATCH 60/72] Resolve faustcompile handles without touching per-note memory The asynchronous compilation worker wrote the resulting handle (or error code) through p->hptr, which init_faustcompile had stored in persistent state. For a note-local destination that memory is reclaimed when the instrument ends, so a compile that outlived the note wrote to freed memory. Reserve the ::factory registry slot during init and publish the handle synchronously, while the opcode is still alive. The worker now only fills in the reserved slot (NULL = pending, (void*)-1 = failure, otherwise the factory); faustdsp/faustaudio resolve the slot and wait for it through a new resolve_factory() helper. This removes the use-after-free for local and global handles alike, and hdata no longer carries p->hptr. --- 7.x/src/faustcsound/faustgen.cpp | 219 ++++++++++++++++--------------- 1 file changed, 115 insertions(+), 104 deletions(-) diff --git a/7.x/src/faustcsound/faustgen.cpp b/7.x/src/faustcsound/faustgen.cpp index a3d5530..108951f 100644 --- a/7.x/src/faustcsound/faustgen.cpp +++ b/7.x/src/faustcsound/faustgen.cpp @@ -294,6 +294,7 @@ struct faustcompile_state { CSOUND *csound; llvm_dsp_factory *factory; void *thread; + faustobj *node; /* reserved ::factory slot, published by the worker */ }; char **parse_cmd(CSOUND *csound, char *str, int32_t *argc) { @@ -341,19 +342,21 @@ int32_t delete_faustcompile(CSOUND *csound, void *p) { pfobj = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); if(pfobj != NULL) { fobj = *pfobj; - prv = fobj; + prv = NULL; while (fobj != NULL) { - if (fobj->obj == (void *)st->factory) { - prv->nxt = fobj->nxt; + if (fobj == st->node) { + if (prv == NULL) + *pfobj = fobj->nxt; + else + prv->nxt = fobj->nxt; break; } prv = fobj; fobj = fobj->nxt; } if (fobj != NULL) { - if (*pfobj == fobj) - *pfobj = fobj->nxt; - deleteDSPFactory(st->factory); + if (st->factory != NULL) + deleteDSPFactory(st->factory); csound->Free(csound, fobj); } } @@ -367,14 +370,18 @@ struct hdata { char *code; char *args; char *target; - cs_float *hptr; faustcompile_state *state; }; +/* A factory slot is published in three states: obj == NULL while the + asynchronous compilation is still running, obj == (void *)-1 if it + failed, and otherwise obj is the llvm_dsp_factory. */ +#define FAUST_SLOT_PENDING ((void *)NULL) +#define FAUST_SLOT_FAILED ((void *)-1L) + void *init_faustcompile_thread(void *pp) { hdata *hd = (hdata *)pp; - faustobj **pffactory, *ffactory; CSOUND *csound = hd->csound; llvm_dsp_factory *factory; int32_t argc = 0; @@ -389,7 +396,6 @@ void *init_faustcompile_thread(void *pp) { strcat(cmd, " -double"); #endif const char **argv = (const char **) parse_cmd(csound, cmd, &argc); - const char *varname = "::factory"; { std::lock_guard guard(faust_compile_mutex); @@ -398,45 +404,18 @@ void *init_faustcompile_thread(void *pp) { } hd->state->factory = factory; - if (factory == NULL) { + if (factory == NULL) csound->Message(csound, Str("\nFaust compilation problem:\nline %s\n"), err_msg.c_str()); - if (hd->hptr) - *(hd->hptr) = FL(-2.0); // error code. - csound->Free(csound, argv); - csound->Free(csound, cmd); - csound->Free(csound, hd->code); - csound->Free(csound, hd->args); - if (hd->target) - csound->Free(csound, hd->target); - csound->Free(csound, hd); - return NULL; - } + /* Publish the outcome into the slot reserved during init; never touch the + per-note output pointer, which may already have been reclaimed. */ { std::lock_guard guard(faust_registry_mutex); - pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); - if (pffactory == NULL) { - csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); - pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); - ffactory = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); - ffactory->obj = factory; - ffactory->nxt = NULL; - ffactory->cnt = 0ul; - *pffactory = ffactory; - } else { - ffactory = *pffactory; - while (ffactory->nxt) { - ffactory = ffactory->nxt; - } - ffactory->nxt = (faustobj *) csound->Calloc(csound, sizeof(faustobj)); - ffactory->nxt->cnt = ffactory->cnt+1ul; - ffactory = ffactory->nxt; - ffactory->obj = factory; - } + if (hd->state->node != NULL) + hd->state->node->obj = factory ? (void *)factory : FAUST_SLOT_FAILED; } - if(hd->hptr) - *hd->hptr = FL(ffactory->cnt); + csound->Free(csound, argv); csound->Free(csound, cmd); csound->Free(csound, hd->code); @@ -453,16 +432,92 @@ static uintptr_t init_faustcompile_thread_runner(void *pp) { return 0; } +/* Append a new (pending) entry to the ::factory registry and return it. Must + be called with faust_registry_mutex held. */ +static faustobj *reserve_factory_slot(CSOUND *csound) { + faustobj **pffactory, *ffactory, *fnew; + const char *varname = "::factory"; + + pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); + if (pffactory == NULL) { + csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *)); + pffactory = (faustobj **)csound->QueryGlobalVariable(csound, varname); + } + ffactory = *pffactory; + if (ffactory == NULL) { + fnew = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fnew->obj = FAUST_SLOT_PENDING; + fnew->nxt = NULL; + fnew->cnt = 0ul; + *pffactory = fnew; + return fnew; + } + while (ffactory->nxt != NULL) + ffactory = ffactory->nxt; + fnew = (faustobj *)csound->Calloc(csound, sizeof(faustobj)); + fnew->obj = FAUST_SLOT_PENDING; + fnew->nxt = NULL; + fnew->cnt = ffactory->cnt + 1ul; + ffactory->nxt = fnew; + return fnew; +} + +/* Resolve a faustcompile handle to its registry entry, waiting for an + asynchronous compilation to publish the factory. Returns NULL (after + issuing an error) on failure. */ +static faustobj *resolve_factory(CSOUND *csound, int32_t handle) { + faustobj **fobjp, *fobj = NULL; + int timout = 0; + int failed = (handle < 0); + + if (!failed) { + fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); + if (fobjp == NULL) { + csound->InitError(csound, "%s", Str("no factory available\n")); + return NULL; + } + for (;;) { + { + std::lock_guard guard(faust_registry_mutex); + fobj = *fobjp; + while (fobj != NULL && (int32_t)fobj->cnt != handle) + fobj = fobj->nxt; + if (fobj == NULL || fobj->obj != FAUST_SLOT_PENDING) + break; + } + csound->Sleep(1); + if (++timout > 1000) { + csound->InitError(csound, "%s", Str("Faust code was not ready. Try compiling it \n" + "in a separate instrument prior to running it here\n")); + return NULL; + } + } + if (fobj == NULL) { + csound->InitError(csound, Str("factory not found %d\n"), handle); + return NULL; + } + failed = (fobj->obj == FAUST_SLOT_FAILED); + } + if (failed) { + csound->InitError(csound, "%s", Str("Faust code did not compile properly.\n" + "Check above messages for Faust compiler errors\n")); + return NULL; + } + return fobj; +} + int32_t init_faustcompile(CSOUND *csound, faustcompile *p) { faustcompile_state *st = (faustcompile_state *)csound->Malloc(csound, sizeof(faustcompile_state)); st->csound = csound; st->factory = NULL; st->thread = NULL; + st->node = NULL; /* Snapshot everything the asynchronous thread needs, so that it never touches the per-note opcode memory (which is freed when this instrument - ends). */ + ends). The thread publishes its result into st->node, never into the + output pointer. */ hdata *data = (hdata *)csound->Malloc(csound, sizeof(hdata)); data->csound = csound; data->code = csound->Strdup(csound, p->code->data); @@ -470,14 +525,23 @@ int32_t init_faustcompile(CSOUND *csound, faustcompile *p) { data->target = NULL; if (p->INOCOUNT > 4 && p->target != NULL && p->target->data != NULL) data->target = csound->Strdup(csound, p->target->data); - data->hptr = p->hptr; data->state = st; - *p->hptr = -1.0; + /* Reserve the registry slot and publish the handle while the opcode is + still alive, so that no write to per-note memory happens after the + instrument ends. */ + { + std::lock_guard guard(faust_registry_mutex); + st->node = reserve_factory_slot(csound); + } + *p->hptr = FL(st->node->cnt); if(!(int)*p->async) { /* synchronous compilation, run on the calling thread (large stack) */ init_faustcompile_thread(data); + /* Preserve the historical output convention for synchronous failure. */ + if (st->node->obj == FAUST_SLOT_FAILED) + *p->hptr = -2.0; } else { st->thread = csound->CreateThread(init_faustcompile_thread_runner, data); } @@ -532,41 +596,15 @@ int32_t delete_faustdsp(CSOUND *csound, void *p) { int32_t init_faustdsp(CSOUND *csound, faustdsp *p) { int32_t factory; - faustobj *fobj, **fobjp, **pfdsp, *fdsp; + faustobj *fobj, **pfdsp, *fdsp; llvm_dsp *dsp; controls *ctls = new controls(); const char *varname = "::dsp"; - int timout = 0; - while (*((cs_float *)p->code) == -1.0) { - csound->Sleep(1); - timout++; - if(timout > 1000) { - return csound->InitError( - csound, "%s", Str("Faust code was not ready. Try compiling it \n" - "in a separate instrument prior to running it here\n")); - } - } factory = (int32_t)*((cs_float *)p->code); - - if (factory == -2) - return csound->InitError( - csound, "%s", Str("Faust code did not compile properly.\n" - "Check above messages for Faust compiler errors\n")); - - fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); - if (fobjp == NULL) - return csound->InitError(csound, "%s", Str("no factory available\n")); - fobj = NULL; - { - std::lock_guard guard(faust_registry_mutex); - fobj = *fobjp; - while (fobj != NULL && (int32_t)fobj->cnt != factory) - fobj = fobj->nxt; - } + fobj = resolve_factory(csound, factory); if (fobj == NULL) - return csound->InitError(csound, Str("factory not found %d\n"), - (int32_t)factory); + return CSOUND_ERROR; dsp = ((llvm_dsp_factory *)fobj->obj)->createDSPInstance(); if (dsp == NULL) @@ -781,42 +819,15 @@ int32_t delete_faustgen(CSOUND *csound, void *p) { int32_t init_faustaudio(CSOUND *csound, faustgen *p) { int32_t factory; const OPARMS *parms = csound->GetOParms(csound); - faustobj *fobj, **fobjp, **pfdsp, *fdsp; + faustobj *fobj, **pfdsp, *fdsp; llvm_dsp *dsp; controls *ctls = new controls(); const char *varname = "::dsp"; - int timout = 0; - while (*((cs_float *)p->code) == -1.0) { - csound->Sleep(1); - timout++; - if(timout > 1000) { - return csound->InitError( - csound, "%s", Str("Faust code was not ready. Try compiling it \n" - "in a separate instrument prior to running it here\n")); - } - } - factory = (int32_t)*((cs_float *)p->code); - - if (factory == -2) - return csound->InitError( - csound, "%s", Str("Faust code did not compile properly.\n" - "Check above messages for Faust compiler errors\n")); - - fobjp = (faustobj **)csound->QueryGlobalVariable(csound, "::factory"); - if (fobjp == NULL) - return csound->InitError(csound, "%s", Str("no factory available\n")); - fobj = NULL; - { - std::lock_guard guard(faust_registry_mutex); - fobj = *fobjp; - while (fobj != NULL && (int32_t)fobj->cnt != factory) - fobj = fobj->nxt; - } + fobj = resolve_factory(csound, factory); if (fobj == NULL) - return csound->InitError(csound, Str("factory not found %d\n"), - (int32_t)factory); + return CSOUND_ERROR; dsp = ((llvm_dsp_factory *)fobj->obj)->createDSPInstance(); if (dsp == NULL) From 3d8b12b38e205ec0d74e3340808bcac0708b0013 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Wed, 14 Oct 2026 11:28:02 +0100 Subject: [PATCH 61/72] Document the Faust opcodes in the 7.x README Add faustgen/faustcompile/faustaudio/faustdsp/faustplay/faustctl to the plugin list, document their call syntax and arguments, the libfaust requirements and CMake hints, the FAUST_STATIC option and the BUILD_FAUST_OPCODES build switch, mirroring the other ported plugins. --- 7.x/README.md | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 59 insertions(+), 1 deletion(-) diff --git a/7.x/README.md b/7.x/README.md index f6691d4..d81e287 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -9,6 +9,9 @@ Currently, the plugins available in this tree are - fluidOpcodes (requires fluidsynth) **fluidEngine fluidLoad fluidNote fluidCCi fluidCCk fluidControl fluidProgramSelect fluidAllOut fluidOut fluidInfo fluidSetInterpMethod** +- faust (requires the Faust compiler library and headers, `libfaust`) +**faustgen faustcompile faustaudio faustdsp faustplay faustctl** + - image (requires libpng) **imageload imagesave imagecreate imagesize imagegetpixel imagesetpixel imagefree** @@ -154,6 +157,61 @@ if set, overrides the built-in default location; otherwise the installed Windows release packages. +Faust opcodes +--- + +The `faust` opcodes embed the [Faust](https://faust.grame.fr/) compiler and +DSP runtime into Csound, so a Faust program supplied as a string is compiled +at init time and run as a Csound opcode. They are a port of the Csound 6.x +plugin to the Csound 7 plugin API: + +``` +ihandle[,asig1,...] faustgen Scode[,ain1,...] +ihandle faustcompile Scode, Sargs[, iasync, istacksize[, Starget]] +ihandle[,asig1,...] faustaudio ifactory[,ain1,...] +ihandle faustdsp ifactory +asig1[,asig2,...] faustplay ihandle[,ain1,...] + faustctl ihandle, Slabel, kval[, Slabel1, kval1, ...] +``` + +Where: + +- `faustgen` compiles `Scode` and runs it in a single opcode, returning a + handle and the audio outputs. +- `faustcompile` compiles `Scode` and returns `ihandle`, a handle to the + compiled factory, to be passed to `faustaudio` or `faustdsp`. +- `faustaudio`/`faustdsp` instantiate the factory named by `ifactory`; + `faustaudio` has audio inputs and outputs, `faustdsp` has none. +- `faustplay` runs the DSP instance named by `ihandle` (one returned by + `faustgen`, `faustaudio` or `faustdsp`) with explicit inputs and outputs. +- `faustctl` sets the control `Slabel` of a DSP instance; both an i-rate + (`iSi`) and a k-rate (`iSk`) form are provided, the latter updating the + control every k-cycle. + +`Scode` is the Faust program (programs that use the standard library need +`import("stdfaust.lib");`). `Sargs` holds any extra Faust compiler options; +`iasync` selects asynchronous compilation (on by default), `istacksize` is +accepted for backwards compatibility but ignored (the Csound 7 threading API +no longer sets the thread stack size) and `Starget` is an optional LLVM +target string (an empty string selects the native target). + +The opcodes need the Faust compiler library (`libfaust`) and headers. The +build looks for them automatically; if Faust is in a non-standard location, +point CMake at it with `FAUST_INCLUDE_DIR_HINT`, `FAUST_LIB_DIR_HINT` and +`FAUST_STDLIB_DIR_HINT`. With `-DFAUST_STATIC=ON` the plugin is linked +against the self-contained `libfaustwithllvm` archive, which bundles LLVM so +the plugin has no runtime dependency on `libfaust` (at the cost of a much +larger plugin). + +It is built by default; configure with `-DBUILD_FAUST_OPCODES=OFF` to +exclude it. The Faust standard library is installed next to the plugin (in a +`faust` subdirectory), so `import("stdfaust.lib")` works without a separate +Faust installation; set `FAUST_LIB_PATH` at run time to override it. The CI +downloads the official Faust release binaries, builds with `FAUST_STATIC=ON` +and includes the plugin (and the standard library) in the Linux, macOS and +Windows release packages. + + Release binaries and macOS architecture -------------- @@ -211,7 +269,7 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_CUDA_OPCODES`, -`BUILD_OPENCL_OPCODES`, `BUILD_FLUID_OPCODES`, +`BUILD_OPENCL_OPCODES`, `BUILD_FAUST_OPCODES`, `BUILD_FLUID_OPCODES`, `BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, `BUILD_P5GLOVE_OPCODES`, `BUILD_STK_OPCODES`, `BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and From ce0529ae90ce2feadc37fea638a474483dda6fb7 Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Wed, 14 Oct 2026 11:38:36 +0100 Subject: [PATCH 62/72] Document the WASM plugins in the 7.x README --- 7.x/README.md | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/7.x/README.md b/7.x/README.md index d81e287..cf9ef7d 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -43,6 +43,55 @@ Currently, the plugins available in this tree are **STKBandedWG STKBeeThree STKBlowBotl STKBlowHole STKBowed STKBrass STKClarinet STKDrummer STKFlute STKFMVoices STKHevyMetl STKMandolin STKModalBar STKMoog STKPercFlut STKPlucked STKResonate STKRhodey STKSaxofony STKShakers STKSimple STKSitar STKStifKarp STKTubeBell STKVoicForm STKWhistle STKWurley** +WebAssembly (WASM) plugins +--- + +Besides the native plugin libraries described above, this tree can also be +built for the browser: Csound 7 runs under WebAssembly (WASI) through the +`@csound/browser` runtime, and a subset of these plugins is available as WASM +side modules. The WASM build is driven by the Nix expression in +[`wasm/default.nix`](../wasm/default.nix) and published as the `@csound/plugins` +npm package; see [`wasm/README.md`](../wasm/README.md) for the build and test +instructions. + +Only four plugins are built for WASM: + +- chua (`chuap`) +- image +- linear_algebra +- STK (`stkops`) + +The remaining plugins are **disabled** in the WASM build, either because their +dependencies do not exist in the WASI/static-PIC toolchain or because they need +platform facilities the browser does not provide: fluidOpcodes (FluidSynth), +hdf5, faust (libfaust), websockets, py (Python), wiimote, p5glove, CUDA and +OpenCL. + +The `@csound/plugins` package exposes one asset URL per WASM plugin: + +| Export | Plugin | File | +| --- | --- | --- | +| `plugins.chua` | chua | `chua.wasm` | +| `plugins.image` | image | `image.wasm` | +| `plugins.linearAlgebra` | linear_algebra | `linear_algebra.wasm` | +| `plugins.stk` | STK | `stkops.wasm` | + +The URLs are passed to the runtime's `withPlugins` option, e.g.: + +```js +import { Csound } from "@csound/browser"; +import { plugins } from "@csound/plugins"; + +const csound = await Csound({ withPlugins: [plugins.chua, plugins.image] }); +``` + +Unlike the native build, the WASM STK plugin embeds its raw-wave samples in +`stkops.wasm` (`STK_EMBED_RAWWAVES` defaults to ON for WASM): at initialization +it writes them to Csound's virtual filesystem and sets the wave path, so no +separate download or `RAWWAVE_PATH` setup is needed. An explicit `RAWWAVE_PATH` +still overrides the embedded samples. + + Fluid settings opcodes --- From 8acfc7005b019f5ca709813c0935b1d3e27a451e Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Thu, 15 Oct 2026 08:04:07 +0100 Subject: [PATCH 63/72] Use cs_float instead of MYFLT in the py opcodes MYFLT is no longer a public Csound 7 type. Update the python opcode sources and the pycall/pyx generators and generated headers to use cs_float, so the py plugin builds against the Csound 7 SDK. --- 7.x/src/py/src/pycall-gen.py | 12 +- 7.x/src/py/src/pycall.auto.h | 274 ++++++++++++++++----------------- 7.x/src/py/src/pythonopcodes.c | 4 +- 7.x/src/py/src/pythonopcodes.h | 4 +- 7.x/src/py/src/pyx-gen.py | 8 +- 7.x/src/py/src/pyx.auto.h | 18 +-- 6 files changed, 160 insertions(+), 160 deletions(-) diff --git a/7.x/src/py/src/pycall-gen.py b/7.x/src/py/src/pycall-gen.py index 2246c5d..c7d983c 100644 --- a/7.x/src/py/src/pycall-gen.py +++ b/7.x/src/py/src/pycall-gen.py @@ -164,20 +164,20 @@ def generate_pycall_opcode_struct(f, n, triggered=0): s = 'typedef struct {\n' s += ' OPDS h;\n' if n == 1: - s += ' MYFLT *result;\n' + s += ' cs_float *result;\n' else: for i in range(n): - s += ' MYFLT *result%d;\n' % (i+1) + s += ' cs_float *result%d;\n' % (i+1) if triggered: - s += ' MYFLT *trigger;\n' + s += ' cs_float *trigger;\n' s += ' STRINGDAT *function;\n' - s += ' MYFLT *args[VARGMAX-3];\n' + s += ' cs_float *args[VARGMAX-3];\n' if triggered: if n == 1: - s += ' MYFLT oresult\n;' + s += ' cs_float oresult\n;' else: for i in range(n): - s += ' MYFLT oresult%d;\n' % (i+1) + s += ' cs_float oresult%d;\n' % (i+1) s += '} PYCALL%d%s;\n' % (n, T) print(s, file=f) diff --git a/7.x/src/py/src/pycall.auto.h b/7.x/src/py/src/pycall.auto.h index 81935c6..6127ad0 100644 --- a/7.x/src/py/src/pycall.auto.h +++ b/7.x/src/py/src/pycall.auto.h @@ -23,225 +23,225 @@ typedef struct { OPDS h; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL0; typedef struct { OPDS h; - MYFLT *trigger; + cs_float *trigger; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL0T; typedef struct { OPDS h; - MYFLT *result; + cs_float *result; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL1; typedef struct { OPDS h; - MYFLT *result; - MYFLT *trigger; + cs_float *result; + cs_float *trigger; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult + cs_float *args[VARGMAX-3]; + cs_float oresult ;} PYCALL1T; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; + cs_float *result1; + cs_float *result2; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL2; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *trigger; + cs_float *result1; + cs_float *result2; + cs_float *trigger; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult1; - MYFLT oresult2; + cs_float *args[VARGMAX-3]; + cs_float oresult1; + cs_float oresult2; } PYCALL2T; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; + cs_float *result1; + cs_float *result2; + cs_float *result3; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL3; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *trigger; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *trigger; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult1; - MYFLT oresult2; - MYFLT oresult3; + cs_float *args[VARGMAX-3]; + cs_float oresult1; + cs_float oresult2; + cs_float oresult3; } PYCALL3T; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL4; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *trigger; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *trigger; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult1; - MYFLT oresult2; - MYFLT oresult3; - MYFLT oresult4; + cs_float *args[VARGMAX-3]; + cs_float oresult1; + cs_float oresult2; + cs_float oresult3; + cs_float oresult4; } PYCALL4T; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL5; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; - MYFLT *trigger; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; + cs_float *trigger; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult1; - MYFLT oresult2; - MYFLT oresult3; - MYFLT oresult4; - MYFLT oresult5; + cs_float *args[VARGMAX-3]; + cs_float oresult1; + cs_float oresult2; + cs_float oresult3; + cs_float oresult4; + cs_float oresult5; } PYCALL5T; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; - MYFLT *result6; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; + cs_float *result6; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL6; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; - MYFLT *result6; - MYFLT *trigger; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; + cs_float *result6; + cs_float *trigger; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult1; - MYFLT oresult2; - MYFLT oresult3; - MYFLT oresult4; - MYFLT oresult5; - MYFLT oresult6; + cs_float *args[VARGMAX-3]; + cs_float oresult1; + cs_float oresult2; + cs_float oresult3; + cs_float oresult4; + cs_float oresult5; + cs_float oresult6; } PYCALL6T; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; - MYFLT *result6; - MYFLT *result7; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; + cs_float *result6; + cs_float *result7; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL7; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; - MYFLT *result6; - MYFLT *result7; - MYFLT *trigger; - STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult1; - MYFLT oresult2; - MYFLT oresult3; - MYFLT oresult4; - MYFLT oresult5; - MYFLT oresult6; - MYFLT oresult7; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; + cs_float *result6; + cs_float *result7; + cs_float *trigger; + STRINGDAT *function; + cs_float *args[VARGMAX-3]; + cs_float oresult1; + cs_float oresult2; + cs_float oresult3; + cs_float oresult4; + cs_float oresult5; + cs_float oresult6; + cs_float oresult7; } PYCALL7T; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; - MYFLT *result6; - MYFLT *result7; - MYFLT *result8; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; + cs_float *result6; + cs_float *result7; + cs_float *result8; STRINGDAT *function; - MYFLT *args[VARGMAX-3]; + cs_float *args[VARGMAX-3]; } PYCALL8; typedef struct { OPDS h; - MYFLT *result1; - MYFLT *result2; - MYFLT *result3; - MYFLT *result4; - MYFLT *result5; - MYFLT *result6; - MYFLT *result7; - MYFLT *result8; - MYFLT *trigger; - STRINGDAT *function; - MYFLT *args[VARGMAX-3]; - MYFLT oresult1; - MYFLT oresult2; - MYFLT oresult3; - MYFLT oresult4; - MYFLT oresult5; - MYFLT oresult6; - MYFLT oresult7; - MYFLT oresult8; + cs_float *result1; + cs_float *result2; + cs_float *result3; + cs_float *result4; + cs_float *result5; + cs_float *result6; + cs_float *result7; + cs_float *result8; + cs_float *trigger; + STRINGDAT *function; + cs_float *args[VARGMAX-3]; + cs_float oresult1; + cs_float oresult2; + cs_float oresult3; + cs_float oresult4; + cs_float oresult5; + cs_float oresult6; + cs_float oresult7; + cs_float oresult8; } PYCALL8T; diff --git a/7.x/src/py/src/pythonopcodes.c b/7.x/src/py/src/pythonopcodes.c index 71689c0..b4cc4fe 100644 --- a/7.x/src/py/src/pythonopcodes.c +++ b/7.x/src/py/src/pythonopcodes.c @@ -55,7 +55,7 @@ static CS_NOINLINE void create_private_namespace_if_needed(OPDS *o) } static void format_call_statement2(char *statement, char *callable, - int argc, MYFLT *argv[], long skip) + int argc, cs_float *argv[], long skip) { int i; @@ -77,7 +77,7 @@ static void format_call_statement2(char *statement, char *callable, } static void format_call_statement(char *statement, char *callable, - int argc, MYFLT *argv[], int skip) + int argc, cs_float *argv[], int skip) { int i; diff --git a/7.x/src/py/src/pythonopcodes.h b/7.x/src/py/src/pythonopcodes.h index 82d7d21..84d17c1 100644 --- a/7.x/src/py/src/pythonopcodes.h +++ b/7.x/src/py/src/pythonopcodes.h @@ -39,8 +39,8 @@ typedef struct { typedef struct { OPDS h; STRINGDAT *function; - MYFLT *nresult; - MYFLT *args[VARGMAX]; + cs_float *nresult; + cs_float *args[VARGMAX]; } PYCALLN; #endif /* _pycsound_pythonopcodes_h_ */ diff --git a/7.x/src/py/src/pyx-gen.py b/7.x/src/py/src/pyx-gen.py index d1e54ce..bbccee8 100644 --- a/7.x/src/py/src/pyx-gen.py +++ b/7.x/src/py/src/pyx-gen.py @@ -154,14 +154,14 @@ def generate_pycall_opcode_struct(f, action, triggered): s = 'typedef struct {\n' s += ' OPDS h;\n' if action == 'eval': - s += ' MYFLT *result;\n' + s += ' cs_float *result;\n' if triggered: - s += ' MYFLT *trigger;\n' + s += ' cs_float *trigger;\n' s += ' STRINGDAT *string;\n' if action == 'assign': - s += ' MYFLT *value;\n' + s += ' cs_float *value;\n' if action == 'eval' and triggered: - s += ' MYFLT oresult;\n' + s += ' cs_float oresult;\n' s += '} PY%(ACTION)s%(T)s;\n' % locals() print(s, file=f) diff --git a/7.x/src/py/src/pyx.auto.h b/7.x/src/py/src/pyx.auto.h index 4744dcf..21703ef 100644 --- a/7.x/src/py/src/pyx.auto.h +++ b/7.x/src/py/src/pyx.auto.h @@ -27,7 +27,7 @@ typedef struct { typedef struct { OPDS h; - MYFLT *trigger; + cs_float *trigger; STRINGDAT *string; } PYEXECT; @@ -38,34 +38,34 @@ typedef struct { typedef struct { OPDS h; - MYFLT *trigger; + cs_float *trigger; STRINGDAT *string; } PYRUNT; typedef struct { OPDS h; - MYFLT *result; + cs_float *result; STRINGDAT *string; } PYEVAL; typedef struct { OPDS h; - MYFLT *result; - MYFLT *trigger; + cs_float *result; + cs_float *trigger; STRINGDAT *string; - MYFLT oresult; + cs_float oresult; } PYEVALT; typedef struct { OPDS h; STRINGDAT *string; - MYFLT *value; + cs_float *value; } PYASSIGN; typedef struct { OPDS h; - MYFLT *trigger; + cs_float *trigger; STRINGDAT *string; - MYFLT *value; + cs_float *value; } PYASSIGNT; From ef03c92d0d9b81f0c707a393a027c7c732ee2bac Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Thu, 15 Oct 2026 08:04:17 +0100 Subject: [PATCH 64/72] Add DSSI/LADSPA opcodes for Csound 7 Migrate the dssi4cs opcodes (dssiinit, dssiactivate, dssiaudio, dssisynth, dssictls, dssiget, dssinote, dssievent, dssinrpn, dssiprogram, dssiconfigure, dssiprograminfo, dssiinfo, dssilist) from the Csound 7 core (Opcodes/dssi4cs) into the plugins tree. - Use the plugin LINKAGE macro for the opcode table. - Add a CMake build (BUILD_DSSI_OPCODES): Linux-only, needs the system ALSA headers, silently disabled elsewhere or when they are missing. - Vendor the DSSI 1.1.1 and LADSPA 1.17 API headers under include/, with their licenses, provenance and update scripts. - Register the plugin, document it in the 7.x README, exclude the vendored headers from CodeRabbit review, and stage the plugin in the Linux CI job. --- .coderabbit.yaml | 2 + .github/workflows/plugins_build_7.yml | 2 + 7.x/CMakeLists.txt | 1 + 7.x/README.md | 51 +- 7.x/src/dssi4cs/CMakeLists.txt | 25 + 7.x/src/dssi4cs/README.md | 193 +++++ 7.x/src/dssi4cs/dssi4cs.c | 820 +++++++++++++++++++++ 7.x/src/dssi4cs/dssi4cs.h | 138 ++++ 7.x/src/dssi4cs/include/dssi/LICENSE | 509 +++++++++++++ 7.x/src/dssi4cs/include/dssi/README.md | 18 + 7.x/src/dssi4cs/include/dssi/SOURCE.json | 9 + 7.x/src/dssi4cs/include/dssi/dssi.h | 426 +++++++++++ 7.x/src/dssi4cs/include/dssi/update.py | 87 +++ 7.x/src/dssi4cs/include/ladspa/LICENSE | 514 +++++++++++++ 7.x/src/dssi4cs/include/ladspa/README.md | 18 + 7.x/src/dssi4cs/include/ladspa/SOURCE.json | 9 + 7.x/src/dssi4cs/include/ladspa/ladspa.h | 603 +++++++++++++++ 7.x/src/dssi4cs/include/ladspa/update.py | 87 +++ 7.x/src/dssi4cs/load.c | 49 ++ 7.x/src/dssi4cs/utils.h | 7 + 20 files changed, 3564 insertions(+), 4 deletions(-) create mode 100644 7.x/src/dssi4cs/CMakeLists.txt create mode 100644 7.x/src/dssi4cs/README.md create mode 100644 7.x/src/dssi4cs/dssi4cs.c create mode 100644 7.x/src/dssi4cs/dssi4cs.h create mode 100644 7.x/src/dssi4cs/include/dssi/LICENSE create mode 100644 7.x/src/dssi4cs/include/dssi/README.md create mode 100644 7.x/src/dssi4cs/include/dssi/SOURCE.json create mode 100644 7.x/src/dssi4cs/include/dssi/dssi.h create mode 100755 7.x/src/dssi4cs/include/dssi/update.py create mode 100644 7.x/src/dssi4cs/include/ladspa/LICENSE create mode 100644 7.x/src/dssi4cs/include/ladspa/README.md create mode 100644 7.x/src/dssi4cs/include/ladspa/SOURCE.json create mode 100644 7.x/src/dssi4cs/include/ladspa/ladspa.h create mode 100755 7.x/src/dssi4cs/include/ladspa/update.py create mode 100644 7.x/src/dssi4cs/load.c create mode 100644 7.x/src/dssi4cs/utils.h diff --git a/.coderabbit.yaml b/.coderabbit.yaml index dbc8cc7..c14d3bf 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -3,3 +3,5 @@ reviews: - "!7.x/src/stk/src/**" - "!7.x/src/stk/include/**" - "!7.x/src/stk/rawwaves/**" + - "!7.x/src/dssi4cs/include/dssi/**" + - "!7.x/src/dssi4cs/include/ladspa/**" diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 2379153..64b8eaf 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -142,6 +142,7 @@ jobs: cp build/src/chua/*.so \ build/src/linear_algebra/*.so \ build/src/fluidOpcodes/*.so \ + build/src/dssi4cs/*.so \ build/src/image/*.so \ build/src/websockets/*.so \ build/src/hdf5/*.so \ @@ -481,6 +482,7 @@ jobs: cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ -DBUILD_CUDA_OPCODES=ON \ -DBUILD_CHUA_OPCODES=OFF \ + -DBUILD_DSSI_OPCODES=OFF \ -DBUILD_FLUID_OPCODES=OFF \ -DBUILD_HDF5_OPCODES=OFF \ -DBUILD_IMAGE_OPCODES=OFF \ diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 90dda4c..35fa501 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -321,6 +321,7 @@ endif() add_subdirectory(./src/chua) add_subdirectory(./src/linear_algebra) add_subdirectory(./src/fluidOpcodes) +add_subdirectory(./src/dssi4cs) add_subdirectory(./src/image) add_subdirectory(./src/websockets) add_subdirectory(./src/hdf5) diff --git a/7.x/README.md b/7.x/README.md index cf9ef7d..d558c38 100644 --- a/7.x/README.md +++ b/7.x/README.md @@ -9,6 +9,9 @@ Currently, the plugins available in this tree are - fluidOpcodes (requires fluidsynth) **fluidEngine fluidLoad fluidNote fluidCCi fluidCCk fluidControl fluidProgramSelect fluidAllOut fluidOut fluidInfo fluidSetInterpMethod** +- dssi4cs (hosts native DSSI/LADSPA plugins; Linux only, requires the ALSA headers) +**dssiinit dssiactivate dssiaudio dssisynth dssictls dssiget dssinote dssievent dssinrpn dssiprogram dssiconfigure dssiprograminfo dssiinfo dssilist** + - faust (requires the Faust compiler library and headers, `libfaust`) **faustgen faustcompile faustaudio faustdsp faustplay faustctl** @@ -261,6 +264,46 @@ and includes the plugin (and the standard library) in the Linux, macOS and Windows release packages. +DSSI and LADSPA opcodes +--- + +The `dssi4cs` plugin hosts native DSSI synths and LADSPA effects: + +``` +ih dssiinit Sfilename, iindex [, iverbose] + dssilist + dssiinfo ih + dssiactivate ih, kactive +a1[,a2,...] dssisynth ih [, ain1, ...] +a1[,a2,...] dssiaudio ih [, ain1, ...] + dssinote ktrigger, ih, knote, kvelocity, kduration [, ichannel] + dssievent ktrigger, ih, knote, kvelocity + dssievent ktrigger, ih, kstatus, kchannel, kdata1, kdata2 [, koffset] + dssinrpn ktrigger, ih, kchannel, kparameter, kvalue [, koffset] + dssictls ih, iport, kvalue, ktrigger +kvalue dssiget ih, iport + dssiprogram ih, kbank, kprogram, ktrigger +Sname, ibank, iprogram dssiprograminfo ih, iindex + dssiconfigure ih, Skey, Svalue +``` + +The opcodes load a plugin library, instantiate a DSSI synth or LADSPA effect, +feed it Csound audio and MIDI events, and return its audio. Libraries are +looked up by path or through `DSSI_PATH` and `LADSPA_PATH`. See the +[module README](src/dssi4cs/README.md) for the full opcode reference. + +Hosting native plugins is Linux-only: the opcodes load the shared objects with +`dlopen` and use the ALSA sequencer event types, so they need the ALSA headers +(`libasound2-dev` on Debian/Ubuntu) but not the ALSA library or a running +sequencer. The DSSI and LADSPA API headers are **vendored under this +directory** (in `src/dssi4cs/include`), so no system DSSI/LADSPA development +package is required. + +It is built by default on Linux when the ALSA headers are found and silently +disabled elsewhere; configure with `-DBUILD_DSSI_OPCODES=OFF` to exclude it. +It is included in the Linux release package only. + + Release binaries and macOS architecture -------------- @@ -318,10 +361,10 @@ $ make By default, all the plugins are built. If one wants to exclude a plugin from the build process, one can pass an option to the cmake command. The options are `BUILD_CHUA_OPCODES`, `BUILD_CUDA_OPCODES`, -`BUILD_OPENCL_OPCODES`, `BUILD_FAUST_OPCODES`, `BUILD_FLUID_OPCODES`, -`BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, `BUILD_LINEAR_ALGEBRA_OPCODES`, -`BUILD_P5GLOVE_OPCODES`, `BUILD_STK_OPCODES`, `BUILD_WIIMOTE_OPCODES`, -`BUILD_WEBSOCKET_OPCODE` and +`BUILD_DSSI_OPCODES`, `BUILD_OPENCL_OPCODES`, `BUILD_FAUST_OPCODES`, +`BUILD_FLUID_OPCODES`, `BUILD_IMAGE_OPCODES`, `BUILD_HDF5_OPCODES`, +`BUILD_LINEAR_ALGEBRA_OPCODES`, `BUILD_P5GLOVE_OPCODES`, `BUILD_STK_OPCODES`, +`BUILD_WIIMOTE_OPCODES`, `BUILD_WEBSOCKET_OPCODE` and `BUILD_PYTHON_OPCODES`. For example, to exclude the chua plugin, the `cmake` command would be: diff --git a/7.x/src/dssi4cs/CMakeLists.txt b/7.x/src/dssi4cs/CMakeLists.txt new file mode 100644 index 0000000..a9a61a1 --- /dev/null +++ b/7.x/src/dssi4cs/CMakeLists.txt @@ -0,0 +1,25 @@ +# Build the DSSI/LADSPA hosting opcodes. +# +# Hosting native DSSI synths and LADSPA effects is Linux-only: the opcodes load +# plugin libraries with dlopen and exchange ALSA sequencer events, so they need +# the system ALSA headers (no ALSA library, and no running sequencer, is +# required). The DSSI and LADSPA API headers are vendored under ./include. +# +# The plugin is built by default and silently disabled where the platform is +# not Linux or the ALSA headers are missing. +option(BUILD_DSSI_OPCODES "Build the DSSI/LADSPA opcodes" ON) + +find_path(DSSI_ALSA_ASOUNDLIB_H alsa/asoundlib.h /usr/local/include /usr/include) +find_path(DSSI_ALSA_SEQ_EVENT_H alsa/seq_event.h /usr/local/include /usr/include) + +check_deps(BUILD_DSSI_OPCODES LINUX DSSI_ALSA_ASOUNDLIB_H DSSI_ALSA_SEQ_EVENT_H) + +if(BUILD_DSSI_OPCODES) + make_plugin(dssi4cs "load.c;dssi4cs.c" ${CMAKE_DL_LIBS} m) + target_include_directories(dssi4cs PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/include/dssi + ${CMAKE_CURRENT_SOURCE_DIR}/include/ladspa + ${DSSI_ALSA_ASOUNDLIB_H} + ${CSOUND_INCLUDE_DIRS}) + target_compile_definitions(dssi4cs PRIVATE BUILD_PLUGINS) +endif() diff --git a/7.x/src/dssi4cs/README.md b/7.x/src/dssi4cs/README.md new file mode 100644 index 0000000..8f6f642 --- /dev/null +++ b/7.x/src/dssi4cs/README.md @@ -0,0 +1,193 @@ +# DSSI and LADSPA opcodes + +This module hosts native DSSI synths and LADSPA effects on Linux. It is built +by default on Linux when the ALSA headers are available (`libasound2-dev` on +Debian/Ubuntu); configure with `-DBUILD_DSSI_OPCODES=OFF` to exclude it, and it +is silently disabled on other platforms. The module does not need the ALSA +sequencer service or link to libasound. Plugins must match the host OS, CPU, +and DSSI/LADSPA ABI. + +## Loading + +```csound +ih dssiinit Sfilename, iindex [, iverbose] +dssilist +dssiinfo ih +``` + +`iindex` selects a plugin within a library. A successful load returns an +instance handle starting at zero. Each call creates a separate instance. +`iverbose` defaults to 1 and prints ports and MIDI mappings. `dssiinfo` prints +that information for an existing handle. `dssilist` lists both DSSI and LADSPA +libraries, including libraries that export only `dssi_descriptor`. + +A name containing `/` is a path. For other names, search `DSSI_PATH`, then +`LADSPA_PATH`, then platform defaults. Each environment variable contains +colon-separated directories; empty entries are skipped. Lookup tries the +name as supplied, then `.so`. + +Linux defaults include `/usr/local/lib`, `/usr/lib`, and `/usr/lib64`, each +with `dssi` and `ladspa` subdirectories. Set the environment paths for +multiarch directories such as `/usr/lib/aarch64-linux-gnu/dssi`. + +Instances and libraries remain loaded until Csound reset or destruction. +Failed loads do not publish a handle. Cleanup calls the plugin's deactivate +and cleanup methods before releasing its buffers and library. + +## Audio and activation + +```csound +dssiactivate ih, kactive +a1 [, a2, ...] dssisynth ih [, ain1, ain2, ...] +a1 [, a2, ...] dssiaudio ih [, ain1, ain2, ...] +``` + +`kactive` must be 0 or 1. Activate before sending events or rendering. +`dssisynth` requires a DSSI synth. `dssiaudio` accepts a LADSPA effect or DSSI +plugin and chooses its synth callback when available. Audio ports follow +the descriptor order, with input and output ports counted separately. +Unused inputs receive silence. Csound's `0dbfs` scales audio to/from LADSPA +float buffers. + +Give each instance one audio renderer. The renderer's `ksmps` may be smaller +than the `ksmps` used to create the instance. Partial first/last blocks produce +silence outside the instrument's active samples. Ending the renderer +instrument deactivates the instance and discards pending events. Keep a +renderer running if notes or release tails must outlive their source +instrument. Deactivation clears pending notes; resuming sends note-offs for +old sounding notes, releases sustain, and sends all-sound-off/all-notes-off +even when the plugin has no activation callbacks. + +The host supports plugins that provide only `run_multiple_synths`. Every +call includes all active instances from the same library and LADSPA label. +Activate all grouped instances before the first renderer in that block. +Late activation reports an error rather than advancing a peer twice. +For groups with more than one instance, all renderers must have the same +`ksmps`, use full blocks, and the plugin must have no audio inputs. Send events +for every instance before the group's first renderer. Later renderers read +the outputs from that same group call. + +## Notes and MIDI + +```csound +dssinote ktrigger, ih, knote, kvelocity, kduration [, ichannel] +dssievent ktrigger, ih, knote, kvelocity +dssievent ktrigger, ih, kstatus, kchannel, kdata1, kdata2 [, koffset] +dssinrpn ktrigger, ih, kchannel, kparameter, kvalue [, koffset] +``` + +Each nonzero trigger sends an event in that control cycle; it is not an +edge detector. Use a one-cycle trigger for one note. Notes/velocities range +from 0 to 127. Channels range from 0 to 15 and default to 0 in `dssinote`. +The four-argument `dssievent` sends a note on channel 0; velocity zero sends +a true note-off. `dssinote` schedules a note-off after `kduration` seconds, +rounded to the nearest sample. Its pending note-off survives the source +instrument if a separate renderer remains active. + +The full MIDI form accepts status bytes without channel bits: + +| Status | Meaning | Data | +| --- | --- | --- | +| 128 / 0x80 | Note off | note, release velocity | +| 144 / 0x90 | Note on | note, velocity; zero means note off | +| 160 / 0xA0 | Key pressure | note, pressure | +| 176 / 0xB0 | Controller | controller, value | +| 192 / 0xC0 | Program change | program, 0 | +| 208 / 0xD0 | Channel pressure | pressure, 0 | +| 224 / 0xE0 | Pitch bend | low 7 bits, high 7 bits | + +`koffset` defaults to zero and counts samples from the instrument's first +active sample in this block. It must fall within that block's active range. +Events sort by sample time; equal-time events retain insertion order. +Queue events before rendering their block. Sending an event after its +samples have rendered reports a performance error. + +Bank select controllers 0/32 and MIDI program changes call `select_program` +instead of reaching the synth as MIDI. CC and NRPN mappings use the plugin's +control-port hints and do not also deliver the mapped event. Rendering splits +at mapped control/program changes so they take effect at the requested +sample. Use `dssinrpn` for assembled 14-bit NRPN messages: parameters and values +range from 0 to 16383. The host does not assemble NRPN from raw CC 98/99/6/38. + +## Controls, programs, and configuration + +```csound +dssictls ih, iport, kvalue, ktrigger +kvalue dssiget ih, iport +dssiprogram ih, kbank, kprogram, ktrigger +Sname, ibank, iprogram dssiprograminfo ih, iindex +dssiconfigure ih, Skey, Svalue +``` + +Port numbers are the descriptor's absolute port indices, including audio +ports. `dssictls` writes input control ports on each nonzero trigger, and +retains its existing sample-rate-hint scaling. `dssiget` reads an input or +output control port in the plugin's units. Output controls reflect the last +render. Input controls start with LADSPA defaults; selecting a program may +replace them. Put control writes after program selection when overriding a +preset. Audio ports and output controls cannot be written through `dssictls`. + +`dssiprograminfo` enumerates by list index, not by bank/program number. It +copies the name because plugins may reuse their descriptor storage. An +index beyond the list returns an empty name and -1 for bank/program. +`dssiprogram` selects the given bank/program when triggered. Select a program +explicitly when the plugin needs one; plugins need not choose a default on +activation. Program selection does not imply a note-on. + +`dssiconfigure` runs at initialization. Use it to load sample files, patches, +or other plugin settings before performance. It reports and frees plugin +error strings. `GLOBAL:` keys apply to all currently loaded instances of the +same plugin. Configuration invalidates program information; enumerate and +select again afterwards. Put configuration calls and sample paths in the +orchestra so reloading it restores them. This module does not save separate +plugin state files or launch plugin GUIs. + +## Example + +```csound +sr = 48000 +ksmps = 64 +nchnls = 2 +0dbfs = 1 + +gih dssiinit "my_synth.so", 0, 1 + +instr 1 + dssiactivate gih, 1 + konce init 1 + ; If needed: dssiprogram gih, 0, 0, konce + dssinote konce, gih, 60, 100, 0.5 + konce = 0 + aleft, aright dssisynth gih + outs aleft, aright +endin +``` + +Run the instrument long enough for the note and its release tail. Request +one output for a mono plugin. + +## Limits + +- Native Linux only; no macOS or WASM backend or OSC plugin GUI host. +- One Csound performance thread (`-j` values greater than 1 are rejected). +- At most 256 instances per engine and 1024 pending events per instance. + A timed note reserves both its on and off events before enqueueing either. + Queue overflow reports an error. +- Up to nine audio inputs and nine outputs per opcode, as in the existing API. +- Grouped rendering has the restrictions described above. +- No SysEx, MIDI system messages, or raw NRPN assembly in this version. +- Control ports are scalar LADSPA controls. Mixing uses Csound; the optional + additive DSSI/LADSPA callbacks are not needed. + +## ABI sources + +The [DSSI](include/dssi/README.md) and [LADSPA](include/ladspa/README.md) +headers are unmodified copies of upstream releases, with their licenses and +source details. They retain upstream's C ABI types (`unsigned long`, `int`, +and `float`). See the [DSSI specification](https://dssi.sourceforge.net/RFC.html) +and [LADSPA SDK](https://www.ladspa.org/ladspa_sdk/). +ALSA declarations come from the installed system headers. + +Run `include/dssi/update.py` and `include/ladspa/update.py` to update the +vendored headers, or pass `--pinned` to reproduce the recorded releases and +check their archive hashes. diff --git a/7.x/src/dssi4cs/dssi4cs.c b/7.x/src/dssi4cs/dssi4cs.c new file mode 100644 index 0000000..c2c9e26 --- /dev/null +++ b/7.x/src/dssi4cs/dssi4cs.c @@ -0,0 +1,820 @@ +/* + * Copyright (C) 2005 Andres Cabrera + * + * The dssi4cs library is free software; you can redistribute it + * and/or modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * The dssi4cs library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with The dssi4cs library; if not, write to the Free Software + * Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA + * + * Uses code by Richard W.E. Furse from the ladspa sdk + */ + +#include "dssi4cs.h" +#include "utils.h" +#include +#include +#include +#include +#include + +/* State belongs to one Csound engine, and survives until reset. */ +static DSSI_HOST *host(CSOUND *csound) +{ + return csound->QueryGlobalVariable(csound, "$DSSI4CS"); +} + +static int integer(cs_float value, int64_t maximum) +{ + /* Compare as integers so float builds do not round UINT32_MAX up. */ + return value >= 0 && value < 0x1p63 && floor(value) == value && + (int64_t)value <= maximum; +} + +static DSSI_PLUGIN *lookup(CSOUND *csound, cs_float id) +{ + DSSI_HOST *h = host(csound); + return h && h->count && integer(id, h->count - 1) ? + h->plugins[(unsigned int)id] : NULL; +} + +static int64_t block_start(OPDS *p) +{ + return ((int64_t)GetLocalKcounter(p) - 1) * GetLocalKsmps(p); +} + +static int64_t event_time(OPDS *p) +{ + return block_start(p) + GetKsmpsOffset(p); +} + +static void set_active(DSSI_PLUGIN *p, int active) +{ + if (active == p->active) return; + if (active) { + if (p->ladspa->activate) p->ladspa->activate(p->handle); + } + else { + if (p->ladspa->deactivate) p->ladspa->deactivate(p->handle); + p->queued = 0; + p->panic = 1; + } + p->active = active; + p->last_block = -1; +} + +static void destroy_plugin(CSOUND *csound, DSSI_PLUGIN *p) +{ + if (!p) return; + if (p->handle) { + set_active(p, 0); + p->ladspa->cleanup(p->handle); + } + if (p->audio) { + for (unsigned long i = 0; i < p->ladspa->PortCount; ++i) + if (p->audio[i]) csound->Free(csound, p->audio[i]); + csound->Free(csound, p->audio); + } + if (p->control) csound->Free(csound, p->control); + if (p->mapping) csound->Free(csound, p->mapping); + if (p->inputs) csound->Free(csound, p->inputs); + if (p->outputs) csound->Free(csound, p->outputs); + if (p->library) dlclose(p->library); + csound->Free(csound, p); +} + +static int32_t reset(CSOUND *csound, void *data) +{ + DSSI_HOST *h = data; + for (unsigned int i = 0; i < h->count; ++i) + destroy_plugin(csound, h->plugins[i]); + csound->DestroyGlobalVariable(csound, "$DSSI4CS"); + return OK; +} + +static cs_double bound(DSSI_PLUGIN *p, unsigned long port, int upper) +{ + const LADSPA_PortRangeHint *hint = &p->ladspa->PortRangeHints[port]; + return (upper ? hint->UpperBound : hint->LowerBound) * + (LADSPA_IS_HINT_SAMPLE_RATE(hint->HintDescriptor) ? p->sample_rate : 1); +} + +static cs_double interpolate(DSSI_PLUGIN *p, unsigned long port, cs_double fraction) +{ + cs_double lo = bound(p, port, 0), hi = bound(p, port, 1); + LADSPA_PortRangeHintDescriptor flags = p->ladspa->PortRangeHints[port].HintDescriptor; + if (LADSPA_IS_HINT_LOGARITHMIC(flags) && lo > 0 && hi > 0) + return exp(log(lo) * (1 - fraction) + log(hi) * fraction); + return lo * (1 - fraction) + hi * fraction; +} + +static LADSPA_Data default_control(DSSI_PLUGIN *p, unsigned long port) +{ + LADSPA_PortRangeHintDescriptor flags = p->ladspa->PortRangeHints[port].HintDescriptor; + cs_double value = 0; + switch (flags & LADSPA_HINT_DEFAULT_MASK) { + case LADSPA_HINT_DEFAULT_MINIMUM: value = bound(p, port, 0); break; + case LADSPA_HINT_DEFAULT_LOW: value = interpolate(p, port, .25); break; + case LADSPA_HINT_DEFAULT_MIDDLE: value = interpolate(p, port, .5); break; + case LADSPA_HINT_DEFAULT_HIGH: value = interpolate(p, port, .75); break; + case LADSPA_HINT_DEFAULT_MAXIMUM: value = bound(p, port, 1); break; + case LADSPA_HINT_DEFAULT_1: value = 1; break; + case LADSPA_HINT_DEFAULT_100: value = 100; break; + case LADSPA_HINT_DEFAULT_440: value = 440; break; + default: + if (LADSPA_IS_HINT_BOUNDED_BELOW(flags)) value = fmax(value, bound(p, port, 0)); + if (LADSPA_IS_HINT_BOUNDED_ABOVE(flags)) value = fmin(value, bound(p, port, 1)); + } + if (LADSPA_IS_HINT_INTEGER(flags)) value = round(value); + return (LADSPA_Data)value; +} + +static void describe(CSOUND *csound, DSSI_PLUGIN *p) +{ + csound->Message(csound, Str("DSSI4CS: %s: %s (%s), %lu audio inputs, %lu outputs\n"), + p->dssi ? "DSSI" : "LADSPA", p->ladspa->Name, + p->ladspa->Label, p->input_count, p->output_count); + for (unsigned long i = 0; i < p->ladspa->PortCount; ++i) { + LADSPA_PortDescriptor flags = p->ladspa->PortDescriptors[i]; + csound->Message(csound, " %lu: %s, %s %s", i, p->ladspa->PortNames[i], + LADSPA_IS_PORT_INPUT(flags) ? "input" : "output", + LADSPA_IS_PORT_AUDIO(flags) ? "audio" : "control"); + if (LADSPA_IS_PORT_CONTROL(flags)) + csound->Message(csound, Str(", value %g, MIDI mapping %d"), + (cs_double)p->control[i], p->mapping[i]); + csound->Message(csound, "\n"); + } +} + +static int32_t dssiinit(CSOUND *csound, DSSIINIT *op) +{ + *op->result = -1; + if (!integer(*op->index, UINT32_MAX)) + return csound->InitError(csound, Str("DSSI4CS: invalid plugin index\n")); + if (csound->GetOParms(csound)->numThreads > 1) + return csound->InitError(csound, Str("DSSI4CS: use one Csound performance thread\n")); + DSSI_HOST *h = host(csound); + if (!h) { + if (csound->CreateGlobalVariable(csound, "$DSSI4CS", sizeof(DSSI_HOST))) + return csound->InitError(csound, Str("DSSI4CS: cannot create host state\n")); + h = host(csound); + csound->RegisterResetCallback(csound, h, reset); + } + if (h->count == DSSI4CS_INSTANCES) + return csound->InitError(csound, Str("DSSI4CS: instance limit reached\n")); + char legacy_name[MAXNAME]; + const char *name; + if (!strcmp(GetTypeForArg(op->filename)->varTypeName, "S")) + name = ((STRINGDAT *)op->filename)->data; + else { + csound->StringArg2Name(csound, legacy_name, + IsStringCode(*op->filename) ? csound->GetArgString(csound, *op->filename) : + (char *)op->filename, "dssiinit.", IsStringCode(*op->filename)); + name = legacy_name; + } + DSSI_PLUGIN *p = csound->Calloc(csound, sizeof(*p)); + p->last_block = p->rendered_until = -1; + p->capacity = GetLocalKsmps(&op->h); + p->sample_rate = csound->GetEngineSr(csound); + p->library = dlopenLADSPA(csound, name, RTLD_NOW); + const char *error = Str_noop("cannot load library"); + if (!p->library) goto fail; + DSSI_Descriptor_Function dssi = (DSSI_Descriptor_Function)dlsym(p->library, "dssi_descriptor"); + LADSPA_Descriptor_Function ladspa = (LADSPA_Descriptor_Function)dlsym(p->library, "ladspa_descriptor"); + error = Str_noop("missing descriptor or plugin index"); + if (dssi) { + p->dssi = dssi((unsigned long)*op->index); + if (!p->dssi) goto fail; + error = Str_noop("unsupported DSSI API version"); + if (p->dssi->DSSI_API_Version != 1) goto fail; + p->ladspa = p->dssi->LADSPA_Plugin; + } + else if (ladspa) p->ladspa = ladspa((unsigned long)*op->index); + error = Str_noop("invalid LADSPA descriptor"); + const LADSPA_Descriptor *d = p->ladspa; + if (!d || !d->instantiate || !d->connect_port || !d->cleanup || + !d->Label || !d->Name || d->PortCount > 65536 || + (d->PortCount && (!d->PortDescriptors || !d->PortNames || !d->PortRangeHints))) goto fail; + error = Str_noop("plugin has no render callback"); + if (!d->run && !(p->dssi && (p->dssi->run_synth || p->dssi->run_multiple_synths))) goto fail; + error = Str_noop("invalid port descriptor"); + for (unsigned long i = 0; i < d->PortCount; ++i) { + LADSPA_PortDescriptor flags = d->PortDescriptors[i]; + if (!!LADSPA_IS_PORT_AUDIO(flags) == !!LADSPA_IS_PORT_CONTROL(flags) || + !!LADSPA_IS_PORT_INPUT(flags) == !!LADSPA_IS_PORT_OUTPUT(flags) || + !d->PortNames[i]) goto fail; + } + p->handle = d->instantiate(d, (unsigned long)p->sample_rate); + error = Str_noop("cannot instantiate plugin"); + if (!p->handle) goto fail; + size_t ports = d->PortCount ? d->PortCount : 1; + p->audio = csound->Calloc(csound, ports * sizeof(*p->audio)); + p->control = csound->Calloc(csound, ports * sizeof(*p->control)); + p->mapping = csound->Malloc(csound, ports * sizeof(*p->mapping)); + p->inputs = csound->Malloc(csound, ports * sizeof(*p->inputs)); + p->outputs = csound->Malloc(csound, ports * sizeof(*p->outputs)); + for (unsigned long i = 0; i < d->PortCount; ++i) { + LADSPA_PortDescriptor flags = d->PortDescriptors[i]; + p->mapping[i] = DSSI_NONE; + if (LADSPA_IS_PORT_AUDIO(flags)) { + p->audio[i] = csound->Calloc(csound, p->capacity * sizeof(LADSPA_Data)); + d->connect_port(p->handle, i, p->audio[i]); + if (LADSPA_IS_PORT_INPUT(flags)) p->inputs[p->input_count++] = i; + else p->outputs[p->output_count++] = i; + } + else { + if (LADSPA_IS_PORT_INPUT(flags)) { + p->control[i] = default_control(p, i); + if (p->dssi && p->dssi->get_midi_controller_for_port) + p->mapping[i] = p->dssi->get_midi_controller_for_port(p->handle, i); + } + d->connect_port(p->handle, i, &p->control[i]); + } + } + h->plugins[h->count] = p; + *op->result = h->count++; + if (*op->verbose != 0) describe(csound, p); + return OK; +fail: + destroy_plugin(csound, p); + return csound->InitError(csound, "DSSI4CS: %s: %s\n", name, Str(error)); +} + +static int32_t dssiactivate_init(CSOUND *csound, DSSIACTIVATE *p) +{ + p->plugin = lookup(csound, *p->id); + return p->plugin ? OK : csound->InitError(csound, Str("DSSI4CS: invalid handle\n")); +} + +static int same_plugin(DSSI_PLUGIN *, DSSI_PLUGIN *); + +static int32_t dssiactivate(CSOUND *csound, DSSIACTIVATE *p) +{ + if (!integer(*p->trigger, 1)) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: activation must be 0 or 1\n")); + DSSI_PLUGIN *q = p->plugin; + if (*p->trigger && !q->active && q->dssi && + !q->dssi->run_synth && q->dssi->run_multiple_synths) { + DSSI_HOST *h = host(csound); + for (unsigned int i = 0; i < h->count; ++i) + if (same_plugin(q, h->plugins[i]) && + h->plugins[i]->rendered_until > block_start(&p->h)) + return csound->PerfError(csound, &p->h, + Str("DSSI4CS: activate all grouped instances before rendering their block\n")); + } + set_active(q, *p->trigger != 0); + return OK; +} + +static int has_synth(DSSI_PLUGIN *p) +{ + return p && p->dssi && (p->dssi->run_synth || p->dssi->run_multiple_synths); +} + +static int32_t synth_handle(CSOUND *csound, cs_float id, DSSI_PLUGIN **p) +{ + *p = lookup(csound, id); + return has_synth(*p) ? OK : csound->InitError(csound, Str("DSSI4CS: handle is not a DSSI synth\n")); +} + +/* Stable insertion preserves note-on/note-off order at the same sample. */ +static void enqueue(DSSI_PLUGIN *p, int64_t time, snd_seq_event_t event) +{ + unsigned int i = p->queued++; + while (i && p->queue[i-1].time > time) { + p->queue[i] = p->queue[i-1]; + --i; + } + p->queue[i].time = time; + p->queue[i].event = event; +} + +static int32_t reserve_events(CSOUND *csound, OPDS *op, DSSI_PLUGIN *p, + unsigned int count, int64_t time) +{ + if (!p->active) + return csound->PerfError(csound, op, Str("DSSI4CS: activate the synth before sending events\n")); + if (time < p->rendered_until) + return csound->PerfError(csound, op, Str("DSSI4CS: send events before rendering their block\n")); + if (count > DSSI4CS_EVENTS - p->queued) + return csound->PerfError(csound, op, Str("DSSI4CS: event queue is full\n")); + return OK; +} + +static int32_t dssinote_init(CSOUND *csound, DSSINOTE *p) +{ + return synth_handle(csound, *p->id, &p->plugin); +} + +static int32_t dssinote(CSOUND *csound, DSSINOTE *p) +{ + if (*p->trigger == 0) return OK; + int64_t now = event_time(&p->h); + cs_double samples = (cs_double)*p->duration * p->plugin->sample_rate; + if (!integer(*p->note, 127) || !integer(*p->velocity, 127) || + !integer(*p->channel, 15) || !isfinite(samples) || samples < 0 || + samples > (cs_double)(INT64_MAX / 2)) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: invalid note, velocity, channel or duration\n")); + if (reserve_events(csound, &p->h, p->plugin, *p->velocity ? 2 : 1, now)) return NOTOK; + snd_seq_event_t event = {0}; + event.type = *p->velocity ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF; + event.data.note.channel = (unsigned char)*p->channel; + event.data.note.note = (unsigned char)*p->note; + event.data.note.velocity = (unsigned char)*p->velocity; + enqueue(p->plugin, now, event); + if (*p->velocity) { + event.type = SND_SEQ_EVENT_NOTEOFF; + event.data.note.velocity = 0; + enqueue(p->plugin, now + (int64_t)llround(samples), event); + } + return OK; +} + +static int32_t dssinoteon_init(CSOUND *csound, DSSINOTEON *p) +{ + return synth_handle(csound, *p->id, &p->plugin); +} + +static int32_t dssinoteon(CSOUND *csound, DSSINOTEON *p) +{ + if (*p->trigger == 0) return OK; + if (!integer(*p->note, 127) || !integer(*p->velocity, 127)) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: invalid note or velocity\n")); + int64_t time = event_time(&p->h); + if (reserve_events(csound, &p->h, p->plugin, 1, time)) return NOTOK; + snd_seq_event_t event = {0}; + event.type = *p->velocity ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF; + event.data.note.note = (unsigned char)*p->note; + event.data.note.velocity = (unsigned char)*p->velocity; + enqueue(p->plugin, time, event); + return OK; +} + +static int32_t dssievent_init(CSOUND *csound, DSSIEVENT *p) +{ + return synth_handle(csound, *p->id, &p->plugin); +} + +static int32_t dssievent(CSOUND *csound, DSSIEVENT *p) +{ + if (*p->trigger == 0) return OK; + if (!integer(*p->channel, 15) || !integer(*p->status, 0xe0) || + !integer(*p->data1, 127) || !integer(*p->data2, 127) || + !integer(*p->offset, (int64_t)GetLocalKsmps(&p->h) - GetKsmpsOffset(&p->h) - + GetEarlySmps(&p->h) - 1)) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: invalid MIDI event or sample offset\n")); + snd_seq_event_t event = {0}; + int status = (int)*p->status, channel = (int)*p->channel; + int a = (int)*p->data1, b = (int)*p->data2; + if (status == 0x80 || status == 0x90 || status == 0xa0) { + event.type = status == 0xa0 ? SND_SEQ_EVENT_KEYPRESS : + status == 0x80 || b == 0 ? SND_SEQ_EVENT_NOTEOFF : SND_SEQ_EVENT_NOTEON; + event.data.note.channel = channel; + event.data.note.note = a; + event.data.note.velocity = b; + } + else { + event.data.control.channel = channel; + switch (status) { + case 0xb0: event.type = SND_SEQ_EVENT_CONTROLLER; event.data.control.param = a; + event.data.control.value = b; break; + case 0xc0: event.type = SND_SEQ_EVENT_PGMCHANGE; event.data.control.value = a; break; + case 0xd0: event.type = SND_SEQ_EVENT_CHANPRESS; event.data.control.value = a; break; + case 0xe0: event.type = SND_SEQ_EVENT_PITCHBEND; event.data.control.value = a + 128*b - 8192; break; + default: return csound->PerfError(csound, &p->h, Str("DSSI4CS: unsupported MIDI status\n")); + } + } + int64_t time = event_time(&p->h) + (int64_t)*p->offset; + if (reserve_events(csound, &p->h, p->plugin, 1, time)) return NOTOK; + enqueue(p->plugin, time, event); + return OK; +} + +static int32_t dssinrpn_init(CSOUND *csound, DSSINRPN *p) +{ + return synth_handle(csound, *p->id, &p->plugin); +} + +static int32_t dssinrpn(CSOUND *csound, DSSINRPN *p) +{ + if (*p->trigger == 0) return OK; + if (!integer(*p->channel, 15) || !integer(*p->parameter, 16383) || + !integer(*p->value, 16383) || + !integer(*p->offset, (int64_t)GetLocalKsmps(&p->h) - GetKsmpsOffset(&p->h) - + GetEarlySmps(&p->h) - 1)) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: invalid NRPN event\n")); + int64_t time = event_time(&p->h) + (int64_t)*p->offset; + if (reserve_events(csound, &p->h, p->plugin, 1, time)) return NOTOK; + snd_seq_event_t event = {0}; + event.type = SND_SEQ_EVENT_NONREGPARAM; + event.data.control.channel = (unsigned char)*p->channel; + event.data.control.param = (unsigned int)*p->parameter; + event.data.control.value = (int)*p->value; + enqueue(p->plugin, time, event); + return OK; +} + +static int mapped(DSSI_PLUGIN *p, snd_seq_event_t *e, int apply) +{ + if (e->type != SND_SEQ_EVENT_CONTROLLER && e->type != SND_SEQ_EVENT_NONREGPARAM) return 0; + int found = 0; + for (unsigned long i = 0; i < p->ladspa->PortCount; ++i) { + int m = p->mapping[i]; + if (m == DSSI_NONE) continue; + int match = e->type == SND_SEQ_EVENT_CONTROLLER ? + (DSSI_IS_CC(m) && DSSI_CC_NUMBER(m) == e->data.control.param) : + (DSSI_IS_NRPN(m) && DSSI_NRPN_NUMBER(m) == e->data.control.param); + if (!match) continue; + found = 1; + if (apply) { + cs_double f = e->data.control.value / + (e->type == SND_SEQ_EVENT_CONTROLLER ? 127. : 16383.); + LADSPA_PortRangeHintDescriptor flags = p->ladspa->PortRangeHints[i].HintDescriptor; + cs_double value = interpolate(p, i, f); + if (LADSPA_IS_HINT_TOGGLED(flags)) value = f >= .5; + else if (LADSPA_IS_HINT_INTEGER(flags)) value = round(value); + p->control[i] = (LADSPA_Data)value; + } + } + return found; +} + +static int host_event(DSSI_PLUGIN *p, snd_seq_event_t *e) +{ + return e->type == SND_SEQ_EVENT_PGMCHANGE || + (e->type == SND_SEQ_EVENT_CONTROLLER && + (e->data.control.param == 0 || e->data.control.param == 32)) || mapped(p, e, 0); +} + +static void apply_event(DSSI_PLUGIN *p, snd_seq_event_t *e) +{ + unsigned int ch = e->data.control.channel; + if (e->type == SND_SEQ_EVENT_PGMCHANGE) { + if (p->dssi->select_program) + p->dssi->select_program(p->handle, p->bank[ch], e->data.control.value); + } + else if (e->type == SND_SEQ_EVENT_CONTROLLER && e->data.control.param == 0) + p->bank[ch] = (p->bank[ch] & 127) | (e->data.control.value << 7); + else if (e->type == SND_SEQ_EVENT_CONTROLLER && e->data.control.param == 32) + p->bank[ch] = (p->bank[ch] & (127 << 7)) | e->data.control.value; + else mapped(p, e, 1); +} + +static int same_plugin(DSSI_PLUGIN *a, DSSI_PLUGIN *b) +{ + return a->library == b->library && !strcmp(a->ladspa->Label, b->ladspa->Label); +} + +static void connect_audio(DSSI_PLUGIN *p, uint32_t offset) +{ + for (unsigned long i = 0; i < p->ladspa->PortCount; ++i) + if (p->audio[i]) p->ladspa->connect_port(p->handle, i, p->audio[i] + offset); +} + +/* Split only at host-handled MIDI events, so controls/programs change at the + requested sample. Other MIDI retains its relative timestamp within a run. */ +static void render(DSSI_PLUGIN **group, unsigned long count, int multiple, + int64_t start, uint32_t frames, uint32_t offset) +{ + int64_t cursor = start, end = start + frames; + LADSPA_Handle handles[DSSI4CS_INSTANCES]; + snd_seq_event_t *events[DSSI4CS_INSTANCES]; + unsigned long counts[DSSI4CS_INSTANCES]; + while (cursor < end) { + int64_t next = end; + for (unsigned long g = 0; g < count; ++g) { + DSSI_PLUGIN *p = group[g]; + for (unsigned int i = 0; i < p->queued; ++i) + if (p->queue[i].time > cursor && p->queue[i].time < next && + host_event(p, &p->queue[i].event)) next = p->queue[i].time; + } + for (unsigned long g = 0; g < count; ++g) { + DSSI_PLUGIN *p = group[g]; + unsigned int used = 0; + p->event_count = 0; + if (p->panic) { + /* A plugin may omit activate/deactivate. End old notes before + delivering new notes when that instance resumes. */ + for (int channel = 0; channel < 16; ++channel) { + const unsigned int controllers[] = {64, 120, 123}; + for (unsigned int i = 0; i < 3; ++i) { + snd_seq_event_t event = {0}; + event.type = SND_SEQ_EVENT_CONTROLLER; + event.data.control.channel = channel; + event.data.control.param = controllers[i]; + if (!mapped(p, &event, 1)) p->events[p->event_count++] = event; + } + } + for (int channel = 0; channel < 16; ++channel) + for (int note = 0; note < 128; ++note) + if (p->notes[channel][note]) { + snd_seq_event_t *e = &p->events[p->event_count++]; + memset(e, 0, sizeof(*e)); + e->type = SND_SEQ_EVENT_NOTEOFF; + e->data.note.channel = channel; + e->data.note.note = note; + } + memset(p->notes, 0, sizeof(p->notes)); + p->panic = 0; + } + while (used < p->queued && p->queue[used].time < next) { + DSSI_EVENT *q = &p->queue[used++]; + if (host_event(p, &q->event)) apply_event(p, &q->event); + else { + snd_seq_event_t *e = &p->events[p->event_count++]; + *e = q->event; + if (e->type == SND_SEQ_EVENT_NOTEON || e->type == SND_SEQ_EVENT_NOTEOFF) + p->notes[e->data.note.channel][e->data.note.note] = e->type == SND_SEQ_EVENT_NOTEON; + e->time.tick = q->time > cursor ? (unsigned int)(q->time - cursor) : 0; + } + } + p->queued -= used; + memmove(p->queue, p->queue + used, p->queued * sizeof(*p->queue)); + connect_audio(p, offset + (uint32_t)(cursor - start)); + handles[g] = p->handle; + events[g] = p->events; + counts[g] = p->event_count; + } + DSSI_PLUGIN *p = group[0]; + if (multiple) + p->dssi->run_multiple_synths(count, handles, (unsigned long)(next-cursor), events, counts); + else if (has_synth(p)) + p->dssi->run_synth(p->handle, (unsigned long)(next-cursor), events[0], counts[0]); + else p->ladspa->run(p->handle, (unsigned long)(next-cursor)); + cursor = next; + } + for (unsigned long g = 0; g < count; ++g) { + group[g]->rendered_until = end; + connect_audio(group[g], 0); + } +} + +static int32_t dssiaudio_init(CSOUND *csound, DSSIAUDIO *p) +{ + p->plugin = lookup(csound, *p->id); + DSSI_PLUGIN *q = p->plugin; + if (!q) return csound->InitError(csound, Str("DSSI4CS: invalid handle\n")); + if (q->owner && q->owner != &p->h) + return csound->InitError(csound, Str("DSSI4CS: each instance needs exactly one audio renderer\n")); + if (GetLocalKsmps(&p->h) > q->capacity || + GetInputArgCnt(&p->h) - 1 > q->input_count || GetOutputArgCnt(&p->h) > q->output_count) + return csound->InitError(csound, Str("DSSI4CS: audio port count or ksmps mismatch\n")); + q->render_ksmps = GetLocalKsmps(&p->h); + q->owner = &p->h; + return OK; +} + +static int32_t dssisynth_init(CSOUND *csound, DSSIAUDIO *p) +{ + if (synth_handle(csound, *p->id, &p->plugin)) return NOTOK; + return dssiaudio_init(csound, p); +} + +static int32_t dssiaudio_deinit(CSOUND *csound, DSSIAUDIO *p) +{ + (void)csound; + if (p->plugin && p->plugin->owner == &p->h) { + p->plugin->owner = NULL; + set_active(p->plugin, 0); + } + return OK; +} + +static int32_t dssiaudio(CSOUND *csound, DSSIAUDIO *p) +{ + DSSI_PLUGIN *q = p->plugin; + uint32_t size = GetLocalKsmps(&p->h), offset = GetKsmpsOffset(&p->h); + uint32_t end = size - GetEarlySmps(&p->h); + int inputs = GetInputArgCnt(&p->h) - 1, outputs = GetOutputArgCnt(&p->h); + for (int i = 0; i < outputs; ++i) memset(p->out[i], 0, size * sizeof(cs_float)); + if (!q->active || offset >= end) return OK; + int64_t block = block_start(&p->h); + if (q->last_block != block) { + if (block + offset < q->rendered_until) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: these samples have already rendered\n")); + for (unsigned long i = 0; i < q->input_count; ++i) { + LADSPA_Data *data = q->audio[q->inputs[i]]; + memset(data, 0, size * sizeof(*data)); + if (i < (unsigned long)inputs) + for (uint32_t n = offset; n < end; ++n) + data[n] = (LADSPA_Data)(p->in[i][n] / csound->Get0dBFS(csound)); + } + DSSI_PLUGIN *group[DSSI4CS_INSTANCES] = {q}; + unsigned long count = 1; + int multiple = has_synth(q) && !q->dssi->run_synth; + if (multiple) { + DSSI_HOST *h = host(csound); + for (unsigned int i = 0; i < h->count; ++i) { + DSSI_PLUGIN *other = h->plugins[i]; + if (other != q && other->active && same_plugin(q, other)) { + if (other->rendered_until > block + offset) + return csound->PerfError(csound, &p->h, + Str("DSSI4CS: activate all grouped instances before rendering their block\n")); + group[count++] = other; + } + } + if (count > 1) { + for (unsigned long i = 0; i < count; ++i) + if (group[i]->input_count || group[i]->render_ksmps != size || + !group[i]->owner || GetKsmpsOffset(group[i]->owner) || + GetEarlySmps(group[i]->owner) || offset || end != size) + return csound->PerfError(csound, &p->h, + Str("DSSI4CS: grouped synths need no audio inputs, matching ksmps and full blocks\n")); + } + } + render(group, count, multiple, block + offset, end - offset, offset); + for (unsigned long i = 0; i < count; ++i) group[i]->last_block = block; + } + for (int i = 0; i < outputs; ++i) + for (uint32_t n = offset; n < end; ++n) + p->out[i][n] = q->audio[q->outputs[i]][n] * csound->Get0dBFS(csound); + return OK; +} + +static int control_port(DSSI_PLUGIN *p, cs_float port, int input) +{ + if (!p || !p->ladspa->PortCount || + !integer(port, (int64_t)(p->ladspa->PortCount - 1))) return 0; + LADSPA_PortDescriptor flags = p->ladspa->PortDescriptors[(unsigned long)port]; + return LADSPA_IS_PORT_CONTROL(flags) && (!input || LADSPA_IS_PORT_INPUT(flags)); +} + +static int32_t dssictls_init(CSOUND *csound, DSSICTLS *p) +{ + p->plugin = lookup(csound, *p->id); + if (!control_port(p->plugin, *p->port, 1)) + return csound->InitError(csound, Str("DSSI4CS: expected an input control port\n")); + p->index = (unsigned long)*p->port; + return OK; +} + +static int32_t dssictls(CSOUND *csound, DSSICTLS *p) +{ + if (*p->trigger == 0) return OK; + cs_double value = *p->value; + if (LADSPA_IS_HINT_SAMPLE_RATE(p->plugin->ladspa->PortRangeHints[p->index].HintDescriptor)) + value *= p->plugin->sample_rate; + if (!isfinite(value) || fabs(value) > FLT_MAX) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: invalid control value\n")); + p->plugin->control[p->index] = (LADSPA_Data)value; + return OK; +} + +static int32_t dssiget_init(CSOUND *csound, DSSIGET *p) +{ + p->plugin = lookup(csound, *p->id); + if (!control_port(p->plugin, *p->port, 0)) + return csound->InitError(csound, Str("DSSI4CS: expected a control port\n")); + p->index = (unsigned long)*p->port; + *p->value = p->plugin->control[p->index]; + return OK; +} + +static int32_t dssiget(CSOUND *csound, DSSIGET *p) +{ + (void)csound; + *p->value = p->plugin->control[p->index]; + return OK; +} + +static int32_t dssiprogram_init(CSOUND *csound, DSSIPROGRAM *p) +{ + p->plugin = lookup(csound, *p->id); + if (!p->plugin || !p->plugin->dssi || !p->plugin->dssi->select_program) + return csound->InitError(csound, Str("DSSI4CS: plugin does not support programs\n")); + return OK; +} + +static int32_t dssiprogram(CSOUND *csound, DSSIPROGRAM *p) +{ + if (*p->trigger == 0) return OK; + if (!integer(*p->bank, UINT32_MAX) || !integer(*p->program, UINT32_MAX)) + return csound->PerfError(csound, &p->h, Str("DSSI4CS: invalid bank or program\n")); + p->plugin->dssi->select_program(p->plugin->handle, (unsigned long)*p->bank, + (unsigned long)*p->program); + return OK; +} + +static int32_t dssiconfigure(CSOUND *csound, DSSICONFIGURE *p) +{ + DSSI_PLUGIN *q = lookup(csound, *p->id); + if (!q || !q->dssi || !q->dssi->configure) + return csound->InitError(csound, Str("DSSI4CS: plugin does not support configuration\n")); + DSSI_HOST *h = host(csound); + int global = !strncmp(p->key->data, DSSI_GLOBAL_CONFIGURE_PREFIX, + strlen(DSSI_GLOBAL_CONFIGURE_PREFIX)); + for (unsigned int i = 0; i < h->count; ++i) { + DSSI_PLUGIN *target = h->plugins[i]; + if (target != q && !(global && same_plugin(q, target))) continue; + char *error = target->dssi->configure(target->handle, p->key->data, p->value->data); + if (error) { + int32_t result = csound->InitError(csound, "DSSI4CS: configure: %s\n", error); + free(error); /* DSSI specifies malloc/free ownership for this string. */ + return result; + } + } + return OK; +} + +static int32_t dssiprograminfo(CSOUND *csound, DSSIPROGRAMINFO *p) +{ + DSSI_PLUGIN *q = lookup(csound, *p->id); + if (!q || !q->dssi || !q->dssi->get_program || !integer(*p->index, UINT32_MAX)) + return csound->InitError(csound, Str("DSSI4CS: cannot enumerate programs\n")); + const DSSI_Program_Descriptor *program = q->dssi->get_program(q->handle, (unsigned long)*p->index); + const char *name = program && program->Name ? program->Name : ""; + size_t size = strlen(name) + 1; + if (p->name->size < size) { + p->name->data = csound->ReAlloc(csound, p->name->data, size); + p->name->size = size; + } + memcpy(p->name->data, name, size); + *p->bank = program ? (cs_float)program->Bank : -1; + *p->program = program ? (cs_float)program->Program : -1; + return OK; +} + +static int32_t dssiinfo(CSOUND *csound, DSSIINFO *p) +{ + DSSI_PLUGIN *q = lookup(csound, *p->id); + if (!q) return csound->InitError(csound, Str("DSSI4CS: invalid handle\n")); + describe(csound, q); + return OK; +} + +static void list_directory(CSOUND *csound, const char *directory) +{ + DIR *dir = opendir(directory); + if (!dir) return; + struct dirent *entry; + while ((entry = readdir(dir))) { + if (entry->d_name[0] == '.') continue; + size_t size = strlen(directory) + strlen(entry->d_name) + 2; + char *path = csound->Malloc(csound, size); + snprintf(path, size, "%s/%s", directory, entry->d_name); + void *library = dlopen(path, RTLD_LAZY | RTLD_LOCAL); + if (library) { + DSSI_Descriptor_Function df = (DSSI_Descriptor_Function)dlsym(library, "dssi_descriptor"); + LADSPA_Descriptor_Function lf = (LADSPA_Descriptor_Function)dlsym(library, "ladspa_descriptor"); + for (unsigned long i = 0; df || lf; ++i) { + const DSSI_Descriptor *d = df ? df(i) : NULL; + const LADSPA_Descriptor *l = df ? (d ? d->LADSPA_Plugin : NULL) : lf(i); + if (!l) break; + csound->Message(csound, "%s: %lu: %s (%s)\n", path, i, l->Name, l->Label); + } + dlclose(library); + } + csound->Free(csound, path); + } + closedir(dir); +} + +static int32_t dssilist(CSOUND *csound, DSSILIST *p) +{ + (void)p; + const char *paths[] = {csound->GetEnv(csound, "DSSI_PATH"), + csound->GetEnv(csound, "LADSPA_PATH"), DSSI4CS_DEFAULT_PATH}; + for (unsigned int i = 0; i < sizeof(paths)/sizeof(paths[0]); ++i) { + const char *start = paths[i]; + while (start && *start) { + const char *end = strchr(start, ':'); + size_t length = end ? (size_t)(end-start) : strlen(start); + if (length) { + char *path = csound->Malloc(csound, length+1); + memcpy(path, start, length); + path[length] = '\0'; + list_directory(csound, path); + csound->Free(csound, path); + } + start = end ? end+1 : NULL; + } + } + return OK; +} + +static OENTRY localops[] = { + {"dssiinit", sizeof(DSSIINIT), 0, "i", "Tip", (SUBR)dssiinit}, + {"dssiactivate", sizeof(DSSIACTIVATE), 0, "", "ik", (SUBR)dssiactivate_init, (SUBR)dssiactivate}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iMMMMMMMMM", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iMMMMMMMMM", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssictls", sizeof(DSSICTLS), 0, "", "iikk", (SUBR)dssictls_init, (SUBR)dssictls}, + {"dssiget", sizeof(DSSIGET), 0, "k", "ii", (SUBR)dssiget_init, (SUBR)dssiget}, + {"dssinote", sizeof(DSSINOTE), 0, "", "kikkko", (SUBR)dssinote_init, (SUBR)dssinote}, + {"dssievent", sizeof(DSSINOTEON), 0, "", "kikk", (SUBR)dssinoteon_init, (SUBR)dssinoteon}, + {"dssievent", sizeof(DSSIEVENT), 0, "", "kikkkkO", (SUBR)dssievent_init, (SUBR)dssievent}, + {"dssinrpn", sizeof(DSSINRPN), 0, "", "kikkkO", (SUBR)dssinrpn_init, (SUBR)dssinrpn}, + {"dssiprogram", sizeof(DSSIPROGRAM), 0, "", "ikkk", (SUBR)dssiprogram_init, (SUBR)dssiprogram}, + {"dssiconfigure", sizeof(DSSICONFIGURE), 0, "", "iSS", (SUBR)dssiconfigure}, + {"dssiprograminfo", sizeof(DSSIPROGRAMINFO), 0, "Sii", "ii", (SUBR)dssiprograminfo}, + {"dssiinfo", sizeof(DSSIINFO), 0, "", "i", (SUBR)dssiinfo}, + {"dssilist", sizeof(DSSILIST), 0, "", "", (SUBR)dssilist} +}; +LINKAGE diff --git a/7.x/src/dssi4cs/dssi4cs.h b/7.x/src/dssi4cs/dssi4cs.h new file mode 100644 index 0000000..c83c083 --- /dev/null +++ b/7.x/src/dssi4cs/dssi4cs.h @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2005 Andres Cabrera + * The dssi4cs library is free software; you can redistribute it + * and/or modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * The dssi4cs library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with The dssi4cs library; if not, write to the Free Software + * Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA + */ + +#ifndef DSSI4CS_H +#define DSSI4CS_H +#include "csdl.h" +#include +#include + +#define DSSI4CS_CHANNELS 9 +#define DSSI4CS_EVENTS 1024 +#define DSSI4CS_INSTANCES 256 + +typedef struct { + int64_t time; + snd_seq_event_t event; +} DSSI_EVENT; + +typedef struct DSSI_PLUGIN_ { + const LADSPA_Descriptor *ladspa; + const DSSI_Descriptor *dssi; + void *library; + LADSPA_Handle handle; + LADSPA_Data *control; + LADSPA_Data **audio; + int *mapping; + unsigned long *inputs, *outputs; + unsigned long input_count, output_count; + uint32_t capacity, render_ksmps; + cs_float sample_rate; + int active; + OPDS *owner; + int64_t last_block, rendered_until; + DSSI_EVENT queue[DSSI4CS_EVENTS]; + unsigned int queued; + snd_seq_event_t events[DSSI4CS_EVENTS + 16 * (128 + 3)]; + unsigned char notes[16][128]; + int panic; + unsigned long event_count; + unsigned int bank[16]; +} DSSI_PLUGIN; + +typedef struct { + unsigned int count; + DSSI_PLUGIN *plugins[DSSI4CS_INSTANCES]; +} DSSI_HOST; + +typedef struct { + OPDS h; + cs_float *result, *filename, *index, *verbose; +} DSSIINIT; + +typedef struct { + OPDS h; + cs_float *id, *trigger; + DSSI_PLUGIN *plugin; +} DSSIACTIVATE; + +typedef struct { + OPDS h; + cs_float *out[DSSI4CS_CHANNELS]; + cs_float *id, *in[DSSI4CS_CHANNELS]; + DSSI_PLUGIN *plugin; +} DSSIAUDIO; + +typedef struct { + OPDS h; + cs_float *id, *port, *value, *trigger; + DSSI_PLUGIN *plugin; + unsigned long index; +} DSSICTLS; + +typedef struct { + OPDS h; + cs_float *value, *id, *port; + DSSI_PLUGIN *plugin; + unsigned long index; +} DSSIGET; + +typedef struct { + OPDS h; + cs_float *trigger, *id, *note, *velocity, *duration, *channel; + DSSI_PLUGIN *plugin; +} DSSINOTE; + +typedef struct { + OPDS h; + cs_float *trigger, *id, *status, *channel, *data1, *data2, *offset; + DSSI_PLUGIN *plugin; +} DSSIEVENT; + +typedef struct { + OPDS h; + cs_float *trigger, *id, *channel, *parameter, *value, *offset; + DSSI_PLUGIN *plugin; +} DSSINRPN; + +typedef struct { + OPDS h; + cs_float *trigger, *id, *note, *velocity; + DSSI_PLUGIN *plugin; +} DSSINOTEON; + +typedef struct { + OPDS h; + cs_float *id, *bank, *program, *trigger; + DSSI_PLUGIN *plugin; +} DSSIPROGRAM; + +typedef struct { + OPDS h; + cs_float *id; + STRINGDAT *key, *value; +} DSSICONFIGURE; + +typedef struct { + OPDS h; + STRINGDAT *name; + cs_float *bank, *program, *id, *index; +} DSSIPROGRAMINFO; + +typedef struct { OPDS h; cs_float *id; } DSSIINFO; +typedef struct { OPDS h; } DSSILIST; +#endif diff --git a/7.x/src/dssi4cs/include/dssi/LICENSE b/7.x/src/dssi4cs/include/dssi/LICENSE new file mode 100644 index 0000000..6a6fbce --- /dev/null +++ b/7.x/src/dssi4cs/include/dssi/LICENSE @@ -0,0 +1,509 @@ + +*** NOTE: This license applies to the DSSI header file. See README +*** for a summary of the licensing of other files, and the individual +*** source code for more details. + + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + diff --git a/7.x/src/dssi4cs/include/dssi/README.md b/7.x/src/dssi4cs/include/dssi/README.md new file mode 100644 index 0000000..99103b8 --- /dev/null +++ b/7.x/src/dssi4cs/include/dssi/README.md @@ -0,0 +1,18 @@ +# DSSI + +Unmodified files from [release 1.1.1](https://downloads.sourceforge.net/project/dssi/dssi/1.1.1/dssi-1.1.1.tar.gz). + +Only the DSSI API header is vendored. +The header uses LGPL-2.1-or-later; see [LICENSE](LICENSE) and its license notice. + +[SOURCE.json](SOURCE.json) records the archive URL, SHA-256, and file paths. +Keep platform adapters in the plugin's own sources, outside this directory. + +Run `./update.py` for the latest stable release, `./update.py VERSION` for a +specific release, or `./update.py --pinned` to reproduce this copy and check its +archive hash. Downloads and extraction finish before checked-in files change. +The script requires curl and Python 3 and works from any directory. + +After an update, review the source and license diff, rebuild the DSSI/LADSPA +plugin on Linux, and verify that a native synth or effect still loads. Commit +the header, license, README, and SOURCE.json together. diff --git a/7.x/src/dssi4cs/include/dssi/SOURCE.json b/7.x/src/dssi4cs/include/dssi/SOURCE.json new file mode 100644 index 0000000..e91e398 --- /dev/null +++ b/7.x/src/dssi4cs/include/dssi/SOURCE.json @@ -0,0 +1,9 @@ +{ + "version": "1.1.1", + "url": "https://downloads.sourceforge.net/project/dssi/dssi/1.1.1/dssi-1.1.1.tar.gz", + "sha256": "f2c82b073a947c8255284249097667f9b14e660bf86186f3fcd3b3b3e087814e", + "files": { + "dssi.h": "dssi-1.1.1/dssi/dssi.h", + "LICENSE": "dssi-1.1.1/COPYING" + } +} diff --git a/7.x/src/dssi4cs/include/dssi/dssi.h b/7.x/src/dssi4cs/include/dssi/dssi.h new file mode 100644 index 0000000..fe4a20b --- /dev/null +++ b/7.x/src/dssi4cs/include/dssi/dssi.h @@ -0,0 +1,426 @@ +/* -*- c-basic-offset: 4 -*- */ + +/* dssi.h + + DSSI version 1.0 + Copyright (c) 2004, 2009 Chris Cannam, Steve Harris and Sean Bolton + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License + as published by the Free Software Foundation; either version 2.1 of + the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + MA 02110-1301 USA +*/ + +#ifndef DSSI_INCLUDED +#define DSSI_INCLUDED + +#include +#include + +#define DSSI_VERSION "1.0" +#define DSSI_VERSION_MAJOR 1 +#define DSSI_VERSION_MINOR 0 + +#ifdef __cplusplus +extern "C" { +#endif + +/* + There is a need for an API that supports hosted MIDI soft synths + with GUIs in Linux audio applications. In time the GMPI initiative + should comprehensively address this need, but the requirement for + Linux applications to be able to support simple hosted synths is + here now, and GMPI is not. This proposal (the "DSSI Soft Synth + Interface" or DSSI, pronounced "dizzy") aims to provide a simple + solution in a way that we hope will prove complete and compelling + enough to support now, yet not so compelling as to supplant GMPI or + any other comprehensive future proposal. + + For simplicity and familiarity, this API is based as far as + possible on existing work -- the LADSPA plugin API for control + values and audio processing, and the ALSA sequencer event types for + MIDI event communication. The GUI part of the proposal is quite + new, but may also be applicable retroactively to LADSPA plugins + that do not otherwise support this synth interface. +*/ + +typedef struct _DSSI_Program_Descriptor { + + /** Bank number for this program. Note that DSSI does not support + MIDI-style separation of bank LSB and MSB values. There is no + restriction on the set of available banks: the numbers do not + need to be contiguous, there does not need to be a bank 0, etc. */ + unsigned long Bank; + + /** Program number (unique within its bank) for this program. + There is no restriction on the set of available programs: the + numbers do not need to be contiguous, there does not need to + be a program 0, etc. */ + unsigned long Program; + + /** Name of the program. */ + const char * Name; + +} DSSI_Program_Descriptor; + + +typedef struct _DSSI_Descriptor { + + /** + * DSSI_API_Version + * + * This member indicates the DSSI API level used by this plugin. + * If we're lucky, this will never be needed. For now all plugins + * must set it to 1. + */ + int DSSI_API_Version; + + /** + * LADSPA_Plugin + * + * A DSSI synth plugin consists of a LADSPA plugin plus an + * additional framework for controlling program settings and + * transmitting MIDI events. A plugin must fully implement the + * LADSPA descriptor fields as well as the required LADSPA + * functions including instantiate() and (de)activate(). It + * should also implement run(), with the same behaviour as if + * run_synth() (below) were called with no synth events. + * + * In order to instantiate a synth the host calls the LADSPA + * instantiate function, passing in this LADSPA_Descriptor + * pointer. The returned LADSPA_Handle is used as the argument + * for the DSSI functions below as well as for the LADSPA ones. + */ + const LADSPA_Descriptor *LADSPA_Plugin; + + /** + * configure() + * + * This member is a function pointer that sends a piece of + * configuration data to the plugin. The key argument specifies + * some aspect of the synth's configuration that is to be changed, + * and the value argument specifies a new value for it. A plugin + * that does not require this facility at all may set this member + * to NULL. + * + * This call is intended to set some session-scoped aspect of a + * plugin's behaviour, for example to tell the plugin to load + * sample data from a particular file. The plugin should act + * immediately on the request. The call should return NULL on + * success, or an error string that may be shown to the user. The + * host will free the returned value after use if it is non-NULL. + * + * Calls to configure() are not automated as timed events. + * Instead, a host should remember the last value associated with + * each key passed to configure() during a given session for a + * given plugin instance, and should call configure() with the + * correct value for each key the next time it instantiates the + * "same" plugin instance, for example on reloading a project in + * which the plugin was used before. Plugins should note that a + * host may typically instantiate a plugin multiple times with the + * same configuration values, and should share data between + * instances where practical. + * + * Calling configure() completely invalidates the program and bank + * information last obtained from the plugin. + * + * Reserved and special key prefixes + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * The DSSI: prefix + * ---------------- + * Configure keys starting with DSSI: are reserved for particular + * purposes documented in the DSSI specification. At the moment, + * there is one such key: DSSI:PROJECT_DIRECTORY. A host may call + * configure() passing this key and a directory path value. This + * indicates to the plugin and its UI that a directory at that + * path exists and may be used for project-local data. Plugins + * may wish to use the project directory as a fallback location + * when looking for other file data, or as a base for relative + * paths in other configuration values. + * + * The GLOBAL: prefix + * ------------------ + * Configure keys starting with GLOBAL: may be used by the plugin + * and its UI for any purpose, but are treated specially by the + * host. When one of these keys is used in a configure OSC call + * from the plugin UI, the host makes the corresponding configure + * call (preserving the GLOBAL: prefix) not only to the target + * plugin but also to all other plugins in the same instance + * group, as well as their UIs. Note that if any instance + * returns non-NULL from configure to indicate error, the host + * may stop there (and the set of plugins on which configure has + * been called will thus depend on the host implementation). + * See also the configure OSC call documentation in RFC.txt. + */ + char *(*configure)(LADSPA_Handle Instance, + const char *Key, + const char *Value); + + #define DSSI_RESERVED_CONFIGURE_PREFIX "DSSI:" + #define DSSI_GLOBAL_CONFIGURE_PREFIX "GLOBAL:" + #define DSSI_PROJECT_DIRECTORY_KEY \ + DSSI_RESERVED_CONFIGURE_PREFIX "PROJECT_DIRECTORY" + + /** + * get_program() + * + * This member is a function pointer that provides a description + * of a program (named preset sound) available on this synth. A + * plugin that does not support programs at all should set this + * member to NULL. + * + * The Index argument is an index into the plugin's list of + * programs, not a program number as represented by the Program + * field of the DSSI_Program_Descriptor. (This distinction is + * needed to support synths that use non-contiguous program or + * bank numbers.) + * + * This function returns a DSSI_Program_Descriptor pointer that is + * guaranteed to be valid only until the next call to get_program, + * deactivate, or configure, on the same plugin instance. This + * function must return NULL if passed an Index argument out of + * range, so that the host can use it to query the number of + * programs as well as their properties. + */ + const DSSI_Program_Descriptor *(*get_program)(LADSPA_Handle Instance, + unsigned long Index); + + /** + * select_program() + * + * This member is a function pointer that selects a new program + * for this synth. The program change should take effect + * immediately at the start of the next run_synth() call. (This + * means that a host providing the capability of changing programs + * between any two notes on a track must vary the block size so as + * to place the program change at the right place. A host that + * wanted to avoid this would probably just instantiate a plugin + * for each program.) + * + * A plugin that does not support programs at all should set this + * member NULL. Plugins should ignore a select_program() call + * with an invalid bank or program. + * + * A plugin is not required to select any particular default + * program on activate(): it's the host's duty to set a program + * explicitly. The current program is invalidated by any call to + * configure(). + * + * A plugin is permitted to re-write the values of its input + * control ports when select_program is called. The host should + * re-read the input control port values and update its own + * records appropriately. (This is the only circumstance in + * which a DSSI plugin is allowed to modify its own input ports.) + */ + void (*select_program)(LADSPA_Handle Instance, + unsigned long Bank, + unsigned long Program); + + /** + * get_midi_controller_for_port() + * + * This member is a function pointer that returns the MIDI + * controller number or NRPN that should be mapped to the given + * input control port. If the given port should not have any MIDI + * controller mapped to it, the function should return DSSI_NONE. + * The behaviour of this function is undefined if the given port + * number does not correspond to an input control port. A plugin + * that does not want MIDI controllers mapped to ports at all may + * set this member NULL. + * + * Correct values can be got using the macros DSSI_CC(num) and + * DSSI_NRPN(num) as appropriate, and values can be combined using + * bitwise OR: e.g. DSSI_CC(23) | DSSI_NRPN(1069) means the port + * should respond to CC #23 and NRPN #1069. + * + * The host is responsible for doing proper scaling from MIDI + * controller and NRPN value ranges to port ranges according to + * the plugin's LADSPA port hints. Hosts should not deliver + * through run_synth any MIDI controller events that have already + * been mapped to control port values. + * + * A plugin should not attempt to request mappings from + * controllers 0 or 32 (MIDI Bank Select MSB and LSB). + */ + int (*get_midi_controller_for_port)(LADSPA_Handle Instance, + unsigned long Port); + + /** + * run_synth() + * + * This member is a function pointer that runs a synth for a + * block. This is identical in function to the LADSPA run() + * function, except that it also supplies events to the synth. + * + * A plugin may provide this function, run_multiple_synths() (see + * below), both, or neither (if it is not in fact a synth). A + * plugin that does not provide this function must set this member + * to NULL. Authors of synth plugins are encouraged to provide + * this function if at all possible. + * + * The Events pointer points to a block of EventCount ALSA + * sequencer events, which is used to communicate MIDI and related + * events to the synth. Each event is timestamped relative to the + * start of the block, (mis)using the ALSA "tick time" field as a + * frame count. The host is responsible for ensuring that events + * with differing timestamps are already ordered by time. + * + * See also the notes on activation, port connection etc in + * ladpsa.h, in the context of the LADSPA run() function. + * + * Note Events + * ~~~~~~~~~~~ + * There are two minor requirements aimed at making the plugin + * writer's life as simple as possible: + * + * 1. A host must never send events of type SND_SEQ_EVENT_NOTE. + * Notes should always be sent as separate SND_SEQ_EVENT_NOTE_ON + * and NOTE_OFF events. A plugin should discard any one-point + * NOTE events it sees. + * + * 2. A host must not attempt to switch notes off by sending + * zero-velocity NOTE_ON events. It should always send true + * NOTE_OFFs. It is the host's responsibility to remap events in + * cases where an external MIDI source has sent it zero-velocity + * NOTE_ONs. + * + * Bank and Program Events + * ~~~~~~~~~~~~~~~~~~~~~~~ + * Hosts must map MIDI Bank Select MSB and LSB (0 and 32) + * controllers and MIDI Program Change events onto the banks and + * programs specified by the plugin, using the DSSI select_program + * call. No host should ever deliver a program change or bank + * select controller to a plugin via run_synth. + */ + void (*run_synth)(LADSPA_Handle Instance, + unsigned long SampleCount, + snd_seq_event_t *Events, + unsigned long EventCount); + + /** + * run_synth_adding() + * + * This member is a function pointer that runs an instance of a + * synth for a block, adding its outputs to the values already + * present at the output ports. This is provided for symmetry + * with LADSPA run_adding(), and is equally optional. A plugin + * that does not provide it must set this member to NULL. + */ + void (*run_synth_adding)(LADSPA_Handle Instance, + unsigned long SampleCount, + snd_seq_event_t *Events, + unsigned long EventCount); + + /** + * run_multiple_synths() + * + * This member is a function pointer that runs multiple synth + * instances for a block. This is very similar to run_synth(), + * except that Instances, Events, and EventCounts each point to + * arrays that hold the LADSPA handles, event buffers, and + * event counts for each of InstanceCount instances. That is, + * Instances points to an array of InstanceCount pointers to + * DSSI plugin instantiations, Events points to an array of + * pointers to each instantiation's respective event list, and + * EventCounts points to an array containing each instantiation's + * respective event count. + * + * A host using this function must guarantee that ALL active + * instances of the plugin are represented in each call to the + * function -- that is, a host may not call run_multiple_synths() + * for some instances of a given plugin and then call run_synth() + * as well for others. 'All .. instances of the plugin' means + * every instance sharing the same LADSPA label and shared object + * (*.so) file (rather than every instance sharing the same *.so). + * 'Active' means any instance for which activate() has been called + * but deactivate() has not. + * + * A plugin may provide this function, run_synths() (see above), + * both, or neither (if it not in fact a synth). A plugin that + * does not provide this function must set this member to NULL. + * Plugin authors implementing run_multiple_synths are strongly + * encouraged to implement run_synth as well if at all possible, + * to aid simplistic hosts, even where it would be less efficient + * to use it. + */ + void (*run_multiple_synths)(unsigned long InstanceCount, + LADSPA_Handle *Instances, + unsigned long SampleCount, + snd_seq_event_t **Events, + unsigned long *EventCounts); + + /** + * run_multiple_synths_adding() + * + * This member is a function pointer that runs multiple synth + * instances for a block, adding each synth's outputs to the + * values already present at the output ports. This is provided + * for symmetry with both the DSSI run_multiple_synths() and LADSPA + * run_adding() functions, and is equally optional. A plugin + * that does not provide it must set this member to NULL. + */ + void (*run_multiple_synths_adding)(unsigned long InstanceCount, + LADSPA_Handle *Instances, + unsigned long SampleCount, + snd_seq_event_t **Events, + unsigned long *EventCounts); +} DSSI_Descriptor; + +/** + * DSSI supports a plugin discovery method similar to that of LADSPA: + * + * - DSSI hosts may wish to locate DSSI plugin shared object files by + * searching the paths contained in the DSSI_PATH and LADSPA_PATH + * environment variables, if they are present. Both are expected + * to be colon-separated lists of directories to be searched (in + * order), and DSSI_PATH should be searched first if both variables + * are set. + * + * - Each shared object file containing DSSI plugins must include a + * function dssi_descriptor(), with the following function prototype + * and C-style linkage. Hosts may enumerate the plugin types + * available in the shared object file by repeatedly calling + * this function with successive Index values (beginning from 0), + * until a return value of NULL indicates no more plugin types are + * available. Each non-NULL return is the DSSI_Descriptor + * of a distinct plugin type. + */ + +const DSSI_Descriptor *dssi_descriptor(unsigned long Index); + +typedef const DSSI_Descriptor *(*DSSI_Descriptor_Function)(unsigned long Index); + +/* + * Macros to specify particular MIDI controllers in return values from + * get_midi_controller_for_port() + */ + +#define DSSI_CC_BITS 0x20000000 +#define DSSI_NRPN_BITS 0x40000000 + +#define DSSI_NONE -1 +#define DSSI_CONTROLLER_IS_SET(n) (DSSI_NONE != (n)) + +#define DSSI_CC(n) (DSSI_CC_BITS | (n)) +#define DSSI_IS_CC(n) (DSSI_CC_BITS & (n)) +#define DSSI_CC_NUMBER(n) ((n) & 0x7f) + +#define DSSI_NRPN(n) (DSSI_NRPN_BITS | ((n) << 7)) +#define DSSI_IS_NRPN(n) (DSSI_NRPN_BITS & (n)) +#define DSSI_NRPN_NUMBER(n) (((n) >> 7) & 0x3fff) + +#ifdef __cplusplus +} +#endif + +#endif /* DSSI_INCLUDED */ diff --git a/7.x/src/dssi4cs/include/dssi/update.py b/7.x/src/dssi4cs/include/dssi/update.py new file mode 100755 index 0000000..6ab2551 --- /dev/null +++ b/7.x/src/dssi4cs/include/dssi/update.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python3 + +# Run from any directory. With no argument, select the latest numbered stable +# release. A version selects that release; --pinned reproduces SOURCE.json. +# Requires curl and Python 3. No upstream build scripts are run. +import hashlib +import json +from pathlib import Path +import re +import subprocess +import sys +import tarfile +import tempfile + +source_dir = Path(__file__).resolve().parent +if len(sys.argv) > 2 or (len(sys.argv) == 2 and sys.argv[1] == '--help'): + print(f'Usage: {sys.argv[0]} [VERSION|--pinned]') + sys.exit(0 if len(sys.argv) == 2 else 1) +selection = sys.argv[1] if len(sys.argv) == 2 else 'latest' + +def fetch(url, destination): + subprocess.run(['curl', '--fail', '--location', '--silent', '--show-error', + '--retry', '3', '--connect-timeout', '20', '--max-time', '120', + url, '-o', str(destination)], check=True) + +with tempfile.TemporaryDirectory(prefix='csound-dssi-') as temporary: + temporary = Path(temporary) + recorded = None + if selection == '--pinned': + recorded = json.loads((source_dir / 'SOURCE.json').read_text()) + version = recorded['version'] + elif selection == 'latest': + listing = temporary / 'releases.html' + fetch('https://sourceforge.net/projects/dssi/files/dssi/', listing) + versions = re.findall('/dssi/(\\d+(?:\\.\\d+)+)/', listing.read_text()) + if not versions: + sys.exit('No stable release found; checked-in files have not changed') + version = max(versions, key=lambda value: tuple(map(int, value.split('.')))) + else: + version = selection + if not re.fullmatch(r'\d+(?:\.\d+)+', version): + sys.exit('Expected a numbered release, for example 1.2.3') + + url = 'https://downloads.sourceforge.net/project/dssi/dssi/{version}/dssi-{version}.tar.gz'.format(version=version) + archive = temporary / 'source.tar' + fetch(url, archive) + digest = hashlib.sha256(archive.read_bytes()).hexdigest() + if recorded and digest != recorded['sha256']: + sys.exit('Archive differs from SOURCE.json; checked-in files have not changed') + files = {'dssi.h': 'dssi-{version}/dssi/dssi.h', 'LICENSE': 'dssi-{version}/COPYING'} + staged = {} + # Read only named files. Preserve upstream bytes, including license notices. + with tarfile.open(archive) as package: + for destination, member in files.items(): + entry = package.getmember(member.format(version=version)) + if not entry.isfile(): + sys.exit(f'Expected a file: {entry.name}') + staged[destination] = package.extractfile(entry).read() + metadata = {'version': version, 'url': url, 'sha256': digest, + 'files': {name: member.format(version=version) for name, member in files.items()}} + staged['SOURCE.json'] = (json.dumps(metadata, indent=2) + '\n').encode() + readme = f"""# DSSI + +Unmodified files from [release {version}]({url}). + +Only the DSSI API header is vendored. +The header uses LGPL-2.1-or-later; see [LICENSE](LICENSE) and its license notice. + +[SOURCE.json](SOURCE.json) records the archive URL, SHA-256, and file paths. +Keep platform adapters in the plugin's own sources, outside this directory. + +Run `./update.py` for the latest stable release, `./update.py VERSION` for a +specific release, or `./update.py --pinned` to reproduce this copy and check its +archive hash. Downloads and extraction finish before checked-in files change. +The script requires curl and Python 3 and works from any directory. + +After an update, review the source and license diff, rebuild the DSSI/LADSPA +plugin on Linux, and verify that a native synth or effect still loads. Commit +the header, license, README, and SOURCE.json together. +""" + staged['README.md'] = readme.encode() + # A failed download or missing archive member leaves the old copy intact. + for name, data in staged.items(): + destination = source_dir / name + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_bytes(data) + print(f'Updated DSSI to {version}. Source: {url}') diff --git a/7.x/src/dssi4cs/include/ladspa/LICENSE b/7.x/src/dssi4cs/include/ladspa/LICENSE new file mode 100644 index 0000000..07d2ddf --- /dev/null +++ b/7.x/src/dssi4cs/include/ladspa/LICENSE @@ -0,0 +1,514 @@ + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations +below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. +^L + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it +becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. +^L + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control +compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. +^L + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. +^L + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. +^L + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. +^L + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply, and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License +may add an explicit geographical distribution limitation excluding those +countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. +^L + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS +^L + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms +of the ordinary General Public License). + + To apply these terms, attach the following notices to the library. +It is safest to attach them to the start of each source file to most +effectively convey the exclusion of warranty; and each file should +have at least the "copyright" line and a pointer to where the full +notice is found. + + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +Also add information on how to contact you by electronic and paper +mail. + +You should also get your employer (if you work as a programmer) or +your school, if any, to sign a "copyright disclaimer" for the library, +if necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James + Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/7.x/src/dssi4cs/include/ladspa/README.md b/7.x/src/dssi4cs/include/ladspa/README.md new file mode 100644 index 0000000..8722ac6 --- /dev/null +++ b/7.x/src/dssi4cs/include/ladspa/README.md @@ -0,0 +1,18 @@ +# LADSPA + +Unmodified files from [release 1.17](https://www.ladspa.org/download/ladspa_sdk_1.17.tgz). + +Only the LADSPA API header is vendored. +The header uses LGPL-2.1-or-later; see [LICENSE](LICENSE) and its license notice. + +[SOURCE.json](SOURCE.json) records the archive URL, SHA-256, and file paths. +Keep platform adapters in the plugin's own sources, outside this directory. + +Run `./update.py` for the latest stable release, `./update.py VERSION` for a +specific release, or `./update.py --pinned` to reproduce this copy and check its +archive hash. Downloads and extraction finish before checked-in files change. +The script requires curl and Python 3 and works from any directory. + +After an update, review the source and license diff, rebuild the DSSI/LADSPA +plugin on Linux, and verify that a native synth or effect still loads. Commit +the header, license, README, and SOURCE.json together. diff --git a/7.x/src/dssi4cs/include/ladspa/SOURCE.json b/7.x/src/dssi4cs/include/ladspa/SOURCE.json new file mode 100644 index 0000000..06fcef5 --- /dev/null +++ b/7.x/src/dssi4cs/include/ladspa/SOURCE.json @@ -0,0 +1,9 @@ +{ + "version": "1.17", + "url": "https://www.ladspa.org/download/ladspa_sdk_1.17.tgz", + "sha256": "27d24f279e4b81bd17ecbdcc38e4c42991bb388826c0b200067ce0eb59d3da5b", + "files": { + "ladspa.h": "ladspa_sdk_1.17/src/ladspa.h", + "LICENSE": "ladspa_sdk_1.17/doc/COPYING" + } +} diff --git a/7.x/src/dssi4cs/include/ladspa/ladspa.h b/7.x/src/dssi4cs/include/ladspa/ladspa.h new file mode 100644 index 0000000..5c30a8a --- /dev/null +++ b/7.x/src/dssi4cs/include/ladspa/ladspa.h @@ -0,0 +1,603 @@ +/* ladspa.h + + Linux Audio Developer's Simple Plugin API Version 1.1[LGPL]. + Copyright (C) 2000-2002 Richard W.E. Furse, Paul Barton-Davis, + Stefan Westerfeld. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License + as published by the Free Software Foundation; either version 2.1 of + the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + USA. */ + +#ifndef LADSPA_INCLUDED +#define LADSPA_INCLUDED + +#define LADSPA_VERSION "1.1" +#define LADSPA_VERSION_MAJOR 1 +#define LADSPA_VERSION_MINOR 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/*****************************************************************************/ + +/* Overview: + + There is a large number of synthesis packages in use or development + on the Linux platform at this time. This API (`The Linux Audio + Developer's Simple Plugin API') attempts to give programmers the + ability to write simple `plugin' audio processors in C/C++ and link + them dynamically (`plug') into a range of these packages (`hosts'). + It should be possible for any host and any plugin to communicate + completely through this interface. + + This API is deliberately short and simple. To achieve compatibility + with a range of promising Linux sound synthesis packages it + attempts to find the `greatest common divisor' in their logical + behaviour. Having said this, certain limiting decisions are + implicit, notably the use of a fixed type (LADSPA_Data) for all + data transfer and absence of a parameterised `initialisation' + phase. See below for the LADSPA_Data typedef. + + Plugins are expected to distinguish between control and audio + data. Plugins have `ports' that are inputs or outputs for audio or + control data and each plugin is `run' for a `block' corresponding + to a short time interval measured in samples. Audio data is + communicated using arrays of LADSPA_Data, allowing a block of audio + to be processed by the plugin in a single pass. Control data is + communicated using single LADSPA_Data values. Control data has a + single value at the start of a call to the `run()' or `run_adding()' + function, and may be considered to remain this value for its + duration. The plugin may assume that all its input and output ports + have been connected to the relevant data location (see the + `connect_port()' function below) before it is asked to run. + + Plugins will reside in shared object files suitable for dynamic + linking by dlopen() and family. The file will provide a number of + `plugin types' that can be used to instantiate actual plugins + (sometimes known as `plugin instances') that can be connected + together to perform tasks. + + This API contains very limited error-handling. */ + +/*****************************************************************************/ + +/* Fundamental data type passed in and out of plugin. This data type + is used to communicate audio samples and control values. It is + assumed that the plugin will work sensibly given any numeric input + value although it may have a preferred range (see hints below). + + For audio it is generally assumed that 1.0f is the `0dB' reference + amplitude and is a `normal' signal level. */ + +typedef float LADSPA_Data; + +/*****************************************************************************/ + +/* Special Plugin Properties: + + Optional features of the plugin type are encapsulated in the + LADSPA_Properties type. This is assembled by ORing individual + properties together. */ + +typedef int LADSPA_Properties; + +/* Property LADSPA_PROPERTY_REALTIME indicates that the plugin has a + real-time dependency (e.g. listens to a MIDI device) and so its + output must not be cached or subject to significant latency. */ +#define LADSPA_PROPERTY_REALTIME 0x1 + +/* Property LADSPA_PROPERTY_INPLACE_BROKEN indicates that the plugin + may cease to work correctly if the host elects to use the same data + location for both input and output (see connect_port()). This + should be avoided as enabling this flag makes it impossible for + hosts to use the plugin to process audio `in-place.' */ +#define LADSPA_PROPERTY_INPLACE_BROKEN 0x2 + +/* Property LADSPA_PROPERTY_HARD_RT_CAPABLE indicates that the plugin + is capable of running not only in a conventional host but also in a + `hard real-time' environment. To qualify for this the plugin must + satisfy all of the following: + + (1) The plugin must not use malloc(), free() or other heap memory + management within its run() or run_adding() functions. All new + memory used in run() must be managed via the stack. These + restrictions only apply to the run() function. + + (2) The plugin will not attempt to make use of any library + functions with the exceptions of functions in the ANSI standard C + and C maths libraries, which the host is expected to provide. + + (3) The plugin will not access files, devices, pipes, sockets, IPC + or any other mechanism that might result in process or thread + blocking. + + (4) The plugin will take an amount of time to execute a run() or + run_adding() call approximately of form (A+B*SampleCount) where A + and B depend on the machine and host in use. This amount of time + may not depend on input signals or plugin state. The host is left + the responsibility to perform timings to estimate upper bounds for + A and B. */ +#define LADSPA_PROPERTY_HARD_RT_CAPABLE 0x4 + +#define LADSPA_IS_REALTIME(x) ((x) & LADSPA_PROPERTY_REALTIME) +#define LADSPA_IS_INPLACE_BROKEN(x) ((x) & LADSPA_PROPERTY_INPLACE_BROKEN) +#define LADSPA_IS_HARD_RT_CAPABLE(x) ((x) & LADSPA_PROPERTY_HARD_RT_CAPABLE) + +/*****************************************************************************/ + +/* Plugin Ports: + + Plugins have `ports' that are inputs or outputs for audio or + data. Ports can communicate arrays of LADSPA_Data (for audio + inputs/outputs) or single LADSPA_Data values (for control + input/outputs). This information is encapsulated in the + LADSPA_PortDescriptor type which is assembled by ORing individual + properties together. + + Note that a port must be an input or an output port but not both + and that a port must be a control or audio port but not both. */ + +typedef int LADSPA_PortDescriptor; + +/* Property LADSPA_PORT_INPUT indicates that the port is an input. */ +#define LADSPA_PORT_INPUT 0x1 + +/* Property LADSPA_PORT_OUTPUT indicates that the port is an output. */ +#define LADSPA_PORT_OUTPUT 0x2 + +/* Property LADSPA_PORT_CONTROL indicates that the port is a control + port. */ +#define LADSPA_PORT_CONTROL 0x4 + +/* Property LADSPA_PORT_AUDIO indicates that the port is a audio + port. */ +#define LADSPA_PORT_AUDIO 0x8 + +#define LADSPA_IS_PORT_INPUT(x) ((x) & LADSPA_PORT_INPUT) +#define LADSPA_IS_PORT_OUTPUT(x) ((x) & LADSPA_PORT_OUTPUT) +#define LADSPA_IS_PORT_CONTROL(x) ((x) & LADSPA_PORT_CONTROL) +#define LADSPA_IS_PORT_AUDIO(x) ((x) & LADSPA_PORT_AUDIO) + +/*****************************************************************************/ + +/* Plugin Port Range Hints: + + The host may wish to provide a representation of data entering or + leaving a plugin (e.g. to generate a GUI automatically). To make + this more meaningful, the plugin should provide `hints' to the host + describing the usual values taken by the data. + + Note that these are only hints. The host may ignore them and the + plugin must not assume that data supplied to it is meaningful. If + the plugin receives invalid input data it is expected to continue + to run without failure and, where possible, produce a sensible + output (e.g. a high-pass filter given a negative cutoff frequency + might switch to an all-pass mode). + + Hints are meaningful for all input and output ports but hints for + input control ports are expected to be particularly useful. + + More hint information is encapsulated in the + LADSPA_PortRangeHintDescriptor type which is assembled by ORing + individual hint types together. Hints may require further + LowerBound and UpperBound information. + + All the hint information for a particular port is aggregated in the + LADSPA_PortRangeHint structure. */ + +typedef int LADSPA_PortRangeHintDescriptor; + +/* Hint LADSPA_HINT_BOUNDED_BELOW indicates that the LowerBound field + of the LADSPA_PortRangeHint should be considered meaningful. The + value in this field should be considered the (inclusive) lower + bound of the valid range. If LADSPA_HINT_SAMPLE_RATE is also + specified then the value of LowerBound should be multiplied by the + sample rate. */ +#define LADSPA_HINT_BOUNDED_BELOW 0x1 + +/* Hint LADSPA_HINT_BOUNDED_ABOVE indicates that the UpperBound field + of the LADSPA_PortRangeHint should be considered meaningful. The + value in this field should be considered the (inclusive) upper + bound of the valid range. If LADSPA_HINT_SAMPLE_RATE is also + specified then the value of UpperBound should be multiplied by the + sample rate. */ +#define LADSPA_HINT_BOUNDED_ABOVE 0x2 + +/* Hint LADSPA_HINT_TOGGLED indicates that the data item should be + considered a Boolean toggle. Data less than or equal to zero should + be considered `off' or `false,' and data above zero should be + considered `on' or `true.' LADSPA_HINT_TOGGLED may not be used in + conjunction with any other hint except LADSPA_HINT_DEFAULT_0 or + LADSPA_HINT_DEFAULT_1. */ +#define LADSPA_HINT_TOGGLED 0x4 + +/* Hint LADSPA_HINT_SAMPLE_RATE indicates that any bounds specified + should be interpreted as multiples of the sample rate. For + instance, a frequency range from 0Hz to the Nyquist frequency (half + the sample rate) could be requested by this hint in conjunction + with LowerBound = 0 and UpperBound = 0.5. Hosts that support bounds + at all must support this hint to retain meaning. */ +#define LADSPA_HINT_SAMPLE_RATE 0x8 + +/* Hint LADSPA_HINT_LOGARITHMIC indicates that it is likely that the + user will find it more intuitive to view values using a logarithmic + scale. This is particularly useful for frequencies and gains. */ +#define LADSPA_HINT_LOGARITHMIC 0x10 + +/* Hint LADSPA_HINT_INTEGER indicates that a user interface would + probably wish to provide a stepped control taking only integer + values. Any bounds set should be slightly wider than the actual + integer range required to avoid floating point rounding errors. For + instance, the integer set {0,1,2,3} might be described as [-0.1, + 3.1]. */ +#define LADSPA_HINT_INTEGER 0x20 + +/* The various LADSPA_HINT_HAS_DEFAULT_* hints indicate a `normal' + value for the port that is sensible as a default. For instance, + this value is suitable for use as an initial value in a user + interface or as a value the host might assign to a control port + when the user has not provided one. Defaults are encoded using a + mask so only one default may be specified for a port. Some of the + hints make use of lower and upper bounds, in which case the + relevant bound or bounds must be available and + LADSPA_HINT_SAMPLE_RATE must be applied as usual. The resulting + default must be rounded if LADSPA_HINT_INTEGER is present. Default + values were introduced in LADSPA v1.1. */ +#define LADSPA_HINT_DEFAULT_MASK 0x3C0 + +/* This default values indicates that no default is provided. */ +#define LADSPA_HINT_DEFAULT_NONE 0x0 + +/* This default hint indicates that the suggested lower bound for the + port should be used. */ +#define LADSPA_HINT_DEFAULT_MINIMUM 0x40 + +/* This default hint indicates that a low value between the suggested + lower and upper bounds should be chosen. For ports with + LADSPA_HINT_LOGARITHMIC, this should be exp(log(lower) * 0.75 + + log(upper) * 0.25). Otherwise, this should be (lower * 0.75 + upper + * 0.25). */ +#define LADSPA_HINT_DEFAULT_LOW 0x80 + +/* This default hint indicates that a middle value between the + suggested lower and upper bounds should be chosen. For ports with + LADSPA_HINT_LOGARITHMIC, this should be exp(log(lower) * 0.5 + + log(upper) * 0.5). Otherwise, this should be (lower * 0.5 + upper * + 0.5). */ +#define LADSPA_HINT_DEFAULT_MIDDLE 0xC0 + +/* This default hint indicates that a high value between the suggested + lower and upper bounds should be chosen. For ports with + LADSPA_HINT_LOGARITHMIC, this should be exp(log(lower) * 0.25 + + log(upper) * 0.75). Otherwise, this should be (lower * 0.25 + upper + * 0.75). */ +#define LADSPA_HINT_DEFAULT_HIGH 0x100 + +/* This default hint indicates that the suggested upper bound for the + port should be used. */ +#define LADSPA_HINT_DEFAULT_MAXIMUM 0x140 + +/* This default hint indicates that the number 0 should be used. Note + that this default may be used in conjunction with + LADSPA_HINT_TOGGLED. */ +#define LADSPA_HINT_DEFAULT_0 0x200 + +/* This default hint indicates that the number 1 should be used. Note + that this default may be used in conjunction with + LADSPA_HINT_TOGGLED. */ +#define LADSPA_HINT_DEFAULT_1 0x240 + +/* This default hint indicates that the number 100 should be used. */ +#define LADSPA_HINT_DEFAULT_100 0x280 + +/* This default hint indicates that the Hz frequency of `concert A' + should be used. This will be 440 unless the host uses an unusual + tuning convention, in which case it may be within a few Hz. */ +#define LADSPA_HINT_DEFAULT_440 0x2C0 + +#define LADSPA_IS_HINT_BOUNDED_BELOW(x) ((x) & LADSPA_HINT_BOUNDED_BELOW) +#define LADSPA_IS_HINT_BOUNDED_ABOVE(x) ((x) & LADSPA_HINT_BOUNDED_ABOVE) +#define LADSPA_IS_HINT_TOGGLED(x) ((x) & LADSPA_HINT_TOGGLED) +#define LADSPA_IS_HINT_SAMPLE_RATE(x) ((x) & LADSPA_HINT_SAMPLE_RATE) +#define LADSPA_IS_HINT_LOGARITHMIC(x) ((x) & LADSPA_HINT_LOGARITHMIC) +#define LADSPA_IS_HINT_INTEGER(x) ((x) & LADSPA_HINT_INTEGER) + +#define LADSPA_IS_HINT_HAS_DEFAULT(x) ((x) & LADSPA_HINT_DEFAULT_MASK) +#define LADSPA_IS_HINT_DEFAULT_MINIMUM(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_MINIMUM) +#define LADSPA_IS_HINT_DEFAULT_LOW(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_LOW) +#define LADSPA_IS_HINT_DEFAULT_MIDDLE(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_MIDDLE) +#define LADSPA_IS_HINT_DEFAULT_HIGH(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_HIGH) +#define LADSPA_IS_HINT_DEFAULT_MAXIMUM(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_MAXIMUM) +#define LADSPA_IS_HINT_DEFAULT_0(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_0) +#define LADSPA_IS_HINT_DEFAULT_1(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_1) +#define LADSPA_IS_HINT_DEFAULT_100(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_100) +#define LADSPA_IS_HINT_DEFAULT_440(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \ + == LADSPA_HINT_DEFAULT_440) + +typedef struct _LADSPA_PortRangeHint { + + /* Hints about the port. */ + LADSPA_PortRangeHintDescriptor HintDescriptor; + + /* Meaningful when hint LADSPA_HINT_BOUNDED_BELOW is active. When + LADSPA_HINT_SAMPLE_RATE is also active then this value should be + multiplied by the relevant sample rate. */ + LADSPA_Data LowerBound; + + /* Meaningful when hint LADSPA_HINT_BOUNDED_ABOVE is active. When + LADSPA_HINT_SAMPLE_RATE is also active then this value should be + multiplied by the relevant sample rate. */ + LADSPA_Data UpperBound; + +} LADSPA_PortRangeHint; + +/*****************************************************************************/ + +/* Plugin Handles: + + This plugin handle indicates a particular instance of the plugin + concerned. It is valid to compare this to NULL (0 for C++) but + otherwise the host should not attempt to interpret it. The plugin + may use it to reference internal instance data. */ + +typedef void * LADSPA_Handle; + +/*****************************************************************************/ + +/* Descriptor for a Type of Plugin: + + This structure is used to describe a plugin type. It provides a + number of functions to examine the type, instantiate it, link it to + buffers and workspaces and to run it. */ + +typedef struct _LADSPA_Descriptor { + + /* This numeric identifier indicates the plugin type + uniquely. Plugin programmers may reserve ranges of IDs from a + central body to avoid clashes. Hosts may assume that IDs are + below 0x1000000. */ + unsigned long UniqueID; + + /* This identifier can be used as a unique, case-sensitive + identifier for the plugin type within the plugin file. Plugin + types should be identified by file and label rather than by index + or plugin name, which may be changed in new plugin + versions. Labels must not contain white-space characters. */ + const char * Label; + + /* This indicates a number of properties of the plugin. */ + LADSPA_Properties Properties; + + /* This member points to the null-terminated name of the plugin + (e.g. "Sine Oscillator"). */ + const char * Name; + + /* This member points to the null-terminated string indicating the + maker of the plugin. This can be an empty string but not NULL. */ + const char * Maker; + + /* This member points to the null-terminated string indicating any + copyright applying to the plugin. If no Copyright applies the + string "None" should be used. */ + const char * Copyright; + + /* This indicates the number of ports (input AND output) present on + the plugin. */ + unsigned long PortCount; + + /* This member indicates an array of port descriptors. Valid indices + vary from 0 to PortCount-1. */ + const LADSPA_PortDescriptor * PortDescriptors; + + /* This member indicates an array of null-terminated strings + describing ports (e.g. "Frequency (Hz)"). Valid indices vary from + 0 to PortCount-1. */ + const char * const * PortNames; + + /* This member indicates an array of range hints for each port (see + above). Valid indices vary from 0 to PortCount-1. */ + const LADSPA_PortRangeHint * PortRangeHints; + + /* This may be used by the plugin developer to pass any custom + implementation data into an instantiate call. It must not be used + or interpreted by the host. It is expected that most plugin + writers will not use this facility as LADSPA_Handle should be + used to hold instance data. */ + void * ImplementationData; + + /* This member is a function pointer that instantiates a plugin. A + handle is returned indicating the new plugin instance. The + instantiation function accepts a sample rate as a parameter. The + plugin descriptor from which this instantiate function was found + must also be passed. This function must return NULL if + instantiation fails. + + Note that instance initialisation should generally occur in + activate() rather than here. */ + LADSPA_Handle (*instantiate)(const struct _LADSPA_Descriptor * Descriptor, + unsigned long SampleRate); + + /* This member is a function pointer that connects a port on an + instantiated plugin to a memory location at which a block of data + for the port will be read/written. The data location is expected + to be an array of LADSPA_Data for audio ports or a single + LADSPA_Data value for control ports. Memory issues will be + managed by the host. The plugin must read/write the data at these + locations every time run() or run_adding() is called and the data + present at the time of this connection call should not be + considered meaningful. + + connect_port() may be called more than once for a plugin instance + to allow the host to change the buffers that the plugin is + reading or writing. These calls may be made before or after + activate() or deactivate() calls. + + connect_port() must be called at least once for each port before + run() or run_adding() is called. When working with blocks of + LADSPA_Data the plugin should pay careful attention to the block + size passed to the run function as the block allocated may only + just be large enough to contain the block of samples. + + Plugin writers should be aware that the host may elect to use the + same buffer for more than one port and even use the same buffer + for both input and output (see LADSPA_PROPERTY_INPLACE_BROKEN). + However, overlapped buffers or use of a single buffer for both + audio and control data may result in unexpected behaviour. */ + void (*connect_port)(LADSPA_Handle Instance, + unsigned long Port, + LADSPA_Data * DataLocation); + + /* This member is a function pointer that initialises a plugin + instance and activates it for use. This is separated from + instantiate() to aid real-time support and so that hosts can + reinitialise a plugin instance by calling deactivate() and then + activate(). In this case the plugin instance must reset all state + information dependent on the history of the plugin instance + except for any data locations provided by connect_port() and any + gain set by set_run_adding_gain(). If there is nothing for + activate() to do then the plugin writer may provide a NULL rather + than an empty function. + + When present, hosts must call this function once before run() (or + run_adding()) is called for the first time. This call should be + made as close to the run() call as possible and indicates to + real-time plugins that they are now live. Plugins should not rely + on a prompt call to run() after activate(). activate() may not be + called again unless deactivate() is called first. Note that + connect_port() may be called before or after a call to + activate(). */ + void (*activate)(LADSPA_Handle Instance); + + /* This method is a function pointer that runs an instance of a + plugin for a block. Two parameters are required: the first is a + handle to the particular instance to be run and the second + indicates the block size (in samples) for which the plugin + instance may run. + + Note that if an activate() function exists then it must be called + before run() or run_adding(). If deactivate() is called for a + plugin instance then the plugin instance may not be reused until + activate() has been called again. + + If the plugin has the property LADSPA_PROPERTY_HARD_RT_CAPABLE + then there are various things that the plugin should not do + within the run() or run_adding() functions (see above). */ + void (*run)(LADSPA_Handle Instance, + unsigned long SampleCount); + + /* This method is a function pointer that runs an instance of a + plugin for a block. This has identical behaviour to run() except + in the way data is output from the plugin. When run() is used, + values are written directly to the memory areas associated with + the output ports. However when run_adding() is called, values + must be added to the values already present in the memory + areas. Furthermore, output values written must be scaled by the + current gain set by set_run_adding_gain() (see below) before + addition. + + run_adding() is optional. When it is not provided by a plugin, + this function pointer must be set to NULL. When it is provided, + the function set_run_adding_gain() must be provided also. */ + void (*run_adding)(LADSPA_Handle Instance, + unsigned long SampleCount); + + /* This method is a function pointer that sets the output gain for + use when run_adding() is called (see above). If this function is + never called the gain is assumed to default to 1. Gain + information should be retained when activate() or deactivate() + are called. + + This function should be provided by the plugin if and only if the + run_adding() function is provided. When it is absent this + function pointer must be set to NULL. */ + void (*set_run_adding_gain)(LADSPA_Handle Instance, + LADSPA_Data Gain); + + /* This is the counterpart to activate() (see above). If there is + nothing for deactivate() to do then the plugin writer may provide + a NULL rather than an empty function. + + Hosts must deactivate all activated units after they have been + run() (or run_adding()) for the last time. This call should be + made as close to the last run() call as possible and indicates to + real-time plugins that they are no longer live. Plugins should + not rely on prompt deactivation. Note that connect_port() may be + called before or after a call to deactivate(). + + Deactivation is not similar to pausing as the plugin instance + will be reinitialised when activate() is called to reuse it. */ + void (*deactivate)(LADSPA_Handle Instance); + + /* Once an instance of a plugin has been finished with it can be + deleted using the following function. The instance handle passed + ceases to be valid after this call. + + If activate() was called for a plugin instance then a + corresponding call to deactivate() must be made before cleanup() + is called. */ + void (*cleanup)(LADSPA_Handle Instance); + +} LADSPA_Descriptor; + +/**********************************************************************/ + +/* Accessing a Plugin: */ + +/* The exact mechanism by which plugins are loaded is host-dependent, + however all most hosts will need to know is the name of shared + object file containing the plugin types. To allow multiple hosts to + share plugin types, hosts may wish to check for environment + variable LADSPA_PATH. If present, this should contain a + colon-separated path indicating directories that should be searched + (in order) when loading plugin types. + + A plugin programmer must include a function called + "ladspa_descriptor" with the following function prototype within + the shared object file. This function will have C-style linkage (if + you are using C++ this is taken care of by the `extern "C"' clause + at the top of the file). + + A host will find the plugin shared object file by one means or + another, find the ladspa_descriptor() function, call it, and + proceed from there. + + Plugin types are accessed by index (not ID) using values from 0 + upwards. Out of range indexes must result in this function + returning NULL, so the plugin count can be determined by checking + for the least index that results in NULL being returned. */ + +const LADSPA_Descriptor * ladspa_descriptor(unsigned long Index); + +/* Datatype corresponding to the ladspa_descriptor() function. */ +typedef const LADSPA_Descriptor * +(*LADSPA_Descriptor_Function)(unsigned long Index); + +/**********************************************************************/ + +#ifdef __cplusplus +} +#endif + +#endif /* LADSPA_INCLUDED */ + +/* EOF */ diff --git a/7.x/src/dssi4cs/include/ladspa/update.py b/7.x/src/dssi4cs/include/ladspa/update.py new file mode 100755 index 0000000..30fc025 --- /dev/null +++ b/7.x/src/dssi4cs/include/ladspa/update.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python3 + +# Run from any directory. With no argument, select the latest numbered stable +# release. A version selects that release; --pinned reproduces SOURCE.json. +# Requires curl and Python 3. No upstream build scripts are run. +import hashlib +import json +from pathlib import Path +import re +import subprocess +import sys +import tarfile +import tempfile + +source_dir = Path(__file__).resolve().parent +if len(sys.argv) > 2 or (len(sys.argv) == 2 and sys.argv[1] == '--help'): + print(f'Usage: {sys.argv[0]} [VERSION|--pinned]') + sys.exit(0 if len(sys.argv) == 2 else 1) +selection = sys.argv[1] if len(sys.argv) == 2 else 'latest' + +def fetch(url, destination): + subprocess.run(['curl', '--fail', '--location', '--silent', '--show-error', + '--retry', '3', '--connect-timeout', '20', '--max-time', '120', + url, '-o', str(destination)], check=True) + +with tempfile.TemporaryDirectory(prefix='csound-ladspa-') as temporary: + temporary = Path(temporary) + recorded = None + if selection == '--pinned': + recorded = json.loads((source_dir / 'SOURCE.json').read_text()) + version = recorded['version'] + elif selection == 'latest': + listing = temporary / 'releases.html' + fetch('https://www.ladspa.org/ladspa_sdk/download.html', listing) + versions = re.findall('ladspa_sdk_(\\d+(?:\\.\\d+)+)\\.tgz', listing.read_text()) + if not versions: + sys.exit('No stable release found; checked-in files have not changed') + version = max(versions, key=lambda value: tuple(map(int, value.split('.')))) + else: + version = selection + if not re.fullmatch(r'\d+(?:\.\d+)+', version): + sys.exit('Expected a numbered release, for example 1.2.3') + + url = 'https://www.ladspa.org/download/ladspa_sdk_{version}.tgz'.format(version=version) + archive = temporary / 'source.tar' + fetch(url, archive) + digest = hashlib.sha256(archive.read_bytes()).hexdigest() + if recorded and digest != recorded['sha256']: + sys.exit('Archive differs from SOURCE.json; checked-in files have not changed') + files = {'ladspa.h': 'ladspa_sdk_{version}/src/ladspa.h', 'LICENSE': 'ladspa_sdk_{version}/doc/COPYING'} + staged = {} + # Read only named files. Preserve upstream bytes, including license notices. + with tarfile.open(archive) as package: + for destination, member in files.items(): + entry = package.getmember(member.format(version=version)) + if not entry.isfile(): + sys.exit(f'Expected a file: {entry.name}') + staged[destination] = package.extractfile(entry).read() + metadata = {'version': version, 'url': url, 'sha256': digest, + 'files': {name: member.format(version=version) for name, member in files.items()}} + staged['SOURCE.json'] = (json.dumps(metadata, indent=2) + '\n').encode() + readme = f"""# LADSPA + +Unmodified files from [release {version}]({url}). + +Only the LADSPA API header is vendored. +The header uses LGPL-2.1-or-later; see [LICENSE](LICENSE) and its license notice. + +[SOURCE.json](SOURCE.json) records the archive URL, SHA-256, and file paths. +Keep platform adapters in the plugin's own sources, outside this directory. + +Run `./update.py` for the latest stable release, `./update.py VERSION` for a +specific release, or `./update.py --pinned` to reproduce this copy and check its +archive hash. Downloads and extraction finish before checked-in files change. +The script requires curl and Python 3 and works from any directory. + +After an update, review the source and license diff, rebuild the DSSI/LADSPA +plugin on Linux, and verify that a native synth or effect still loads. Commit +the header, license, README, and SOURCE.json together. +""" + staged['README.md'] = readme.encode() + # A failed download or missing archive member leaves the old copy intact. + for name, data in staged.items(): + destination = source_dir / name + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_bytes(data) + print(f'Updated LADSPA to {version}. Source: {url}') diff --git a/7.x/src/dssi4cs/load.c b/7.x/src/dssi4cs/load.c new file mode 100644 index 0000000..8456999 --- /dev/null +++ b/7.x/src/dssi4cs/load.c @@ -0,0 +1,49 @@ +/* load.c + + Copyright 2005 Richard W.E. Furse + with Csound adjustments by Andres Cabrera, Istvan Varga, John ffitch + + Free software by Richard W.E. Furse. Do with as you will. No + warranty. */ + +#include "utils.h" +#include + +static void *try_library(CSOUND *csound, const char *path, int flags) +{ + const char *suffixes[] = {"", ".so", NULL}; + for (int i = 0; suffixes[i]; ++i) { + size_t size = strlen(path) + strlen(suffixes[i]) + 1; + char *name = csound->Malloc(csound, size); + snprintf(name, size, "%s%s", path, suffixes[i]); + void *library = dlopen(name, flags | RTLD_LOCAL); + csound->Free(csound, name); + if (library) return library; + } + return NULL; +} + +void *dlopenLADSPA(CSOUND *csound, const char *name, int32_t flags) +{ + if (strchr(name, '/')) return try_library(csound, name, flags); + const char *paths[] = {csound->GetEnv(csound, "DSSI_PATH"), + csound->GetEnv(csound, "LADSPA_PATH"), + DSSI4CS_DEFAULT_PATH}; + for (unsigned i = 0; i < sizeof(paths)/sizeof(paths[0]); ++i) { + const char *start = paths[i]; + while (start && *start) { + const char *end = strchr(start, ':'); + size_t len = end ? (size_t)(end - start) : strlen(start); + if (len) { + size_t size = len + strlen(name) + 2; + char *path = csound->Malloc(csound, size); + snprintf(path, size, "%.*s/%s", (int)len, start, name); + void *library = try_library(csound, path, flags); + csound->Free(csound, path); + if (library) return library; + } + start = end ? end + 1 : NULL; + } + } + return NULL; +} diff --git a/7.x/src/dssi4cs/utils.h b/7.x/src/dssi4cs/utils.h new file mode 100644 index 0000000..2d1f68a --- /dev/null +++ b/7.x/src/dssi4cs/utils.h @@ -0,0 +1,7 @@ +/* Native DSSI/LADSPA library lookup. */ +#ifndef DSSI4CS_UTILS_H +#define DSSI4CS_UTILS_H +#include "csdl.h" +#define DSSI4CS_DEFAULT_PATH "/usr/local/lib/dssi:/usr/lib/dssi:/usr/lib64/dssi:/usr/local/lib/ladspa:/usr/lib/ladspa:/usr/lib64/ladspa" +void *dlopenLADSPA(CSOUND *, const char *, int32_t); +#endif From 2ced540a5958acc25af39491c200f1684fc9356d Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Thu, 15 Oct 2026 08:15:36 +0100 Subject: [PATCH 65/72] Fix misplaced semicolon in generated pycall oresult field The pycall generator emitted the terminating semicolon after the newline, producing a malformed 'cs_float oresult\n;}' in the generated struct. Move the semicolon before the newline and update the generated header to match the generator output. --- 7.x/src/py/src/pycall-gen.py | 2 +- 7.x/src/py/src/pycall.auto.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/7.x/src/py/src/pycall-gen.py b/7.x/src/py/src/pycall-gen.py index c7d983c..9a6b283 100644 --- a/7.x/src/py/src/pycall-gen.py +++ b/7.x/src/py/src/pycall-gen.py @@ -174,7 +174,7 @@ def generate_pycall_opcode_struct(f, n, triggered=0): s += ' cs_float *args[VARGMAX-3];\n' if triggered: if n == 1: - s += ' cs_float oresult\n;' + s += ' cs_float oresult;\n' else: for i in range(n): s += ' cs_float oresult%d;\n' % (i+1) diff --git a/7.x/src/py/src/pycall.auto.h b/7.x/src/py/src/pycall.auto.h index 6127ad0..aa59ce1 100644 --- a/7.x/src/py/src/pycall.auto.h +++ b/7.x/src/py/src/pycall.auto.h @@ -46,8 +46,8 @@ typedef struct { cs_float *trigger; STRINGDAT *function; cs_float *args[VARGMAX-3]; - cs_float oresult -;} PYCALL1T; + cs_float oresult; +} PYCALL1T; typedef struct { OPDS h; From bc4672495cd6b990fdd37d188f9a8543b4d91f8c Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Thu, 15 Oct 2026 08:44:34 +0100 Subject: [PATCH 66/72] Fix dssiaudio/dssisynth input types and multiarch search path Two issues inherited from the migrated upstream sources: - dssiaudio/dssisynth declared their audio inputs with the 'M' vararg type, which also accepts i-rate and k-rate arguments. The opcode always reads ksmps samples from each input, so an i- or k-rate argument led to out-of-bounds reads. Use 'y' (a-rate only) instead. - DSSI4CS_DEFAULT_PATH omitted the multiarch library directories used on Debian/Ubuntu, so plugins installed under /usr/lib//dssi and /usr/lib//ladspa were not found unless DSSI_PATH or LADSPA_PATH was set. The build now prepends the detected CMAKE_LIBRARY_ARCHITECTURE directory. --- 7.x/src/dssi4cs/CMakeLists.txt | 9 +++++++++ 7.x/src/dssi4cs/README.md | 6 ++++-- 7.x/src/dssi4cs/dssi4cs.c | 4 ++-- 7.x/src/dssi4cs/utils.h | 9 ++++++++- 4 files changed, 23 insertions(+), 5 deletions(-) diff --git a/7.x/src/dssi4cs/CMakeLists.txt b/7.x/src/dssi4cs/CMakeLists.txt index a9a61a1..ea3de70 100644 --- a/7.x/src/dssi4cs/CMakeLists.txt +++ b/7.x/src/dssi4cs/CMakeLists.txt @@ -22,4 +22,13 @@ if(BUILD_DSSI_OPCODES) ${DSSI_ALSA_ASOUNDLIB_H} ${CSOUND_INCLUDE_DIRS}) target_compile_definitions(dssi4cs PRIVATE BUILD_PLUGINS) + + # On multiarch distributions (Debian, Ubuntu, ...) plugins may be + # installed under /usr/lib//dssi and /usr/lib//ladspa. + # Prepend the triplet detected for this build to the default search path; + # DSSI_PATH and LADSPA_PATH still take precedence at runtime. + if(CMAKE_LIBRARY_ARCHITECTURE) + target_compile_definitions(dssi4cs PRIVATE + "DSSI4CS_DEFAULT_PATH=\"/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/dssi:/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/ladspa:/usr/local/lib/dssi:/usr/lib/dssi:/usr/lib64/dssi:/usr/local/lib/ladspa:/usr/lib/ladspa:/usr/lib64/ladspa\"") + endif() endif() diff --git a/7.x/src/dssi4cs/README.md b/7.x/src/dssi4cs/README.md index 8f6f642..3421178 100644 --- a/7.x/src/dssi4cs/README.md +++ b/7.x/src/dssi4cs/README.md @@ -27,8 +27,10 @@ colon-separated directories; empty entries are skipped. Lookup tries the name as supplied, then `.so`. Linux defaults include `/usr/local/lib`, `/usr/lib`, and `/usr/lib64`, each -with `dssi` and `ladspa` subdirectories. Set the environment paths for -multiarch directories such as `/usr/lib/aarch64-linux-gnu/dssi`. +with `dssi` and `ladspa` subdirectories. On multiarch distributions the build +also adds the detected triplet directory, such as +`/usr/lib/x86_64-linux-gnu/dssi`; set the environment paths to search any +other location. Instances and libraries remain loaded until Csound reset or destruction. Failed loads do not publish a handle. Cleanup calls the plugin's deactivate diff --git a/7.x/src/dssi4cs/dssi4cs.c b/7.x/src/dssi4cs/dssi4cs.c index c2c9e26..0f6f2e0 100644 --- a/7.x/src/dssi4cs/dssi4cs.c +++ b/7.x/src/dssi4cs/dssi4cs.c @@ -803,8 +803,8 @@ static int32_t dssilist(CSOUND *csound, DSSILIST *p) static OENTRY localops[] = { {"dssiinit", sizeof(DSSIINIT), 0, "i", "Tip", (SUBR)dssiinit}, {"dssiactivate", sizeof(DSSIACTIVATE), 0, "", "ik", (SUBR)dssiactivate_init, (SUBR)dssiactivate}, - {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iMMMMMMMMM", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, - {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iMMMMMMMMM", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iyyyyyyyyy", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iyyyyyyyyy", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, {"dssictls", sizeof(DSSICTLS), 0, "", "iikk", (SUBR)dssictls_init, (SUBR)dssictls}, {"dssiget", sizeof(DSSIGET), 0, "k", "ii", (SUBR)dssiget_init, (SUBR)dssiget}, {"dssinote", sizeof(DSSINOTE), 0, "", "kikkko", (SUBR)dssinote_init, (SUBR)dssinote}, diff --git a/7.x/src/dssi4cs/utils.h b/7.x/src/dssi4cs/utils.h index 2d1f68a..e882912 100644 --- a/7.x/src/dssi4cs/utils.h +++ b/7.x/src/dssi4cs/utils.h @@ -2,6 +2,13 @@ #ifndef DSSI4CS_UTILS_H #define DSSI4CS_UTILS_H #include "csdl.h" -#define DSSI4CS_DEFAULT_PATH "/usr/local/lib/dssi:/usr/lib/dssi:/usr/lib64/dssi:/usr/local/lib/ladspa:/usr/lib/ladspa:/usr/lib64/ladspa" +/* Search path used when neither DSSI_PATH nor LADSPA_PATH is set. The build + may override this (see CMakeLists.txt) to prepend the multiarch library + directory detected on the build host, e.g. /usr/lib/x86_64-linux-gnu. */ +#ifndef DSSI4CS_DEFAULT_PATH +#define DSSI4CS_DEFAULT_PATH \ + "/usr/local/lib/dssi:/usr/lib/dssi:/usr/lib64/dssi:" \ + "/usr/local/lib/ladspa:/usr/lib/ladspa:/usr/lib64/ladspa" +#endif void *dlopenLADSPA(CSOUND *, const char *, int32_t); #endif From 8de8d04b70b85da48e6ddd127113b828cde0ed8f Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Thu, 15 Oct 2026 11:18:20 +0100 Subject: [PATCH 67/72] Add DSSI host regression tests and allow omitting audio inputs (#56) * Add DSSI host regression tests and allow omitting audio inputs Move the DSSI/LADSPA host regression test and its fixture plugin out of the Csound core tree into the plugin that they exercise. The fixture is built from the vendored DSSI/LADSPA headers so its ABI matches the host, and the suite now talks to Csound through the public API (csound.h) instead of the private csoundCore.h internals. Register the tests with CTest: enable_testing() at the top level, a GoogleTest-gated target in dssi4cs/CMakeLists.txt (C++14, as required by recent GoogleTest), and a "Run plugin tests" step in the 7.x build workflow. While adapting the tests, replace the single variable-argument OENTRY for dssiaudio/dssisynth ("iyyyyyyyyy") with one entry per input count ("i".."iaaaaaaaaa"). The parser only treats the M/N/m/W lists as omittable, so the previous entry made every audio input mandatory even though the manual documents them as optional. Fixed a-rate inputs are still a-rate only, so the opcode can never read past a scalar, and the matching entry is selected by argument count. * Cover zero-input dssiaudio and reset audio between runs Address review feedback: exercise dssiaudio with all audio inputs omitted (only dssisynth was covered), guarding the optional-input behaviour, and clear the captured audio at the start of run() so a future test that calls it twice cannot read stale samples. --- .github/workflows/plugins_build_7.yml | 4 + 7.x/CMakeLists.txt | 3 + 7.x/src/dssi4cs/CMakeLists.txt | 32 ++ 7.x/src/dssi4cs/dssi4cs.c | 29 +- 7.x/src/dssi4cs/tests/dssi_test.cpp | 446 ++++++++++++++++++ .../dssi4cs/tests/fixtures/dssi_test_plugin.c | 195 ++++++++ 6 files changed, 707 insertions(+), 2 deletions(-) create mode 100644 7.x/src/dssi4cs/tests/dssi_test.cpp create mode 100644 7.x/src/dssi4cs/tests/fixtures/dssi_test_plugin.c diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 64b8eaf..989c4e0 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -73,6 +73,7 @@ jobs: libeigen3-dev libfluidsynth-dev libpng-dev \ libwebsockets-dev libuv1-dev libhdf5-dev \ ocl-icd-opencl-dev libtinfo-dev \ + libgtest-dev \ flex bison - name: Cache Csound install @@ -136,6 +137,9 @@ jobs: -DFAUST_STDLIB_DIR_HINT="$FAUST_STDLIB_DIR_HINT" cmake --build build --parallel "$(nproc)" + - name: Run plugin tests + run: ctest --test-dir build --output-on-failure + - name: Stage plugins run: | mkdir -p package diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 35fa501..734f933 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -318,6 +318,9 @@ if(WIN32) add_definitions(-DWIN32) endif() +# Register CTest so subdirectory regression tests (e.g. dssi4cs) can be run. +enable_testing() + add_subdirectory(./src/chua) add_subdirectory(./src/linear_algebra) add_subdirectory(./src/fluidOpcodes) diff --git a/7.x/src/dssi4cs/CMakeLists.txt b/7.x/src/dssi4cs/CMakeLists.txt index ea3de70..b7b2849 100644 --- a/7.x/src/dssi4cs/CMakeLists.txt +++ b/7.x/src/dssi4cs/CMakeLists.txt @@ -31,4 +31,36 @@ if(BUILD_DSSI_OPCODES) target_compile_definitions(dssi4cs PRIVATE "DSSI4CS_DEFAULT_PATH=\"/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/dssi:/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/ladspa:/usr/local/lib/dssi:/usr/lib/dssi:/usr/lib64/dssi:/usr/local/lib/ladspa:/usr/lib/ladspa:/usr/lib64/ladspa\"") endif() + + # Regression tests for the host, built and registered with CTest when + # GoogleTest is available. The fixture is a small real DSSI/LADSPA plugin + # built from the vendored headers, so its ABI matches the host. + find_package(GTest QUIET) + if(GTest_FOUND) + add_library(dssi_test_plugin MODULE tests/fixtures/dssi_test_plugin.c) + add_library(ladspa_test_plugin MODULE tests/fixtures/dssi_test_plugin.c) + target_compile_definitions(ladspa_test_plugin PRIVATE DSSI_TEST_LADSPA) + foreach(plugin dssi_test_plugin ladspa_test_plugin) + target_include_directories(${plugin} PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/include/dssi + ${CMAKE_CURRENT_SOURCE_DIR}/include/ladspa + ${DSSI_ALSA_ASOUNDLIB_H}) + endforeach() + + add_executable(dssi_tests tests/dssi_test.cpp) + # Recent GoogleTest releases require C++14, which is newer than the + # C++11 default used for the plugin itself. + set_target_properties(dssi_tests PROPERTIES + CXX_STANDARD 14 + CXX_STANDARD_REQUIRED ON) + target_include_directories(dssi_tests PRIVATE ${CSOUND_INCLUDE_DIRS}) + target_link_libraries(dssi_tests PRIVATE + GTest::gtest_main ${CSOUND_LIBRARY} ${CMAKE_DL_LIBS}) + target_compile_definitions(dssi_tests PRIVATE + CSOUND_TEST_DSSI_HOST="$" + CSOUND_TEST_DSSI_PLUGIN="$" + CSOUND_TEST_LADSPA_PLUGIN="$") + add_dependencies(dssi_tests dssi4cs dssi_test_plugin ladspa_test_plugin) + add_test(NAME dssi_tests COMMAND dssi_tests) + endif() endif() diff --git a/7.x/src/dssi4cs/dssi4cs.c b/7.x/src/dssi4cs/dssi4cs.c index 0f6f2e0..3939a2b 100644 --- a/7.x/src/dssi4cs/dssi4cs.c +++ b/7.x/src/dssi4cs/dssi4cs.c @@ -803,8 +803,33 @@ static int32_t dssilist(CSOUND *csound, DSSILIST *p) static OENTRY localops[] = { {"dssiinit", sizeof(DSSIINIT), 0, "i", "Tip", (SUBR)dssiinit}, {"dssiactivate", sizeof(DSSIACTIVATE), 0, "", "ik", (SUBR)dssiactivate_init, (SUBR)dssiactivate}, - {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iyyyyyyyyy", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, - {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iyyyyyyyyy", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + /* The audio inputs are optional (see README) and must be a-rate. A single + 'y' (indefinite a-rate list) entry would make every input mandatory, + because the parser only treats the 'M'/'N'/'m'/'W' lists as omittable. + Register one entry per possible input count instead: fixed 'a' inputs + are a-rate only (so the opcode never reads past a scalar) and the + matching entry is selected by argument count, allowing the inputs to be + omitted. */ + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "i", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "ia", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaaaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssiaudio", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaaaaa", (SUBR)dssiaudio_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "i", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "ia", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaaaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, + {"dssisynth", sizeof(DSSIAUDIO), 0, "mmmmmmmmm", "iaaaaaaaaa", (SUBR)dssisynth_init, (SUBR)dssiaudio, (SUBR)dssiaudio_deinit}, {"dssictls", sizeof(DSSICTLS), 0, "", "iikk", (SUBR)dssictls_init, (SUBR)dssictls}, {"dssiget", sizeof(DSSIGET), 0, "k", "ii", (SUBR)dssiget_init, (SUBR)dssiget}, {"dssinote", sizeof(DSSINOTE), 0, "", "kikkko", (SUBR)dssinote_init, (SUBR)dssinote}, diff --git a/7.x/src/dssi4cs/tests/dssi_test.cpp b/7.x/src/dssi4cs/tests/dssi_test.cpp new file mode 100644 index 0000000..0733dd2 --- /dev/null +++ b/7.x/src/dssi4cs/tests/dssi_test.cpp @@ -0,0 +1,446 @@ +#include "csound.h" +#include "gtest/gtest.h" +#include +#include +#include + +#ifndef CSOUND_TEST_DSSI_HOST +#error DSSI host path is required +#endif + +class DssiTests : public ::testing::Test { +protected: + CSOUND *csound = nullptr; + void *fixture = nullptr; + int (*stat)(int) = nullptr; + std::vector audio; + std::string pending; + // Move any queued messages into 'pending' so that run() can report their + // text without reading Csound internals. + void drain() { + while (csoundGetMessageCnt(csound)) { + pending += csoundGetFirstMessage(csound); + csoundPopFirstMessage(csound); + } + } + std::string messages() { + drain(); + std::string result = pending; + pending.clear(); + return result; + } + std::string load(int index = 0, const char *id = "gih", const char *path = CSOUND_TEST_DSSI_PLUGIN) { + return std::string(id) + " dssiinit \"" + path + "\", " + std::to_string(index) + ", 1\n"; + } + int run(const std::string &orc, const std::string &score = "i1 0 .01", int ksmps = 16, int dbfs = 1) { + pending.clear(); + audio.clear(); + std::string csd = "\n\n-n -d -m0 --sample-accurate\n\n" + "\nsr=8192\nksmps=" + std::to_string(ksmps) + + "\nnchnls=2\n0dbfs=" + std::to_string(dbfs) + "\n" + orc + + "\n\n\n" + score + + "\ne\n\n\n"; + // Initialisation errors (bad handle, missing DSSI/LADSPA descriptor, + // two renderers for one instance, ...) make csoundStart() fail, while + // performance errors are counted by csoundErrCnt(). Together these + // replace reading the private inerrcnt/perferrcnt fields. + int result = csoundCompileCSD(csound, csd.c_str(), 1, 0); + if (result == 0) result = csoundStart(csound); + if (result) { drain(); return result; } + for (int blocks = 0; blocks < 1000; ++blocks) { + int done = csoundPerformKsmps(csound); + const cs_float *out = csoundGetSpout(csound); + audio.insert(audio.end(), out, out + ksmps * 2); + if (done) { drain(); return csoundErrCnt(csound); } + } + ADD_FAILURE() << "Performance did not terminate"; + return -1; + } + void samples(int begin, int end, cs_double expected) { + ASSERT_GE(audio.size(), size_t(end * 2)); + for (int i = begin; i < end; ++i) { + EXPECT_NEAR(audio[2*i], expected, 1e-6) << "sample " << i; + EXPECT_NEAR(audio[2*i+1], expected, 1e-6) << "sample " << i; + } + } + void SetUp() override { + fixture = dlopen(CSOUND_TEST_DSSI_PLUGIN, RTLD_NOW | RTLD_LOCAL); + ASSERT_NE(fixture, nullptr) << dlerror(); + stat = reinterpret_cast(dlsym(fixture, "dssi_test_stat")); + ASSERT_NE(stat, nullptr); + reinterpret_cast(dlsym(fixture, "dssi_test_reset"))(); + csound = csoundCreate(nullptr, nullptr); + csoundCreateMessageBuffer(csound, 0); + csoundSetOption(csound, "-n"); + csoundSetOption(csound, "-d"); + csoundSetOption(csound, "--sample-accurate"); + csoundSetOption(csound, "--opcode-lib=" CSOUND_TEST_DSSI_HOST); + } + void TearDown() override { + csoundDestroy(csound); + EXPECT_EQ(stat(0), 0) << "plugin instances leaked"; + EXPECT_EQ(stat(2), 0) << "plugin callback contract failed"; + dlclose(fixture); + } +}; + +TEST_F(DssiTests, SynthAndNoteOpcodesAreAvailable) { + const char *orc = "sr=48000\nksmps=16\nnchnls=2\n0dbfs=1\n" + "instr 1\n" + "dssinote 1, 0, 60, 100, 1\n" + "dssievent 1, 0, 60, 100\n" + "a1, a2 dssisynth 0\n" + "endin\n"; + EXPECT_EQ(csoundCompileOrc(csound, orc, 0), 0); +} + +TEST_F(DssiTests, DurationSchedulesNoteOffAcrossBlocks) { + ASSERT_EQ(run(load() + R"( +instr 1 + dssiactivate gih, 1 + konce init 1 + dssinote konce, gih, 60, 127, 20/sr + konce = 0 + a1,a2 dssisynth gih + outs a1,a2 +endin +)"), 0) << messages(); + samples(0,20,1); + samples(20,64,0); + csoundReset(csound); + EXPECT_EQ(stat(1),1); +} + +TEST_F(DssiTests, MidiOffsetsAreSortedAndZeroVelocityBecomesNoteOff) { + ASSERT_EQ(run(load() + R"( +instr 1 + dssiactivate gih,1 + konce init 1 + dssievent konce,gih,144,0,60,0,11 + dssievent konce,gih,144,0,60,127,3 + konce=0 + a1,a2 dssisynth gih + outs a1,a2 +endin +)"), 0) << messages(); + samples(0,3,0); samples(3,11,1); samples(11,64,0); +} + +TEST_F(DssiTests, ProgramAndMappedControllerChangesSplitAtTheirSample) { + ASSERT_EQ(run(load() + R"( +instr 1 + dssiactivate gih,1 + konce init 1 + dssievent konce,gih,144,0,60,127 + dssievent konce,gih,176,0,0,1,4 + dssievent konce,gih,176,0,32,2,4 + dssievent konce,gih,192,0,5,0,4 + dssievent konce,gih,176,0,7,0,10 + konce=0 + a1,a2 dssisynth gih + kprogram dssiget gih,6 + chnset kprogram,"program" + outs a1,a2 +endin +)"), 0) << messages(); + samples(0,4,1); samples(4,10,.5); samples(10,64,0); + EXPECT_EQ(csoundGetControlChannel(csound,"program",nullptr),130*128+5); +} + +TEST_F(DssiTests, InterleavedControlPortsAndConfiguration) { + ASSERT_EQ(run(load() + R"( +dssiconfigure gih,"bias",".125" +Sname,ibank,iprog dssiprograminfo gih,1 +chnset ibank,"bank" +chnset iprog,"preset" +instr 1 + dssiactivate gih,1 + dssictls gih,4,.25,1 + dssievent 1,gih,60,127 + a1,a2 dssisynth gih + kvalue dssiget gih,4 + chnset kvalue,"bias" + outs a1,a2 +endin +)"), 0) << messages(); + samples(0,64,1.25); + EXPECT_EQ(csoundGetControlChannel(csound,"bias",nullptr),.25); + EXPECT_EQ(csoundGetControlChannel(csound,"bank",nullptr),130); + EXPECT_EQ(csoundGetControlChannel(csound,"preset",nullptr),5); +} + +TEST_F(DssiTests, OptionalCallbacksAndPartialBlocks) { + ASSERT_EQ(run(load(2) + R"( +instr 1 + dssiactivate gih,1 + konce init 1 + dssievent konce,gih,60,127 + konce=0 + a1,a2 dssisynth gih + outs a1,a2 +endin +)","i1 [3/8192] [8/8192]"), 0) << messages(); + samples(0,3,0); samples(3,11,1); samples(11,16,0); +} + +TEST_F(DssiTests, LocalKsmpsAndDbfsConversion) { + ASSERT_EQ(run(load() + R"( +opcode render,aa,i + setksmps 4 + ih xin + dssiactivate ih,1 + konce init 1 + dssinote konce,ih,60,127,7/sr + konce=0 + a1,a2 dssisynth ih + xout a1,a2 +endop +instr 1 + a1,a2 render gih + outs a1,a2 +endin +)","i1 0 .01",16,32768),0) << messages(); + samples(0,7,32768); samples(7,64,0); +} + +TEST_F(DssiTests, MultipleSynthCallbackReceivesEveryActiveInstance) { + ASSERT_EQ(run(load(1,"gih") + load(1,"gih2") + R"( +instr 1 + dssiactivate gih,1 + dssiactivate gih2,1 + konce init 1 + dssievent konce,gih,60,127 + dssievent konce,gih2,64,127 + konce=0 + a1,a2 dssisynth gih + a3,a4 dssisynth gih2 + outs a1+a3,a2+a4 +endin +)","i1 0 [64/8192]"),0) << messages(); + samples(0,64,2); + EXPECT_EQ(stat(4),2); + EXPECT_EQ(stat(3),4); +} + +TEST_F(DssiTests, LadspaEffectUsesInputAndOutputScaling) { + ASSERT_EQ(run(load(0,"gih",CSOUND_TEST_LADSPA_PLUGIN) + R"( +instr 1 + dssiactivate gih,1 + dssictls gih,1,.5,1 + ain init 16384 + a1,a2 dssiaudio gih,ain + outs a1,a2 +endin +)","i1 0 .01",16,32768),0) << messages(); + samples(0,64,8192); +} + +TEST_F(DssiTests, DssiAudioAllowsOmittedInputs) { + // The audio inputs are optional. Every other dssiaudio call in this suite + // supplies them, so a regression that made them mandatory would go + // unnoticed without this case. + ASSERT_EQ(run(load() + R"( +instr 1 + dssiactivate gih,1 + a1,a2 dssiaudio gih + outs a1,a2 +endin +)"), 0) << messages(); +} + +TEST_F(DssiTests, RejectsBadDescriptorWithoutPublishingAnInstance) { + EXPECT_NE(run(load(99)),0); + EXPECT_EQ(stat(0),0); +} + +TEST_F(DssiTests, RejectsBankBeyondUnsigned32BitRange) { + // 2^32 is exact in float, but UINT32_MAX is not. + EXPECT_NE(run(load() + R"( +instr 1 + dssiprogram gih,4294967296,0,1 +endin +)"), 0); + const auto error = messages(); + EXPECT_NE(error.find("invalid bank or program"), std::string::npos) << error; +} + +TEST_F(DssiTests, RejectsProgramBeyondUnsigned32BitRange) { + EXPECT_NE(run(load() + R"( +instr 1 + dssiprogram gih,0,4294967296,1 +endin +)"), 0); + const auto error = messages(); + EXPECT_NE(error.find("invalid bank or program"), std::string::npos) << error; +} + +TEST_F(DssiTests, RejectsMalformedDescriptor) { + EXPECT_NE(run(load(3)),0); + EXPECT_EQ(stat(0),0); +} + +TEST_F(DssiTests, RejectsAudioPortUsedAsControl) { + EXPECT_NE(run(load()+"instr 1\ndssictls gih,3,1,1\nendin\n"),0); + EXPECT_NE(messages().find("input control port"),std::string::npos); +} + +TEST_F(DssiTests, RejectsInvalidActivationHandle) { + EXPECT_NE(run("instr 1\ndssiactivate -1,1\nendin\n"),0); + EXPECT_NE(messages().find("invalid handle"),std::string::npos); +} + +TEST_F(DssiTests, RejectsTwoRenderersForOneInstance) { + EXPECT_NE(run(load()+R"( +instr 1 + a1,a2 dssisynth gih + a3,a4 dssisynth gih +endin +)"),0); + EXPECT_NE(messages().find("exactly one audio renderer"),std::string::npos); +} + +TEST_F(DssiTests, QueueOverflowReportsAnError) { + EXPECT_NE(run(load()+R"( +instr 1 + dssiactivate gih,1 + kindex=0 + while kindex < 1025 do + dssievent 1,gih,60,127 + kindex+=1 + od + a1,a2 dssisynth gih +endin +)"),0); + EXPECT_NE(messages().find("event queue is full"),std::string::npos); +} + +TEST_F(DssiTests, DiscoveryIncludesDssiOnlyLibrary) { + std::string path = CSOUND_TEST_DSSI_PLUGIN; + csoundSetOption(csound,("--env:DSSI_PATH="+path.substr(0,path.find_last_of('/'))).c_str()); + ASSERT_EQ(run("dssilist\ninstr 1\nendin\n"),0) << messages(); + EXPECT_NE(messages().find("fixture (fixture)"),std::string::npos); +} + +TEST_F(DssiTests, ConfigurationErrorsReachCsound) { + EXPECT_NE(run(load()+"dssiconfigure gih,\"bad\",\"value\"\n"),0); + EXPECT_NE(messages().find("unknown fixture key"),std::string::npos); +} + +TEST_F(DssiTests, NrpnMappingChangesControlsWithoutDuplicateEvents) { + ASSERT_EQ(run(load()+R"( +instr 1 + dssiactivate gih,1 + konce init 1 + dssievent konce,gih,60,127 + dssinrpn konce,gih,0,42,0,9 + konce=0 + a1,a2 dssisynth gih + kcount dssiget gih,2 + chnset kcount,"events" + outs a1,a2 +endin +)"),0) << messages(); + samples(0,9,1); samples(9,64,0); + EXPECT_EQ(csoundGetControlChannel(csound,"events",nullptr),1); +} + +TEST_F(DssiTests, ResumeStopsOldNotesWhenPluginOmitsActivationCallbacks) { + ASSERT_EQ(run(load(2)+R"( +instr 1 + kcycle timeinstk + kactive = (kcycle == 2 ? 0 : 1) + dssiactivate gih,kactive + dssievent (kcycle == 1 ? 1 : 0),gih,60,127 + a1,a2 dssisynth gih + outs a1,a2 +endin +)"),0) << messages(); + samples(0,16,1); samples(16,64,0); +} + +TEST_F(DssiTests, GlobalConfigurationAppliesToEachMatchingInstance) { + ASSERT_EQ(run(load()+load(0,"gih2")+R"( +dssiconfigure gih,"GLOBAL:bias",".125" +instr 1 + dssiactivate gih,1 + dssiactivate gih2,1 + a1,a2 dssisynth gih + a3,a4 dssisynth gih2 + outs a1+a3,a2+a4 +endin +)"),0) << messages(); + samples(0,64,.25); +} + +TEST_F(DssiTests, RejectsEventsSentAfterTheRenderer) { + EXPECT_NE(run(load()+R"( +instr 1 + dssiactivate gih,1 + a1,a2 dssisynth gih + dssievent 1,gih,60,127 +endin +)"),0); + EXPECT_NE(messages().find("before rendering"),std::string::npos); +} + +TEST_F(DssiTests, ProgramNamesAreCopiedBeforeNextEnumeration) { + ASSERT_EQ(run(load()+R"( +Sfirst,ibank,iprog dssiprograminfo gih,0 +Ssecond,ibank2,iprog2 dssiprograminfo gih,1 +idiff strcmp Sfirst,"first" +chnset idiff,"diff" +Snone,ibank3,iprog3 dssiprograminfo gih,2 +chnset ibank3,"end" +instr 1 +endin +)"),0) << messages(); + EXPECT_EQ(csoundGetControlChannel(csound,"diff",nullptr),0); + EXPECT_EQ(csoundGetControlChannel(csound,"end",nullptr),-1); +} + +TEST_F(DssiTests, SustainedAndRepeatedNotesDoNotSurviveResume) { + ASSERT_EQ(run(load(2)+R"( +instr 1 + kcycle timeinstk + kactive = (kcycle == 2 ? 0 : 1) + dssiactivate gih,kactive + konce = (kcycle == 1 ? 1 : 0) + dssievent konce,gih,176,0,64,127 + dssievent konce,gih,144,0,60,127 + dssievent konce,gih,144,0,60,127 + dssievent konce,gih,128,0,60,0,8 + dssievent konce,gih,128,0,60,0,8 + a1,a2 dssisynth gih + outs a1,a2 +endin +)"),0) << messages(); + samples(0,16,1); samples(16,64,0); +} + +TEST_F(DssiTests, LateActivationCannotRenderAGroupTwice) { + EXPECT_NE(run(load(1)+load(1,"gih2")+R"( +instr 1 + dssiactivate gih,1 + dssievent 1,gih,60,127 + a1,a2 dssisynth gih +endin +instr 2 + dssiactivate gih2,1 + a1,a2 dssisynth gih2 +endin +)","i1 0 .01\ni2 0 .01"),0); + EXPECT_NE(messages().find("activate all grouped instances"),std::string::npos); + EXPECT_EQ(stat(4),1); +} + +TEST_F(DssiTests, FailedFirstLoadThenInvalidHandleReportsInitErrors) { + EXPECT_NE(run(R"( +instr 1 + ih dssiinit "/does/not/exist.so",0,0 +endin +instr 2 + dssiactivate 4096,1 +endin +)","i1 0 .002\ni2 .004 .002"),0); + EXPECT_NE(messages().find("invalid handle"),std::string::npos); +} diff --git a/7.x/src/dssi4cs/tests/fixtures/dssi_test_plugin.c b/7.x/src/dssi4cs/tests/fixtures/dssi_test_plugin.c new file mode 100644 index 0000000..2f354da --- /dev/null +++ b/7.x/src/dssi4cs/tests/fixtures/dssi_test_plugin.c @@ -0,0 +1,195 @@ +/* Deterministic native plugin for DSSI/LADSPA host integration tests. + Built against the same vendored headers as the host, so the ABI matches. */ +#include +#include +#include +#include + +#define EXPORT __attribute__((visibility("default"))) +static int live, cleanups, failures, group_calls, largest_group; +static int active[4]; +typedef struct { + LADSPA_Data *ports[8]; + float voice; + int held, sustain; + int kind; + unsigned int events, program; +} Instance; + +EXPORT int dssi_test_stat(int which) +{ + switch (which) { + case 0: return live; + case 1: return cleanups; + case 2: return failures; + case 3: return group_calls; + case 4: return largest_group; + default: return -1; + } +} +EXPORT void dssi_test_reset(void) +{ + if (live) ++failures; + cleanups = failures = group_calls = largest_group = 0; + memset(active, 0, sizeof(active)); +} + +static LADSPA_Handle instantiate(const LADSPA_Descriptor *d, unsigned long sr) +{ + (void)sr; + Instance *p = calloc(1, sizeof(*p)); + p->kind = (int)(d->UniqueID - 900001); + ++live; + return p; +} +static void connect_port(LADSPA_Handle h, unsigned long port, LADSPA_Data *data) +{ ((Instance *)h)->ports[port] = data; } +static void activate(LADSPA_Handle h) +{ Instance *p = h; p->voice = 0; ++active[p->kind]; } +static void deactivate(LADSPA_Handle h) +{ Instance *p = h; p->voice = 0; --active[p->kind]; } +static void cleanup(LADSPA_Handle h) +{ --live; ++cleanups; free(h); } + +static void run_synth(LADSPA_Handle h, unsigned long n, snd_seq_event_t *events, + unsigned long count) +{ + Instance *p = h; + unsigned long e = 0; + for (unsigned long i = 0; i < count; ++i) + if (events[i].time.tick >= n || (i && events[i].time.tick < events[i-1].time.tick)) ++failures; + for (unsigned long i = 0; i < n; ++i) { + while (e < count && events[e].time.tick == i) { + snd_seq_event_t *event = &events[e++]; + ++p->events; + *p->ports[7] = event->time.tick; + if (event->type == SND_SEQ_EVENT_NOTEON) { + if (!event->data.note.velocity) ++failures; + ++p->held; + p->voice = event->data.note.velocity / 127.f; + } + else if (event->type == SND_SEQ_EVENT_NOTEOFF) { + if (p->held) --p->held; + if (!p->held && !p->sustain) p->voice = 0; + } + else if (event->type == SND_SEQ_EVENT_CONTROLLER && event->data.control.param == 64) { + p->sustain = event->data.control.value >= 64; + if (!p->sustain && !p->held) p->voice = 0; + } + else if (event->type == SND_SEQ_EVENT_CONTROLLER && + (event->data.control.param == 120 || event->data.control.param == 123)) { + p->held = 0; + p->voice = 0; + } + else if (event->type == SND_SEQ_EVENT_PGMCHANGE || event->type == SND_SEQ_EVENT_NOTE) + ++failures; + else if (event->type == SND_SEQ_EVENT_CONTROLLER && + (event->data.control.param == 0 || event->data.control.param == 32 || + event->data.control.param == 7)) ++failures; + } + float input = p->kind == 1 ? 0 : p->ports[3][i]; +#ifdef DSSI_TEST_LADSPA + p->voice = 0; +#endif + p->ports[0][i] = (input + p->voice) * *p->ports[1] + *p->ports[4]; + p->ports[5][i] = p->ports[0][i]; + } + *p->ports[2] = p->events; + *p->ports[6] = p->program; +} +#ifdef DSSI_TEST_LADSPA +static void run(LADSPA_Handle h, unsigned long n) { run_synth(h, n, NULL, 0); } +#endif +static void run_multiple(unsigned long count, LADSPA_Handle *handles, + unsigned long n, snd_seq_event_t **events, + unsigned long *counts) +{ + ++group_calls; + if ((int)count > largest_group) largest_group = (int)count; + if ((int)count != active[1]) ++failures; + for (unsigned long i = 0; i < count; ++i) run_synth(handles[i], n, events[i], counts[i]); +} +static int midi_mapping(LADSPA_Handle h, unsigned long port) +{ (void)h; return port == 1 ? DSSI_CC(7) | DSSI_NRPN(42) : DSSI_NONE; } +static const DSSI_Program_Descriptor *get_program(LADSPA_Handle h, unsigned long index) +{ + (void)h; + static DSSI_Program_Descriptor p; + static char name[32]; + if (index > 1) return NULL; + strcpy(name, index ? "second" : "first"); + p.Bank = index ? 130 : 0; + p.Program = index ? 5 : 0; + p.Name = name; + return &p; +} +static void select_program(LADSPA_Handle h, unsigned long bank, unsigned long program) +{ + Instance *p = h; + p->program = (unsigned int)(bank * 128 + program); + *p->ports[1] = program == 5 ? .5f : 1.f; +} +static char *configure(LADSPA_Handle h, const char *key, const char *value) +{ + Instance *p = h; + if (!strcmp(key, "bias") || !strcmp(key, "GLOBAL:bias")) { + *p->ports[4] = atof(value); + return NULL; + } + return strdup("unknown fixture key"); +} + +static const LADSPA_PortDescriptor ports[] = { + LADSPA_PORT_AUDIO | LADSPA_PORT_OUTPUT, LADSPA_PORT_CONTROL | LADSPA_PORT_INPUT, + LADSPA_PORT_CONTROL | LADSPA_PORT_OUTPUT, LADSPA_PORT_AUDIO | LADSPA_PORT_INPUT, + LADSPA_PORT_CONTROL | LADSPA_PORT_INPUT, LADSPA_PORT_AUDIO | LADSPA_PORT_OUTPUT, + LADSPA_PORT_CONTROL | LADSPA_PORT_OUTPUT, LADSPA_PORT_CONTROL | LADSPA_PORT_OUTPUT +}; +static const char *names[] = {"left", "gain", "events", "input", "bias", "right", "program", "tick"}; +static const LADSPA_PortRangeHint hints[] = { + {0,0,0}, {LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_1, 0,1}, + {0,0,0}, {0,0,0}, {LADSPA_HINT_DEFAULT_0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} +}; +static LADSPA_Descriptor descriptors[4]; +static DSSI_Descriptor synths[4]; +static LADSPA_PortDescriptor multi_ports[8]; +static int initialized; +static void init(void) +{ + if (initialized) return; + initialized = 1; + memcpy(multi_ports, ports, sizeof(ports)); + multi_ports[3] = LADSPA_PORT_CONTROL | LADSPA_PORT_INPUT; + const char *labels[] = {"fixture", "multi", "optional", "invalid"}; + for (int i = 0; i < 4; ++i) { + descriptors[i] = (LADSPA_Descriptor){ + .UniqueID = 900001 + i, .Label = labels[i], .Name = labels[i], + .Maker = "Csound", .Copyright = "LGPL-2.1-or-later", .PortCount = 8, + .PortDescriptors = i == 1 ? multi_ports : ports, .PortNames = names, + .PortRangeHints = hints, .instantiate = instantiate, .connect_port = connect_port, + .activate = i == 2 ? NULL : activate, .deactivate = i == 2 ? NULL : deactivate, + .cleanup = cleanup, +#ifdef DSSI_TEST_LADSPA + .run = run +#else + .run = NULL +#endif + }; + synths[i] = (DSSI_Descriptor){.DSSI_API_Version = 1, .LADSPA_Plugin = &descriptors[i], + .configure = i == 2 ? NULL : configure, + .get_program = i == 2 ? NULL : get_program, + .select_program = i == 2 ? NULL : select_program, + .get_midi_controller_for_port = i == 2 ? NULL : midi_mapping, + .run_synth = i == 1 ? NULL : run_synth, + .run_multiple_synths = i == 1 ? run_multiple : NULL}; + } + descriptors[3].connect_port = NULL; +} +#ifdef DSSI_TEST_LADSPA +EXPORT const LADSPA_Descriptor *ladspa_descriptor(unsigned long i) +{ init(); return i < 4 ? &descriptors[i] : NULL; } +#else +/* Deliberately export only dssi_descriptor: discovery must handle this. */ +EXPORT const DSSI_Descriptor *dssi_descriptor(unsigned long i) +{ init(); return i < 4 ? &synths[i] : NULL; } +#endif From 1267e42558323448f3294ce37abe53408f14a4a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Sun, 18 Oct 2026 20:14:38 +0300 Subject: [PATCH 68/72] fix(stk): use the Csound sample rate in instrument adapters (#58) --- 7.x/src/stk/CMakeLists.txt | 18 ++ 7.x/src/stk/STKInstrumentAdapter.hpp | 327 +++++++++++++++++++++++++ 7.x/src/stk/stkOpcodes.cpp | 296 +--------------------- 7.x/src/stk/tests/stk_adapter_test.cpp | 75 ++++++ 4 files changed, 421 insertions(+), 295 deletions(-) create mode 100644 7.x/src/stk/STKInstrumentAdapter.hpp create mode 100644 7.x/src/stk/tests/stk_adapter_test.cpp diff --git a/7.x/src/stk/CMakeLists.txt b/7.x/src/stk/CMakeLists.txt index bd809aa..b98aa7c 100644 --- a/7.x/src/stk/CMakeLists.txt +++ b/7.x/src/stk/CMakeLists.txt @@ -53,5 +53,23 @@ if(BUILD_STK_OPCODES) endif() endif() + # Native unit tests exercise both adapters without an audio device or engine. + if(NOT WASM) + find_package(GTest QUIET) + if(GTest_FOUND) + add_executable(stk_adapter_tests tests/stk_adapter_test.cpp src/Stk.cpp) + set_target_properties(stk_adapter_tests PROPERTIES + CXX_STANDARD 14 + CXX_STANDARD_REQUIRED ON) + target_include_directories(stk_adapter_tests PRIVATE + ${CSOUND_INCLUDE_DIRS} + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_SOURCE_DIR}/include") + target_compile_definitions(stk_adapter_tests PRIVATE BUILD_PLUGINS) + target_link_libraries(stk_adapter_tests PRIVATE GTest::gtest_main) + add_test(NAME stk_adapter_tests COMMAND stk_adapter_tests) + endif() + endif() + message(STATUS "Building STK opcodes") endif() diff --git a/7.x/src/stk/STKInstrumentAdapter.hpp b/7.x/src/stk/STKInstrumentAdapter.hpp new file mode 100644 index 0000000..0b94e27 --- /dev/null +++ b/7.x/src/stk/STKInstrumentAdapter.hpp @@ -0,0 +1,327 @@ +/* + This file is part of Csound. + Copyright (C) 2005 Michael Gogins. + + The Csound Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Csound is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with Csound; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA +*/ +#pragma once + +#include "Stk.h" +#include "OpcodeBase.hpp" + +namespace csound { + +template +class STKInstrumentAdapter : public OpcodeBase> { +public: + // Outputs. + cs_float *aoutput; + // Inputs. + cs_float *ifrequency; + cs_float *igain; + cs_float *kcontroller0; + cs_float *kvalue0; + cs_float *kcontroller1; + cs_float *kvalue1; + cs_float *kcontroller2; + cs_float *kvalue2; + cs_float *kcontroller3; + cs_float *kvalue3; + cs_float *kcontroller4; + cs_float *kvalue4; + cs_float *kcontroller5; + cs_float *kvalue5; + cs_float *kcontroller6; + cs_float *kvalue6; + cs_float *kcontroller7; + cs_float *kvalue7; + // State. + T *instrument; + bool released; + cs_float oldkcontroller0; + cs_float oldkvalue0; + cs_float oldkcontroller1; + cs_float oldkvalue1; + cs_float oldkcontroller2; + cs_float oldkvalue2; + cs_float oldkcontroller3; + cs_float oldkvalue3; + cs_float oldkcontroller4; + cs_float oldkvalue4; + cs_float oldkcontroller5; + cs_float oldkvalue5; + cs_float oldkcontroller6; + cs_float oldkvalue6; + cs_float oldkcontroller7; + cs_float oldkvalue7; + STKInstrumentAdapter() : instrument(0) {} + int32_t init(CSOUND *csound) { + // Constructors size delay lines and filters from STK's shared sample rate. + // Set it on reinit too, before noteOn() retunes an existing instrument. + stk::Stk::setSampleRate(static_cast(this->opds.insdshead->esr)); + if (!instrument) { + try { + instrument = new T(); + } catch (stk::StkError &e) { + return csound->InitError(csound, "STK: %s", e.getMessage().c_str()); + } + } + instrument->noteOn(*ifrequency, *igain); + released = false; + oldkcontroller0 = -1.0; + oldkvalue0 = -1.0; + oldkcontroller1 = -1.0; + oldkvalue1 = -1.0; + oldkcontroller2 = -1.0; + oldkvalue2 = -1.0; + oldkcontroller3 = -1.0; + oldkvalue3 = -1.0; + oldkcontroller4 = -1.0; + oldkvalue4 = -1.0; + oldkcontroller5 = -1.0; + oldkvalue5 = -1.0; + oldkcontroller6 = -1.0; + oldkvalue6 = -1.0; + oldkcontroller7 = -1.0; + oldkvalue7 = -1.0; + return OK; + } + int32_t kontrol(CSOUND *csound) { + if (!released) { + if (*kcontroller0 != oldkcontroller0 || *kvalue0 != oldkvalue0) { + instrument->controlChange(static_cast(*kcontroller0), *kvalue0); + oldkcontroller0 = *kcontroller0; + oldkvalue0 = *kvalue0; + } + if (*kcontroller1 != oldkcontroller1 || *kvalue1 != oldkvalue1) { + instrument->controlChange(static_cast(*kcontroller1), *kvalue1); + oldkcontroller1 = *kcontroller1; + oldkvalue1 = *kvalue1; + } + if (*kcontroller2 != oldkcontroller2 || *kvalue2 != oldkvalue2) { + instrument->controlChange(static_cast(*kcontroller2), *kvalue2); + oldkcontroller2 = *kcontroller2; + oldkvalue2 = *kvalue2; + } + if (*kcontroller3 != oldkcontroller3 || *kvalue3 != oldkvalue3) { + instrument->controlChange(static_cast(*kcontroller3), *kvalue3); + oldkcontroller3 = *kcontroller3; + oldkvalue3 = *kvalue3; + } + if (*kcontroller4 != oldkcontroller4 || *kvalue4 != oldkvalue4) { + instrument->controlChange(static_cast(*kcontroller4), *kvalue4); + oldkcontroller4 = *kcontroller4; + oldkvalue4 = *kvalue4; + } + if (*kcontroller5 != oldkcontroller5 || *kvalue5 != oldkvalue5) { + instrument->controlChange(static_cast(*kcontroller5), *kvalue5); + oldkcontroller5 = *kcontroller5; + oldkvalue5 = *kvalue5; + } + if (*kcontroller6 != oldkcontroller6 || *kvalue6 != oldkvalue6) { + instrument->controlChange(static_cast(*kcontroller6), *kvalue6); + oldkcontroller6 = *kcontroller6; + oldkvalue6 = *kvalue6; + } + if (*kcontroller7 != oldkcontroller7 || *kvalue7 != oldkvalue7) { + instrument->controlChange(static_cast(*kcontroller7), *kvalue7); + oldkcontroller7 = *kcontroller7; + oldkvalue7 = *kvalue7; + } + } + uint32_t offset = this->kperiodOffset(); + uint32_t end = this->kperiodEnd(); + uint32_t nsmps = this->ksmps(); + for (uint32_t i = 0; i < offset; i++) { + aoutput[i] = 0; + } + if (!released) { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = instrument->tick(); + } + } else { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = 0; + } + } + for (uint32_t i = end; i < nsmps; i++) { + aoutput[i] = 0; + } + return OK; + } + int32_t deinit(CSOUND *csound) { + if (instrument) { + delete instrument; + instrument = 0; + } + return OK; + } + static int32_t deinit_(CSOUND *csound, void *opcode) { + return reinterpret_cast *>(opcode)->deinit(csound); + } +}; + +template +class STKInstrumentAdapter1 : public OpcodeBase> { +public: + // Outputs. + cs_float *aoutput; + // Inputs. + cs_float *ifrequency; + cs_float *igain; + cs_float *kcontroller0; + cs_float *kvalue0; + cs_float *kcontroller1; + cs_float *kvalue1; + cs_float *kcontroller2; + cs_float *kvalue2; + cs_float *kcontroller3; + cs_float *kvalue3; + cs_float *kcontroller4; + cs_float *kvalue4; + cs_float *kcontroller5; + cs_float *kvalue5; + cs_float *kcontroller6; + cs_float *kvalue6; + cs_float *kcontroller7; + cs_float *kvalue7; + // State. + T *instrument; + bool released; + cs_float oldkcontroller0; + cs_float oldkvalue0; + cs_float oldkcontroller1; + cs_float oldkvalue1; + cs_float oldkcontroller2; + cs_float oldkvalue2; + cs_float oldkcontroller3; + cs_float oldkvalue3; + cs_float oldkcontroller4; + cs_float oldkvalue4; + cs_float oldkcontroller5; + cs_float oldkvalue5; + cs_float oldkcontroller6; + cs_float oldkvalue6; + cs_float oldkcontroller7; + cs_float oldkvalue7; + STKInstrumentAdapter1() : instrument(0) {} + int32_t init(CSOUND *csound) { + // Constructors size delay lines and filters from STK's shared sample rate. + // Set it on reinit too, before noteOn() retunes an existing instrument. + stk::Stk::setSampleRate(static_cast(this->opds.insdshead->esr)); + if (!instrument) { + try { + instrument = new T((stk::StkFloat)10.0); + } catch (stk::StkError &e) { + return csound->InitError(csound, "STK: %s", e.getMessage().c_str()); + } + } + instrument->noteOn(*ifrequency, *igain); + released = false; + oldkcontroller0 = -1.0; + oldkvalue0 = -1.0; + oldkcontroller1 = -1.0; + oldkvalue1 = -1.0; + oldkcontroller2 = -1.0; + oldkvalue2 = -1.0; + oldkcontroller3 = -1.0; + oldkvalue3 = -1.0; + oldkcontroller4 = -1.0; + oldkvalue4 = -1.0; + oldkcontroller5 = -1.0; + oldkvalue5 = -1.0; + oldkcontroller6 = -1.0; + oldkvalue6 = -1.0; + oldkcontroller7 = -1.0; + oldkvalue7 = -1.0; + return OK; + } + int32_t kontrol(CSOUND *csound) { + if (!released) { + if (*kcontroller0 != oldkcontroller0 || *kvalue0 != oldkvalue0) { + instrument->controlChange(static_cast(*kcontroller0), *kvalue0); + oldkcontroller0 = *kcontroller0; + oldkvalue0 = *kvalue0; + } + if (*kcontroller1 != oldkcontroller1 || *kvalue1 != oldkvalue1) { + instrument->controlChange(static_cast(*kcontroller1), *kvalue1); + oldkcontroller1 = *kcontroller1; + oldkvalue1 = *kvalue1; + } + if (*kcontroller2 != oldkcontroller2 || *kvalue2 != oldkvalue2) { + instrument->controlChange(static_cast(*kcontroller2), *kvalue2); + oldkcontroller2 = *kcontroller2; + oldkvalue2 = *kvalue2; + } + if (*kcontroller3 != oldkcontroller3 || *kvalue3 != oldkvalue3) { + instrument->controlChange(static_cast(*kcontroller3), *kvalue3); + oldkcontroller3 = *kcontroller3; + oldkvalue3 = *kvalue3; + } + if (*kcontroller4 != oldkcontroller4 || *kvalue4 != oldkvalue4) { + instrument->controlChange(static_cast(*kcontroller4), *kvalue4); + oldkcontroller4 = *kcontroller4; + oldkvalue4 = *kvalue4; + } + if (*kcontroller5 != oldkcontroller5 || *kvalue5 != oldkvalue5) { + instrument->controlChange(static_cast(*kcontroller5), *kvalue5); + oldkcontroller5 = *kcontroller5; + oldkvalue5 = *kvalue5; + } + if (*kcontroller6 != oldkcontroller6 || *kvalue6 != oldkvalue6) { + instrument->controlChange(static_cast(*kcontroller6), *kvalue6); + oldkcontroller6 = *kcontroller6; + oldkvalue6 = *kvalue6; + } + if (*kcontroller7 != oldkcontroller7 || *kvalue7 != oldkvalue7) { + instrument->controlChange(static_cast(*kcontroller7), *kvalue7); + oldkcontroller7 = *kcontroller7; + oldkvalue7 = *kvalue7; + } + } + uint32_t offset = this->kperiodOffset(); + uint32_t end = this->kperiodEnd(); + uint32_t nsmps = this->ksmps(); + for (uint32_t i = 0; i < offset; i++) { + aoutput[i] = 0; + } + if (!released) { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = instrument->tick(); + } + } else { + for (uint32_t i = offset; i < end; i++) { + aoutput[i] = 0; + } + } + for (uint32_t i = end; i < nsmps; i++) { + aoutput[i] = 0; + } + return OK; + } + int32_t deinit(CSOUND *csound) { + if (instrument) { + delete instrument; + instrument = 0; + } + return OK; + } + static int32_t deinit_(CSOUND *csound, void *opcode) { + return reinterpret_cast *>(opcode)->deinit(csound); + } +}; + +} // namespace csound diff --git a/7.x/src/stk/stkOpcodes.cpp b/7.x/src/stk/stkOpcodes.cpp index d672079..5db1c94 100644 --- a/7.x/src/stk/stkOpcodes.cpp +++ b/7.x/src/stk/stkOpcodes.cpp @@ -97,306 +97,12 @@ extern "C" { #include } -#include "OpcodeBase.hpp" +#include "STKInstrumentAdapter.hpp" using namespace stk; using namespace csound; using namespace std; -template -class STKInstrumentAdapter : public OpcodeBase> { -public: - // Outputs. - cs_float *aoutput; - // Inputs. - cs_float *ifrequency; - cs_float *igain; - cs_float *kcontroller0; - cs_float *kvalue0; - cs_float *kcontroller1; - cs_float *kvalue1; - cs_float *kcontroller2; - cs_float *kvalue2; - cs_float *kcontroller3; - cs_float *kvalue3; - cs_float *kcontroller4; - cs_float *kvalue4; - cs_float *kcontroller5; - cs_float *kvalue5; - cs_float *kcontroller6; - cs_float *kvalue6; - cs_float *kcontroller7; - cs_float *kvalue7; - // State. - T *instrument; - bool released; - cs_float oldkcontroller0; - cs_float oldkvalue0; - cs_float oldkcontroller1; - cs_float oldkvalue1; - cs_float oldkcontroller2; - cs_float oldkvalue2; - cs_float oldkcontroller3; - cs_float oldkvalue3; - cs_float oldkcontroller4; - cs_float oldkvalue4; - cs_float oldkcontroller5; - cs_float oldkvalue5; - cs_float oldkcontroller6; - cs_float oldkvalue6; - cs_float oldkcontroller7; - cs_float oldkvalue7; - STKInstrumentAdapter() : instrument(0) {} - int32_t init(CSOUND *csound) { - if (!instrument) { - try { - instrument = new T(); - } catch (StkError &e) { - return csound->InitError(csound, "STK: %s", e.getMessage().c_str()); - } - } - instrument->noteOn(*ifrequency, *igain); - released = false; - oldkcontroller0 = -1.0; - oldkvalue0 = -1.0; - oldkcontroller1 = -1.0; - oldkvalue1 = -1.0; - oldkcontroller2 = -1.0; - oldkvalue2 = -1.0; - oldkcontroller3 = -1.0; - oldkvalue3 = -1.0; - oldkcontroller4 = -1.0; - oldkvalue4 = -1.0; - oldkcontroller5 = -1.0; - oldkvalue5 = -1.0; - oldkcontroller6 = -1.0; - oldkvalue6 = -1.0; - oldkcontroller7 = -1.0; - oldkvalue7 = -1.0; - return OK; - } - int32_t kontrol(CSOUND *csound) { - if (!released) { - if (*kcontroller0 != oldkcontroller0 || *kvalue0 != oldkvalue0) { - instrument->controlChange(static_cast(*kcontroller0), *kvalue0); - oldkcontroller0 = *kcontroller0; - oldkvalue0 = *kvalue0; - } - if (*kcontroller1 != oldkcontroller1 || *kvalue1 != oldkvalue1) { - instrument->controlChange(static_cast(*kcontroller1), *kvalue1); - oldkcontroller1 = *kcontroller1; - oldkvalue1 = *kvalue1; - } - if (*kcontroller2 != oldkcontroller2 || *kvalue2 != oldkvalue2) { - instrument->controlChange(static_cast(*kcontroller2), *kvalue2); - oldkcontroller2 = *kcontroller2; - oldkvalue2 = *kvalue2; - } - if (*kcontroller3 != oldkcontroller3 || *kvalue3 != oldkvalue3) { - instrument->controlChange(static_cast(*kcontroller3), *kvalue3); - oldkcontroller3 = *kcontroller3; - oldkvalue3 = *kvalue3; - } - if (*kcontroller4 != oldkcontroller4 || *kvalue4 != oldkvalue4) { - instrument->controlChange(static_cast(*kcontroller4), *kvalue4); - oldkcontroller4 = *kcontroller4; - oldkvalue4 = *kvalue4; - } - if (*kcontroller5 != oldkcontroller5 || *kvalue5 != oldkvalue5) { - instrument->controlChange(static_cast(*kcontroller5), *kvalue5); - oldkcontroller5 = *kcontroller5; - oldkvalue5 = *kvalue5; - } - if (*kcontroller6 != oldkcontroller6 || *kvalue6 != oldkvalue6) { - instrument->controlChange(static_cast(*kcontroller6), *kvalue6); - oldkcontroller6 = *kcontroller6; - oldkvalue6 = *kvalue6; - } - if (*kcontroller7 != oldkcontroller7 || *kvalue7 != oldkvalue7) { - instrument->controlChange(static_cast(*kcontroller7), *kvalue7); - oldkcontroller7 = *kcontroller7; - oldkvalue7 = *kvalue7; - } - } - uint32_t offset = this->kperiodOffset(); - uint32_t end = this->kperiodEnd(); - uint32_t nsmps = this->ksmps(); - for (uint32_t i = 0; i < offset; i++) { - aoutput[i] = 0; - } - if (!released) { - for (uint32_t i = offset; i < end; i++) { - aoutput[i] = instrument->tick(); - } - } else { - for (uint32_t i = offset; i < end; i++) { - aoutput[i] = 0; - } - } - for (uint32_t i = end; i < nsmps; i++) { - aoutput[i] = 0; - } - return OK; - } - int32_t deinit(CSOUND *csound) { - if (instrument) { - delete instrument; - instrument = 0; - } - return OK; - } - static int32_t deinit_(CSOUND *csound, void *opcode) { - return reinterpret_cast *>(opcode)->deinit(csound); - } -}; - -template -class STKInstrumentAdapter1 : public OpcodeBase> { -public: - // Outputs. - cs_float *aoutput; - // Inputs. - cs_float *ifrequency; - cs_float *igain; - cs_float *kcontroller0; - cs_float *kvalue0; - cs_float *kcontroller1; - cs_float *kvalue1; - cs_float *kcontroller2; - cs_float *kvalue2; - cs_float *kcontroller3; - cs_float *kvalue3; - cs_float *kcontroller4; - cs_float *kvalue4; - cs_float *kcontroller5; - cs_float *kvalue5; - cs_float *kcontroller6; - cs_float *kvalue6; - cs_float *kcontroller7; - cs_float *kvalue7; - // State. - T *instrument; - bool released; - cs_float oldkcontroller0; - cs_float oldkvalue0; - cs_float oldkcontroller1; - cs_float oldkvalue1; - cs_float oldkcontroller2; - cs_float oldkvalue2; - cs_float oldkcontroller3; - cs_float oldkvalue3; - cs_float oldkcontroller4; - cs_float oldkvalue4; - cs_float oldkcontroller5; - cs_float oldkvalue5; - cs_float oldkcontroller6; - cs_float oldkvalue6; - cs_float oldkcontroller7; - cs_float oldkvalue7; - STKInstrumentAdapter1() : instrument(0) {} - int32_t init(CSOUND *csound) { - if (!instrument) { - try { - instrument = new T((StkFloat)10.0); - } catch (StkError &e) { - return csound->InitError(csound, "STK: %s", e.getMessage().c_str()); - } - } - instrument->noteOn(*ifrequency, *igain); - released = false; - oldkcontroller0 = -1.0; - oldkvalue0 = -1.0; - oldkcontroller1 = -1.0; - oldkvalue1 = -1.0; - oldkcontroller2 = -1.0; - oldkvalue2 = -1.0; - oldkcontroller3 = -1.0; - oldkvalue3 = -1.0; - oldkcontroller4 = -1.0; - oldkvalue4 = -1.0; - oldkcontroller5 = -1.0; - oldkvalue5 = -1.0; - oldkcontroller6 = -1.0; - oldkvalue6 = -1.0; - oldkcontroller7 = -1.0; - oldkvalue7 = -1.0; - return OK; - } - int32_t kontrol(CSOUND *csound) { - if (!released) { - if (*kcontroller0 != oldkcontroller0 || *kvalue0 != oldkvalue0) { - instrument->controlChange(static_cast(*kcontroller0), *kvalue0); - oldkcontroller0 = *kcontroller0; - oldkvalue0 = *kvalue0; - } - if (*kcontroller1 != oldkcontroller1 || *kvalue1 != oldkvalue1) { - instrument->controlChange(static_cast(*kcontroller1), *kvalue1); - oldkcontroller1 = *kcontroller1; - oldkvalue1 = *kvalue1; - } - if (*kcontroller2 != oldkcontroller2 || *kvalue2 != oldkvalue2) { - instrument->controlChange(static_cast(*kcontroller2), *kvalue2); - oldkcontroller2 = *kcontroller2; - oldkvalue2 = *kvalue2; - } - if (*kcontroller3 != oldkcontroller3 || *kvalue3 != oldkvalue3) { - instrument->controlChange(static_cast(*kcontroller3), *kvalue3); - oldkcontroller3 = *kcontroller3; - oldkvalue3 = *kvalue3; - } - if (*kcontroller4 != oldkcontroller4 || *kvalue4 != oldkvalue4) { - instrument->controlChange(static_cast(*kcontroller4), *kvalue4); - oldkcontroller4 = *kcontroller4; - oldkvalue4 = *kvalue4; - } - if (*kcontroller5 != oldkcontroller5 || *kvalue5 != oldkvalue5) { - instrument->controlChange(static_cast(*kcontroller5), *kvalue5); - oldkcontroller5 = *kcontroller5; - oldkvalue5 = *kvalue5; - } - if (*kcontroller6 != oldkcontroller6 || *kvalue6 != oldkvalue6) { - instrument->controlChange(static_cast(*kcontroller6), *kvalue6); - oldkcontroller6 = *kcontroller6; - oldkvalue6 = *kvalue6; - } - if (*kcontroller7 != oldkcontroller7 || *kvalue7 != oldkvalue7) { - instrument->controlChange(static_cast(*kcontroller7), *kvalue7); - oldkcontroller7 = *kcontroller7; - oldkvalue7 = *kvalue7; - } - } - uint32_t offset = this->kperiodOffset(); - uint32_t end = this->kperiodEnd(); - uint32_t nsmps = this->ksmps(); - for (uint32_t i = 0; i < offset; i++) { - aoutput[i] = 0; - } - if (!released) { - for (uint32_t i = offset; i < end; i++) { - aoutput[i] = instrument->tick(); - } - } else { - for (uint32_t i = offset; i < end; i++) { - aoutput[i] = 0; - } - } - for (uint32_t i = end; i < nsmps; i++) { - aoutput[i] = 0; - } - return OK; - } - int32_t deinit(CSOUND *csound) { - if (instrument) { - delete instrument; - instrument = 0; - } - return OK; - } - static int32_t deinit_(CSOUND *csound, void *opcode) { - return reinterpret_cast *>(opcode)->deinit(csound); - } -}; - extern "C" { OENTRY oentries[] = { { diff --git a/7.x/src/stk/tests/stk_adapter_test.cpp b/7.x/src/stk/tests/stk_adapter_test.cpp new file mode 100644 index 0000000..d249d01 --- /dev/null +++ b/7.x/src/stk/tests/stk_adapter_test.cpp @@ -0,0 +1,75 @@ +#include +#include "STKInstrumentAdapter.hpp" + +// Observe the rate the instrument sees, without depending on any sound model. +struct SampleRateProbe { + double constructedAt = stk::Stk::sampleRate(); + double noteStartedAt = 0; + + SampleRateProbe() = default; + explicit SampleRateProbe(stk::StkFloat) {} + + void noteOn(stk::StkFloat, stk::StkFloat) { + noteStartedAt = stk::Stk::sampleRate(); + } +}; + +template +class StkAdapterTest : public ::testing::Test { +protected: + INSDS instrument = {}; + cs_float frequency = 440; + cs_float gain = 0.5; + Adapter adapter; + + void SetUp() override { + stk::Stk::setSampleRate(44100); + adapter.opds.insdshead = &instrument; + adapter.ifrequency = &frequency; + adapter.igain = &gain; + } + + void TearDown() override { + adapter.deinit(nullptr); + stk::Stk::setSampleRate(44100); + } +}; + +// Default construction (e.g. BeeThree) and a lowest-frequency argument (Saxofony). +using Adapters = ::testing::Types< + csound::STKInstrumentAdapter, + csound::STKInstrumentAdapter1>; +TYPED_TEST_SUITE(StkAdapterTest, Adapters); + +TYPED_TEST(StkAdapterTest, SetsSampleRateBeforeConstructingInstrument) { + this->instrument.esr = 48000; + ASSERT_EQ(this->adapter.init(nullptr), OK); + + EXPECT_DOUBLE_EQ(this->adapter.instrument->constructedAt, 48000); + EXPECT_DOUBLE_EQ(this->adapter.instrument->noteStartedAt, 48000); +} + +TYPED_TEST(StkAdapterTest, NewInstrumentsFollowSampleRateChanges) { + for (double rate : {48000, 96000, 44100}) { + SCOPED_TRACE(rate); + this->instrument.esr = rate; + ASSERT_EQ(this->adapter.init(nullptr), OK); + + EXPECT_DOUBLE_EQ(this->adapter.instrument->constructedAt, rate); + EXPECT_DOUBLE_EQ(this->adapter.instrument->noteStartedAt, rate); + this->adapter.deinit(nullptr); + } +} + +TYPED_TEST(StkAdapterTest, ReinitializationSetsSampleRateBeforeNoteOn) { + this->instrument.esr = 48000; + ASSERT_EQ(this->adapter.init(nullptr), OK); + auto *existing = this->adapter.instrument; + + // Another initialization may have changed STK's shared sample rate. + stk::Stk::setSampleRate(44100); + ASSERT_EQ(this->adapter.init(nullptr), OK); + + EXPECT_EQ(this->adapter.instrument, existing); + EXPECT_DOUBLE_EQ(this->adapter.instrument->noteStartedAt, 48000); +} From 7e4af2e966cf10cb25469224ff15b5241bd455d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Sun, 18 Oct 2026 20:20:22 +0300 Subject: [PATCH 69/72] fix(wasm): update npm plugins for shared-memory Csound (#57) * fix(wasm): build npm plugins for the shared-memory runtime * fix(wasm): pass exception mode to C++ plugin links --- 7.x/cmake/WasmPlugins.cmake | 12 ++++++++++- package-lock.json | 20 +++++++++--------- package.json | 7 +++---- wasm/README.md | 23 ++++++++++++--------- wasm/default.nix | 39 ++++++++++++++++++++++++++--------- wasm/libunwind/CMakeLists.txt | 2 +- wasm/tests/runtime.test.js | 12 ++++++++++- 7 files changed, 78 insertions(+), 37 deletions(-) diff --git a/7.x/cmake/WasmPlugins.cmake b/7.x/cmake/WasmPlugins.cmake index 541f6c4..1d183cf 100644 --- a/7.x/cmake/WasmPlugins.cmake +++ b/7.x/cmake/WasmPlugins.cmake @@ -3,6 +3,9 @@ set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) set(USE_COMPILER_OPTIMIZATIONS OFF CACHE BOOL "" FORCE) set(REQUIRE_PTHREADS OFF CACHE BOOL "" FORCE) set(USE_DOUBLE ON CACHE BOOL "" FORCE) +if(NOT WASM_MAX_MEMORY) + message(FATAL_ERROR "WASM_MAX_MEMORY must match the shared-memory Csound engine") +endif() execute_process(COMMAND ${CMAKE_C_COMPILER} --print-libgcc-file-name OUTPUT_VARIABLE WASM_BUILTINS OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ERROR_IS_FATAL ANY) @@ -13,12 +16,14 @@ function(configure_wasm_plugin target) target_compile_definitions(${target} PRIVATE USE_DOUBLE=1 _WASI_EMULATED_SIGNAL _WASI_EMULATED_MMAN) target_compile_options(${target} PRIVATE - -fPIC "SHELL:-mllvm -wasm-enable-sjlj" + -fPIC -pthread "SHELL:-mllvm -wasm-enable-sjlj" + "SHELL:-mllvm -wasm-use-legacy-eh=false" "$<$:-std=gnu11>" "$<$:-nostdinc++>" "$<$:-isystem${WASM_CXX_INCLUDE_DIR}>") if(WASM_CXX_EXCEPTIONS) target_compile_options(${target} PRIVATE "$<$:-fwasm-exceptions>") + target_link_options(${target} PRIVATE "$<$:-fwasm-exceptions>") else() target_compile_options(${target} PRIVATE "$<$:-fno-exceptions>") endif() @@ -29,7 +34,12 @@ function(configure_wasm_plugin target) "LINKER:--no-entry" "LINKER:--import-table" "LINKER:--import-memory" + "LINKER:--shared-memory" + "LINKER:--max-memory=${WASM_MAX_MEMORY}" "LINKER:--allow-undefined" + "LINKER:--export=__wasm_init_tls" + "LINKER:--export=__tls_size" + "LINKER:--export=__tls_align" "LINKER:--export=__wasm_call_ctors" "LINKER:--export-if-defined=__wasm_apply_data_relocs" "LINKER:--export-if-defined=csound_opcode_init" diff --git a/package-lock.json b/package-lock.json index 1f9e10f..0948b95 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,16 +1,16 @@ { "name": "@csound/plugins", - "version": "7.0.0-beta.0", + "version": "7.0.0-beta.1", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@csound/plugins", - "version": "7.0.0-beta.0", + "version": "7.0.0-beta.1", "license": "LGPL-2.1-or-later", "devDependencies": { - "@csound/browser": "7.0.0-beta39", - "@csound/wasm-bin": "7.0.0-beta29" + "@csound/browser": "7.0.0-beta41", + "@csound/wasm-bin": "7.0.0-beta31" }, "engines": { "node": ">=22.13.0" @@ -27,9 +27,9 @@ } }, "node_modules/@csound/browser": { - "version": "7.0.0-beta39", - "resolved": "https://registry.npmjs.org/@csound/browser/-/browser-7.0.0-beta39.tgz", - "integrity": "sha512-/POVGpLfRrQ3kVjCPBp5bTnfYgMUQRCUHtrAilwSjrlRMQbQvQw3qjtcNbwTAxdY6uhppbpy7GbUAU2kl+OHug==", + "version": "7.0.0-beta41", + "resolved": "https://registry.npmjs.org/@csound/browser/-/browser-7.0.0-beta41.tgz", + "integrity": "sha512-FKZ9v3HGtqksZkM+Oc7C1mUfvCk0y+PTL/iXYiCGDYj6gHVjoms34z9wc/BqYGDM+gzuAnimV65SlSb1mEqrZg==", "dev": true, "license": "Apache-2.0", "dependencies": { @@ -49,9 +49,9 @@ } }, "node_modules/@csound/wasm-bin": { - "version": "7.0.0-beta29", - "resolved": "https://registry.npmjs.org/@csound/wasm-bin/-/wasm-bin-7.0.0-beta29.tgz", - "integrity": "sha512-OfrrLaS+h6Br7S9XaJWK9tBxj1JgPRxEySYx2XyZjgAnt+UIn9Dm8H2qBSJUJgBWIT2KBmFCyw4fcdcwtGGyOg==", + "version": "7.0.0-beta31", + "resolved": "https://registry.npmjs.org/@csound/wasm-bin/-/wasm-bin-7.0.0-beta31.tgz", + "integrity": "sha512-CaFhe9LZ/KwPQKTnVc8L5EJXaTgGCX/1/xepLlRETIv5kdbSEnhyWcrGxltxg2EPhgDK8gmvtN85cTCq21FxrQ==", "dev": true, "license": "LGPL-2.1" }, diff --git a/package.json b/package.json index 5242717..2df63e8 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,6 @@ { "name": "@csound/plugins", - "version": "7.0.0-beta.0", - "private": true, + "version": "7.0.0-beta.1", "description": "Csound 7 opcode plugins for WebAssembly", "type": "module", "license": "LGPL-2.1-or-later", @@ -41,8 +40,8 @@ "prepack": "npm test" }, "devDependencies": { - "@csound/browser": "7.0.0-beta39", - "@csound/wasm-bin": "7.0.0-beta29" + "@csound/browser": "7.0.0-beta41", + "@csound/wasm-bin": "7.0.0-beta31" }, "keywords": [ "csound", diff --git a/wasm/README.md b/wasm/README.md index 5a361cf..a2039f2 100644 --- a/wasm/README.md +++ b/wasm/README.md @@ -8,9 +8,11 @@ Csound 6 is not supported. ## Runtime dependency -Builds use the plugin SDK from `@csound/wasm-bin`, and tests use the published -`@csound/browser` runtime. [package.json](../package.json) and +Builds use the shared-memory plugin SDK and toolchain from `@csound/wasm-bin`. +Tests use the published `@csound/browser` runtime. [package.json](../package.json) and [package-lock.json](../package-lock.json) record the versions used together. +Rebuild after updating these dependencies. Plugins built for the old, +non-shared engine cannot load in the shared-memory runtime. ## Use @@ -62,8 +64,10 @@ npm pack ``` Nix pins the toolchain and builds the existing `7.x` CMake targets with Ninja. -Dependencies use static PIC builds. The C runtime imports the engine's allocator; -it does not link its own heap. STK uses a separate libc++ build with C++ exceptions +Dependencies use threaded static PIC builds. Each plugin exports its TLS size, +alignment, and initializer so the engine can set up thread-local storage. +The C runtime imports the engine's allocator; it does not link its own heap. +STK uses a separate libc++ build with C++ exceptions and a static WASM unwinder. Other C++ plugins keep exceptions disabled. CMake's `STK_EMBED_RAWWAVES` option embeds the samples and defaults to on for WASM. Native builds keep using the installed raw-wave directory by default. @@ -93,10 +97,9 @@ uses the `csound` Cachix cache and uploads builds when `CACHIX_AUTH_TOKEN` is available. Fork PRs read from the cache without the secret. Native builds use GitHub Actions caches. -## First npm release +## npm releases -Run the build, test, and pack commands against the published browser package -with `CSOUND_BROWSER_URL` unset. When ready to publish, remove `private` from -`package.json`, set the package version with `npm version`, and run -`npm publish --tag beta --access public` from a clean build. No workflow publishes -this package yet. +Set the next package version with `npm version`, then run the build, test, and +pack commands against the published browser package with `CSOUND_BROWSER_URL` +unset. Publish with `npm publish --tag beta --access public` from that build. +No workflow publishes this package yet. diff --git a/wasm/default.nix b/wasm/default.nix index 9b7353a..fa6ac34 100644 --- a/wasm/default.nix +++ b/wasm/default.nix @@ -3,7 +3,16 @@ , csoundSdkArchive ? null }: let - wasi = pkgs.pkgsCross.wasi32.clangStdenv; + lock = builtins.fromJSON (builtins.readFile ../package-lock.json); + wasmBin = lock.packages."node_modules/@csound/wasm-bin"; + wasmPackage = pkgs.runCommand "csound-wasm-bin-${wasmBin.version}" {} '' + mkdir -p $out + tar -xzf ${pkgs.fetchurl { url = wasmBin.resolved; hash = wasmBin.integrity; }} --strip-components=1 -C $out + ''; + # Use the same threaded WASI toolchain and memory limit as the engine. + toolchain = import "${wasmPackage}/src/wasi-realtime-toolchain.nix" { inherit pkgs; }; + maxMemory = builtins.fromJSON (builtins.readFile "${wasmPackage}/src/shared-memory-max.txt"); + wasi = toolchain.stdenv; # Nix's WASI wrapper otherwise forces -fno-exceptions after CMake's flags. # Let each target select its exception mode instead. wasiCxx = pkgs.overrideCC wasi (wasi.cc.override (old: { @@ -11,15 +20,17 @@ let cc-cflags = builtins.filter (flag: flag != "-fno-exceptions") old.nixSupport.cc-cflags; }; })); - libc = pkgs.pkgsCross.wasi32.wasilibc.overrideAttrs (old: { - NIX_CFLAGS_COMPILE = (old.NIX_CFLAGS_COMPILE or []) ++ [ "-fPIC" ]; + libc = toolchain.libc.overrideAttrs (old: { + NIX_CFLAGS_COMPILE = (old.NIX_CFLAGS_COMPILE or []) ++ [ + "-fPIC" "-mllvm" "-wasm-enable-sjlj" "-mllvm" "-wasm-use-legacy-eh=false" + ]; # Use the engine's allocator. wasi-libc also skips its fixed symbol list # for this mode; PIC adds imports absent from that non-PIC list. makeFlags = (old.makeFlags or []) ++ [ "MALLOC_IMPL=none" ]; preFixup = ""; dontStrip = true; }); - libcxx = pkgs.pkgsCross.wasi32.llvmPackages.libcxx.overrideAttrs (old: { + libcxx = toolchain.libcxx.overrideAttrs (old: { cmakeFlags = old.cmakeFlags ++ [ "-DCMAKE_POSITION_INDEPENDENT_CODE=ON" "-DLIBCXX_ENABLE_FILESYSTEM=ON" @@ -43,11 +54,9 @@ let "-DLIBCXXABI_ENABLE_EXCEPTIONS=ON" ]; preConfigure = (old.preConfigure or "") + '' - cmakeFlagsArray+=("-DCMAKE_CXX_FLAGS=-fexceptions -fwasm-exceptions -I${libunwindSource}/libunwind/include") + cmakeFlagsArray+=("-DCMAKE_CXX_FLAGS=-fexceptions -fwasm-exceptions -mllvm -wasm-use-legacy-eh=false -I${libunwindSource}/libunwind/include") ''; }); - lock = builtins.fromJSON (builtins.readFile ../package-lock.json); - wasmBin = lock.packages."node_modules/@csound/wasm-bin"; sdkArchive = if csoundSdkArchive == null then null else builtins.path { path = csoundSdkArchive; name = "csound-plugin-sdk.tar.gz"; @@ -55,8 +64,7 @@ let sdk = pkgs.runCommand "csound-wasm-plugin-sdk-${wasmBin.version}" {} '' mkdir -p $out ${if csoundSdkArchive == null then '' - tar -xzf ${pkgs.fetchurl { url = wasmBin.resolved; hash = wasmBin.integrity; }} - tar -xzf package/lib/csound-plugin-sdk.tar.gz --strip-components=1 -C $out + tar -xzf ${wasmPackage}/lib/csound-plugin-sdk.tar.gz --strip-components=1 -C $out '' else '' tar -xzf ${sdkArchive} --strip-components=1 -C $out ''} @@ -66,6 +74,16 @@ let inherit (pkgs.zlib) version src; nativeBuildInputs = [ pkgs.cmake pkgs.ninja ]; cmakeFlags = [ "-DCMAKE_POSITION_INDEPENDENT_CODE=ON" "-DCMAKE_INSTALL_LIBDIR=lib" "-DZLIB_BUILD_EXAMPLES=OFF" ]; + # zlib 1.3.1 has no CMake switch to omit its shared library. Build only + # the static target so it does not link the toolchain's non-PIC libc. + ninjaFlags = [ "zlibstatic" ]; + installPhase = '' + runHook preInstall + install -Dm644 libzlibstatic.a $out/lib/libzlibstatic.a + install -Dm644 ../zlib.h $out/include/zlib.h + install -Dm644 zconf.h $out/include/zconf.h + runHook postInstall + ''; dontStrip = true; }; libpng = wasi.mkDerivation { @@ -80,7 +98,7 @@ let "-DPNG_SHARED=OFF" "-DPNG_STATIC=ON" "-DPNG_TESTS=OFF" "-DPNG_TOOLS=OFF" "-DZLIB_LIBRARY=${zlib}/lib/libzlibstatic.a" ]; - NIX_CFLAGS_COMPILE = [ "-mllvm" "-wasm-enable-sjlj" ]; + NIX_CFLAGS_COMPILE = [ "-mllvm" "-wasm-enable-sjlj" "-mllvm" "-wasm-use-legacy-eh=false" ]; dontStrip = true; }; in wasiCxx.mkDerivation { @@ -94,6 +112,7 @@ in wasiCxx.mkDerivation { "-DCMAKE_POLICY_VERSION_MINIMUM=3.5" "-DCMAKE_BUILD_TYPE=Release" "-DCSOUND_INCLUDE_DIR=${sdk}/include/csound" + "-DWASM_MAX_MEMORY=${toString maxMemory}" "-DWASM_LIBC=${libc}/lib/libc.a" "-DWASM_SETJMP=${libc}/lib/libsetjmp.a" "-DWASM_LIBCXX=${libcxx}/lib/libc++.a" diff --git a/wasm/libunwind/CMakeLists.txt b/wasm/libunwind/CMakeLists.txt index 5e79ec6..c722bd2 100644 --- a/wasm/libunwind/CMakeLists.txt +++ b/wasm/libunwind/CMakeLists.txt @@ -6,7 +6,7 @@ project(CsoundWasmUnwind C) add_library(unwind STATIC "${LIBUNWIND_SOURCE_DIR}/src/Unwind-wasm.c") set_target_properties(unwind PROPERTIES POSITION_INDEPENDENT_CODE ON) target_compile_features(unwind PRIVATE c_std_11) -target_compile_options(unwind PRIVATE -fwasm-exceptions) +target_compile_options(unwind PRIVATE -fwasm-exceptions "SHELL:-mllvm -wasm-use-legacy-eh=false") target_compile_definitions(unwind PRIVATE _LIBUNWIND_HIDE_SYMBOLS) target_include_directories(unwind PRIVATE "${LIBUNWIND_SOURCE_DIR}/include") install(TARGETS unwind ARCHIVE DESTINATION lib) diff --git a/wasm/tests/runtime.test.js b/wasm/tests/runtime.test.js index b7ca0f6..3b69d97 100644 --- a/wasm/tests/runtime.test.js +++ b/wasm/tests/runtime.test.js @@ -70,7 +70,7 @@ async function run(body, check, withPlugins = binaries, prepare = () => {}) { } } -test("all plugins are WASI side modules", async () => { +test("all plugins are WASI side modules with the shared-memory TLS exports", async () => { for (const bytes of binaries) { const module = await WebAssembly.compile(bytes); const imports = WebAssembly.Module.imports(module); @@ -79,6 +79,16 @@ test("all plugins are WASI side modules", async () => { assert.ok(imports.some(({ kind, name }) => kind === "memory" && name === "memory")); assert.ok(imports.some(({ kind }) => kind === "table")); assert.ok(exports.some(({ name }) => name === "__wasm_call_ctors")); + for (const [name, kind] of [ + ["__wasm_init_tls", "function"], + ["__tls_size", "global"], + ["__tls_align", "global"], + ]) { + assert.ok( + exports.some((entry) => entry.name === name && entry.kind === kind), + `${name} must be exported as a ${kind}`, + ); + } assert.ok(exports.some(({ name }) => ["csoundModuleInit", "csound_opcode_init"].includes(name))); assert.ok(!exports.some(({ name }) => name === "_start")); } From b72cfe1306b8d26a3821d8c7fe84912afb72b6ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Hl=C3=B6=C3=B0ver=20Sigur=C3=B0sson?= Date: Sun, 25 Oct 2026 11:57:17 +0200 Subject: [PATCH 70/72] fix: support the Csound 7 plugin API (#59) * fix: support the Csound 7 plugin API Keep the const type descriptor returned by GetTypeForArg in Fluid. Export csoundModuleInfo from Chua and linear algebra so Csound 7 can validate their ABI and load them. Add native loader tests and update Csound 7 CI to the stable release. Assisted-by: Codex (GPT-6) * test: verify the requested Csound plugin loads Quote opcode library paths so build directories can contain spaces. Check the exact load message as well as orchestra compilation: an rc file can load an installed copy and hide a failed load of the build artifact. Assisted-by: Codex (GPT-6) --- .github/workflows/plugins_build_7.yml | 2 +- 7.x/CMakeLists.txt | 26 +++++++++ 7.x/src/chua/ChuaOscillator.cpp | 2 + 7.x/src/fluidOpcodes/fluidOpcodes.cpp | 2 +- 7.x/src/linear_algebra/linear_algebra.cpp | 2 + 7.x/tests/plugin_load_test.cpp | 70 +++++++++++++++++++++++ 6 files changed, 102 insertions(+), 2 deletions(-) create mode 100644 7.x/tests/plugin_load_test.cpp diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml index 989c4e0..b118242 100644 --- a/.github/workflows/plugins_build_7.yml +++ b/.github/workflows/plugins_build_7.yml @@ -19,7 +19,7 @@ on: workflow_dispatch: env: - CSOUND_VERSION: 7.0.0-beta.18 + CSOUND_VERSION: 7.0.0 FAUST_VERSION: 2.88.0 VCPKG_BINARY_SOURCES: "clear;files,${{ github.workspace }}/vcpkg-cache,readwrite" diff --git a/7.x/CMakeLists.txt b/7.x/CMakeLists.txt index 734f933..07eb007 100644 --- a/7.x/CMakeLists.txt +++ b/7.x/CMakeLists.txt @@ -335,3 +335,29 @@ add_subdirectory(./src/CUDA) add_subdirectory(./src/OpenCL) add_subdirectory(./src/stk) add_subdirectory(./src/faustcsound) + +# Exercise the native loader as well as compilation against the Csound headers. +if(NOT WASM AND (TARGET chua OR TARGET linear_algebra OR TARGET fluidOpcodes)) + find_package(GTest QUIET) + if(GTest_FOUND) + add_executable(plugin_load_tests tests/plugin_load_test.cpp) + set_target_properties(plugin_load_tests PROPERTIES + CXX_STANDARD 14 + CXX_STANDARD_REQUIRED ON) + target_include_directories(plugin_load_tests PRIVATE ${CSOUND_INCLUDE_DIRS}) + target_link_libraries(plugin_load_tests PRIVATE GTest::gtest_main ${CSOUND_LIBRARY}) + foreach(plugin IN ITEMS chua linear_algebra fluidOpcodes) + if(TARGET ${plugin}) + if(plugin STREQUAL "fluidOpcodes") + set(test_name FLUID) + else() + string(TOUPPER "${plugin}" test_name) + endif() + target_compile_definitions(plugin_load_tests PRIVATE + CSOUND_TEST_${test_name}="$") + add_dependencies(plugin_load_tests ${plugin}) + endif() + endforeach() + add_test(NAME plugin_load_tests COMMAND plugin_load_tests) + endif() +endif() diff --git a/7.x/src/chua/ChuaOscillator.cpp b/7.x/src/chua/ChuaOscillator.cpp index 9d7a42c..1da760c 100644 --- a/7.x/src/chua/ChuaOscillator.cpp +++ b/7.x/src/chua/ChuaOscillator.cpp @@ -611,6 +611,8 @@ OENTRY oentries[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }}; +PUBLIC int32_t csoundModuleInfo(void) { return CSOUND_MODULE_INFO; } + PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { return 0; } PUBLIC int32_t csoundModuleInit(CSOUND *csound) { diff --git a/7.x/src/fluidOpcodes/fluidOpcodes.cpp b/7.x/src/fluidOpcodes/fluidOpcodes.cpp index 666f76e..4cf568b 100644 --- a/7.x/src/fluidOpcodes/fluidOpcodes.cpp +++ b/7.x/src/fluidOpcodes/fluidOpcodes.cpp @@ -283,7 +283,7 @@ class FluidLoad : public csound::OpcodeBase { soundFontId = -1; toa(csound, iFluidSynth, fluidSynth); listPresets = (int32_t)*iListPresets; - CS_TYPE *argType = GetTypeForArg(iFilename); + const CS_TYPE *argType = GetTypeForArg(iFilename); if (strcmp("S", argType->varTypeName) == 0) { filename = csound->Strdup(csound, ((STRINGDAT *)iFilename)->data); } else { diff --git a/7.x/src/linear_algebra/linear_algebra.cpp b/7.x/src/linear_algebra/linear_algebra.cpp index ca9dfa8..ac6eaea 100644 --- a/7.x/src/linear_algebra/linear_algebra.cpp +++ b/7.x/src/linear_algebra/linear_algebra.cpp @@ -3926,6 +3926,8 @@ class la_k_qr_sym_eigen_mc_t : public OpcodeBase { extern "C" { +PUBLIC int32_t csoundModuleInfo(void) { return CSOUND_MODULE_INFO; } + PUBLIC int32_t csoundModuleCreate(CSOUND *csound) { return 0; } PUBLIC int32_t csoundModuleInit(CSOUND *csound) { diff --git a/7.x/tests/plugin_load_test.cpp b/7.x/tests/plugin_load_test.cpp new file mode 100644 index 0000000..88711d4 --- /dev/null +++ b/7.x/tests/plugin_load_test.cpp @@ -0,0 +1,70 @@ +#include "csound.h" +#include "gtest/gtest.h" +#include + +class PluginLoadTests : public ::testing::Test { +protected: + CSOUND *csound = nullptr; + + void SetUp() override { + // Skip the default plugin directories; rc files may still add libraries. + csound = csoundCreate(nullptr, ""); + ASSERT_NE(csound, nullptr); + csoundCreateMessageBuffer(csound, 0); + } + + void TearDown() override { + csoundDestroy(csound); + } + + std::string messages() { + std::string result; + while (csoundGetMessageCnt(csound)) { + result += csoundGetFirstMessage(csound); + csoundPopFirstMessage(csound); + } + return result; + } + + void compile(const char *plugin, const char *orchestra) { + std::string option = std::string("--opcode-lib=\"") + plugin + "\""; + ASSERT_EQ(csoundSetOption(csound, option.c_str()), 0); + const int result = csoundCompileOrc(csound, orchestra, 0); + const std::string log = messages(); + EXPECT_EQ(result, 0) << log; + // An installed copy can supply the opcodes if the requested library fails. + const std::string loaded = std::string("\nloaded ") + plugin + "\n"; + EXPECT_NE(("\n" + log).find(loaded), std::string::npos) << log; + } +}; + +#ifdef CSOUND_TEST_CHUA +TEST_F(PluginLoadTests, ChuaRegistersItsOpcode) { + compile(CSOUND_TEST_CHUA, R"( + instr 1 + a1, a2, a3 chuap 0.00945, 7.5, 2e-7, 0.00105, 0, -0.00121, 1.76e-5, 1.5e-8, 0, -0.1, 0.1, 5e-6 + endin + )"); +} +#endif + +#ifdef CSOUND_TEST_LINEAR_ALGEBRA +TEST_F(PluginLoadTests, LinearAlgebraRegistersItsOpcodes) { + compile(CSOUND_TEST_LINEAR_ALGEBRA, R"( + instr 1 + ivector la_i_vr_create 3 + endin + )"); +} +#endif + +#ifdef CSOUND_TEST_FLUID +TEST_F(PluginLoadTests, FluidRegistersItsOpcodes) { + compile(CSOUND_TEST_FLUID, R"( + instr 1 + iengine fluidEngine + aleft, aright fluidOut iengine + endin + )"); +} +#endif From cb0005ef697bf53d01ffa5bc6a11686c4f004d3c Mon Sep 17 00:00:00 2001 From: vlazzarini Date: Thu, 29 Oct 2026 10:16:25 +0000 Subject: [PATCH 71/72] Flatten Csound 7 plugins tree to repository root --- .coderabbit.yaml | 10 +- .github/workflows/plugins_build.yml | 622 +- .github/workflows/plugins_build_7.yml | 567 -- .gitignore | 1 - .gitmodules | 5 +- 6.x/CMakeLists.txt | 317 - 6.x/README.md | 114 - 6.x/cmake/Modules/FindCSOUND.cmake | 65 - 6.x/cmake/Modules/FindFAUST.cmake | 59 - 6.x/cmake/Modules/FindGMM.cmake | 20 - 6.x/installer/macosx/release-build.sh | 73 - 6.x/installer/macosx/scripts/postinstall | 10 - 6.x/installer/win64/Installer.iss | 104 - .../Csound6-Plugins-Windows_x86_64-1.0.exe | Bin 9487217 -> 0 bytes 6.x/installer/win64/buildWindows.sh | 21 - 6.x/src/AbletonLinkOpcodes/CMakeLists.txt | 53 - .../ableton_link_opcodes.cpp | 890 --- 6.x/src/AbletonLinkOpcodes/jni/Android.mk | 20 - 6.x/src/AbletonLinkOpcodes/jni/Application.mk | 6 - 6.x/src/CUDA/CMakeLists.txt | 68 - 6.x/src/CUDA/adsyn.cu | 187 - 6.x/src/CUDA/adsyn11.cu | 185 - 6.x/src/CUDA/build.sh | 9 - 6.x/src/CUDA/conv.cu | 153 - 6.x/src/CUDA/convf.cu | 141 - 6.x/src/CUDA/cuda_pvs_example.csd | 40 - 6.x/src/CUDA/cuda_sliding_example.csd | 24 - 6.x/src/CUDA/cudaconv.csd | 22 - 6.x/src/CUDA/cudadsyn_pvs_example.csd | 39 - 6.x/src/CUDA/cudapconv.csd | 45 - 6.x/src/CUDA/pconv.cu | 263 - 6.x/src/CUDA/pconv11.cu | 266 - 6.x/src/CUDA/pvsops.cu | 448 -- 6.x/src/CUDA/pvsops2-build.sh | 5 - 6.x/src/CUDA/pvsops2.cu | 530 -- 6.x/src/CUDA/pvsopsf.cu | 445 -- 6.x/src/CUDA/slidingm.cu | 640 -- 6.x/src/chua/CMakeLists.txt | 27 - 6.x/src/chua/ChuaOscillator.cpp | 636 -- 6.x/src/chua/OpcodeBase.hpp | 492 -- 6.x/src/faustcsound/CMakeLists.txt | 37 - 6.x/src/faustcsound/README.md | 29 - 6.x/src/faustcsound/faustgen.cpp | 1115 --- 6.x/src/fluidOpcodes/Android/.gitignore | 10 - 6.x/src/fluidOpcodes/Android/build.sh | 9 - 6.x/src/fluidOpcodes/Android/jni/Android.mk | 24 - .../fluidOpcodes/Android/jni/Application.mk | 8 - 6.x/src/fluidOpcodes/CMakeLists.txt | 11 - 6.x/src/fluidOpcodes/OpcodeBase.hpp | 492 -- 6.x/src/fluidOpcodes/fluidOpcodes.cpp | 748 -- 6.x/src/fluidOpcodes/fluidOpcodes.h | 120 - 6.x/src/fluidOpcodes/fluidOpcodes.html | 80 - 6.x/src/fluidOpcodes/test.csd | 58 - 6.x/src/hdf5/CMakeLists.txt | 31 - 6.x/src/hdf5/HDF5IO.c | 1404 ---- 6.x/src/hdf5/HDF5IO.h | 144 - 6.x/src/image/CMakeLists.txt | 15 - 6.x/src/image/README.md | 6 - 6.x/src/image/imageOpcodes.c | 659 -- 6.x/src/image/imageOpcodes.h | 80 - 6.x/src/jackops/CMakeLists.txt | 23 - 6.x/src/jackops/OpcodeBase.hpp | 492 -- 6.x/src/jackops/cs_jack.h | 67 - 6.x/src/jackops/jackTransport.c | 98 - 6.x/src/jackops/jacko.cpp | 1468 ---- 6.x/src/jackops/jacko_test.csd | 93 - 6.x/src/linear_algebra/CMakeLists.txt | 16 - 6.x/src/linear_algebra/OpcodeBase.hpp | 492 -- 6.x/src/linear_algebra/linear_algebra.cpp | 4753 ------------- 6.x/src/mp3/CMakeLists.txt | 19 - 6.x/src/mp3/mp3out.c | 141 - 6.x/src/opencl/CMakeLists.txt | 29 - 6.x/src/opencl/build.sh | 1 - 6.x/src/opencl/buildc.sh | 2 - 6.x/src/opencl/buildcpp.sh | 2 - 6.x/src/opencl/cladsyn.csd | 45 - 6.x/src/opencl/cladsynth.c | 393 -- 6.x/src/opencl/cladsynth.cpp | 404 -- 6.x/src/opencl/cladsynth2.cpp | 412 -- 6.x/src/opencl/clconv.csd | 28 - 6.x/src/opencl/libcl.dylib | Bin 4224 -> 0 bytes 6.x/src/opencl/libclconv.dylib | Bin 44392 -> 0 bytes .../libclconv.dylib.dSYM/Contents/Info.plist | 20 - .../Contents/Resources/DWARF/libclconv.dylib | Bin 304807 -> 0 bytes 6.x/src/opencl/openclop.cpp | 271 - 6.x/src/p5glove/CMakeLists.txt | 19 - 6.x/src/p5glove/libp5glove/p5glove.c | 690 -- 6.x/src/p5glove/libp5glove/usb_hid_macosx.c | 365 - 6.x/src/p5glove/libp5glove/usb_hid_win32.c | 346 - 6.x/src/p5glove/p5g_mac | 24 - 6.x/src/p5glove/p5glove.c | 262 - 6.x/src/py/examples/cabrera/python0.csd | 23 - 6.x/src/py/examples/cabrera/python1.csd | 37 - 6.x/src/py/examples/cabrera/python2.csd | 34 - 6.x/src/py/examples/cabrera/python3.csd | 35 - 6.x/src/py/examples/cabrera/python4.csd | 35 - 6.x/src/py/examples/cabrera/python5.csd | 32 - 6.x/src/py/examples/cabrera/pythonlocal.csd | 32 - 6.x/src/py/examples/cabrera/pythonlocal2.csd | 39 - 6.x/src/py/examples/ievent.orc | 33 - 6.x/src/py/examples/pyexect1.py | 1 - 6.x/src/py/examples/pyexect2.py | 1 - 6.x/src/py/examples/pyexect3.py | 1 - 6.x/src/py/examples/pyexect4.py | 1 - 6.x/src/py/src/pycall-gen.py | 249 - 6.x/src/py/src/pycall.auto.h | 247 - 6.x/src/py/src/pythonhelper.h | 39 - 6.x/src/py/src/pythonopcodes.c | 435 -- 6.x/src/py/src/pythonopcodes.h | 47 - 6.x/src/py/src/pyx-gen.py | 257 - 6.x/src/py/src/pyx.auto.h | 71 - 6.x/src/stk/Android/jni/Android.mk | 106 - 6.x/src/stk/Android/jni/Application.mk | 9 - 6.x/src/stk/CMakeLists.txt | 96 - 6.x/src/stk/OpcodeBase.hpp | 492 -- 6.x/src/stk/stkOpcodes.cpp | 597 -- 6.x/src/websockets/CMakeLists.txt | 32 - 6.x/src/websockets/WebSocketOpcode.c | 712 -- 6.x/src/websockets/WebSocketOpcode.h | 77 - 6.x/src/widgets/CMakeLists.txt | 57 - 6.x/src/widgets/FL_graph.cpp | 504 -- 6.x/src/widgets/virtual_keyboard/Bank.cpp | 190 - 6.x/src/widgets/virtual_keyboard/Bank.hpp | 50 - .../widgets/virtual_keyboard/FLTKKeyboard.cpp | 547 -- .../widgets/virtual_keyboard/FLTKKeyboard.hpp | 60 - .../virtual_keyboard/FLTKKeyboardWidget.cpp | 210 - .../virtual_keyboard/FLTKKeyboardWidget.hpp | 66 - .../virtual_keyboard/FLTKKeyboardWindow.cpp | 200 - .../virtual_keyboard/FLTKKeyboardWindow.hpp | 68 - .../virtual_keyboard/KeyboardMapping.cpp | 233 - .../virtual_keyboard/KeyboardMapping.hpp | 67 - 6.x/src/widgets/virtual_keyboard/Program.cpp | 31 - 6.x/src/widgets/virtual_keyboard/Program.hpp | 35 - .../widgets/virtual_keyboard/SliderBank.cpp | 154 - .../widgets/virtual_keyboard/SliderBank.hpp | 66 - .../widgets/virtual_keyboard/SliderData.cpp | 38 - .../widgets/virtual_keyboard/SliderData.hpp | 39 - 6.x/src/widgets/virtual_keyboard/keyboard.map | 41 - .../virtual_keyboard/virtual_keyboard.cpp | 473 -- 6.x/src/widgets/widgets.cpp | 6127 ----------------- 6.x/src/widgets/widgets.h | 645 -- 6.x/src/widgets/widglobals.h | 272 - 6.x/src/widgets/winFLTK.c | 151 - 6.x/src/widgets/winFLTK.h | 140 - 6.x/src/wiimote/CMakeLists.txt | 10 - 6.x/src/wiimote/wiimote.c | 425 -- 6.x/vcpkg | 1 - 6.x/vcpkg.json | 17 - 6.x/x64-windows-csound.cmake | 8 - 7.x/README.md | 408 -- 7.x/cmake/CompilerOptimizations.cmake | 53 - 7.x/cmake/Modules/FindEIGEN3.cmake | 100 - 7.x/cmake/Modules/FindFLUIDSYNTH.cmake | 34 - 7.x/cmake/Modules/FindLAME.cmake | 20 - 7.x/cmake/Modules/FindSTK.cmake | 19 - 7.x/src/p5glove/libp5glove/macosx_usb_hid.h | 54 - 7.x/src/p5glove/libp5glove/p5glove.h | 226 - 7.x/src/p5glove/libp5glove/usb_hid.h | 77 - 7.x/src/p5glove/libp5glove/usb_hid_libusb.c | 162 - 7.x/src/py/CMakeLists.txt | 18 - 7.x/src/py/README.md | 14 - 7.x/src/py/examples/cabrera/pythonmarkov.csd | 82 - 7.x/src/py/examples/embeddedCtcsound.csd | 38 - 7.x/src/py/examples/ievent.sco | 1 - 7.x/src/py/examples/pyassign.orc | 13 - 7.x/src/py/examples/pyassign.sco | 1 - 7.x/src/py/examples/pycall1.orc | 31 - 7.x/src/py/examples/pycall1.sco | 1 - 7.x/src/py/examples/pycall2.orc | 35 - 7.x/src/py/examples/pycall2.sco | 1 - 7.x/src/py/examples/pycall3.orc | 57 - 7.x/src/py/examples/pycall3.sco | 1 - 7.x/src/py/examples/pycallt.orc | 67 - 7.x/src/py/examples/pycallt.sco | 1 - 7.x/src/py/examples/pyeval.orc | 15 - 7.x/src/py/examples/pyeval.sco | 1 - 7.x/src/py/examples/pyexec.orc | 19 - 7.x/src/py/examples/pyexec.sco | 2 - 7.x/src/py/examples/pyexec1.py | 12 - 7.x/src/py/examples/pyexec2.py | 1 - 7.x/src/py/examples/pyexec3.py | 1 - 7.x/src/py/examples/pyexec4.py | 1 - 7.x/src/py/examples/pyexect.orc | 25 - 7.x/src/py/examples/pyexect.sco | 2 - 7.x/src/py/examples/pyrun.csd | 31 - 7.x/src/py/examples/pyrun.orc | 20 - 7.x/src/py/examples/pyrun.sco | 1 - 7.x/src/py/examples/pyrunt.orc | 23 - 7.x/src/py/examples/pyrunt.sco | 2 - 7.x/src/py/src/README.md | 25 - 7.x/src/py/src/pycall.auto.c | 1970 ------ 7.x/src/py/src/pyx.auto.c | 680 -- 7.x/src/wiimote/wii_mac.h | 58 - 7.x/CMakeLists.txt => CMakeLists.txt | 0 README.md | 412 +- THIRD_PARTY.md | 2 +- .../CompilerOptimizations.cmake | 0 {7.x/cmake => cmake}/Modules/FindCSOUND.cmake | 0 {6.x/cmake => cmake}/Modules/FindEIGEN3.cmake | 0 {7.x/cmake => cmake}/Modules/FindFAUST.cmake | 0 .../Modules/FindFLUIDSYNTH.cmake | 0 {7.x/cmake => cmake}/Modules/FindGMM.cmake | 0 {6.x/cmake => cmake}/Modules/FindLAME.cmake | 0 {6.x/cmake => cmake}/Modules/FindSTK.cmake | 0 {7.x/cmake => cmake}/WasmPlugins.cmake | 0 {7.x/src => src}/CUDA/CMakeLists.txt | 0 {7.x/src => src}/CUDA/adsyn.cu | 0 {7.x/src => src}/CUDA/conv.cu | 0 {7.x/src => src}/CUDA/pconv.cu | 0 {7.x/src => src}/CUDA/pvsops.cu | 0 {7.x/src => src}/CUDA/slidingm.cu | 0 {7.x/src => src}/OpenCL/CMakeLists.txt | 0 {7.x/src => src}/OpenCL/cladsynth.c | 0 {7.x/src => src}/chua/CMakeLists.txt | 0 {7.x/src => src}/chua/ChuaOscillator.cpp | 0 {7.x/src => src}/chua/OpcodeBase.hpp | 0 {7.x/src => src}/dssi4cs/CMakeLists.txt | 0 {7.x/src => src}/dssi4cs/README.md | 0 {7.x/src => src}/dssi4cs/dssi4cs.c | 0 {7.x/src => src}/dssi4cs/dssi4cs.h | 0 {7.x/src => src}/dssi4cs/include/dssi/LICENSE | 0 .../dssi4cs/include/dssi/README.md | 0 .../dssi4cs/include/dssi/SOURCE.json | 0 {7.x/src => src}/dssi4cs/include/dssi/dssi.h | 0 .../dssi4cs/include/dssi/update.py | 0 .../dssi4cs/include/ladspa/LICENSE | 0 .../dssi4cs/include/ladspa/README.md | 0 .../dssi4cs/include/ladspa/SOURCE.json | 0 .../dssi4cs/include/ladspa/ladspa.h | 0 .../dssi4cs/include/ladspa/update.py | 0 {7.x/src => src}/dssi4cs/load.c | 0 {7.x/src => src}/dssi4cs/tests/dssi_test.cpp | 0 .../dssi4cs/tests/fixtures/dssi_test_plugin.c | 0 {7.x/src => src}/dssi4cs/utils.h | 0 {7.x/src => src}/faustcsound/CMakeLists.txt | 0 {7.x/src => src}/faustcsound/README.md | 0 .../faustcsound/faustcsound.exports | 0 {7.x/src => src}/faustcsound/faustgen.cpp | 0 {7.x/src => src}/fluidOpcodes/CMakeLists.txt | 0 {7.x/src => src}/fluidOpcodes/OpcodeBase.hpp | 0 .../src => src}/fluidOpcodes/fluidOpcodes.cpp | 0 {7.x/src => src}/hdf5/CMakeLists.txt | 0 {7.x/src => src}/hdf5/HDF5IO.c | 0 {7.x/src => src}/hdf5/HDF5IO.h | 0 {7.x/src => src}/image/CMakeLists.txt | 0 {7.x/src => src}/image/README.md | 0 {7.x/src => src}/image/imageOpcodes.c | 0 {7.x/src => src}/image/imageOpcodes.h | 0 .../src => src}/linear_algebra/CMakeLists.txt | 0 .../src => src}/linear_algebra/OpcodeBase.hpp | 0 {7.x/src => src}/linear_algebra/gmm/gmm.h | 0 .../linear_algebra/gmm/gmm_MUMPS_interface.h | 0 .../linear_algebra/gmm/gmm_algobase.h | 0 .../linear_algebra/gmm/gmm_arch_config.h | 0 .../src => src}/linear_algebra/gmm/gmm_blas.h | 0 .../linear_algebra/gmm/gmm_blas_interface.h | 0 .../linear_algebra/gmm/gmm_condition_number.h | 0 .../linear_algebra/gmm/gmm_conjugated.h | 0 {7.x/src => src}/linear_algebra/gmm/gmm_def.h | 0 .../gmm/gmm_dense_Householder.h | 0 .../linear_algebra/gmm/gmm_dense_lu.h | 0 .../gmm/gmm_dense_matrix_functions.h | 0 .../linear_algebra/gmm/gmm_dense_qr.h | 0 .../linear_algebra/gmm/gmm_dense_sylvester.h | 0 .../linear_algebra/gmm/gmm_domain_decomp.h | 0 .../linear_algebra/gmm/gmm_except.h | 0 .../gmm/gmm_feedback_management.h | 0 .../linear_algebra/gmm/gmm_inoutput.h | 0 .../linear_algebra/gmm/gmm_interface.h | 0 .../linear_algebra/gmm/gmm_interface_bgeot.h | 0 .../src => src}/linear_algebra/gmm/gmm_iter.h | 0 .../linear_algebra/gmm/gmm_iter_solvers.h | 0 .../linear_algebra/gmm/gmm_kernel.h | 0 .../linear_algebra/gmm/gmm_lapack_interface.h | 0 .../linear_algebra/gmm/gmm_least_squares_cg.h | 0 .../linear_algebra/gmm/gmm_matrix.h | 0 .../gmm/gmm_modified_gram_schmidt.h | 0 {7.x/src => src}/linear_algebra/gmm/gmm_opt.h | 0 .../linear_algebra/gmm/gmm_precond.h | 0 .../linear_algebra/gmm/gmm_precond_diagonal.h | 0 .../linear_algebra/gmm/gmm_precond_ildlt.h | 0 .../linear_algebra/gmm/gmm_precond_ildltt.h | 0 .../linear_algebra/gmm/gmm_precond_ilu.h | 0 .../linear_algebra/gmm/gmm_precond_ilut.h | 0 .../linear_algebra/gmm/gmm_precond_ilutp.h | 0 .../gmm/gmm_precond_mr_approx_inverse.h | 0 .../linear_algebra/gmm/gmm_range_basis.h | 0 .../linear_algebra/gmm/gmm_real_part.h | 0 {7.x/src => src}/linear_algebra/gmm/gmm_ref.h | 0 .../linear_algebra/gmm/gmm_scaled.h | 0 .../gmm/gmm_solver_Schwarz_additive.h | 0 .../linear_algebra/gmm/gmm_solver_bfgs.h | 0 .../linear_algebra/gmm/gmm_solver_bicgstab.h | 0 .../linear_algebra/gmm/gmm_solver_cg.h | 0 .../gmm/gmm_solver_constrained_cg.h | 0 .../linear_algebra/gmm/gmm_solver_gmres.h | 0 .../linear_algebra/gmm/gmm_solver_idgmres.h | 0 .../linear_algebra/gmm/gmm_solver_qmr.h | 0 {7.x/src => src}/linear_algebra/gmm/gmm_std.h | 0 .../linear_algebra/gmm/gmm_sub_index.h | 0 .../linear_algebra/gmm/gmm_sub_matrix.h | 0 .../linear_algebra/gmm/gmm_sub_vector.h | 0 .../gmm/gmm_superlu_interface.h | 0 .../linear_algebra/gmm/gmm_transposed.h | 0 .../linear_algebra/gmm/gmm_tri_solve.h | 0 .../linear_algebra/gmm/gmm_vector.h | 0 .../linear_algebra/gmm/gmm_vector_to_matrix.h | 0 .../linear_algebra/linear_algebra.cpp | 0 {7.x/src => src}/p5glove/CMakeLists.txt | 0 .../p5glove/libp5glove/macosx_usb_hid.h | 0 {7.x/src => src}/p5glove/libp5glove/p5glove.c | 0 {6.x/src => src}/p5glove/libp5glove/p5glove.h | 0 {6.x/src => src}/p5glove/libp5glove/usb_hid.h | 0 .../p5glove/libp5glove/usb_hid_libusb.c | 0 .../p5glove/libp5glove/usb_hid_macosx.c | 0 .../p5glove/libp5glove/usb_hid_win32.c | 0 {7.x/src => src}/p5glove/p5glove.c | 0 {6.x/src => src}/py/CMakeLists.txt | 0 {6.x/src => src}/py/README.md | 0 .../py/examples/cabrera/python0.csd | 0 .../py/examples/cabrera/python1.csd | 0 .../py/examples/cabrera/python2.csd | 0 .../py/examples/cabrera/python3.csd | 0 .../py/examples/cabrera/python4.csd | 0 .../py/examples/cabrera/python5.csd | 0 .../py/examples/cabrera/pythonlocal.csd | 0 .../py/examples/cabrera/pythonlocal2.csd | 0 .../py/examples/cabrera/pythonmarkov.csd | 0 .../py/examples/embeddedCtcsound.csd | 0 {7.x/src => src}/py/examples/ievent.orc | 0 {6.x/src => src}/py/examples/ievent.sco | 0 {6.x/src => src}/py/examples/pyassign.orc | 0 {6.x/src => src}/py/examples/pyassign.sco | 0 {6.x/src => src}/py/examples/pycall1.orc | 0 {6.x/src => src}/py/examples/pycall1.sco | 0 {6.x/src => src}/py/examples/pycall2.orc | 0 {6.x/src => src}/py/examples/pycall2.sco | 0 {6.x/src => src}/py/examples/pycall3.orc | 0 {6.x/src => src}/py/examples/pycall3.sco | 0 {6.x/src => src}/py/examples/pycallt.orc | 0 {6.x/src => src}/py/examples/pycallt.sco | 0 {6.x/src => src}/py/examples/pyeval.orc | 0 {6.x/src => src}/py/examples/pyeval.sco | 0 {6.x/src => src}/py/examples/pyexec.orc | 0 {6.x/src => src}/py/examples/pyexec.sco | 0 {6.x/src => src}/py/examples/pyexec1.py | 0 {6.x/src => src}/py/examples/pyexec2.py | 0 {6.x/src => src}/py/examples/pyexec3.py | 0 {6.x/src => src}/py/examples/pyexec4.py | 0 {6.x/src => src}/py/examples/pyexect.orc | 0 {6.x/src => src}/py/examples/pyexect.sco | 0 {7.x/src => src}/py/examples/pyexect1.py | 0 {7.x/src => src}/py/examples/pyexect2.py | 0 {7.x/src => src}/py/examples/pyexect3.py | 0 {7.x/src => src}/py/examples/pyexect4.py | 0 {6.x/src => src}/py/examples/pyrun.csd | 0 {6.x/src => src}/py/examples/pyrun.orc | 0 {6.x/src => src}/py/examples/pyrun.sco | 0 {6.x/src => src}/py/examples/pyrunt.orc | 0 {6.x/src => src}/py/examples/pyrunt.sco | 0 {6.x/src => src}/py/src/README.md | 0 {7.x/src => src}/py/src/pycall-gen.py | 0 {6.x/src => src}/py/src/pycall.auto.c | 0 {7.x/src => src}/py/src/pycall.auto.h | 0 {7.x/src => src}/py/src/pythonhelper.h | 0 {7.x/src => src}/py/src/pythonopcodes.c | 0 {7.x/src => src}/py/src/pythonopcodes.h | 0 {7.x/src => src}/py/src/pyx-gen.py | 0 {6.x/src => src}/py/src/pyx.auto.c | 0 {7.x/src => src}/py/src/pyx.auto.h | 0 {7.x/src => src}/stk/CMakeLists.txt | 0 {7.x/src => src}/stk/EmbedRawwaves.cmake | 0 {7.x/src => src}/stk/LICENSE | 0 {7.x/src => src}/stk/OpcodeBase.hpp | 0 {7.x/src => src}/stk/STKInstrumentAdapter.hpp | 0 {7.x/src => src}/stk/include/ADSR.h | 0 {7.x/src => src}/stk/include/Asymp.h | 0 {7.x/src => src}/stk/include/BandedWG.h | 0 {7.x/src => src}/stk/include/BeeThree.h | 0 {7.x/src => src}/stk/include/BiQuad.h | 0 {7.x/src => src}/stk/include/Blit.h | 0 {7.x/src => src}/stk/include/BlitSaw.h | 0 {7.x/src => src}/stk/include/BlitSquare.h | 0 {7.x/src => src}/stk/include/BlowBotl.h | 0 {7.x/src => src}/stk/include/BlowHole.h | 0 {7.x/src => src}/stk/include/BowTable.h | 0 {7.x/src => src}/stk/include/Bowed.h | 0 {7.x/src => src}/stk/include/Brass.h | 0 {7.x/src => src}/stk/include/Chorus.h | 0 {7.x/src => src}/stk/include/Clarinet.h | 0 {7.x/src => src}/stk/include/Cubic.h | 0 {7.x/src => src}/stk/include/Delay.h | 0 {7.x/src => src}/stk/include/DelayA.h | 0 {7.x/src => src}/stk/include/DelayL.h | 0 {7.x/src => src}/stk/include/Drummer.h | 0 {7.x/src => src}/stk/include/Echo.h | 0 {7.x/src => src}/stk/include/Effect.h | 0 {7.x/src => src}/stk/include/Envelope.h | 0 {7.x/src => src}/stk/include/FM.h | 0 {7.x/src => src}/stk/include/FMVoices.h | 0 {7.x/src => src}/stk/include/FileLoop.h | 0 {7.x/src => src}/stk/include/FileRead.h | 0 {7.x/src => src}/stk/include/FileWrite.h | 0 {7.x/src => src}/stk/include/FileWvIn.h | 0 {7.x/src => src}/stk/include/FileWvOut.h | 0 {7.x/src => src}/stk/include/Filter.h | 0 {7.x/src => src}/stk/include/Fir.h | 0 {7.x/src => src}/stk/include/Flute.h | 0 {7.x/src => src}/stk/include/FormSwep.h | 0 {7.x/src => src}/stk/include/FreeVerb.h | 0 {7.x/src => src}/stk/include/Function.h | 0 {7.x/src => src}/stk/include/Generator.h | 0 {7.x/src => src}/stk/include/Granulate.h | 0 {7.x/src => src}/stk/include/Guitar.h | 0 {7.x/src => src}/stk/include/HevyMetl.h | 0 {7.x/src => src}/stk/include/Iir.h | 0 {7.x/src => src}/stk/include/Instrmnt.h | 0 {7.x/src => src}/stk/include/JCRev.h | 0 {7.x/src => src}/stk/include/JetTable.h | 0 {7.x/src => src}/stk/include/LentPitShift.h | 0 {7.x/src => src}/stk/include/Mandolin.h | 0 {7.x/src => src}/stk/include/Mesh2D.h | 0 {7.x/src => src}/stk/include/MidiFileIn.h | 0 {7.x/src => src}/stk/include/Modal.h | 0 {7.x/src => src}/stk/include/ModalBar.h | 0 {7.x/src => src}/stk/include/Modulate.h | 0 {7.x/src => src}/stk/include/Moog.h | 0 {7.x/src => src}/stk/include/NRev.h | 0 {7.x/src => src}/stk/include/Noise.h | 0 {7.x/src => src}/stk/include/OnePole.h | 0 {7.x/src => src}/stk/include/OneZero.h | 0 {7.x/src => src}/stk/include/PRCRev.h | 0 {7.x/src => src}/stk/include/PercFlut.h | 0 {7.x/src => src}/stk/include/Phonemes.h | 0 {7.x/src => src}/stk/include/PitShift.h | 0 {7.x/src => src}/stk/include/Plucked.h | 0 {7.x/src => src}/stk/include/PoleZero.h | 0 {7.x/src => src}/stk/include/Recorder.h | 0 {7.x/src => src}/stk/include/ReedTable.h | 0 {7.x/src => src}/stk/include/Resonate.h | 0 {7.x/src => src}/stk/include/Rhodey.h | 0 {7.x/src => src}/stk/include/SKINImsg.h | 0 {7.x/src => src}/stk/include/SKINItbl.h | 0 {7.x/src => src}/stk/include/Sampler.h | 0 {7.x/src => src}/stk/include/Saxofony.h | 0 {7.x/src => src}/stk/include/Shakers.h | 0 {7.x/src => src}/stk/include/Simple.h | 0 {7.x/src => src}/stk/include/SineWave.h | 0 {7.x/src => src}/stk/include/SingWave.h | 0 {7.x/src => src}/stk/include/Sitar.h | 0 {7.x/src => src}/stk/include/Skini.h | 0 {7.x/src => src}/stk/include/Sphere.h | 0 {7.x/src => src}/stk/include/StifKarp.h | 0 {7.x/src => src}/stk/include/Stk.h | 0 {7.x/src => src}/stk/include/TapDelay.h | 0 {7.x/src => src}/stk/include/TubeBell.h | 0 {7.x/src => src}/stk/include/Twang.h | 0 {7.x/src => src}/stk/include/TwoPole.h | 0 {7.x/src => src}/stk/include/TwoZero.h | 0 {7.x/src => src}/stk/include/Vector3D.h | 0 {7.x/src => src}/stk/include/VoicForm.h | 0 {7.x/src => src}/stk/include/Voicer.h | 0 {7.x/src => src}/stk/include/Whistle.h | 0 {7.x/src => src}/stk/include/Wurley.h | 0 {7.x/src => src}/stk/include/WvIn.h | 0 {7.x/src => src}/stk/include/WvOut.h | 0 {7.x/src => src}/stk/rawwaves/ahh.raw | Bin {7.x/src => src}/stk/rawwaves/bassdrum.raw | Bin {7.x/src => src}/stk/rawwaves/britestk.raw | Bin {7.x/src => src}/stk/rawwaves/cowbell1.raw | Bin {7.x/src => src}/stk/rawwaves/crashcym.raw | Bin {7.x/src => src}/stk/rawwaves/dope.raw | Bin {7.x/src => src}/stk/rawwaves/eee.raw | Bin {7.x/src => src}/stk/rawwaves/fwavblnk.raw | Bin {7.x/src => src}/stk/rawwaves/halfwave.raw | Bin {7.x/src => src}/stk/rawwaves/hihatcym.raw | Bin {7.x/src => src}/stk/rawwaves/impuls10.raw | Bin {7.x/src => src}/stk/rawwaves/impuls20.raw | Bin {7.x/src => src}/stk/rawwaves/impuls40.raw | Bin {7.x/src => src}/stk/rawwaves/makefunc.c | 0 {7.x/src => src}/stk/rawwaves/makemidi.c | 0 {7.x/src => src}/stk/rawwaves/makewavs.c | 0 {7.x/src => src}/stk/rawwaves/mand1.raw | Bin {7.x/src => src}/stk/rawwaves/mand10.raw | Bin {7.x/src => src}/stk/rawwaves/mand11.raw | Bin {7.x/src => src}/stk/rawwaves/mand12.raw | Bin {7.x/src => src}/stk/rawwaves/mand2.raw | Bin {7.x/src => src}/stk/rawwaves/mand3.raw | Bin {7.x/src => src}/stk/rawwaves/mand4.raw | Bin {7.x/src => src}/stk/rawwaves/mand5.raw | Bin {7.x/src => src}/stk/rawwaves/mand6.raw | Bin {7.x/src => src}/stk/rawwaves/mand7.raw | Bin {7.x/src => src}/stk/rawwaves/mand8.raw | Bin {7.x/src => src}/stk/rawwaves/mand9.raw | Bin {7.x/src => src}/stk/rawwaves/mandpluk.raw | Bin {7.x/src => src}/stk/rawwaves/marmstk1.raw | Bin {7.x/src => src}/stk/rawwaves/ooo.raw | Bin {7.x/src => src}/stk/rawwaves/peksblnk.raw | Bin {7.x/src => src}/stk/rawwaves/ppksblnk.raw | Bin {7.x/src => src}/stk/rawwaves/ridecymb.raw | Bin {7.x/src => src}/stk/rawwaves/silence.raw | Bin {7.x/src => src}/stk/rawwaves/sine.c | 0 {7.x/src => src}/stk/rawwaves/sineblnk.raw | Bin {7.x/src => src}/stk/rawwaves/sinewave.raw | Bin {7.x/src => src}/stk/rawwaves/snardrum.raw | Bin {7.x/src => src}/stk/rawwaves/snglpeak.raw | Bin {7.x/src => src}/stk/rawwaves/tambourn.raw | Bin {7.x/src => src}/stk/rawwaves/tomhidrm.raw | Bin {7.x/src => src}/stk/rawwaves/tomlowdr.raw | Bin {7.x/src => src}/stk/rawwaves/tommiddr.raw | Bin {7.x/src => src}/stk/rawwaves/twopeaks.raw | Bin {7.x/src => src}/stk/src/ADSR.cpp | 0 {7.x/src => src}/stk/src/Asymp.cpp | 0 {7.x/src => src}/stk/src/BandedWG.cpp | 0 {7.x/src => src}/stk/src/BeeThree.cpp | 0 {7.x/src => src}/stk/src/BiQuad.cpp | 0 {7.x/src => src}/stk/src/Blit.cpp | 0 {7.x/src => src}/stk/src/BlitSaw.cpp | 0 {7.x/src => src}/stk/src/BlitSquare.cpp | 0 {7.x/src => src}/stk/src/BlowBotl.cpp | 0 {7.x/src => src}/stk/src/BlowHole.cpp | 0 {7.x/src => src}/stk/src/Bowed.cpp | 0 {7.x/src => src}/stk/src/Brass.cpp | 0 {7.x/src => src}/stk/src/Chorus.cpp | 0 {7.x/src => src}/stk/src/Clarinet.cpp | 0 {7.x/src => src}/stk/src/Delay.cpp | 0 {7.x/src => src}/stk/src/DelayA.cpp | 0 {7.x/src => src}/stk/src/DelayL.cpp | 0 {7.x/src => src}/stk/src/Drummer.cpp | 0 {7.x/src => src}/stk/src/Echo.cpp | 0 {7.x/src => src}/stk/src/Envelope.cpp | 0 {7.x/src => src}/stk/src/FM.cpp | 0 {7.x/src => src}/stk/src/FMVoices.cpp | 0 {7.x/src => src}/stk/src/FileLoop.cpp | 0 {7.x/src => src}/stk/src/FileRead.cpp | 0 {7.x/src => src}/stk/src/FileWrite.cpp | 0 {7.x/src => src}/stk/src/FileWvIn.cpp | 0 {7.x/src => src}/stk/src/FileWvOut.cpp | 0 {7.x/src => src}/stk/src/Fir.cpp | 0 {7.x/src => src}/stk/src/Flute.cpp | 0 {7.x/src => src}/stk/src/FormSwep.cpp | 0 {7.x/src => src}/stk/src/FreeVerb.cpp | 0 {7.x/src => src}/stk/src/Granulate.cpp | 0 {7.x/src => src}/stk/src/Guitar.cpp | 0 {7.x/src => src}/stk/src/HevyMetl.cpp | 0 {7.x/src => src}/stk/src/Iir.cpp | 0 {7.x/src => src}/stk/src/JCRev.cpp | 0 {7.x/src => src}/stk/src/LentPitShift.cpp | 0 {7.x/src => src}/stk/src/Mandolin.cpp | 0 {7.x/src => src}/stk/src/Mesh2D.cpp | 0 {7.x/src => src}/stk/src/MidiFileIn.cpp | 0 {7.x/src => src}/stk/src/Modal.cpp | 0 {7.x/src => src}/stk/src/ModalBar.cpp | 0 {7.x/src => src}/stk/src/Modulate.cpp | 0 {7.x/src => src}/stk/src/Moog.cpp | 0 {7.x/src => src}/stk/src/NRev.cpp | 0 {7.x/src => src}/stk/src/Noise.cpp | 0 {7.x/src => src}/stk/src/OnePole.cpp | 0 {7.x/src => src}/stk/src/OneZero.cpp | 0 {7.x/src => src}/stk/src/PRCRev.cpp | 0 {7.x/src => src}/stk/src/PercFlut.cpp | 0 {7.x/src => src}/stk/src/Phonemes.cpp | 0 {7.x/src => src}/stk/src/PitShift.cpp | 0 {7.x/src => src}/stk/src/Plucked.cpp | 0 {7.x/src => src}/stk/src/PoleZero.cpp | 0 {7.x/src => src}/stk/src/Recorder.cpp | 0 {7.x/src => src}/stk/src/Resonate.cpp | 0 {7.x/src => src}/stk/src/Rhodey.cpp | 0 {7.x/src => src}/stk/src/Sampler.cpp | 0 {7.x/src => src}/stk/src/Saxofony.cpp | 0 {7.x/src => src}/stk/src/Shakers.cpp | 0 {7.x/src => src}/stk/src/Simple.cpp | 0 {7.x/src => src}/stk/src/SineWave.cpp | 0 {7.x/src => src}/stk/src/SingWave.cpp | 0 {7.x/src => src}/stk/src/Sitar.cpp | 0 {7.x/src => src}/stk/src/Skini.cpp | 0 {7.x/src => src}/stk/src/Sphere.cpp | 0 {7.x/src => src}/stk/src/StifKarp.cpp | 0 {7.x/src => src}/stk/src/Stk.cpp | 0 {7.x/src => src}/stk/src/TapDelay.cpp | 0 {7.x/src => src}/stk/src/TubeBell.cpp | 0 {7.x/src => src}/stk/src/Twang.cpp | 0 {7.x/src => src}/stk/src/TwoPole.cpp | 0 {7.x/src => src}/stk/src/TwoZero.cpp | 0 {7.x/src => src}/stk/src/VoicForm.cpp | 0 {7.x/src => src}/stk/src/Voicer.cpp | 0 {7.x/src => src}/stk/src/Whistle.cpp | 0 {7.x/src => src}/stk/src/Wurley.cpp | 0 {7.x/src => src}/stk/stkOpcodes.cpp | 0 .../stk/tests/stk_adapter_test.cpp | 0 {7.x/src => src}/websockets/CMakeLists.txt | 0 {7.x/src => src}/websockets/WebSocketOpcode.c | 0 {7.x/src => src}/websockets/WebSocketOpcode.h | 0 {7.x/src => src}/wiimote/CMakeLists.txt | 0 {6.x/src => src}/wiimote/wii_mac.h | 0 {7.x/src => src}/wiimote/wiimote.c | 0 {7.x/tests => tests}/plugin_load_test.cpp | 0 7.x/vcpkg => vcpkg | 0 7.x/vcpkg.json => vcpkg.json | 0 wasm/README.md | 2 +- wasm/default.nix | 14 +- ...s-csound.cmake => x64-windows-csound.cmake | 0 602 files changed, 973 insertions(+), 42232 deletions(-) delete mode 100644 .github/workflows/plugins_build_7.yml delete mode 100644 6.x/CMakeLists.txt delete mode 100644 6.x/README.md delete mode 100644 6.x/cmake/Modules/FindCSOUND.cmake delete mode 100644 6.x/cmake/Modules/FindFAUST.cmake delete mode 100644 6.x/cmake/Modules/FindGMM.cmake delete mode 100644 6.x/installer/macosx/release-build.sh delete mode 100755 6.x/installer/macosx/scripts/postinstall delete mode 100644 6.x/installer/win64/Installer.iss delete mode 100644 6.x/installer/win64/Output/Csound6-Plugins-Windows_x86_64-1.0.exe delete mode 100644 6.x/installer/win64/buildWindows.sh delete mode 100644 6.x/src/AbletonLinkOpcodes/CMakeLists.txt delete mode 100644 6.x/src/AbletonLinkOpcodes/ableton_link_opcodes.cpp delete mode 100644 6.x/src/AbletonLinkOpcodes/jni/Android.mk delete mode 100644 6.x/src/AbletonLinkOpcodes/jni/Application.mk delete mode 100644 6.x/src/CUDA/CMakeLists.txt delete mode 100644 6.x/src/CUDA/adsyn.cu delete mode 100644 6.x/src/CUDA/adsyn11.cu delete mode 100644 6.x/src/CUDA/build.sh delete mode 100644 6.x/src/CUDA/conv.cu delete mode 100644 6.x/src/CUDA/convf.cu delete mode 100644 6.x/src/CUDA/cuda_pvs_example.csd delete mode 100644 6.x/src/CUDA/cuda_sliding_example.csd delete mode 100644 6.x/src/CUDA/cudaconv.csd delete mode 100644 6.x/src/CUDA/cudadsyn_pvs_example.csd delete mode 100644 6.x/src/CUDA/cudapconv.csd delete mode 100644 6.x/src/CUDA/pconv.cu delete mode 100644 6.x/src/CUDA/pconv11.cu delete mode 100644 6.x/src/CUDA/pvsops.cu delete mode 100644 6.x/src/CUDA/pvsops2-build.sh delete mode 100644 6.x/src/CUDA/pvsops2.cu delete mode 100644 6.x/src/CUDA/pvsopsf.cu delete mode 100644 6.x/src/CUDA/slidingm.cu delete mode 100644 6.x/src/chua/CMakeLists.txt delete mode 100644 6.x/src/chua/ChuaOscillator.cpp delete mode 100644 6.x/src/chua/OpcodeBase.hpp delete mode 100644 6.x/src/faustcsound/CMakeLists.txt delete mode 100644 6.x/src/faustcsound/README.md delete mode 100644 6.x/src/faustcsound/faustgen.cpp delete mode 100644 6.x/src/fluidOpcodes/Android/.gitignore delete mode 100644 6.x/src/fluidOpcodes/Android/build.sh delete mode 100644 6.x/src/fluidOpcodes/Android/jni/Android.mk delete mode 100644 6.x/src/fluidOpcodes/Android/jni/Application.mk delete mode 100644 6.x/src/fluidOpcodes/CMakeLists.txt delete mode 100644 6.x/src/fluidOpcodes/OpcodeBase.hpp delete mode 100644 6.x/src/fluidOpcodes/fluidOpcodes.cpp delete mode 100644 6.x/src/fluidOpcodes/fluidOpcodes.h delete mode 100644 6.x/src/fluidOpcodes/fluidOpcodes.html delete mode 100644 6.x/src/fluidOpcodes/test.csd delete mode 100644 6.x/src/hdf5/CMakeLists.txt delete mode 100644 6.x/src/hdf5/HDF5IO.c delete mode 100644 6.x/src/hdf5/HDF5IO.h delete mode 100644 6.x/src/image/CMakeLists.txt delete mode 100644 6.x/src/image/README.md delete mode 100644 6.x/src/image/imageOpcodes.c delete mode 100644 6.x/src/image/imageOpcodes.h delete mode 100644 6.x/src/jackops/CMakeLists.txt delete mode 100644 6.x/src/jackops/OpcodeBase.hpp delete mode 100644 6.x/src/jackops/cs_jack.h delete mode 100644 6.x/src/jackops/jackTransport.c delete mode 100644 6.x/src/jackops/jacko.cpp delete mode 100644 6.x/src/jackops/jacko_test.csd delete mode 100644 6.x/src/linear_algebra/CMakeLists.txt delete mode 100644 6.x/src/linear_algebra/OpcodeBase.hpp delete mode 100644 6.x/src/linear_algebra/linear_algebra.cpp delete mode 100644 6.x/src/mp3/CMakeLists.txt delete mode 100644 6.x/src/mp3/mp3out.c delete mode 100644 6.x/src/opencl/CMakeLists.txt delete mode 100644 6.x/src/opencl/build.sh delete mode 100644 6.x/src/opencl/buildc.sh delete mode 100644 6.x/src/opencl/buildcpp.sh delete mode 100644 6.x/src/opencl/cladsyn.csd delete mode 100644 6.x/src/opencl/cladsynth.c delete mode 100644 6.x/src/opencl/cladsynth.cpp delete mode 100644 6.x/src/opencl/cladsynth2.cpp delete mode 100644 6.x/src/opencl/clconv.csd delete mode 100644 6.x/src/opencl/libcl.dylib delete mode 100644 6.x/src/opencl/libclconv.dylib delete mode 100644 6.x/src/opencl/libclconv.dylib.dSYM/Contents/Info.plist delete mode 100644 6.x/src/opencl/libclconv.dylib.dSYM/Contents/Resources/DWARF/libclconv.dylib delete mode 100644 6.x/src/opencl/openclop.cpp delete mode 100644 6.x/src/p5glove/CMakeLists.txt delete mode 100644 6.x/src/p5glove/libp5glove/p5glove.c delete mode 100644 6.x/src/p5glove/libp5glove/usb_hid_macosx.c delete mode 100644 6.x/src/p5glove/libp5glove/usb_hid_win32.c delete mode 100644 6.x/src/p5glove/p5g_mac delete mode 100644 6.x/src/p5glove/p5glove.c delete mode 100644 6.x/src/py/examples/cabrera/python0.csd delete mode 100644 6.x/src/py/examples/cabrera/python1.csd delete mode 100644 6.x/src/py/examples/cabrera/python2.csd delete mode 100644 6.x/src/py/examples/cabrera/python3.csd delete mode 100644 6.x/src/py/examples/cabrera/python4.csd delete mode 100644 6.x/src/py/examples/cabrera/python5.csd delete mode 100644 6.x/src/py/examples/cabrera/pythonlocal.csd delete mode 100644 6.x/src/py/examples/cabrera/pythonlocal2.csd delete mode 100644 6.x/src/py/examples/ievent.orc delete mode 100644 6.x/src/py/examples/pyexect1.py delete mode 100644 6.x/src/py/examples/pyexect2.py delete mode 100644 6.x/src/py/examples/pyexect3.py delete mode 100644 6.x/src/py/examples/pyexect4.py delete mode 100644 6.x/src/py/src/pycall-gen.py delete mode 100644 6.x/src/py/src/pycall.auto.h delete mode 100644 6.x/src/py/src/pythonhelper.h delete mode 100644 6.x/src/py/src/pythonopcodes.c delete mode 100644 6.x/src/py/src/pythonopcodes.h delete mode 100644 6.x/src/py/src/pyx-gen.py delete mode 100644 6.x/src/py/src/pyx.auto.h delete mode 100644 6.x/src/stk/Android/jni/Android.mk delete mode 100644 6.x/src/stk/Android/jni/Application.mk delete mode 100644 6.x/src/stk/CMakeLists.txt delete mode 100644 6.x/src/stk/OpcodeBase.hpp delete mode 100644 6.x/src/stk/stkOpcodes.cpp delete mode 100644 6.x/src/websockets/CMakeLists.txt delete mode 100644 6.x/src/websockets/WebSocketOpcode.c delete mode 100644 6.x/src/websockets/WebSocketOpcode.h delete mode 100644 6.x/src/widgets/CMakeLists.txt delete mode 100644 6.x/src/widgets/FL_graph.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/Bank.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/Bank.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/FLTKKeyboard.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/FLTKKeyboard.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/FLTKKeyboardWidget.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/FLTKKeyboardWidget.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/FLTKKeyboardWindow.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/FLTKKeyboardWindow.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/KeyboardMapping.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/KeyboardMapping.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/Program.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/Program.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/SliderBank.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/SliderBank.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/SliderData.cpp delete mode 100644 6.x/src/widgets/virtual_keyboard/SliderData.hpp delete mode 100644 6.x/src/widgets/virtual_keyboard/keyboard.map delete mode 100644 6.x/src/widgets/virtual_keyboard/virtual_keyboard.cpp delete mode 100644 6.x/src/widgets/widgets.cpp delete mode 100644 6.x/src/widgets/widgets.h delete mode 100644 6.x/src/widgets/widglobals.h delete mode 100644 6.x/src/widgets/winFLTK.c delete mode 100644 6.x/src/widgets/winFLTK.h delete mode 100644 6.x/src/wiimote/CMakeLists.txt delete mode 100644 6.x/src/wiimote/wiimote.c delete mode 160000 6.x/vcpkg delete mode 100644 6.x/vcpkg.json delete mode 100644 6.x/x64-windows-csound.cmake delete mode 100644 7.x/README.md delete mode 100644 7.x/cmake/CompilerOptimizations.cmake delete mode 100644 7.x/cmake/Modules/FindEIGEN3.cmake delete mode 100644 7.x/cmake/Modules/FindFLUIDSYNTH.cmake delete mode 100644 7.x/cmake/Modules/FindLAME.cmake delete mode 100644 7.x/cmake/Modules/FindSTK.cmake delete mode 100644 7.x/src/p5glove/libp5glove/macosx_usb_hid.h delete mode 100644 7.x/src/p5glove/libp5glove/p5glove.h delete mode 100644 7.x/src/p5glove/libp5glove/usb_hid.h delete mode 100644 7.x/src/p5glove/libp5glove/usb_hid_libusb.c delete mode 100644 7.x/src/py/CMakeLists.txt delete mode 100644 7.x/src/py/README.md delete mode 100644 7.x/src/py/examples/cabrera/pythonmarkov.csd delete mode 100644 7.x/src/py/examples/embeddedCtcsound.csd delete mode 100644 7.x/src/py/examples/ievent.sco delete mode 100644 7.x/src/py/examples/pyassign.orc delete mode 100644 7.x/src/py/examples/pyassign.sco delete mode 100644 7.x/src/py/examples/pycall1.orc delete mode 100644 7.x/src/py/examples/pycall1.sco delete mode 100644 7.x/src/py/examples/pycall2.orc delete mode 100644 7.x/src/py/examples/pycall2.sco delete mode 100644 7.x/src/py/examples/pycall3.orc delete mode 100644 7.x/src/py/examples/pycall3.sco delete mode 100644 7.x/src/py/examples/pycallt.orc delete mode 100644 7.x/src/py/examples/pycallt.sco delete mode 100644 7.x/src/py/examples/pyeval.orc delete mode 100644 7.x/src/py/examples/pyeval.sco delete mode 100644 7.x/src/py/examples/pyexec.orc delete mode 100644 7.x/src/py/examples/pyexec.sco delete mode 100644 7.x/src/py/examples/pyexec1.py delete mode 100644 7.x/src/py/examples/pyexec2.py delete mode 100644 7.x/src/py/examples/pyexec3.py delete mode 100644 7.x/src/py/examples/pyexec4.py delete mode 100644 7.x/src/py/examples/pyexect.orc delete mode 100644 7.x/src/py/examples/pyexect.sco delete mode 100644 7.x/src/py/examples/pyrun.csd delete mode 100644 7.x/src/py/examples/pyrun.orc delete mode 100644 7.x/src/py/examples/pyrun.sco delete mode 100644 7.x/src/py/examples/pyrunt.orc delete mode 100644 7.x/src/py/examples/pyrunt.sco delete mode 100644 7.x/src/py/src/README.md delete mode 100644 7.x/src/py/src/pycall.auto.c delete mode 100644 7.x/src/py/src/pyx.auto.c delete mode 100644 7.x/src/wiimote/wii_mac.h rename 7.x/CMakeLists.txt => CMakeLists.txt (100%) rename {6.x/cmake => cmake}/CompilerOptimizations.cmake (100%) rename {7.x/cmake => cmake}/Modules/FindCSOUND.cmake (100%) rename {6.x/cmake => cmake}/Modules/FindEIGEN3.cmake (100%) rename {7.x/cmake => cmake}/Modules/FindFAUST.cmake (100%) rename {6.x/cmake => cmake}/Modules/FindFLUIDSYNTH.cmake (100%) rename {7.x/cmake => cmake}/Modules/FindGMM.cmake (100%) rename {6.x/cmake => cmake}/Modules/FindLAME.cmake (100%) rename {6.x/cmake => cmake}/Modules/FindSTK.cmake (100%) rename {7.x/cmake => cmake}/WasmPlugins.cmake (100%) rename {7.x/src => src}/CUDA/CMakeLists.txt (100%) rename {7.x/src => src}/CUDA/adsyn.cu (100%) rename {7.x/src => src}/CUDA/conv.cu (100%) rename {7.x/src => src}/CUDA/pconv.cu (100%) rename {7.x/src => src}/CUDA/pvsops.cu (100%) rename {7.x/src => src}/CUDA/slidingm.cu (100%) rename {7.x/src => src}/OpenCL/CMakeLists.txt (100%) rename {7.x/src => src}/OpenCL/cladsynth.c (100%) rename {7.x/src => src}/chua/CMakeLists.txt (100%) rename {7.x/src => src}/chua/ChuaOscillator.cpp (100%) rename {7.x/src => src}/chua/OpcodeBase.hpp (100%) rename {7.x/src => src}/dssi4cs/CMakeLists.txt (100%) rename {7.x/src => src}/dssi4cs/README.md (100%) rename {7.x/src => src}/dssi4cs/dssi4cs.c (100%) rename {7.x/src => src}/dssi4cs/dssi4cs.h (100%) rename {7.x/src => src}/dssi4cs/include/dssi/LICENSE (100%) rename {7.x/src => src}/dssi4cs/include/dssi/README.md (100%) rename {7.x/src => src}/dssi4cs/include/dssi/SOURCE.json (100%) rename {7.x/src => src}/dssi4cs/include/dssi/dssi.h (100%) rename {7.x/src => src}/dssi4cs/include/dssi/update.py (100%) rename {7.x/src => src}/dssi4cs/include/ladspa/LICENSE (100%) rename {7.x/src => src}/dssi4cs/include/ladspa/README.md (100%) rename {7.x/src => src}/dssi4cs/include/ladspa/SOURCE.json (100%) rename {7.x/src => src}/dssi4cs/include/ladspa/ladspa.h (100%) rename {7.x/src => src}/dssi4cs/include/ladspa/update.py (100%) rename {7.x/src => src}/dssi4cs/load.c (100%) rename {7.x/src => src}/dssi4cs/tests/dssi_test.cpp (100%) rename {7.x/src => src}/dssi4cs/tests/fixtures/dssi_test_plugin.c (100%) rename {7.x/src => src}/dssi4cs/utils.h (100%) rename {7.x/src => src}/faustcsound/CMakeLists.txt (100%) rename {7.x/src => src}/faustcsound/README.md (100%) rename {7.x/src => src}/faustcsound/faustcsound.exports (100%) rename {7.x/src => src}/faustcsound/faustgen.cpp (100%) rename {7.x/src => src}/fluidOpcodes/CMakeLists.txt (100%) rename {7.x/src => src}/fluidOpcodes/OpcodeBase.hpp (100%) rename {7.x/src => src}/fluidOpcodes/fluidOpcodes.cpp (100%) rename {7.x/src => src}/hdf5/CMakeLists.txt (100%) rename {7.x/src => src}/hdf5/HDF5IO.c (100%) rename {7.x/src => src}/hdf5/HDF5IO.h (100%) rename {7.x/src => src}/image/CMakeLists.txt (100%) rename {7.x/src => src}/image/README.md (100%) rename {7.x/src => src}/image/imageOpcodes.c (100%) rename {7.x/src => src}/image/imageOpcodes.h (100%) rename {7.x/src => src}/linear_algebra/CMakeLists.txt (100%) rename {7.x/src => src}/linear_algebra/OpcodeBase.hpp (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_MUMPS_interface.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_algobase.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_arch_config.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_blas.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_blas_interface.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_condition_number.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_conjugated.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_def.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_dense_Householder.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_dense_lu.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_dense_matrix_functions.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_dense_qr.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_dense_sylvester.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_domain_decomp.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_except.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_feedback_management.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_inoutput.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_interface.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_interface_bgeot.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_iter.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_iter_solvers.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_kernel.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_lapack_interface.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_least_squares_cg.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_matrix.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_modified_gram_schmidt.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_opt.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond_diagonal.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond_ildlt.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond_ildltt.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond_ilu.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond_ilut.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond_ilutp.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_precond_mr_approx_inverse.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_range_basis.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_real_part.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_ref.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_scaled.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_Schwarz_additive.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_bfgs.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_bicgstab.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_cg.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_constrained_cg.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_gmres.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_idgmres.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_solver_qmr.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_std.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_sub_index.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_sub_matrix.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_sub_vector.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_superlu_interface.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_transposed.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_tri_solve.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_vector.h (100%) rename {7.x/src => src}/linear_algebra/gmm/gmm_vector_to_matrix.h (100%) rename {7.x/src => src}/linear_algebra/linear_algebra.cpp (100%) rename {7.x/src => src}/p5glove/CMakeLists.txt (100%) rename {6.x/src => src}/p5glove/libp5glove/macosx_usb_hid.h (100%) rename {7.x/src => src}/p5glove/libp5glove/p5glove.c (100%) rename {6.x/src => src}/p5glove/libp5glove/p5glove.h (100%) rename {6.x/src => src}/p5glove/libp5glove/usb_hid.h (100%) rename {6.x/src => src}/p5glove/libp5glove/usb_hid_libusb.c (100%) rename {7.x/src => src}/p5glove/libp5glove/usb_hid_macosx.c (100%) rename {7.x/src => src}/p5glove/libp5glove/usb_hid_win32.c (100%) rename {7.x/src => src}/p5glove/p5glove.c (100%) rename {6.x/src => src}/py/CMakeLists.txt (100%) rename {6.x/src => src}/py/README.md (100%) rename {7.x/src => src}/py/examples/cabrera/python0.csd (100%) rename {7.x/src => src}/py/examples/cabrera/python1.csd (100%) rename {7.x/src => src}/py/examples/cabrera/python2.csd (100%) rename {7.x/src => src}/py/examples/cabrera/python3.csd (100%) rename {7.x/src => src}/py/examples/cabrera/python4.csd (100%) rename {7.x/src => src}/py/examples/cabrera/python5.csd (100%) rename {7.x/src => src}/py/examples/cabrera/pythonlocal.csd (100%) rename {7.x/src => src}/py/examples/cabrera/pythonlocal2.csd (100%) rename {6.x/src => src}/py/examples/cabrera/pythonmarkov.csd (100%) rename {6.x/src => src}/py/examples/embeddedCtcsound.csd (100%) rename {7.x/src => src}/py/examples/ievent.orc (100%) rename {6.x/src => src}/py/examples/ievent.sco (100%) rename {6.x/src => src}/py/examples/pyassign.orc (100%) rename {6.x/src => src}/py/examples/pyassign.sco (100%) rename {6.x/src => src}/py/examples/pycall1.orc (100%) rename {6.x/src => src}/py/examples/pycall1.sco (100%) rename {6.x/src => src}/py/examples/pycall2.orc (100%) rename {6.x/src => src}/py/examples/pycall2.sco (100%) rename {6.x/src => src}/py/examples/pycall3.orc (100%) rename {6.x/src => src}/py/examples/pycall3.sco (100%) rename {6.x/src => src}/py/examples/pycallt.orc (100%) rename {6.x/src => src}/py/examples/pycallt.sco (100%) rename {6.x/src => src}/py/examples/pyeval.orc (100%) rename {6.x/src => src}/py/examples/pyeval.sco (100%) rename {6.x/src => src}/py/examples/pyexec.orc (100%) rename {6.x/src => src}/py/examples/pyexec.sco (100%) rename {6.x/src => src}/py/examples/pyexec1.py (100%) rename {6.x/src => src}/py/examples/pyexec2.py (100%) rename {6.x/src => src}/py/examples/pyexec3.py (100%) rename {6.x/src => src}/py/examples/pyexec4.py (100%) rename {6.x/src => src}/py/examples/pyexect.orc (100%) rename {6.x/src => src}/py/examples/pyexect.sco (100%) rename {7.x/src => src}/py/examples/pyexect1.py (100%) rename {7.x/src => src}/py/examples/pyexect2.py (100%) rename {7.x/src => src}/py/examples/pyexect3.py (100%) rename {7.x/src => src}/py/examples/pyexect4.py (100%) rename {6.x/src => src}/py/examples/pyrun.csd (100%) rename {6.x/src => src}/py/examples/pyrun.orc (100%) rename {6.x/src => src}/py/examples/pyrun.sco (100%) rename {6.x/src => src}/py/examples/pyrunt.orc (100%) rename {6.x/src => src}/py/examples/pyrunt.sco (100%) rename {6.x/src => src}/py/src/README.md (100%) rename {7.x/src => src}/py/src/pycall-gen.py (100%) rename {6.x/src => src}/py/src/pycall.auto.c (100%) rename {7.x/src => src}/py/src/pycall.auto.h (100%) rename {7.x/src => src}/py/src/pythonhelper.h (100%) rename {7.x/src => src}/py/src/pythonopcodes.c (100%) rename {7.x/src => src}/py/src/pythonopcodes.h (100%) rename {7.x/src => src}/py/src/pyx-gen.py (100%) rename {6.x/src => src}/py/src/pyx.auto.c (100%) rename {7.x/src => src}/py/src/pyx.auto.h (100%) rename {7.x/src => src}/stk/CMakeLists.txt (100%) rename {7.x/src => src}/stk/EmbedRawwaves.cmake (100%) rename {7.x/src => src}/stk/LICENSE (100%) rename {7.x/src => src}/stk/OpcodeBase.hpp (100%) rename {7.x/src => src}/stk/STKInstrumentAdapter.hpp (100%) rename {7.x/src => src}/stk/include/ADSR.h (100%) rename {7.x/src => src}/stk/include/Asymp.h (100%) rename {7.x/src => src}/stk/include/BandedWG.h (100%) rename {7.x/src => src}/stk/include/BeeThree.h (100%) rename {7.x/src => src}/stk/include/BiQuad.h (100%) rename {7.x/src => src}/stk/include/Blit.h (100%) rename {7.x/src => src}/stk/include/BlitSaw.h (100%) rename {7.x/src => src}/stk/include/BlitSquare.h (100%) rename {7.x/src => src}/stk/include/BlowBotl.h (100%) rename {7.x/src => src}/stk/include/BlowHole.h (100%) rename {7.x/src => src}/stk/include/BowTable.h (100%) rename {7.x/src => src}/stk/include/Bowed.h (100%) rename {7.x/src => src}/stk/include/Brass.h (100%) rename {7.x/src => src}/stk/include/Chorus.h (100%) rename {7.x/src => src}/stk/include/Clarinet.h (100%) rename {7.x/src => src}/stk/include/Cubic.h (100%) rename {7.x/src => src}/stk/include/Delay.h (100%) rename {7.x/src => src}/stk/include/DelayA.h (100%) rename {7.x/src => src}/stk/include/DelayL.h (100%) rename {7.x/src => src}/stk/include/Drummer.h (100%) rename {7.x/src => src}/stk/include/Echo.h (100%) rename {7.x/src => src}/stk/include/Effect.h (100%) rename {7.x/src => src}/stk/include/Envelope.h (100%) rename {7.x/src => src}/stk/include/FM.h (100%) rename {7.x/src => src}/stk/include/FMVoices.h (100%) rename {7.x/src => src}/stk/include/FileLoop.h (100%) rename {7.x/src => src}/stk/include/FileRead.h (100%) rename {7.x/src => src}/stk/include/FileWrite.h (100%) rename {7.x/src => src}/stk/include/FileWvIn.h (100%) rename {7.x/src => src}/stk/include/FileWvOut.h (100%) rename {7.x/src => src}/stk/include/Filter.h (100%) rename {7.x/src => src}/stk/include/Fir.h (100%) rename {7.x/src => src}/stk/include/Flute.h (100%) rename {7.x/src => src}/stk/include/FormSwep.h (100%) rename {7.x/src => src}/stk/include/FreeVerb.h (100%) rename {7.x/src => src}/stk/include/Function.h (100%) rename {7.x/src => src}/stk/include/Generator.h (100%) rename {7.x/src => src}/stk/include/Granulate.h (100%) rename {7.x/src => src}/stk/include/Guitar.h (100%) rename {7.x/src => src}/stk/include/HevyMetl.h (100%) rename {7.x/src => src}/stk/include/Iir.h (100%) rename {7.x/src => src}/stk/include/Instrmnt.h (100%) rename {7.x/src => src}/stk/include/JCRev.h (100%) rename {7.x/src => src}/stk/include/JetTable.h (100%) rename {7.x/src => src}/stk/include/LentPitShift.h (100%) rename {7.x/src => src}/stk/include/Mandolin.h (100%) rename {7.x/src => src}/stk/include/Mesh2D.h (100%) rename {7.x/src => src}/stk/include/MidiFileIn.h (100%) rename {7.x/src => src}/stk/include/Modal.h (100%) rename {7.x/src => src}/stk/include/ModalBar.h (100%) rename {7.x/src => src}/stk/include/Modulate.h (100%) rename {7.x/src => src}/stk/include/Moog.h (100%) rename {7.x/src => src}/stk/include/NRev.h (100%) rename {7.x/src => src}/stk/include/Noise.h (100%) rename {7.x/src => src}/stk/include/OnePole.h (100%) rename {7.x/src => src}/stk/include/OneZero.h (100%) rename {7.x/src => src}/stk/include/PRCRev.h (100%) rename {7.x/src => src}/stk/include/PercFlut.h (100%) rename {7.x/src => src}/stk/include/Phonemes.h (100%) rename {7.x/src => src}/stk/include/PitShift.h (100%) rename {7.x/src => src}/stk/include/Plucked.h (100%) rename {7.x/src => src}/stk/include/PoleZero.h (100%) rename {7.x/src => src}/stk/include/Recorder.h (100%) rename {7.x/src => src}/stk/include/ReedTable.h (100%) rename {7.x/src => src}/stk/include/Resonate.h (100%) rename {7.x/src => src}/stk/include/Rhodey.h (100%) rename {7.x/src => src}/stk/include/SKINImsg.h (100%) rename {7.x/src => src}/stk/include/SKINItbl.h (100%) rename {7.x/src => src}/stk/include/Sampler.h (100%) rename {7.x/src => src}/stk/include/Saxofony.h (100%) rename {7.x/src => src}/stk/include/Shakers.h (100%) rename {7.x/src => src}/stk/include/Simple.h (100%) rename {7.x/src => src}/stk/include/SineWave.h (100%) rename {7.x/src => src}/stk/include/SingWave.h (100%) rename {7.x/src => src}/stk/include/Sitar.h (100%) rename {7.x/src => src}/stk/include/Skini.h (100%) rename {7.x/src => src}/stk/include/Sphere.h (100%) rename {7.x/src => src}/stk/include/StifKarp.h (100%) rename {7.x/src => src}/stk/include/Stk.h (100%) rename {7.x/src => src}/stk/include/TapDelay.h (100%) rename {7.x/src => src}/stk/include/TubeBell.h (100%) rename {7.x/src => src}/stk/include/Twang.h (100%) rename {7.x/src => src}/stk/include/TwoPole.h (100%) rename {7.x/src => src}/stk/include/TwoZero.h (100%) rename {7.x/src => src}/stk/include/Vector3D.h (100%) rename {7.x/src => src}/stk/include/VoicForm.h (100%) rename {7.x/src => src}/stk/include/Voicer.h (100%) rename {7.x/src => src}/stk/include/Whistle.h (100%) rename {7.x/src => src}/stk/include/Wurley.h (100%) rename {7.x/src => src}/stk/include/WvIn.h (100%) rename {7.x/src => src}/stk/include/WvOut.h (100%) rename {7.x/src => src}/stk/rawwaves/ahh.raw (100%) rename {7.x/src => src}/stk/rawwaves/bassdrum.raw (100%) rename {7.x/src => src}/stk/rawwaves/britestk.raw (100%) rename {7.x/src => src}/stk/rawwaves/cowbell1.raw (100%) rename {7.x/src => src}/stk/rawwaves/crashcym.raw (100%) rename {7.x/src => src}/stk/rawwaves/dope.raw (100%) rename {7.x/src => src}/stk/rawwaves/eee.raw (100%) rename {7.x/src => src}/stk/rawwaves/fwavblnk.raw (100%) rename {7.x/src => src}/stk/rawwaves/halfwave.raw (100%) rename {7.x/src => src}/stk/rawwaves/hihatcym.raw (100%) rename {7.x/src => src}/stk/rawwaves/impuls10.raw (100%) rename {7.x/src => src}/stk/rawwaves/impuls20.raw (100%) rename {7.x/src => src}/stk/rawwaves/impuls40.raw (100%) rename {7.x/src => src}/stk/rawwaves/makefunc.c (100%) rename {7.x/src => src}/stk/rawwaves/makemidi.c (100%) rename {7.x/src => src}/stk/rawwaves/makewavs.c (100%) rename {7.x/src => src}/stk/rawwaves/mand1.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand10.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand11.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand12.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand2.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand3.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand4.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand5.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand6.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand7.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand8.raw (100%) rename {7.x/src => src}/stk/rawwaves/mand9.raw (100%) rename {7.x/src => src}/stk/rawwaves/mandpluk.raw (100%) rename {7.x/src => src}/stk/rawwaves/marmstk1.raw (100%) rename {7.x/src => src}/stk/rawwaves/ooo.raw (100%) rename {7.x/src => src}/stk/rawwaves/peksblnk.raw (100%) rename {7.x/src => src}/stk/rawwaves/ppksblnk.raw (100%) rename {7.x/src => src}/stk/rawwaves/ridecymb.raw (100%) rename {7.x/src => src}/stk/rawwaves/silence.raw (100%) rename {7.x/src => src}/stk/rawwaves/sine.c (100%) rename {7.x/src => src}/stk/rawwaves/sineblnk.raw (100%) rename {7.x/src => src}/stk/rawwaves/sinewave.raw (100%) rename {7.x/src => src}/stk/rawwaves/snardrum.raw (100%) rename {7.x/src => src}/stk/rawwaves/snglpeak.raw (100%) rename {7.x/src => src}/stk/rawwaves/tambourn.raw (100%) rename {7.x/src => src}/stk/rawwaves/tomhidrm.raw (100%) rename {7.x/src => src}/stk/rawwaves/tomlowdr.raw (100%) rename {7.x/src => src}/stk/rawwaves/tommiddr.raw (100%) rename {7.x/src => src}/stk/rawwaves/twopeaks.raw (100%) rename {7.x/src => src}/stk/src/ADSR.cpp (100%) rename {7.x/src => src}/stk/src/Asymp.cpp (100%) rename {7.x/src => src}/stk/src/BandedWG.cpp (100%) rename {7.x/src => src}/stk/src/BeeThree.cpp (100%) rename {7.x/src => src}/stk/src/BiQuad.cpp (100%) rename {7.x/src => src}/stk/src/Blit.cpp (100%) rename {7.x/src => src}/stk/src/BlitSaw.cpp (100%) rename {7.x/src => src}/stk/src/BlitSquare.cpp (100%) rename {7.x/src => src}/stk/src/BlowBotl.cpp (100%) rename {7.x/src => src}/stk/src/BlowHole.cpp (100%) rename {7.x/src => src}/stk/src/Bowed.cpp (100%) rename {7.x/src => src}/stk/src/Brass.cpp (100%) rename {7.x/src => src}/stk/src/Chorus.cpp (100%) rename {7.x/src => src}/stk/src/Clarinet.cpp (100%) rename {7.x/src => src}/stk/src/Delay.cpp (100%) rename {7.x/src => src}/stk/src/DelayA.cpp (100%) rename {7.x/src => src}/stk/src/DelayL.cpp (100%) rename {7.x/src => src}/stk/src/Drummer.cpp (100%) rename {7.x/src => src}/stk/src/Echo.cpp (100%) rename {7.x/src => src}/stk/src/Envelope.cpp (100%) rename {7.x/src => src}/stk/src/FM.cpp (100%) rename {7.x/src => src}/stk/src/FMVoices.cpp (100%) rename {7.x/src => src}/stk/src/FileLoop.cpp (100%) rename {7.x/src => src}/stk/src/FileRead.cpp (100%) rename {7.x/src => src}/stk/src/FileWrite.cpp (100%) rename {7.x/src => src}/stk/src/FileWvIn.cpp (100%) rename {7.x/src => src}/stk/src/FileWvOut.cpp (100%) rename {7.x/src => src}/stk/src/Fir.cpp (100%) rename {7.x/src => src}/stk/src/Flute.cpp (100%) rename {7.x/src => src}/stk/src/FormSwep.cpp (100%) rename {7.x/src => src}/stk/src/FreeVerb.cpp (100%) rename {7.x/src => src}/stk/src/Granulate.cpp (100%) rename {7.x/src => src}/stk/src/Guitar.cpp (100%) rename {7.x/src => src}/stk/src/HevyMetl.cpp (100%) rename {7.x/src => src}/stk/src/Iir.cpp (100%) rename {7.x/src => src}/stk/src/JCRev.cpp (100%) rename {7.x/src => src}/stk/src/LentPitShift.cpp (100%) rename {7.x/src => src}/stk/src/Mandolin.cpp (100%) rename {7.x/src => src}/stk/src/Mesh2D.cpp (100%) rename {7.x/src => src}/stk/src/MidiFileIn.cpp (100%) rename {7.x/src => src}/stk/src/Modal.cpp (100%) rename {7.x/src => src}/stk/src/ModalBar.cpp (100%) rename {7.x/src => src}/stk/src/Modulate.cpp (100%) rename {7.x/src => src}/stk/src/Moog.cpp (100%) rename {7.x/src => src}/stk/src/NRev.cpp (100%) rename {7.x/src => src}/stk/src/Noise.cpp (100%) rename {7.x/src => src}/stk/src/OnePole.cpp (100%) rename {7.x/src => src}/stk/src/OneZero.cpp (100%) rename {7.x/src => src}/stk/src/PRCRev.cpp (100%) rename {7.x/src => src}/stk/src/PercFlut.cpp (100%) rename {7.x/src => src}/stk/src/Phonemes.cpp (100%) rename {7.x/src => src}/stk/src/PitShift.cpp (100%) rename {7.x/src => src}/stk/src/Plucked.cpp (100%) rename {7.x/src => src}/stk/src/PoleZero.cpp (100%) rename {7.x/src => src}/stk/src/Recorder.cpp (100%) rename {7.x/src => src}/stk/src/Resonate.cpp (100%) rename {7.x/src => src}/stk/src/Rhodey.cpp (100%) rename {7.x/src => src}/stk/src/Sampler.cpp (100%) rename {7.x/src => src}/stk/src/Saxofony.cpp (100%) rename {7.x/src => src}/stk/src/Shakers.cpp (100%) rename {7.x/src => src}/stk/src/Simple.cpp (100%) rename {7.x/src => src}/stk/src/SineWave.cpp (100%) rename {7.x/src => src}/stk/src/SingWave.cpp (100%) rename {7.x/src => src}/stk/src/Sitar.cpp (100%) rename {7.x/src => src}/stk/src/Skini.cpp (100%) rename {7.x/src => src}/stk/src/Sphere.cpp (100%) rename {7.x/src => src}/stk/src/StifKarp.cpp (100%) rename {7.x/src => src}/stk/src/Stk.cpp (100%) rename {7.x/src => src}/stk/src/TapDelay.cpp (100%) rename {7.x/src => src}/stk/src/TubeBell.cpp (100%) rename {7.x/src => src}/stk/src/Twang.cpp (100%) rename {7.x/src => src}/stk/src/TwoPole.cpp (100%) rename {7.x/src => src}/stk/src/TwoZero.cpp (100%) rename {7.x/src => src}/stk/src/VoicForm.cpp (100%) rename {7.x/src => src}/stk/src/Voicer.cpp (100%) rename {7.x/src => src}/stk/src/Whistle.cpp (100%) rename {7.x/src => src}/stk/src/Wurley.cpp (100%) rename {7.x/src => src}/stk/stkOpcodes.cpp (100%) rename {7.x/src => src}/stk/tests/stk_adapter_test.cpp (100%) rename {7.x/src => src}/websockets/CMakeLists.txt (100%) rename {7.x/src => src}/websockets/WebSocketOpcode.c (100%) rename {7.x/src => src}/websockets/WebSocketOpcode.h (100%) rename {7.x/src => src}/wiimote/CMakeLists.txt (100%) rename {6.x/src => src}/wiimote/wii_mac.h (100%) rename {7.x/src => src}/wiimote/wiimote.c (100%) rename {7.x/tests => tests}/plugin_load_test.cpp (100%) rename 7.x/vcpkg => vcpkg (100%) rename 7.x/vcpkg.json => vcpkg.json (100%) rename 7.x/x64-windows-csound.cmake => x64-windows-csound.cmake (100%) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index c14d3bf..114c588 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -1,7 +1,7 @@ reviews: path_filters: - - "!7.x/src/stk/src/**" - - "!7.x/src/stk/include/**" - - "!7.x/src/stk/rawwaves/**" - - "!7.x/src/dssi4cs/include/dssi/**" - - "!7.x/src/dssi4cs/include/ladspa/**" + - "!src/stk/src/**" + - "!src/stk/include/**" + - "!src/stk/rawwaves/**" + - "!src/dssi4cs/include/dssi/**" + - "!src/dssi4cs/include/ladspa/**" diff --git a/.github/workflows/plugins_build.yml b/.github/workflows/plugins_build.yml index 2f81107..fa13ad7 100644 --- a/.github/workflows/plugins_build.yml +++ b/.github/workflows/plugins_build.yml @@ -1,93 +1,567 @@ -name: Csound plugins build +name: Csound 7 plugins build -env: - VCPKG_BINARY_SOURCES: "clear;nuget,GitHub,readwrite" +permissions: + contents: read + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true on: + push: + branches: + - develop + - main + pull_request: + branches: + - develop + - main workflow_dispatch: +env: + CSOUND_VERSION: 7.0.0 + FAUST_VERSION: 2.88.0 + VCPKG_BINARY_SOURCES: "clear;files,${{ github.workspace }}/vcpkg-cache,readwrite" + jobs: - build_package: - runs-on: ${{ matrix.os }} - - env: - CSOUND_VERSION: 6.17.2 - - strategy: - matrix: - os: [windows-latest] - version: ["6.17.0"] - include: - - os: "windows-latest" - mono: "" - # - os: "ubuntu-latest" - # mono: "mono" - # - os: "macos-latest" - # mono: "mono" + update_version: + name: Update plugin version + runs-on: ubuntu-latest + permissions: + contents: write + outputs: + version: ${{ steps.tag.outputs.new_tag }} + release: ${{ steps.check_pr.outputs.has_label }} + steps: + - name: Checkout source + uses: actions/checkout@v7.0.1 + with: + fetch-depth: 0 + - name: Compute next version + id: tag + uses: anothrNick/github-tag-action@1.75.0 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + DEFAULT_BUMP: patch + DEFAULT_BRANCH: main + PRERELEASE: ${{ github.ref != 'refs/heads/main' }} + PRERELEASE_SUFFIX: beta + DRY_RUN: true + + - name: Check for release label + id: check_pr + uses: ./.github/actions/check-pr-label + with: + label: release + github_token: ${{ secrets.GITHUB_TOKEN }} + + linux: + name: Linux (ubuntu-latest) + needs: update_version + runs-on: ubuntu-latest steps: - - name: Checkout Source Code + - name: Checkout source uses: actions/checkout@v7.0.1 + + - name: Install Csound build dependencies + run: | + sudo apt-get update + sudo apt-get install -y \ + build-essential cmake pkg-config \ + libsndfile1-dev libsamplerate0-dev libasound2-dev libportaudio2 libportmidi-dev \ + libeigen3-dev libfluidsynth-dev libpng-dev \ + libwebsockets-dev libuv1-dev libhdf5-dev \ + ocl-icd-opencl-dev libtinfo-dev \ + libgtest-dev \ + flex bison + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v6.1.0 with: - fetch-depth: 1 - submodules: true + path: ~/csound-install + key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} - - name: Setup platform (windows) - if: startsWith(matrix.os, 'windows') + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + git clone --depth 1 --branch "$CSOUND_VERSION" \ + https://github.com/csound/csound.git "$RUNNER_TEMP/csound" + cmake -S "$RUNNER_TEMP/csound" -B "$RUNNER_TEMP/csound-build" \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX="$HOME/csound-install" \ + -DBUILD_TESTS=OFF \ + -DINSTALL_PYTHON_INTERFACE=OFF + cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(nproc)" + cmake --install "$RUNNER_TEMP/csound-build" + + - name: Cache Faust + id: cache-faust + uses: actions/cache@v4 + with: + path: ~/faust + key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} + + - name: Install Faust + if: steps.cache-faust.outputs.cache-hit != 'true' + run: | + mkdir -p "$HOME/faust" + curl -sL -o "$RUNNER_TEMP/libfaust.zip" \ + "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/libfaust-ubuntu-x86_64.zip" + curl -sL -o "$RUNNER_TEMP/faust-src.tar.gz" \ + "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/faust-$FAUST_VERSION.tar.gz" + unzip -q "$RUNNER_TEMP/libfaust.zip" -d "$HOME/faust" + tar xzf "$RUNNER_TEMP/faust-src.tar.gz" -C "$RUNNER_TEMP" \ + "faust-$FAUST_VERSION/architecture" "faust-$FAUST_VERSION/libraries" + mv "$RUNNER_TEMP/faust-$FAUST_VERSION/architecture" "$HOME/faust/include" + mv "$RUNNER_TEMP/faust-$FAUST_VERSION/libraries" "$HOME/faust/stdlib" + rm -f "$RUNNER_TEMP/libfaust.zip" "$RUNNER_TEMP/faust-src.tar.gz" + + - name: Configure plugin build + run: | + echo "CSOUND_INCLUDE_DIR_HINT=$HOME/csound-install/include/csound" >> "$GITHUB_ENV" + echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/lib" >> "$GITHUB_ENV" + echo "FAUST_INCLUDE_DIR_HINT=$HOME/faust/include" >> "$GITHUB_ENV" + echo "FAUST_LIB_DIR_HINT=$HOME/faust/lib" >> "$GITHUB_ENV" + echo "FAUST_STDLIB_DIR_HINT=$HOME/faust/stdlib" >> "$GITHUB_ENV" + + - name: Build plugins + run: | + cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \ + -DFAUST_STATIC=ON \ + -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ + -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" \ + -DFAUST_INCLUDE_DIR_HINT="$FAUST_INCLUDE_DIR_HINT" \ + -DFAUST_LIB_DIR_HINT="$FAUST_LIB_DIR_HINT" \ + -DFAUST_STDLIB_DIR_HINT="$FAUST_STDLIB_DIR_HINT" + cmake --build build --parallel "$(nproc)" + + - name: Run plugin tests + run: ctest --test-dir build --output-on-failure + + - name: Stage plugins + run: | + mkdir -p package + cp build/src/chua/*.so \ + build/src/linear_algebra/*.so \ + build/src/fluidOpcodes/*.so \ + build/src/dssi4cs/*.so \ + build/src/image/*.so \ + build/src/websockets/*.so \ + build/src/hdf5/*.so \ + build/src/py/*.so \ + build/src/OpenCL/*.so \ + build/src/stk/*.so package/ + cp build/src/faustcsound/*.so package/ + mkdir -p package/stk/rawwaves + cp src/stk/rawwaves/*.raw package/stk/rawwaves/ + mkdir -p package/faust + cp -R "$HOME/faust/stdlib/." package/faust/ + + - name: Upload plugins + uses: actions/upload-artifact@v7.0.2 + with: + name: csound7-plugins-linux + path: package/ + if-no-files-found: error + + macos: + name: macOS (macos-latest) + needs: update_version + runs-on: macos-latest + steps: + - name: Checkout source + uses: actions/checkout@v7.0.1 + + - name: Install Csound build dependencies env: - FAUST_URL: https://github.com/grame-cncm/faust/releases/download/2.60.3/Faust-2.60.3-win64.exe - run: | - Invoke-WebRequest $env:FAUST_URL -OutFile faustInstaller.exe - ./faustInstaller.exe /S - echo "C:/Program Files/csound/bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append - echo "OPCODE6DIR64=C:/Program Files/csound/plugins64" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append - echo "PYTHONPATH=C:/Program Files/csound/bin" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append - echo "RAWWAVE_PATH=C:/Program Files/csound/samples" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append - .\6.x\vcpkg\bootstrap-vcpkg.bat - choco install csound --version=6.17.0 - echo $GITHUB_ENV - ls 'C:\Program Files\Faust\' - echo "C:\Program Files\Faust\;C:\Program Files\Faust\lib" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append - - # - name: Setup platform (linux) - # if: startsWith(matrix.os, 'ubuntu') - # run: | - # ./vcpkg/bootstrap-vcpkg.sh - # sudo apt-get update - # sudo apt-get install libcsound64-dev - - # - name: Setup platform (macos) - # if: startsWith(matrix.os, 'macos') - # run: | - # ./vcpkg/bootstrap-vcpkg.sh - # brew install csound - - - name: Setup VCPKG cache - shell: bash - run: | - ${{ matrix.mono }} `./6.x/vcpkg/vcpkg fetch nuget | tail -n 1` \ - sources add \ - -source "https://nuget.pkg.github.com/csound/index.json" \ - -storepasswordincleartext \ - -name "GitHub" \ - -username "csound" \ - -password "${{ secrets.GITHUB_TOKEN }}" - ${{ matrix.mono }} `./6.x/vcpkg/vcpkg fetch nuget | tail -n 1` \ - setapikey "${{ secrets.GITHUB_TOKEN }}" \ - -source "https://nuget.pkg.github.com/csound/index.json" - - - name: Generate CMake build - run: cmake 6.x/. -B build -DUSE_VCPKG=1 -DBUILD_ABLETON_LINK_OPCODES=OFF + HOMEBREW_NO_AUTO_UPDATE: 1 + run: | + brew install cmake ninja pkg-config bison flex libsndfile + echo "$(brew --prefix bison)/bin" >> "$GITHUB_PATH" + echo "$(brew --prefix flex)/bin" >> "$GITHUB_PATH" + + - name: Checkout vcpkg submodule + run: git submodule update --init vcpkg + + - name: Set up vcpkg + run: vcpkg/bootstrap-vcpkg.sh -disableMetrics + + - name: Cache vcpkg binary cache + uses: actions/cache@v6.1.0 + with: + path: vcpkg-cache + key: vcpkg-macos-${{ github.run_id }} + restore-keys: vcpkg-macos- + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v6.1.0 + with: + path: ~/csound-install + key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} + + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + git clone --depth 1 --branch "$CSOUND_VERSION" \ + https://github.com/csound/csound.git "$RUNNER_TEMP/csound" + cmake -S "$RUNNER_TEMP/csound" -B "$RUNNER_TEMP/csound-build" -G Ninja \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX="$HOME/csound-install" \ + -DCS_FRAMEWORK_DEST="$HOME/csound-install/Frameworks" \ + -DCMAKE_PREFIX_PATH="$(brew --prefix)" \ + -DBUILD_TESTS=OFF \ + -DBUILD_STATIC_LIBRARY=OFF \ + -DBUILD_VIRTUAL_KEYBOARD=OFF \ + -DBUILD_JAVA_INTERFACE=OFF \ + -DBUILD_PYTHON_INTERFACE=OFF \ + -DINSTALL_PYTHON_INTERFACE=OFF \ + -DBUILD_LUA_INTERFACE=OFF \ + -DBUILD_CSBEATS=OFF \ + -DUSE_LIBSAMPLERATE=OFF \ + -DUSE_CURL=OFF \ + -DUSE_GETTEXT=OFF \ + -DUSE_JACK=OFF \ + -DUSE_PORTAUDIO=OFF \ + -DUSE_PORTMIDI=OFF \ + -DUSE_MP3=OFF + cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(sysctl -n hw.ncpu)" + cmake --install "$RUNNER_TEMP/csound-build" + + - name: Cache Faust + id: cache-faust + uses: actions/cache@v4 + with: + path: ~/faust + key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} + + - name: Install Faust + if: steps.cache-faust.outputs.cache-hit != 'true' + run: | + if [ "$(uname -m)" = "arm64" ]; then + asset="Faust-$FAUST_VERSION-arm64.dmg" + else + asset="Faust-$FAUST_VERSION-x64.dmg" + fi + curl -sL -o "$RUNNER_TEMP/faust.dmg" \ + "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/$asset" + mkdir -p "$HOME/faust" "$RUNNER_TEMP/faust_dmg" + hdiutil attach "$RUNNER_TEMP/faust.dmg" \ + -mountpoint "$RUNNER_TEMP/faust_dmg" -nobrowse -quiet + root=$(dirname "$(find "$RUNNER_TEMP/faust_dmg" -maxdepth 2 -type d -name include | head -1)") + cp -R "$root/include" "$HOME/faust/include" + cp -R "$root/lib" "$HOME/faust/lib" + cp -R "$root/share/faust" "$HOME/faust/stdlib" + hdiutil detach "$RUNNER_TEMP/faust_dmg" -quiet + rm -f "$RUNNER_TEMP/faust.dmg" + + - name: Configure plugin build + run: | + framework="$HOME/csound-install/Frameworks/CsoundLib64.framework" + headers="$framework/Versions/7.0/Headers" + if [ ! -f "$headers/csound.h" ]; then + headers="$framework/Headers" + fi + echo "CSOUND_INCLUDE_DIR_HINT=$headers" >> "$GITHUB_ENV" + echo "CSOUND_FRAMEWORK_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" + echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" + echo "FAUST_INCLUDE_DIR_HINT=$HOME/faust/include" >> "$GITHUB_ENV" + echo "FAUST_LIB_DIR_HINT=$HOME/faust/lib" >> "$GITHUB_ENV" + echo "FAUST_STDLIB_DIR_HINT=$HOME/faust/stdlib" >> "$GITHUB_ENV" + + - name: Build plugins + run: | + cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \ + -DUSE_VCPKG=ON \ + -DFAUST_STATIC=ON \ + -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ + -DCSOUND_FRAMEWORK_DIR_HINT="$CSOUND_FRAMEWORK_DIR_HINT" \ + -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" \ + -DFAUST_INCLUDE_DIR_HINT="$FAUST_INCLUDE_DIR_HINT" \ + -DFAUST_LIB_DIR_HINT="$FAUST_LIB_DIR_HINT" \ + -DFAUST_STDLIB_DIR_HINT="$FAUST_STDLIB_DIR_HINT" + cmake --build build --parallel "$(sysctl -n hw.ncpu)" + + - name: Stage plugins + run: | + mkdir -p package + cp build/src/chua/*.dylib \ + build/src/linear_algebra/*.dylib \ + build/src/fluidOpcodes/*.dylib \ + build/src/image/*.dylib \ + build/src/websockets/*.dylib \ + build/src/hdf5/*.dylib \ + build/src/py/*.dylib \ + build/src/OpenCL/*.dylib \ + build/src/stk/*.dylib package/ + cp build/src/faustcsound/*.dylib package/ + mkdir -p package/stk/rawwaves + cp src/stk/rawwaves/*.raw package/stk/rawwaves/ + mkdir -p package/faust + cp -R "$HOME/faust/stdlib/." package/faust/ + + - name: Upload plugins + uses: actions/upload-artifact@v7.0.2 + with: + name: csound7-plugins-macos + path: package/ + if-no-files-found: error + + windows: + name: Windows (windows-latest) + needs: update_version + runs-on: windows-latest + defaults: + run: + shell: pwsh + steps: + - name: Checkout source + uses: actions/checkout@v7.0.1 + + - name: Install Csound build dependencies + run: choco install -y winflexbison3 + + - name: Clone Csound (with vcpkg) + run: | + git clone --recursive --depth 1 --branch "$env:CSOUND_VERSION" ` + https://github.com/csound/csound.git csound + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v6.1.0 + with: + path: ${{ runner.temp }}\csound-install + key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} + + - name: Bootstrap vcpkg (Csound) + if: steps.cache-csound.outputs.cache-hit != 'true' + run: .\csound\vcpkg\bootstrap-vcpkg.bat -disableMetrics + + - name: Checkout vcpkg submodule + run: git submodule update --init vcpkg + + - name: Bootstrap vcpkg (plugins) + run: .\vcpkg\bootstrap-vcpkg.bat -disableMetrics + + - name: Cache vcpkg binary cache + uses: actions/cache@v6.1.0 + with: + path: ${{ github.workspace }}\vcpkg-cache + key: vcpkg-windows-${{ github.run_id }} + restore-keys: vcpkg-windows- + + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + cmake -S csound -B csound-build -A x64 ` + -DUSE_VCPKG=ON ` + -DCMAKE_INSTALL_PREFIX="$env:RUNNER_TEMP\csound-install" ` + -DBUILD_TESTS=OFF ` + -DBUILD_STATIC_LIBRARY=OFF ` + -DBUILD_VIRTUAL_KEYBOARD=OFF ` + -DBUILD_JAVA_INTERFACE=OFF ` + -DBUILD_PYTHON_INTERFACE=OFF ` + -DINSTALL_PYTHON_INTERFACE=OFF ` + -DBUILD_LUA_INTERFACE=OFF ` + -DBUILD_CSBEATS=OFF + cmake --build csound-build --config Release --parallel + cmake --install csound-build --config Release + + - name: Cache Faust + id: cache-faust + uses: actions/cache@v4 + with: + path: ~/faust + key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} + + - name: Install Faust + if: steps.cache-faust.outputs.cache-hit != 'true' + run: | + $faustDir = Join-Path $env:USERPROFILE 'faust' + New-Item -ItemType Directory -Force -Path $faustDir | Out-Null + curl.exe -sL -o "$env:RUNNER_TEMP\faust.exe" ` + "https://github.com/grame-cncm/faust/releases/download/$env:FAUST_VERSION/Faust-$env:FAUST_VERSION-win64.exe" + & 'C:\Program Files\7-Zip\7z.exe' x "$env:RUNNER_TEMP\faust.exe" "-o$faustDir" -y | Out-Null + Remove-Item "$env:RUNNER_TEMP\faust.exe" + + - name: Configure plugin build + run: | + $install = Join-Path $env:RUNNER_TEMP 'csound-install' + $header = Get-ChildItem -Path $install -Recurse -File -Filter 'csound.h' | + Select-Object -First 1 + $lib = Get-ChildItem -Path $install -Recurse -File -Filter 'csound64.lib' | + Select-Object -First 1 + if (-not $header) { throw "csound.h not found under $install" } + if (-not $lib) { throw "csound64.lib not found under $install" } + "CSOUND_INCLUDE_DIR_HINT=$($header.DirectoryName)" >> $env:GITHUB_ENV + "CSOUND_LIBRARY_DIR_HINT=$($lib.DirectoryName)" >> $env:GITHUB_ENV + $faustDir = Join-Path $env:USERPROFILE 'faust' + "FAUST_INCLUDE_DIR_HINT=$faustDir\include" >> $env:GITHUB_ENV + "FAUST_LIB_DIR_HINT=$faustDir\lib" >> $env:GITHUB_ENV + "FAUST_STDLIB_DIR_HINT=$faustDir\share\faust" >> $env:GITHUB_ENV - name: Build plugins - run: cmake --build build --config Release + run: | + cmake -S . -B build -A x64 ` + -DUSE_VCPKG=ON ` + -DFAUST_STATIC=ON ` + -DCSOUND_INCLUDE_DIR_HINT="$env:CSOUND_INCLUDE_DIR_HINT" ` + -DCSOUND_LIBRARY_DIR_HINT="$env:CSOUND_LIBRARY_DIR_HINT" ` + -DFAUST_INCLUDE_DIR_HINT="$env:FAUST_INCLUDE_DIR_HINT" ` + -DFAUST_LIB_DIR_HINT="$env:FAUST_LIB_DIR_HINT" ` + -DFAUST_STDLIB_DIR_HINT="$env:FAUST_STDLIB_DIR_HINT" + cmake --build build --config Release --parallel - - name: Build installer - run: iscc /o. .\installer\win64\Installer.iss + - name: Stage plugins + run: | + $package = 'package' + New-Item -ItemType Directory -Force -Path $package | Out-Null + Get-ChildItem -Path build/src -Recurse -Include *.dll | + Where-Object { $_.FullName -match 'Release' } | + Copy-Item -Destination $package + $vcpkgBin = Join-Path 'build' 'vcpkg_installed\x64-windows-csound\bin' + if (Test-Path $vcpkgBin) { + Copy-Item (Join-Path $vcpkgBin '*.dll') -Destination $package -ErrorAction SilentlyContinue + } + $rawwaves = Join-Path $package 'stk/rawwaves' + New-Item -ItemType Directory -Force -Path $rawwaves | Out-Null + Copy-Item 'src\stk\rawwaves\*.raw' -Destination $rawwaves + $faustOut = Join-Path $package 'faust' + New-Item -ItemType Directory -Force -Path $faustOut | Out-Null + Copy-Item "$env:USERPROFILE\faust\share\faust\*" -Destination $faustOut -Recurse - - name: Upload installer + - name: Upload plugins uses: actions/upload-artifact@v7.0.2 with: - name: Csound_win_x64-${{env.CSOUND_VERSION}}.${{github.run_number}}-plugins-installer - path: ./csound6-plugins-win_x86_64-*.exe + name: csound7-plugins-windows + path: package/ if-no-files-found: error + + linux_cuda: + name: Linux CUDA (ubuntu-latest) + needs: update_version + runs-on: ubuntu-latest + container: + image: nvidia/cuda:12.4.1-devel-ubuntu22.04 + steps: + - name: Checkout source + uses: actions/checkout@v7.0.1 + + - name: Install build dependencies + run: | + apt-get update + apt-get install -y --no-install-recommends \ + build-essential cmake git ca-certificates pkg-config \ + libsndfile1-dev libsamplerate0-dev libasound2-dev flex bison + + - name: Show CUDA toolchain + run: | + nvcc --version + nvidia-smi || true + + - name: Cache Csound install + id: cache-csound + uses: actions/cache@v6.1.0 + with: + path: /csound-install + key: csound-cuda-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} + + - name: Build and install Csound + if: steps.cache-csound.outputs.cache-hit != 'true' + run: | + git clone --depth 1 --branch "$CSOUND_VERSION" \ + https://github.com/csound/csound.git /tmp/csound + cmake -S /tmp/csound -B /tmp/csound-build \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/csound-install \ + -DBUILD_TESTS=OFF \ + -DINSTALL_PYTHON_INTERFACE=OFF + cmake --build /tmp/csound-build --parallel "$(nproc)" + cmake --install /tmp/csound-build + + - name: Build CUDA plugins + run: | + cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \ + -DBUILD_CUDA_OPCODES=ON \ + -DBUILD_CHUA_OPCODES=OFF \ + -DBUILD_DSSI_OPCODES=OFF \ + -DBUILD_FLUID_OPCODES=OFF \ + -DBUILD_HDF5_OPCODES=OFF \ + -DBUILD_IMAGE_OPCODES=OFF \ + -DBUILD_LINEAR_ALGEBRA_OPCODES=OFF \ + -DBUILD_PYTHON_OPCODES=OFF \ + -DBUILD_WEBSOCKET_OPCODE=OFF \ + -DBUILD_WIIMOTE_OPCODES=OFF \ + -DBUILD_P5GLOVE_OPCODES=OFF \ + -DCMAKE_CUDA_ARCHITECTURES="50;60;70;75;80;86" \ + -DCSOUND_INCLUDE_DIR_HINT=/csound-install/include/csound \ + -DCSOUND_LIBRARY_DIR_HINT=/csound-install/lib + cmake --build build --parallel "$(nproc)" \ + --target cudaop1 cudaop2 cudaop3 cudaop4 cudaop5 + + - name: Stage plugins + run: | + mkdir -p package + cp build/src/CUDA/*.so package/ + + - name: Upload plugins + uses: actions/upload-artifact@v7.0.2 + with: + name: csound7-plugins-linux-cuda + path: package/ + if-no-files-found: error + + publish_release: + name: Publish release + if: ${{ (github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main') && needs.update_version.outputs.release == 'true' }} + needs: [update_version, linux, linux_cuda, macos, windows] + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - name: Download Linux plugins + uses: actions/download-artifact@v8.0.2 + with: + name: csound7-plugins-linux + path: release/linux + + - name: Download Linux CUDA plugins + uses: actions/download-artifact@v8.0.2 + with: + name: csound7-plugins-linux-cuda + path: release/linux + + - name: Download macOS plugins + uses: actions/download-artifact@v8.0.2 + with: + name: csound7-plugins-macos + path: release/macos + + - name: Download Windows plugins + uses: actions/download-artifact@v8.0.2 + with: + name: csound7-plugins-windows + path: release/windows + + - name: Package release assets + run: | + version="${{ needs.update_version.outputs.version }}" + ( cd release/linux && zip -r "../../csound7-plugins-${version}-linux-x86_64.zip" . ) + ( cd release/macos && zip -r "../../csound7-plugins-${version}-macos.zip" . ) + ( cd release/windows && zip -r "../../csound7-plugins-${version}-windows.zip" . ) + ls -l csound7-plugins-*.zip + + - name: Create release + uses: softprops/action-gh-release@v3.0.3 + with: + token: ${{ secrets.GITHUB_TOKEN }} + tag_name: ${{ needs.update_version.outputs.version }} + name: ${{ needs.update_version.outputs.version }} + generate_release_notes: true + prerelease: ${{ github.ref != 'refs/heads/main' }} + files: | + csound7-plugins-${{ needs.update_version.outputs.version }}-linux-x86_64.zip + csound7-plugins-${{ needs.update_version.outputs.version }}-macos.zip + csound7-plugins-${{ needs.update_version.outputs.version }}-windows.zip diff --git a/.github/workflows/plugins_build_7.yml b/.github/workflows/plugins_build_7.yml deleted file mode 100644 index b118242..0000000 --- a/.github/workflows/plugins_build_7.yml +++ /dev/null @@ -1,567 +0,0 @@ -name: Csound 7 plugins build - -permissions: - contents: read - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - -on: - push: - branches: - - develop - - main - pull_request: - branches: - - develop - - main - workflow_dispatch: - -env: - CSOUND_VERSION: 7.0.0 - FAUST_VERSION: 2.88.0 - VCPKG_BINARY_SOURCES: "clear;files,${{ github.workspace }}/vcpkg-cache,readwrite" - -jobs: - update_version: - name: Update plugin version - runs-on: ubuntu-latest - permissions: - contents: write - outputs: - version: ${{ steps.tag.outputs.new_tag }} - release: ${{ steps.check_pr.outputs.has_label }} - steps: - - name: Checkout source - uses: actions/checkout@v7.0.1 - with: - fetch-depth: 0 - - - name: Compute next version - id: tag - uses: anothrNick/github-tag-action@1.75.0 - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - DEFAULT_BUMP: patch - DEFAULT_BRANCH: main - PRERELEASE: ${{ github.ref != 'refs/heads/main' }} - PRERELEASE_SUFFIX: beta - DRY_RUN: true - - - name: Check for release label - id: check_pr - uses: ./.github/actions/check-pr-label - with: - label: release - github_token: ${{ secrets.GITHUB_TOKEN }} - - linux: - name: Linux (ubuntu-latest) - needs: update_version - runs-on: ubuntu-latest - steps: - - name: Checkout source - uses: actions/checkout@v7.0.1 - - - name: Install Csound build dependencies - run: | - sudo apt-get update - sudo apt-get install -y \ - build-essential cmake pkg-config \ - libsndfile1-dev libasound2-dev libportaudio2 libportmidi-dev \ - libeigen3-dev libfluidsynth-dev libpng-dev \ - libwebsockets-dev libuv1-dev libhdf5-dev \ - ocl-icd-opencl-dev libtinfo-dev \ - libgtest-dev \ - flex bison - - - name: Cache Csound install - id: cache-csound - uses: actions/cache@v6.1.0 - with: - path: ~/csound-install - key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} - - - name: Build and install Csound - if: steps.cache-csound.outputs.cache-hit != 'true' - run: | - git clone --depth 1 --branch "$CSOUND_VERSION" \ - https://github.com/csound/csound.git "$RUNNER_TEMP/csound" - cmake -S "$RUNNER_TEMP/csound" -B "$RUNNER_TEMP/csound-build" \ - -DCMAKE_BUILD_TYPE=Release \ - -DCMAKE_INSTALL_PREFIX="$HOME/csound-install" \ - -DBUILD_TESTS=OFF \ - -DINSTALL_PYTHON_INTERFACE=OFF - cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(nproc)" - cmake --install "$RUNNER_TEMP/csound-build" - - - name: Cache Faust - id: cache-faust - uses: actions/cache@v4 - with: - path: ~/faust - key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} - - - name: Install Faust - if: steps.cache-faust.outputs.cache-hit != 'true' - run: | - mkdir -p "$HOME/faust" - curl -sL -o "$RUNNER_TEMP/libfaust.zip" \ - "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/libfaust-ubuntu-x86_64.zip" - curl -sL -o "$RUNNER_TEMP/faust-src.tar.gz" \ - "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/faust-$FAUST_VERSION.tar.gz" - unzip -q "$RUNNER_TEMP/libfaust.zip" -d "$HOME/faust" - tar xzf "$RUNNER_TEMP/faust-src.tar.gz" -C "$RUNNER_TEMP" \ - "faust-$FAUST_VERSION/architecture" "faust-$FAUST_VERSION/libraries" - mv "$RUNNER_TEMP/faust-$FAUST_VERSION/architecture" "$HOME/faust/include" - mv "$RUNNER_TEMP/faust-$FAUST_VERSION/libraries" "$HOME/faust/stdlib" - rm -f "$RUNNER_TEMP/libfaust.zip" "$RUNNER_TEMP/faust-src.tar.gz" - - - name: Configure plugin build - run: | - echo "CSOUND_INCLUDE_DIR_HINT=$HOME/csound-install/include/csound" >> "$GITHUB_ENV" - echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/lib" >> "$GITHUB_ENV" - echo "FAUST_INCLUDE_DIR_HINT=$HOME/faust/include" >> "$GITHUB_ENV" - echo "FAUST_LIB_DIR_HINT=$HOME/faust/lib" >> "$GITHUB_ENV" - echo "FAUST_STDLIB_DIR_HINT=$HOME/faust/stdlib" >> "$GITHUB_ENV" - - - name: Build plugins - run: | - cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ - -DFAUST_STATIC=ON \ - -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ - -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" \ - -DFAUST_INCLUDE_DIR_HINT="$FAUST_INCLUDE_DIR_HINT" \ - -DFAUST_LIB_DIR_HINT="$FAUST_LIB_DIR_HINT" \ - -DFAUST_STDLIB_DIR_HINT="$FAUST_STDLIB_DIR_HINT" - cmake --build build --parallel "$(nproc)" - - - name: Run plugin tests - run: ctest --test-dir build --output-on-failure - - - name: Stage plugins - run: | - mkdir -p package - cp build/src/chua/*.so \ - build/src/linear_algebra/*.so \ - build/src/fluidOpcodes/*.so \ - build/src/dssi4cs/*.so \ - build/src/image/*.so \ - build/src/websockets/*.so \ - build/src/hdf5/*.so \ - build/src/py/*.so \ - build/src/OpenCL/*.so \ - build/src/stk/*.so package/ - cp build/src/faustcsound/*.so package/ - mkdir -p package/stk/rawwaves - cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ - mkdir -p package/faust - cp -R "$HOME/faust/stdlib/." package/faust/ - - - name: Upload plugins - uses: actions/upload-artifact@v7.0.2 - with: - name: csound7-plugins-linux - path: package/ - if-no-files-found: error - - macos: - name: macOS (macos-latest) - needs: update_version - runs-on: macos-latest - steps: - - name: Checkout source - uses: actions/checkout@v7.0.1 - - - name: Install Csound build dependencies - env: - HOMEBREW_NO_AUTO_UPDATE: 1 - run: | - brew install cmake ninja pkg-config bison flex libsndfile - echo "$(brew --prefix bison)/bin" >> "$GITHUB_PATH" - echo "$(brew --prefix flex)/bin" >> "$GITHUB_PATH" - - - name: Checkout 7.x/vcpkg submodule - run: git submodule update --init 7.x/vcpkg - - - name: Set up vcpkg - run: 7.x/vcpkg/bootstrap-vcpkg.sh -disableMetrics - - - name: Cache vcpkg binary cache - uses: actions/cache@v6.1.0 - with: - path: vcpkg-cache - key: vcpkg-macos-${{ github.run_id }} - restore-keys: vcpkg-macos- - - - name: Cache Csound install - id: cache-csound - uses: actions/cache@v6.1.0 - with: - path: ~/csound-install - key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} - - - name: Build and install Csound - if: steps.cache-csound.outputs.cache-hit != 'true' - run: | - git clone --depth 1 --branch "$CSOUND_VERSION" \ - https://github.com/csound/csound.git "$RUNNER_TEMP/csound" - cmake -S "$RUNNER_TEMP/csound" -B "$RUNNER_TEMP/csound-build" -G Ninja \ - -DCMAKE_BUILD_TYPE=Release \ - -DCMAKE_INSTALL_PREFIX="$HOME/csound-install" \ - -DCS_FRAMEWORK_DEST="$HOME/csound-install/Frameworks" \ - -DCMAKE_PREFIX_PATH="$(brew --prefix)" \ - -DBUILD_TESTS=OFF \ - -DBUILD_STATIC_LIBRARY=OFF \ - -DBUILD_VIRTUAL_KEYBOARD=OFF \ - -DBUILD_JAVA_INTERFACE=OFF \ - -DBUILD_PYTHON_INTERFACE=OFF \ - -DINSTALL_PYTHON_INTERFACE=OFF \ - -DBUILD_LUA_INTERFACE=OFF \ - -DBUILD_CSBEATS=OFF \ - -DUSE_LIBSAMPLERATE=OFF \ - -DUSE_CURL=OFF \ - -DUSE_GETTEXT=OFF \ - -DUSE_JACK=OFF \ - -DUSE_PORTAUDIO=OFF \ - -DUSE_PORTMIDI=OFF \ - -DUSE_MP3=OFF - cmake --build "$RUNNER_TEMP/csound-build" --parallel "$(sysctl -n hw.ncpu)" - cmake --install "$RUNNER_TEMP/csound-build" - - - name: Cache Faust - id: cache-faust - uses: actions/cache@v4 - with: - path: ~/faust - key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} - - - name: Install Faust - if: steps.cache-faust.outputs.cache-hit != 'true' - run: | - if [ "$(uname -m)" = "arm64" ]; then - asset="Faust-$FAUST_VERSION-arm64.dmg" - else - asset="Faust-$FAUST_VERSION-x64.dmg" - fi - curl -sL -o "$RUNNER_TEMP/faust.dmg" \ - "https://github.com/grame-cncm/faust/releases/download/$FAUST_VERSION/$asset" - mkdir -p "$HOME/faust" "$RUNNER_TEMP/faust_dmg" - hdiutil attach "$RUNNER_TEMP/faust.dmg" \ - -mountpoint "$RUNNER_TEMP/faust_dmg" -nobrowse -quiet - root=$(dirname "$(find "$RUNNER_TEMP/faust_dmg" -maxdepth 2 -type d -name include | head -1)") - cp -R "$root/include" "$HOME/faust/include" - cp -R "$root/lib" "$HOME/faust/lib" - cp -R "$root/share/faust" "$HOME/faust/stdlib" - hdiutil detach "$RUNNER_TEMP/faust_dmg" -quiet - rm -f "$RUNNER_TEMP/faust.dmg" - - - name: Configure plugin build - run: | - framework="$HOME/csound-install/Frameworks/CsoundLib64.framework" - headers="$framework/Versions/7.0/Headers" - if [ ! -f "$headers/csound.h" ]; then - headers="$framework/Headers" - fi - echo "CSOUND_INCLUDE_DIR_HINT=$headers" >> "$GITHUB_ENV" - echo "CSOUND_FRAMEWORK_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" - echo "CSOUND_LIBRARY_DIR_HINT=$HOME/csound-install/Frameworks" >> "$GITHUB_ENV" - echo "FAUST_INCLUDE_DIR_HINT=$HOME/faust/include" >> "$GITHUB_ENV" - echo "FAUST_LIB_DIR_HINT=$HOME/faust/lib" >> "$GITHUB_ENV" - echo "FAUST_STDLIB_DIR_HINT=$HOME/faust/stdlib" >> "$GITHUB_ENV" - - - name: Build plugins - run: | - cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ - -DUSE_VCPKG=ON \ - -DFAUST_STATIC=ON \ - -DCSOUND_INCLUDE_DIR_HINT="$CSOUND_INCLUDE_DIR_HINT" \ - -DCSOUND_FRAMEWORK_DIR_HINT="$CSOUND_FRAMEWORK_DIR_HINT" \ - -DCSOUND_LIBRARY_DIR_HINT="$CSOUND_LIBRARY_DIR_HINT" \ - -DFAUST_INCLUDE_DIR_HINT="$FAUST_INCLUDE_DIR_HINT" \ - -DFAUST_LIB_DIR_HINT="$FAUST_LIB_DIR_HINT" \ - -DFAUST_STDLIB_DIR_HINT="$FAUST_STDLIB_DIR_HINT" - cmake --build build --parallel "$(sysctl -n hw.ncpu)" - - - name: Stage plugins - run: | - mkdir -p package - cp build/src/chua/*.dylib \ - build/src/linear_algebra/*.dylib \ - build/src/fluidOpcodes/*.dylib \ - build/src/image/*.dylib \ - build/src/websockets/*.dylib \ - build/src/hdf5/*.dylib \ - build/src/py/*.dylib \ - build/src/OpenCL/*.dylib \ - build/src/stk/*.dylib package/ - cp build/src/faustcsound/*.dylib package/ - mkdir -p package/stk/rawwaves - cp 7.x/src/stk/rawwaves/*.raw package/stk/rawwaves/ - mkdir -p package/faust - cp -R "$HOME/faust/stdlib/." package/faust/ - - - name: Upload plugins - uses: actions/upload-artifact@v7.0.2 - with: - name: csound7-plugins-macos - path: package/ - if-no-files-found: error - - windows: - name: Windows (windows-latest) - needs: update_version - runs-on: windows-latest - defaults: - run: - shell: pwsh - steps: - - name: Checkout source - uses: actions/checkout@v7.0.1 - - - name: Install Csound build dependencies - run: choco install -y winflexbison3 - - - name: Clone Csound (with vcpkg) - run: | - git clone --recursive --depth 1 --branch "$env:CSOUND_VERSION" ` - https://github.com/csound/csound.git csound - - - name: Cache Csound install - id: cache-csound - uses: actions/cache@v6.1.0 - with: - path: ${{ runner.temp }}\csound-install - key: csound-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} - - - name: Bootstrap vcpkg (Csound) - if: steps.cache-csound.outputs.cache-hit != 'true' - run: .\csound\vcpkg\bootstrap-vcpkg.bat -disableMetrics - - - name: Checkout 7.x/vcpkg submodule - run: git submodule update --init 7.x/vcpkg - - - name: Bootstrap vcpkg (plugins) - run: .\7.x\vcpkg\bootstrap-vcpkg.bat -disableMetrics - - - name: Cache vcpkg binary cache - uses: actions/cache@v6.1.0 - with: - path: ${{ github.workspace }}\vcpkg-cache - key: vcpkg-windows-${{ github.run_id }} - restore-keys: vcpkg-windows- - - - name: Build and install Csound - if: steps.cache-csound.outputs.cache-hit != 'true' - run: | - cmake -S csound -B csound-build -A x64 ` - -DUSE_VCPKG=ON ` - -DCMAKE_INSTALL_PREFIX="$env:RUNNER_TEMP\csound-install" ` - -DBUILD_TESTS=OFF ` - -DBUILD_STATIC_LIBRARY=OFF ` - -DBUILD_VIRTUAL_KEYBOARD=OFF ` - -DBUILD_JAVA_INTERFACE=OFF ` - -DBUILD_PYTHON_INTERFACE=OFF ` - -DINSTALL_PYTHON_INTERFACE=OFF ` - -DBUILD_LUA_INTERFACE=OFF ` - -DBUILD_CSBEATS=OFF - cmake --build csound-build --config Release --parallel - cmake --install csound-build --config Release - - - name: Cache Faust - id: cache-faust - uses: actions/cache@v4 - with: - path: ~/faust - key: faust-${{ runner.os }}-${{ runner.arch }}-${{ env.FAUST_VERSION }} - - - name: Install Faust - if: steps.cache-faust.outputs.cache-hit != 'true' - run: | - $faustDir = Join-Path $env:USERPROFILE 'faust' - New-Item -ItemType Directory -Force -Path $faustDir | Out-Null - curl.exe -sL -o "$env:RUNNER_TEMP\faust.exe" ` - "https://github.com/grame-cncm/faust/releases/download/$env:FAUST_VERSION/Faust-$env:FAUST_VERSION-win64.exe" - & 'C:\Program Files\7-Zip\7z.exe' x "$env:RUNNER_TEMP\faust.exe" "-o$faustDir" -y | Out-Null - Remove-Item "$env:RUNNER_TEMP\faust.exe" - - - name: Configure plugin build - run: | - $install = Join-Path $env:RUNNER_TEMP 'csound-install' - $header = Get-ChildItem -Path $install -Recurse -File -Filter 'csound.h' | - Select-Object -First 1 - $lib = Get-ChildItem -Path $install -Recurse -File -Filter 'csound64.lib' | - Select-Object -First 1 - if (-not $header) { throw "csound.h not found under $install" } - if (-not $lib) { throw "csound64.lib not found under $install" } - "CSOUND_INCLUDE_DIR_HINT=$($header.DirectoryName)" >> $env:GITHUB_ENV - "CSOUND_LIBRARY_DIR_HINT=$($lib.DirectoryName)" >> $env:GITHUB_ENV - $faustDir = Join-Path $env:USERPROFILE 'faust' - "FAUST_INCLUDE_DIR_HINT=$faustDir\include" >> $env:GITHUB_ENV - "FAUST_LIB_DIR_HINT=$faustDir\lib" >> $env:GITHUB_ENV - "FAUST_STDLIB_DIR_HINT=$faustDir\share\faust" >> $env:GITHUB_ENV - - - name: Build plugins - run: | - cmake -S 7.x -B build -A x64 ` - -DUSE_VCPKG=ON ` - -DFAUST_STATIC=ON ` - -DCSOUND_INCLUDE_DIR_HINT="$env:CSOUND_INCLUDE_DIR_HINT" ` - -DCSOUND_LIBRARY_DIR_HINT="$env:CSOUND_LIBRARY_DIR_HINT" ` - -DFAUST_INCLUDE_DIR_HINT="$env:FAUST_INCLUDE_DIR_HINT" ` - -DFAUST_LIB_DIR_HINT="$env:FAUST_LIB_DIR_HINT" ` - -DFAUST_STDLIB_DIR_HINT="$env:FAUST_STDLIB_DIR_HINT" - cmake --build build --config Release --parallel - - - name: Stage plugins - run: | - $package = 'package' - New-Item -ItemType Directory -Force -Path $package | Out-Null - Get-ChildItem -Path build/src -Recurse -Include *.dll | - Where-Object { $_.FullName -match 'Release' } | - Copy-Item -Destination $package - $vcpkgBin = Join-Path 'build' 'vcpkg_installed\x64-windows-csound\bin' - if (Test-Path $vcpkgBin) { - Copy-Item (Join-Path $vcpkgBin '*.dll') -Destination $package -ErrorAction SilentlyContinue - } - $rawwaves = Join-Path $package 'stk/rawwaves' - New-Item -ItemType Directory -Force -Path $rawwaves | Out-Null - Copy-Item '7.x\src\stk\rawwaves\*.raw' -Destination $rawwaves - $faustOut = Join-Path $package 'faust' - New-Item -ItemType Directory -Force -Path $faustOut | Out-Null - Copy-Item "$env:USERPROFILE\faust\share\faust\*" -Destination $faustOut -Recurse - - - name: Upload plugins - uses: actions/upload-artifact@v7.0.2 - with: - name: csound7-plugins-windows - path: package/ - if-no-files-found: error - - linux_cuda: - name: Linux CUDA (ubuntu-latest) - needs: update_version - runs-on: ubuntu-latest - container: - image: nvidia/cuda:12.4.1-devel-ubuntu22.04 - steps: - - name: Checkout source - uses: actions/checkout@v7.0.1 - - - name: Install build dependencies - run: | - apt-get update - apt-get install -y --no-install-recommends \ - build-essential cmake git ca-certificates pkg-config \ - libsndfile1-dev libasound2-dev flex bison - - - name: Show CUDA toolchain - run: | - nvcc --version - nvidia-smi || true - - - name: Cache Csound install - id: cache-csound - uses: actions/cache@v6.1.0 - with: - path: /csound-install - key: csound-cuda-${{ runner.os }}-${{ runner.arch }}-${{ env.CSOUND_VERSION }} - - - name: Build and install Csound - if: steps.cache-csound.outputs.cache-hit != 'true' - run: | - git clone --depth 1 --branch "$CSOUND_VERSION" \ - https://github.com/csound/csound.git /tmp/csound - cmake -S /tmp/csound -B /tmp/csound-build \ - -DCMAKE_BUILD_TYPE=Release \ - -DCMAKE_INSTALL_PREFIX=/csound-install \ - -DBUILD_TESTS=OFF \ - -DINSTALL_PYTHON_INTERFACE=OFF - cmake --build /tmp/csound-build --parallel "$(nproc)" - cmake --install /tmp/csound-build - - - name: Build CUDA plugins - run: | - cmake -S 7.x -B build -DCMAKE_BUILD_TYPE=Release \ - -DBUILD_CUDA_OPCODES=ON \ - -DBUILD_CHUA_OPCODES=OFF \ - -DBUILD_DSSI_OPCODES=OFF \ - -DBUILD_FLUID_OPCODES=OFF \ - -DBUILD_HDF5_OPCODES=OFF \ - -DBUILD_IMAGE_OPCODES=OFF \ - -DBUILD_LINEAR_ALGEBRA_OPCODES=OFF \ - -DBUILD_PYTHON_OPCODES=OFF \ - -DBUILD_WEBSOCKET_OPCODE=OFF \ - -DBUILD_WIIMOTE_OPCODES=OFF \ - -DBUILD_P5GLOVE_OPCODES=OFF \ - -DCMAKE_CUDA_ARCHITECTURES="50;60;70;75;80;86" \ - -DCSOUND_INCLUDE_DIR_HINT=/csound-install/include/csound \ - -DCSOUND_LIBRARY_DIR_HINT=/csound-install/lib - cmake --build build --parallel "$(nproc)" \ - --target cudaop1 cudaop2 cudaop3 cudaop4 cudaop5 - - - name: Stage plugins - run: | - mkdir -p package - cp build/src/CUDA/*.so package/ - - - name: Upload plugins - uses: actions/upload-artifact@v7.0.2 - with: - name: csound7-plugins-linux-cuda - path: package/ - if-no-files-found: error - - publish_release: - name: Publish release - if: ${{ (github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main') && needs.update_version.outputs.release == 'true' }} - needs: [update_version, linux, linux_cuda, macos, windows] - runs-on: ubuntu-latest - permissions: - contents: write - steps: - - name: Download Linux plugins - uses: actions/download-artifact@v8.0.2 - with: - name: csound7-plugins-linux - path: release/linux - - - name: Download Linux CUDA plugins - uses: actions/download-artifact@v8.0.2 - with: - name: csound7-plugins-linux-cuda - path: release/linux - - - name: Download macOS plugins - uses: actions/download-artifact@v8.0.2 - with: - name: csound7-plugins-macos - path: release/macos - - - name: Download Windows plugins - uses: actions/download-artifact@v8.0.2 - with: - name: csound7-plugins-windows - path: release/windows - - - name: Package release assets - run: | - version="${{ needs.update_version.outputs.version }}" - ( cd release/linux && zip -r "../../csound7-plugins-${version}-linux-x86_64.zip" . ) - ( cd release/macos && zip -r "../../csound7-plugins-${version}-macos.zip" . ) - ( cd release/windows && zip -r "../../csound7-plugins-${version}-windows.zip" . ) - ls -l csound7-plugins-*.zip - - - name: Create release - uses: softprops/action-gh-release@v3.0.3 - with: - token: ${{ secrets.GITHUB_TOKEN }} - tag_name: ${{ needs.update_version.outputs.version }} - name: ${{ needs.update_version.outputs.version }} - generate_release_notes: true - prerelease: ${{ github.ref != 'refs/heads/main' }} - files: | - csound7-plugins-${{ needs.update_version.outputs.version }}-linux-x86_64.zip - csound7-plugins-${{ needs.update_version.outputs.version }}-macos.zip - csound7-plugins-${{ needs.update_version.outputs.version }}-windows.zip diff --git a/.gitignore b/.gitignore index d91c3aa..8754df9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ build dist -csound6-plugins-win_x86_64-* node_modules/ result* *.tgz diff --git a/.gitmodules b/.gitmodules index 4e57bf2..a0a57f3 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,3 @@ [submodule "vcpkg"] - path = 6.x/vcpkg - url = https://github.com/microsoft/vcpkg.git -[submodule "7.x/vcpkg"] - path = 7.x/vcpkg + path = vcpkg url = https://github.com/microsoft/vcpkg.git diff --git a/6.x/CMakeLists.txt b/6.x/CMakeLists.txt deleted file mode 100644 index 3cea4fa..0000000 --- a/6.x/CMakeLists.txt +++ /dev/null @@ -1,317 +0,0 @@ -cmake_minimum_required(VERSION 3.5) -cmake_policy(SET CMP0077 NEW) - -option(USE_VCPKG "Use VCPKG to download and manage dependencies" OFF) - -if (USE_VCPKG) - # Detect correct triplet based on CMake env - if (WIN32) - set(VCPKG_HOST_TRIPLET "x64-windows-csound" CACHE STRING "") - set(VCPKG_TARGET_TRIPLET "x64-windows-csound") - set(CSOUND_INCLUDE_DIR_HINT "C:/Program Files/Csound6_x64") - elseif(APPLE) - set(VCPKG_HOST_TRIPLET "x64-osx" CACHE STRING "") - set(VCPKG_TARGET_TRIPLET "x64-osx") - elseif (UNIX) - set(VCPKG_HOST_TRIPLET "x64-linux" CACHE STRING "") - set(VCPKG_TARGET_TRIPLET "x64-linux") - endif() - - set(VCPKG_FEATURE_FLAGS versions) - set(X_VCPKG_APPLOCAL_DEPS_INSTALL ON) - set(VCPKG_OVERLAY_TRIPLETS ${CMAKE_CURRENT_SOURCE_DIR}/) - set(VCPKG_OVERLAY_PORTS ${CMAKE_CURRENT_SOURCE_DIR}/) - set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake - CACHE STRING "Vcpkg toolchain file") -endif() - -project(Csound-plugins) - -if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") - set(CMAKE_COMPILER_IS_CLANG 1) -endif() - -set(APIVERSION "6.0") - -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_MACOSX_RPATH 1) -set(CMAKE_VERBOSE_MAKEFILE ON) -set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/") - -find_package(CSOUND) - -if(NOT CSOUND_INCLUDE_DIRS) - message(FATAL_ERROR "Csound header files are required") -endif() - -include(TestBigEndian) -include(CheckFunctionExists) -include(CheckCCompilerFlag) -include(CheckCXXCompilerFlag) - -### COMPILER OPTIMIZATION FLAGS -option(USE_COMPILER_OPTIMIZATIONS "Use the default Csound compiler optimization flags" ON) -if(USE_COMPILER_OPTIMIZATIONS) - include(${CMAKE_SOURCE_DIR}/cmake/CompilerOptimizations.cmake) -endif() - -##/Library/Frameworks/CsoundLib64.framework/Versions/Current/Resources/Opcodes64 - -if(APPLE) - message(STATUS "Building on OSX") - set(OSX_VERSION " ") -endif() - -## USER OPTIONS ## -# Optional targets, they should all default to ON (check_deps will disable them if not possible to build) -option(USE_DOUBLE "Set to use double-precision floating point for audio samples." ON) -option(USE_LRINT "Use lrint/lrintf for converting floating point values to integers." ON) -option(BUILD_RELEASE "Build for release" ON) -option(USE_GIT_COMMIT "Show the git commit in version information" ON) -option(REQUIRE_PTHREADS "For non-Windows systems, set whether Csound will use threads or not" ON) - -# in Release configuration, set NDEBUG -if(${CMAKE_BUILD_TYPE} MATCHES "Release") - message("-----> Release mode") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNDEBUG") -elseif(${CMAKE_BUILD_TYPE} MATCHES "Debug") - message("-----> Debug mode") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBETA") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBETA") -endif() - -# set -Werror if in Debug configuration -if(NOT MSVC AND NOT WASM) - set(CMAKE_CXX_FLAGS_RELEASE "-O3 ") - set(CMAKE_C_FLAGS_RELEASE "-O3 ") - if(${CMAKE_BUILD_TYPE} MATCHES "Debug") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wno-missing-field-initializers") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wno-missing-field-initializers") - endif() -endif() - -if(NOT MSVC AND REQUIRE_PTHREADS) - # Use ladder of if's to support older CMake versions (i.e., travis) - find_library(PTHREAD_LIBRARY winpthread-1) - - if(NOT PTHREAD_LIBRARY) - find_library(PTHREAD_LIBRARY pthread) - endif() - - if(NOT PTHREAD_LIBRARY) - find_library(PTHREAD_LIBRARY pthreadGC2) - endif() - - if(NOT (PTHREAD_LIBRARY OR HAIKU)) - # pthreads are built in to Haiku - message(STATUS "Csound requires the pthread library") - endif() - - #FIXME this variable is for required include directories, possible bug - list(APPEND CMAKE_REQUIRED_INCLUDES pthread.h) - if (NOT HAIKU) - set(CMAKE_REQUIRED_LIBRARIES pthread) - endif() -endif() - -if(CMAKE_SYSTEM_NAME MATCHES "Linux") - set(LINUX YES) -else() - set(LINUX NO) -endif() - -set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}) -check_c_compiler_flag(-fvisibility=hidden HAS_VISIBILITY_HIDDEN) -check_cxx_compiler_flag(-fvisibility=hidden HAS_CXX_VISIBILITY_HIDDEN) - -if (HAS_VISIBILITY_HIDDEN) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") -endif() - -if (HAS_CXX_VISIBILITY_HIDDEN) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") -endif() - -check_c_compiler_flag(-std=gnu99 HAS_GNU99) -if (HAS_GNU99) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99") -endif() - -if (HAS_CXX_VISIBILITY_HIDDEN) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") -endif() - -if(LINUX) - option(USE_LIB64 "Set to on to set installation directory for libraries to lib64" OFF) - - if(USE_LIB64) - set(LIBRARY_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib64") - add_definitions("-DLIB64") - else() - set(LIBRARY_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib") - endif() - - message(STATUS "LIBRARY INSTALL DIR: ${LIBRARY_INSTALL_DIR}") -endif() - -# plugin install directories (CS_USER_PLUGIN on MacOs/Windows) -if(USE_DOUBLE) - message(STATUS "Building with 64-bit floats") - if(APPLE) - set(PLUGIN_INSTALL_DIR "$ENV{HOME}/Library/csound/${APIVERSION}/plugins64") - elseif(LINUX) - set(PLUGIN_INSTALL_DIR "${LIBRARY_INSTALL_DIR}/csound/plugins64-${APIVERSION}") - elseif(MSVC) - set(PLUGIN_INSTALL_DIR "$ENV{LOCALAPPDATA}/csound/${APIVERSION}/plugins64") - endif() -else() - message(STATUS "Building with 32-bit floats") - if(APPLE) - set(PLUGIN_INSTALL_DIR "$ENV{HOME}/Library/csound/${APIVERSION}/plugins") - elseif(LINUX) - set(PLUGIN_INSTALL_DIR "${LIBRARY_INSTALL_DIR}/csound/plugins-${APIVERSION}") - elseif(MSVC) - set(PLUGIN_INSTALL_DIR "$ENV{LOCALAPPDATA}/csound/${APIVERSION}/plugins") - endif() -endif() - -message("-- Csound headers: ${CSOUND_INCLUDE_DIR}") -if(APPLE) - message("-- Csound framework: ${CSOUND_FRAMEWORK}") -endif() -message("-- Plugins to be installed at: ${PLUGIN_INSTALL_DIR}") - -# Checks if dependencies for an enabled target are fulfilled. -# If FAIL_MISSING is true and the dependencies are not fulfilled, -# it will abort the cmake run. -# If FAIL_MISSING is false, it will set the option to OFF. -# If the target is not enabled, it will do nothing. -# example: check_deps(BUILD_NEW_PARSER FLEX_EXECUTABLE BISON_EXECUTABLE) -function(check_deps option) - if(${option}) - set(i 1) - while( ${i} LESS ${ARGC} ) - set(dep ${ARGV${i}}) - if(NOT ${dep}) - if(FAIL_MISSING) - message(FATAL_ERROR - "${option} is enabled, but ${dep}=\"${${dep}}\"") - else() - message(STATUS "${dep}=\"${${dep}}\", so disabling ${option}") - set(${option} OFF PARENT_SCOPE) - # Set it in the local scope too - set(${option} OFF) - endif() - endif() - math(EXPR i "${i}+1") - endwhile() - endif() - if(${option}) - message(STATUS "${option} is enabled.") - else() - message(STATUS "${option} is disabled.") - endif() -endfunction(check_deps) - -# Utility function to make plugins. All plugin targets should use this as it -# sets up output directory set in top-level CmakeLists.txt -# and adds the appropriate install target -# -# libname - name of library to produce -# srcs - list of src files (must be quoted if a list) -# extralibs (OPTIONAL) - extra libraries to link the plugin to -# -# NB - this was moved here as it needs some VARS defined above -# for setting up the framework -function(make_plugin libname srcs) - if(APPLE) - add_library(${libname} SHARED ${srcs}) - else() - add_library(${libname} MODULE ${srcs}) - endif() - - set(i 2) - while( ${i} LESS ${ARGC} ) - target_link_libraries(${libname} PRIVATE ${ARGV${i}}) - math(EXPR i "${i}+1") - endwhile() - - install(TARGETS ${libname} - LIBRARY DESTINATION "${PLUGIN_INSTALL_DIR}" - ARCHIVE DESTINATION "${PLUGIN_INSTALL_DIR}" ) -endfunction(make_plugin) - -#checking pthread functions -if(REQUIRE_PTHREADS AND (PTHREAD_LIBRARY OR HAIKU)) - - #list(APPEND libcsound_CFLAGS -DHAVE_PTHREAD) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHAVE_PTHREAD") - - check_function_exists(pthread_spin_lock PTHREAD_SPIN_LOCK_EXISTS) - check_function_exists(pthread_barrier_init PTHREAD_BARRIER_INIT_EXISTS) - - if(PTHREAD_SPIN_LOCK_EXISTS) - list(APPEND libcsound_CFLAGS -DHAVE_PTHREAD_SPIN_LOCK) - endif() - - if(PTHREAD_BARRIER_INIT_EXISTS) - list(APPEND libcsound_CFLAGS -DHAVE_PTHREAD_BARRIER_INIT) - endif() -endif() - -# Linux does not have a separate libintl, it is part of libc -set(LIBINTL_AVAIL (LIBINTL_LIBRARY OR LINUX)) - -if(LINUX) - message(STATUS "Building on Linux.") - add_definitions(-DLINUX -DPIPES -DNO_FLTK_THREADS -D_GNU_SOURCE -DHAVE_SOCKETS) - list(APPEND libcsound_LIBS ${MATH_LIBRARY} dl) - - find_library(LIBRT_LIBRARY rt) - - if(LIBRT_LIBRARY) - list(APPEND libcsound_LIBS ${LIBRT_LIBRARY}) - message(STATUS " ADDING LIBRT LIBRARY: ${LIBRT_LIBRARY}.") - endif() - - find_library(LIBEXECINFO_LIBRARY execinfo) - - if(LIBEXECINFO_LIBRARY) - list(APPEND libcsound_LIBS ${LIBEXECINFO_LIBRARY}) - message(STATUS " ADDING LIBEXECINFO LIBRARY: ${LIBEXECINFO_LIBRARY}.") - endif() -endif() - -if(APPLE AND NOT IOS) - add_definitions(-DMACOSX -DPIPES -DNO_FLTK_THREADS -DHAVE_SOCKETS) - find_library(ACCELERATE_LIBRARY Accelerate) - find_path(VECLIB_PATH "Accelerate/Accelerate.h") - include_directories(${VECLIB_PATH}) - list(APPEND libcsound_LIBS ${MATH_LIBRARY} dl ${ACCELERATE_LIBRARY}) -endif() - -if(WIN32) - add_definitions(-DWIN32) -endif() - -add_subdirectory(./src/chua) -add_subdirectory(./src/faustcsound) -add_subdirectory(./src/image) -add_subdirectory(./src/py) -add_subdirectory(./src/widgets) - -if(BUILD_ABLETON_LINK_OPCODES) -add_subdirectory(./src/AbletonLinkOpcodes) -endif() -add_subdirectory(./src/stk) -add_subdirectory(./src/CUDA) -add_subdirectory(./src/opencl) -add_subdirectory(./src/websockets) -add_subdirectory(./src/hdf5) -add_subdirectory(./src/linear_algebra) -add_subdirectory(./src/mp3) -add_subdirectory(./src/wiimote) -add_subdirectory(./src/p5glove) -add_subdirectory(./src/jackops) -add_subdirectory(./src/fluidOpcodes) diff --git a/6.x/README.md b/6.x/README.md deleted file mode 100644 index f251e7d..0000000 --- a/6.x/README.md +++ /dev/null @@ -1,114 +0,0 @@ -Plugins for Csound 6.x -======= - -Currently, the plugins available in this tree are - -- AbletonLive Link (requires Ableton link) - **link_create link_enable link_is_enabled link_tempo_set link_tempo_get link_beat_get link_metro link_beat_request link_beat_force** - -- chua (requires Eigen library, header-only) - **chuap** - -- Faust (requires libfaust) - **faustgen faustcompile faustaudio faustdsp faustplay faustctl** - -- image (requires libpng) - **imageload imagesave imagecreate imagesize imagegetpixel imagesetpixel imagefree** - -- py (requires a Python 3.x installation with dev libs) - **Many opcodes to call Python code** - -- widgets (requires the FLTK LIB) -**FLTK-based widgets.** -NB: These opcodes do not work correctly on MacOS due -to incompatibilities with the operating system. - -- virtual keyboard (requires the FLTK LIB) -**Virtual MIDI keyboard midi backend** - -- STK opcodes (requires STK library) -**Physical model opcodes using the STK library** - - -Install location --------------- -The CMake scripts in this repository use the default CS_USER_PLUGIN -location on MacOS and Windows as defined in the Csound build, or a -library instalation directory (customisable) on LINUX. These are: - -- LINUX: depends on both `CMAKE_INSTALL_PREFIX` and `USE_LIB64`. It is then installed in: - * if `USE_LIB64=1` then to - * for doubles: `${CSOUND_INSTALL_PREFIX}/lib64/csound/plugins64-${APIVERSION}` - * for floats: `${CSOUND_INSTALL_PREFIX}/lib64/csound/plugins-${APIVERSION}` (floats)` - * if `USE_LIB64=0` then to - * for doubles: `${CSOUND_INSTALL_PREFIX}/lib/csound/plugins64-${APIVERSION}` - * for floats: `${CSOUND_INSTALL_PREFIX}/lib/csound/plugins-${APIVERSION}` - -- MACOS: - * For doubles: `$HOME/Library/csound/${APIVERSION}/plugins64` - * For floats: `$HOME/Library/csound/${APIVERSION}/plugins` -- Windows: - * For doubles: `%LOCALAPPDATA%\csound\${APIVERSION}\plugins64` - * For floats: `%LOCALAPPDATA%\csound\${APIVERSION}\plugins` - - -Build Instructions for Linux and MacOS ---- - -The build requires Csound to be installed, as well as CMake. With this -in place, you can do : - -``` -$ git clone https://github.com/csound/plugins.git -$ cd plugins -$ mkdir build -$ cd build -$ cmake ../ -$ make -``` - -By default, all the plugins are built. If one wants to exclude a -plugin from the build process, one can pass an option to the cmake command. -For example, to exclude the chua plugin, the `cmake` command would be: - -``` -$ cmake -DBUILD_CHUA_OPCODES=OFF ../ -``` - -For the FLTK dependent plugins, the configuration variable used is -`USE_FLTK`. - -To install the opcodes you have built - -``` -$ make install -``` - -Depending on your permissions, you might need to prepend `sudo` to -these commands. After the first build the plugins can be updated with - -``` -$ git pull -$ make -$ make install -``` - -using `sudo` in the last step if raised permissions are needed. On -Linux, the installation location can be set with the relevant CMake -variables as indicated above. - -Csound Location ------------- -CMake will normally find the installed Csound headers (and library) -automatically. However, if your Csound headers and library are not -placed in the usual locations, you can use the following CMake option variables -to tell CMake where they are: - -``` -CSOUND_INCLUDE_DIR_HINT -``` -and - -``` -CSOUND_LIBRARY_DIR_HINT -``` diff --git a/6.x/cmake/Modules/FindCSOUND.cmake b/6.x/cmake/Modules/FindCSOUND.cmake deleted file mode 100644 index d83c0c0..0000000 --- a/6.x/cmake/Modules/FindCSOUND.cmake +++ /dev/null @@ -1,65 +0,0 @@ -# Try to find the Csound library. -# Once done this will define: -# CSOUND_FOUND - System has the Csound library -# CSOUND_INCLUDE_DIRS - The Csound include directories. -# CSOUND_LIBRARIES - The libraries needed to use the Csound library. - -if(APPLE) - find_path(CSOUND_INCLUDE_DIR csound.h - HINTS - "$ENV{HOME}/Library/Frameworks/CsoundLib64.framework/Headers" - "$ENV{HOME}/Library/Frameworks/CsoundLib.framework/Headers" - /Library/Frameworks/CsoundLib64.framework/Headers - /Library/Frameworks/CsoundLib.framework/Headers - ${CSOUND_INCLUDE_DIR_HINT} - ) - - find_path(CSOUND_FRAMEWORK CsoundLib64 - HINTS - "$ENV{HOME}/Library/Frameworks/CsoundLib64.framework" - /Library/Frameworks/CsoundLib64.framework - ${CSOUND_FRAMEWORK_DIR_HINT} - ) - - find_path(CSOUND_FRAMEWORK32 CsoundLib - HINTS - "$ENV{HOME}/Library/Frameworks/CsoundLib64.framework" - "$ENV{HOME}/Library/Frameworks/CsoundLib.framework" - /Library/Frameworks/CsoundLib64.framework - /Library/Frameworks/CsoundLib.framework - ${CSOUND_FRAMEWORK32_DIR_HINT} - ) -else() - find_path(CSOUND_INCLUDE_DIR csound.h - PATH_SUFFIXES csound - HINTS ${CSOUND_INCLUDE_DIR_HINT} - ) -endif() - -if(APPLE) - find_library(CSOUND_LIBRARY - NAMES CsoundLib64 - HINTS - /Library/Frameworks/CsoundLib64.framework/ - "$ENV{HOME}/Library/Frameworks/CsoundLib64.framework" - ${CSOUND_LIBRARY_DIR_HINT} - ) -else() - find_library(CSOUND_LIBRARY - NAMES csound64 csound - HINTS ${CSOUND_LIBRARY_DIR_HINT} - ) -endif() - -include(FindPackageHandleStandardArgs) - -# handle the QUIETLY and REQUIRED arguments and set CSOUND_FOUND to TRUE -# if all listed variables are TRUE -find_package_handle_standard_args(CSOUND - CSOUND_LIBRARY CSOUND_INCLUDE_DIR -) - -mark_as_advanced(CSOUND_INCLUDE_DIR CSOUND_LIBRARY) - -set(CSOUND_INCLUDE_DIRS ${CSOUND_INCLUDE_DIR}) -set(CSOUND_LIBRARIES ${CSOUND_LIBRARY}) diff --git a/6.x/cmake/Modules/FindFAUST.cmake b/6.x/cmake/Modules/FindFAUST.cmake deleted file mode 100644 index d1d329e..0000000 --- a/6.x/cmake/Modules/FindFAUST.cmake +++ /dev/null @@ -1,59 +0,0 @@ -# Find Faust2 -include(FindPackageHandleStandardArgs) - -find_path(FAUST_INCLUDE_DIR faust/dsp/llvm-dsp.h - HINTS - C:/Program Files/Faust/include/ - /opt/lib/faust/architecture/ - /usr/lib/faust/architecture/ - /usr/local/lib/faust/architecture/ - "${FAUST_INCLUDE_DIR_HINT}" -) - -find_library(FAUST_LIBRARY - NAMES - libfaust.so - libfaust.dylib - faust.dll - faust - libfaust - HINTS - "${FAUST_LIB_DIR_HINT}" -) - -find_package_handle_standard_args(FAUST FAUST_INCLUDE_DIR FAUST_LIBRARY) - -if(FAUST_FOUND) - set(FAUST_LIBRARIES ${FAUST_LIBRARY}) - set(FAUST_INCLUDE_DIRS ${FAUST_INCLUDE_DIR}) - - if("${FAUST_LIBRARY}" MATCHES ".*\\.a") - # This is a static build of faust, hence - # we have to add all the LLVM flags... - - find_program(LLVM_CONFIG llvm-config - HINTS - /usr/bin - /usr/local/bin - /usr/local/opt/llvm/bin - ) - - if(NOT LLVM_CONFIG) - message(WARNING "Using a static Faust library requires LLVM tooling to be present in the path.") - UNSET(FAUST_FOUND) - else() - exec_program(${LLVM_CONFIG} ARGS --includedir OUTPUT_VARIABLE LLVM_DIR) - exec_program(${LLVM_CONFIG} ARGS --libs OUTPUT_VARIABLE LLVM_LIBS) - exec_program(${LLVM_CONFIG} ARGS --version OUTPUT_VARIABLE LLVM_VERSION) - exec_program(${LLVM_CONFIG} ARGS --ldflags OUTPUT_VARIABLE LLVM_LDFLAGS) - - set(LLVM_VERSION LLVM_${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR}) - - find_package(OpenSSL REQUIRED) - set(FAUST_LIBRARIES ${FAUST_LIBRARIES} dl ${OPENSSL_LIBRARIES} ncurses z ${LLVM_LDFLAGS} ${LLVM_LIBS} ) - endif() - endif() -else() - set(FAUST_LIBRARIES) - set(FAUST_INCLUDE_DIRS) -endif() diff --git a/6.x/cmake/Modules/FindGMM.cmake b/6.x/cmake/Modules/FindGMM.cmake deleted file mode 100644 index 1b4d359..0000000 --- a/6.x/cmake/Modules/FindGMM.cmake +++ /dev/null @@ -1,20 +0,0 @@ -# Try to find the GMM library. -# Once done this will define: -# GMM_FOUND - System has the GMM library. -# GMM_VERSION -# GMM_INCLUDE_DIR - The GMM include directories. -# GMM_HAS_VECTOR_OSTREAM - Wether GMM defines operator<< for std::vector - -if (GMM_INCLUDE_DIR) - # in cache already - set(GMM_FOUND TRUE) -else (GMM_INCLUDE_DIR) - find_path(GMM_INCLUDE_DIR NAMES gmm/gmm.h - PATHS - ${INCLUDE_INSTALL_DIR} - ${GMM_INCLUDE_PATH} - ) - include(FindPackageHandleStandardArgs) - find_package_handle_standard_args(GMM DEFAULT_MSG GMM_INCLUDE_DIR) - mark_as_advanced(GMM_INCLUDE_DIR) -endif(GMM_INCLUDE_DIR) \ No newline at end of file diff --git a/6.x/installer/macosx/release-build.sh b/6.x/installer/macosx/release-build.sh deleted file mode 100644 index a7af92d..0000000 --- a/6.x/installer/macosx/release-build.sh +++ /dev/null @@ -1,73 +0,0 @@ -#!/bin/sh -# set -x -# directories -export OPVERSION=$2 -export BRANCH_NAME=$1 -echo "Using branch: $BRANCH_NAME" -export RELEASE_DIR=`date +%Y-%m-%d-%H%M%S` -export BASEDIR=`pwd`/$RELEASE_DIR -export INSTALLDIR=Package_Contents -export DMGNAME="Csound6-Plugins-MacOS_x86_64-${OPVERSION}.dmg" - -# build -mkdir $RELEASE_DIR -cd $RELEASE_DIR -export BUILD_DIR=build -mkdir $BUILD_DIR -git clone -b $BRANCH_NAME https://github.com/csound/plugins -cd $BUILD_DIR -cmake ../plugins -DCMAKE_BUILD_TYPE=Release -make - -# zip install - -# image opcodes (LIB_PNG needs to be set correctly) -echo "--- making image zip ---" -cd .. -export IMAGE_DIR=$BUILD_DIR/image -export LIB_PNG=/usr/local/lib/libpng16.16.dylib -cp $IMAGE_DIR/libimage.dylib . -cp $LIB_PNG . -install_name_tool -id libpng16.16.dylib libpng16.16.dylib -install_name_tool -change /usr/local/lib/libpng16.16.dylib libpng16.16.dylib libimage.dylib -mkdir image -mv *.dylib image -zip image.zip image/*.dylib - -# chua -echo "--- making chua zip ---" -export CHUA_DIR=$BUILD_DIR/chua -mkdir chua -cp $CHUA_DIR/libchua.dylib chua -zip chua.zip chua/*.dylib - -# faustcsound -echo "--- making faustcsound zip ---" -export FCS_DIR=$BUILD_DIR/faustcsound -mkdir faustcsound -cp $FCS_DIR/libfaustcsound.dylib faustcsound -zip faustcsound.zip faustcsound/*.dylib - -# python opcodes (python PYVERSION used needs to be set correctly) -echo "--- making py zip ---" -export PYVERSION=3.9 -export PY_ZIP_DIR="python${PYVERSION}-opcodes" -export PY_DIR=$BUILD_DIR/py -mkdir $PY_ZIP_DIR -cp $PY_DIR/libpy.dylib $PY_ZIP_DIR/libpy${PYVERSION}.dylib -zip $PY_ZIP_DIR.zip $PY_ZIP_DIR/*.dylib - -# installer (ALL) -cd $BASEDIR -mkdir -p $INSTALLDIR/tmp/csound - -cp chua/*.dylib $INSTALLDIR/tmp/csound/. -cp faustcsound/*.dylib $INSTALLDIR/tmp/csound/. -cp $PY_ZIP_DIR/*.dylib $INSTALLDIR/tmp/csound/. -cp image/*.dylib $INSTALLDIR/tmp/csound/. - -mkdir dmgsrc -pkgbuild --identifier com.csound.csound6Environment.csoundOps64 --root $INSTALLDIR --version 1 --scripts ../scripts dmgsrc/CsoundPlugins64.pkg -hdiutil create $DMGNAME -srcfolder dmgsrc -fs HFS+ - -open $BASEDIR diff --git a/6.x/installer/macosx/scripts/postinstall b/6.x/installer/macosx/scripts/postinstall deleted file mode 100755 index 3c7469f..0000000 --- a/6.x/installer/macosx/scripts/postinstall +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -set -x -if [ -d "$HOME/Library/csound/6.0/plugins64/" ]; then - mv /tmp/csound/*.dylib $HOME/Library/csound/6.0/plugins64/. -else - mkdir -p $HOME/Library/csound/6.0/plugins64 - mv /tmp/csound/*.dylib $HOME/Library/csound/6.0/plugins64/. -fi -chown -R $USER $HOME/Library/csound - diff --git a/6.x/installer/win64/Installer.iss b/6.x/installer/win64/Installer.iss deleted file mode 100644 index 12763dc..0000000 --- a/6.x/installer/win64/Installer.iss +++ /dev/null @@ -1,104 +0,0 @@ -; Cabbage Installer Script, Copyright Rory Walsh 2017. - -;swap this with plugin name -#define MyAppName "Csound Plugins" -#define Manufacturer "Csound" -#define OPVERSION "1.0" -#define AppMinVersion GetEnv("CSOUND_VERSION") -#define BuildNumber GetEnv("GITHUB_RUN_NUMBER") - -[Setup] -; NOTE: The value of AppId uniquely identifies this application. -; Do not use the same AppId value in installers for other applications. -; (To generate a new GUID, click Tools | Generate GUID inside the IDE.) -AppId={{0E50FA48-4C41-4D27-A742-C77D1A3A3905} -AppName={#MyAppName} -AppVersion={#OPVERSION} -DefaultDirName={localappdata}\csound\6.0\ -DisableDirPage=no -DisableProgramGroupPage=yes -UsePreviousAppDir=no - -;if you want to add a license.. -;LicenseFile= "../LICENSE" - -;swap this with plugin name -OutputBaseFilename=csound6-plugins-win_x86_64-{#AppMinVersion}-{#BuildNumber} - -;to add install icon -;SetupIconFile=icon.ico -Compression=lzma -SolidCompression=yes -ChangesEnvironment=yes - - -[Components] -Name: "core"; Description: "Install all plugins"; Types: full custom; Flags: fixed - -[Languages] -Name: "english"; MessagesFile: "compiler:Default.isl" -Name: "french"; MessagesFile: "compiler:Languages\French.isl" -Name: "german"; MessagesFile: "compiler:Languages\German.isl" -Name: "norwegian"; MessagesFile: "compiler:Languages\Norwegian.isl" - -; add files - dlls go standard location, or one of the users choosing, csd and other reousrce go to program data -[Files] -Source: "..\..\build\src\AbletonLinkOpcodes\Release\ableton_link_opcodes.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\chua\Release\chua.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\image\Release\image.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\py\Release\py.dll"; DestDir: "{app}\plugins64"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\stk\Release\stkops.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\websockets\Release\websocketIO.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; - -; faust -Source: "..\..\build\src\faustcsound\Release\faustcsound.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "C:\Program Files\Faust\lib\faust.dll"; DestDir: "{autopf64}\Csound6_x64\bin\"; Flags: ignoreversion; Components: core; Permissions: users-full; - -; widgets -Source: "..\..\build\src\widgets\Release\virtual.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\widgets\Release\widgets.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; - -; fluidsynth -Source: "..\..\build\src\fluidOpcodes\Release\fluidOpcodes.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\fluidOpcodes\Release\glib-2.0-0.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\fluidOpcodes\Release\iconv-2.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\fluidOpcodes\Release\intl-8.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\fluidOpcodes\Release\libfluidsynth-3.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\fluidOpcodes\Release\pcre2-8.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; - -; hdf5 -Source: "..\..\build\src\hdf5\Release\hdf5ops.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; -Source: "..\..\build\src\hdf5\Release\zlib1.dll"; DestDir: "{app}\plugins64\"; Flags: ignoreversion; Components: core; Permissions: users-full; - -[Tasks] -;Name: modifypath; Description: &Add application directory to your PATH environment variable (recommended); - -[Code] -var - NewPage: TWizardPage; - -const - installerMessage = -'This installer will install the Python, Faust, Image, Chua and Ableton Link ' + #13#10 + -'plugin opcodes for Csound.' + #13#10 + #13#10 + -'Opcodes will be installed to C:\Users\\AppData\Local\csound\6.0\plugins64' + #13#10 + -'' + #13#10 + -'Csound should detect and load these plugins whenever it runs. The Faust library will' + #13#10 + -'be installed to C:/Program Files/Csound_x64/bin. If you do not have Csound installed' + #13#10 + -'at this location, please move the faust.dll file after installation'; - - -procedure InitializeWizard(); -var - DescLabel: TNewStaticText ; -begin - NewPage := CreateCustomPage(wpWelcome, 'Csound Plugins Installer', - '') - DescLabel := TNewStaticText .Create(NewPage); - DescLabel.AutoSize := True - DescLabel.Width := NewPage.SurfaceWidth; - DescLabel.WordWrap := True - DescLabel.Parent := NewPage.Surface; - DescLabel.Caption := installerMessage; -end; - diff --git a/6.x/installer/win64/Output/Csound6-Plugins-Windows_x86_64-1.0.exe b/6.x/installer/win64/Output/Csound6-Plugins-Windows_x86_64-1.0.exe deleted file mode 100644 index c5843b82ee15a7704a48b32fa1bc8ef4df763894..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9487217 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�WT8e#AO~`qrPT$P*wCX7jO%cK;}eALv*;*m_$e*+{ybQ`pFT)!YCbF>sGlXi^ zSX_mBG43Gl7Tg`UH{kX^Q|7z3J*9oFw`ZDvYncyj9r>fc|Jz8yx&9}k38xs5_+#;C z0_`Z%(Q;XEQaM5s*cfuZPl2;K;{K7l4G&(xjr9e(K@(a$VQV1nOs36`gm$*U`z>gL8D<$h{O8aUz*x?Rl_2l@U zk$L>Tm4Pat|8_y%jx$_R$95{2`>an^F~aZ^B(YzFQd>BHeGjs4F#8x}r*3N9c~GLX zOXXiIQ9>UNjRI_{z2b~^%#Ug@YS-ey*E7525^tywNbbGQLedxX1I?VCGv6roy*WAW zM?L4ftshPs07$09;hk^cOAg5Y=D0j8M4rlE z?=ts1p$wlc^DCIYn8)ri&yGa(SW*9i*OB$XPh&-W;}y8yDptwE zH-Qus&m;gLel3$SLm7C!6VFDWR{~!o3i}s!QPqou7&j45J63sL`XY+|Lip9-4`@&BDDxU4Y0H?&f00q<)jiZ% z7$%mjd2@9cOg;4eGMIX0S+LwQI_CIbp1)}J-3}{yRlf*c3NWN_N~o}PwNC^ug0?V3 zdsh|kUkvqkWqWeZm_u)(zxKmswub57e~L;X!*rR~T>GBvp77^dIJ2L_JFeVxZ3@c?KAr&3Kjr! zn8dJZ$%Xr@0Sy=}bYL_B7>({3LyYciFYRrwI@ps(tgIi$0we1gvj-|gnG52ZqX5zE zd*|PQ3dZzfU&mGg+!eTQ#r-1g`*FX!wD*mLdw&!T?d>StXMW>OdM)Ye)C3-eF5SHe zAdv6vgD{b7xhi`;G20uf-fnRrlbCVrc3#s>@PEr16KG?j!UtW^5O-sTtRXkPK6!gHBU}>H4xJX%NryR$WeS?8VMao0m0}*&MSh~)5LZn=0r|iv? zYJJgSpL;<^*z`YIk54i0jX0k=VtIgZOE;<5cDu6s&nv=IOw4#Y1p4hgD;}$its@o_@>|+4g?~ z@gx{y57eMwjmRT=SAW!8qGf2m<4>ZaTK**Qjx{ybGGD-CiJzY3Q?qfWh;21~k1*7* z>VA~{Taz_}ej?=z#|rM(vBrwexU{q|T~9MM9H8=0ehs?W6Y}TiZGj_6c)T8u`6*)U zylZ}nSUbf_aRBvibgE=v|`W=u!jbz4TAP4nhH`@L~7*87qqL@wq zhGib3Bf<&!JF`{=j#Mo44Ek4FrE9Z@OD zsZIYfc^ty@8gd^DdK|ZY2h#zV``wQUwSVE>`!VcPpA>3+J}uNnd?xHweI2Ri$<#k0 z<#9-P9_|Ua@4)>>+~Ec3!N5V|x+*f-L3`9V2fW)b0C_RJ0rfxX%3*7VF;%47VW&%D zx=b^j8s1(ori*l3f>Q$O6YxO8K}b;vPmXPCjWr^jV;J1XbX#P)y&da81II{siAe1j z32T}99;8MiU3i~OBG?T{qHj^bRFLK(+*5Jihr13pW@;ZiJRPItL*c(NkmI2-aVa~G zd-UwV5_%Kdf=tq?riA0{B$1Lo?Hc}whHs#t0d#YquNlPD5-xw*so!PlJrGVJwH)hf za+$hDz~)ao^-c2ZQA?_QJ~GS2MV<_aF4^i z68EdP|BHLyjghozV#odEZKMr<+9e#r60!jfc|Ll0C*Facdk}>G$_FXwjB`a!A@nS6 zcn>_@@IIznSsM$pOH9&kLMEfHNY0;jLBD76r;r>4ee$wLK@@GqNRd-WIjf-Q%t?P8 z$hp_WPBqJ!=g<;Xi$Cqs1~AWsoC|I<4&G}Mt~;VYxMApL6LH^*`(@mXxI3ZWeG)~u zc`PASl)#^M3A?bQEOyNykJ-6u#xu2Fq~=dM^*W~h0|qvcT6VFT0;cwf)ck3uzL}|S zMQW3(J(;qfNXege%8^VtTEdN>O*ZrFTuj>Vr=6!W^PGY_piTWfHf=IkU|!7>&|x9& zXGjm++33GRa0Bzb17&A!{eYsRrUh1C<4fQfT+N?$2`{ck34eo>bmWoZr{)0jd?xbn zr=8~x=Aqfnkw?*~o_RhLdHB=Lb2;)fj&o#CeQ*OaB#El?r=8&xW;oNN>KZ2dvw+K= zcCy1TQaIG@S5f<5jYuK}%FP`)$}hnftP}wmo66W5M68fMj@Z$N4K*xXfzmB~NmKgw z?OU7BJlI0EuXa*v?WC64NzJvRnxx*_q($y_ahK1^@zp7 z6M7S`lrw5Pt0EA)yMjMFLAU;Fj*F$@>45FD7_ zbX!{geGNr`8>}Hg^wJioP5ogl@&rsu+)Hh#UM1OWlza`9tRpi)r7LYUwm^AB;u1-> z@y2yBxzP9WnD$ek;l$`xs4GyJU@($9BZrq04WaE@Wp)9O5+pKSCn~$IHa`3ckhrNx zuV{7FWDJFh%w}lO-!Z;?LSUsDa|gC&%308EVHU(;F+%jq@QiEB8kWuq*G)xl=1S{|6<}v-m`;2QB;SKEdPW?&Lw_g7zm}&~p zQESgm`;mLL`7!o<2Qg0!8M$a9y~6 zCZbsn8xImT9I{L1+@yLdm%StAxl>Ux%6qNW2i572@#At7*Jb`W&mYK*+U40g zTIqq$py)P<66J=_a~NBVSmRWnsJAqB($n($RrsGzYRu8obj?T;(J(WnRR2<|_zdmP z16xCx>l9L6$RJYVDup1Y-d$j>d>(o=bXuY)Xv1}hs8%lqdU}7*=P}Zy1RIC1EWy+L z;we)vNY96rx}sygKX1bLtmi5#J(skICSK3w>;I#8pjE9& z(4ZMKn0S{>gZJ?oG}wu{8n}mjiSJ);Zzygh9ZZq#c0F=HPbTA!~5U2eta#Y4hB6<23OU#d9?P-{_w(e#uf7 zzil)AQ)B1eW_&81tlS+0$1XTqfl{ z%k2cCkia4AF9ZdHf#tGmY{oQ3GyVzUh8j|q0nq1GkC*EOo4eU?!ODwm2w39&;`XlN!6iJ|O=e+~<6Sy&Slo z!+iud`&8+n+Ccs7UjpB%+R`1L%&y;`vIQu8Flj4nwp-bBQ*MfAy7R!bat07P|3{P7 zA^+3iigm%jdSj#jvEHWcf56!dhebD!iGn#x46HB)iTo?<{LeD~i}CY+vcy86rkvBj zO9^E)f7*bi5zy@TfcAFW3W}H$?V4){Yu7x&;!hja$%J*f*&?=ZdgTtgMX-OLEi(J- zLhW|k&*DCS`xq2(A#PZ$P0H64v79gFvK;=j%Xtor*FdcgsXv-j4?6D%SJVe%r*Cg=!_}1qchg) zLz41`q}(g)`z6)qcd3?pBGTMIv3hZA1j$ayfd)Kv6C`xK{_y3=1izLC)*0Ztt1ze zuO{d=zl5%2(OcOacgV@rj@n5(YbP~ve#Kcms9(V1Po#yx76l&eRmG?M=H{f1~`!3uM z;{FrvI^6qkH{z~tIbms!tYyQIyV~fOwTye;s*U9GYlmkoI|;uLoQj}fk%-U9TGmTO z4nWYS5rtvLL4ySRYasRB3q{5oaZpXXm}1+V9Uy0<5a$HLb>6JRu$EYQ6IUY1~cj{S5#nn zlGd;hQS2o6da33#@u!s_yD+D$>kk#0_7xBj_ARGBWt~(VQLY2z7 z$LN3wGC6K9IPM#avyNRke+Rn&=1ZI!8}HreR(UmNH)AU`(%g)21@3464?7hR zc0BH#9gh@@EuAy>7#J?$`aOK#1B7(8}39wVk5~jGm^CBfrf1X z18ZAN!BWHc%MrYvCf*xw{Da2(mb0+C1^WVwq5H$(k0u>>=%c^^Lh8blgJsI+k&;%8 z$13WN9`^ZR{fSwoanzB{w8tPDChg zwfq!rycrVhbd z>MyOv^WP(~OR$u?>bigwdMTE(n~YrGEm-pkd|!yYg%#lC^^j3UHw=E_=N6;$OsYj& zbj-n|M%x9P+t@W&x{46Gi?^%nw?BeI9mC#6@If%JN^xG!Z^*vujr6qyzeUCVghjw$ zV2|*lc@)isgR)cHHq_vmG&bPlI;T@jbEJH<3$ML(s0Sb}0w1!Lml< zWzsg(9Gk0_oHwpQr3&d-?;0fV9si7H9phtdI#)6?}v9gMupv|Jx3a;J&Lj6Vqt;15!NJoW`^BO z_%=Z^{yq_$qBaL%yPkn*bvUU%HXDuB_sDtOC)9>vcfsB-EADM~oG4`@;<7d};Yy~1 z?9`0M8TTUNw2~jNr0BcoT*mV{4)+V#i0J$pozGw|?u(m=%~xWhE?e{`s9arAGB+Ly z+6X#41@&IhLEoA6Vn*^?L-g19P4fr(Te}VY?UzV_-Jf0B?RBvq8N-n7uPJ)?GA*Rl z0}1EV+=}TC;(8(EH3A`ht37&4;=a`i2Ew1(fPl7hdXYBv{D3y=0(`xMupII7O2*e< z=N4#rcyfIWH}$k4;o0mM@rm5nxtC9#U4|N#Tu>z3njKTjh_Q3|wHYg(tc?SD{QPYR z!b{;FWrGOu*$DidTv;}GmU7_ILnBVnpK~=Kx%IW1PwOwxw2rh-7Dw9i!zx$00v>eF zkHG2m0LD!~PKVEfsl+N-qg$D%EIxjhkfa?uWHgT=m^Pzqs;rq$Bfa65#DObYgpOsr zy(U!tDBA_E#kJ}u`Mgrazlacx-~P z#fK2`6VLYe18N;q?e9R6js6`%_OO%j#1Bfxs!&(qD=KVOA$s&!I$$c9J9k!htqy3r zzA+^q3;;bGy$;`6B2{$fj7WBowr41kfnD4k&6P}jIqCi&^#ZLWft>t;1qX=^DV#NV z!2)(|>8#F!+gv5Oq=7uyj^BeSaxO>~O+&VJ=VF7|GDIAs7cE0vSz_}j`76z)I$18Z zClFA6I?_j+TLqHxgXF#?q%D7$Cs-{gpFd;H4dT2f4kGN0g7GMRH(gtd|JZvdz5SW* ztg~M{&#z)t6-S87@TfpI>ijBEN$2@hIliK!IKQf`>WKPG1sO1&h8Ze{Ui|6P_M=Sa zRhcZG532ZY5wbhAr~gL!Pagr8>`p$-It!_Mu62x9+h-xQS;Lqf*ULq1EGdk7uzvP= zMgLngNXtaLe#5~=il4+MW3d@<{ltGtd8@+Ds&LqJ39D5hvGZD=BtGv#yYO4d-=U16> zi|l|_m4hCCJI}EaGKg`uEMt00mJyprfs5xkR*B(aonw^^I21e#<2ifedzRZdtw_u2 z74sacsM3$_L@V?!l#|{s{uxoxg~6*s>X> z=#P+eybhrpKdj0-gljZCduW6hJshkOxLV}&9u7!z;myOH_&kl+*~7s>_8Uk-7t8|2 zTEl@x+Su(C7iE$)k@hmhyEZ)2-3~<^i_o!(wA)quZxLpLnmtjSM18xHk27z?{1vyn z&|zp=@Z%|wGq65Hp`8140y44#c%6w9)nE}ibKkM>nd@}r-xc^oOon{v1t`Os3}p~Y zuQRZ&LspMdK3thORA{81=lMqM#Fp(MyKTG?it3r~WfUp(Hg>$0nUd%+^tM6Ay4!nt zR*_bKxEU(`E`&6nPX{9<+TQFXD^TnKRkTnVz1lnS46L_M7~44oNU)vHLnu4wQMb44 zaz9^N1$?5~dn(FktG)YZJCQZg(={8LJ=z6<{&QLH=pOA#=IYU;`O));T|>5|lpAgG z$fqb$@(3*s%TzzZsgk8DxTQ&l)0VS8nB>!w_=3@}mZc$}jS!HV5MsZh5tH zyjp=mDaW=WluYe)Mp4@%fbj6;8nJ*;lmu%MRaGq*d&ELkj}gn28Pz2HJkJ_xH@0jU z*)Q9aMsstVJ?y~jxFeRP9YS*Fm3tzHjkr@f$@qMP9JBg?mlADrc8+osT(1gGc+9Fo zVQlNaA!J({2xVvd8EtOM^n7hGFp6sPuBdX`qt+&5jU2Vu;OxpS2pqLo^XRVZO6Km$ z8tMLXc*U+ITT}{-HhJYC6l#xLvs80=j$An>x%ni!bCK2+aidiH6oixw%V2Ctlusxd zcAzUAI9l286bdE3e1=fU2CtKz+U{+U=TaG7q9GGCZi`KNYQ5)riUwC^Dzl`Y=ebnv z#g+{t&7N&G_uVK{HaCrsYZTSp&21VX{lBo=I|sj~LwWCu@EaBX+mnmL+G$VNyb^8i zP16F}y0U<_VR}GYk8mq)=?|V1SqqDhA7KtGHIz8=!uW2!aQlVlz;FA7H!~%8F4ba` zL651C=TZ&A+%OmMSWJpImx>x^Pw@s5AG@;warWxocoXAXs<%NX@~FRy3@=t;tqMab z%2&j*v3+dG&k%p%3s+6SFbk z<#{euTU>adwjYfbB}zFlvHD1R&ZTl?%wTIqpG%bk_HmU+r>m}v9wiD`37$*kf|WsA zbE4-`wVBfsjUF0%M6?>|f=2JE%}C}vtRSM=!ggpL+ap$)oJT0dIG4&@2xqqz1PyK) zu#)9Imx>~TN1w#bS0Y!Km_}(bQmBa^&XC9Vz%z=?qpPP#uQeF<+)U(eteb@J0N^&yNTqww5TJhT-e3ub=X#b zlIIy!ZAml^cyf6u{y2&=s(iU(96dt@Lu7Eh3~FTXj0{Nq_MB10QKlYE#LGP{i!-V? z)EJ(x)frW47>svDl^XimIHO7pgyCG+=-r4!oKdwG6^&SLmy=}EU>HSr*Lu6CDMx>0 z4zSj!AdjdFSZh=XueXEeto3#Pajv&7JN;ARQ!o}Zf_eE%#(JesR(IjnhhAVGp$0%wt5YroZ4D# z<}l#2z24qtn_*iZijGz;no+Q&qQyEzo$X2iACdSxjn%Qok1BL1F0ix3@*i==F9#`6cFhJ7o~wo9pcmLu4OImWlaa_ZaK#iQ!_c zw^yM~6g&*$4P1QBa`&TL=e4&7)y`i1h zvRx9i@QvMF6$m?e)K$I*N|UKVBdF91eSTw;i-wj~voA*+W} zaAig{Nk30pZo9E%%Oto`eM4`v#W@4+s>tqcaZ4)Tpi(4vUY+|EX@?NksgI2BkC1Yq zy=&DQAUOS2o1^$dgBoO}@6tYb3})mD`pK&Bz)l8Q9>I z3@!+i46L~=8O;4Bu4Jy&YV3al5{_x#6I`*rABEa>|EEzyUT$7d(joI4H=m^U zE7Ech7f|sN5mGiZL+MM@4$S#W6DZ}sBKT+(q`*6_0X(5DE3U5(iNQEiq%l8+na1lbv&}Y>1UW7it&lDPOEW3YOTzH{& z4H_@1k5I^4eZ<2G@6#?6w!!!rGuWEZcK=n8CDQKSR*3>uf_8rwtPDH-<{M+i`+)vKO!es!EN`a=(QCS({AI+<+9uK(Pkk>q~62P%%eF6MB4p@!NV8P>dpr8 zDOQU%_PbD0pM}ZK7NXihj7^@l{Ym91Y5eerDlYPf5|)~^P?Hf{Ylcf&mL@Uye<5jc+W z!#Dl8_+S+NJv0qxr|8@88F`k`^=#JxhCFc_d2t^47`zbvQH%YSYfRlxN27;z9M9t4 zWW3U?H9QPQqvLE9<2n3RhXMW;KgAL0+l&`bx;P>o(q;UG_^D#ddB+oGJfq?1YD|d2XW8FttJAlBG(|E z^FdzgL7Tk%BJF9!nOE<@@^??f^D0Kj?||EL#;m!nLCfk)jrKb7ASr5}tJzQH44ZZ`!GK5FPlyWnV9K)>WC#EK+_Z0Lo4GjEfIZ5-6ESpviRfA6$WUicX!*o3QG}1CH zk!rFL7^;pD_F_9?Hzw<>+V>Mb}H z3eJFW*wnn%%WDoV?pxe{pE!D|1*Z%SUc>VTcn}qybpIOT5GD)x!~9vx=!v-S@``_m zmprHnhhD+W3!SXtR89Oa;FXnrUn-gj^(qspN-7{<;>=9w_ekhGK^*B+QoK+InlU(Y zCudEgAH}bS3o)(Yd8@oHSC?Dvm=+etK*yN6N<;_t;7} z_2t3aX&X*9QcuL;tBf_aU<{~!3%=ER!0X7a(&^t9u&nc@)}EoCqTx(My^C@CE$}NM z8m^!Zh8^y?k@mAdiXq}H%eejXecP6DU1rRmuOXP@F&+T*A9Mg?%} zQ;G2^6`#Q237qb<2)8VHCjsizYk<*KoXE)Ym=q3x)guzt?yiH$WP|`yTyDs z(+n=EttS5%L^8@M!5gKm`9m|yPcEf=p`G)jK)%3|2mWm=1-~q(hnNH)p$xUC+WQ( z7A05j(%@M~?|Q#JF*pC?g?|0@MxXwc{$8)0moDA!%#*(pXTSkq*E?_k7}{=px`pX& zC{Z}x5t#lN&U!)(b$y5_9ar%r6zM}&d9S3eaGqIxBAD?);HCrle;OC$X`1lU^SWP? zbsIefzMwXJ{e-CH2hX%MwnwMX0)*+)9zb52V_rqb zb$Ct77)v)EW9QyjHmAGRxyZwphat*WV>ZuCC$Q*gdqgsccbWq{@sB;yC|{Q?rfz-b zsjcDVrANTVQN3$HXR~)Xh2l5arcit;PYT5@XGqswAD~v!(Np!s2ZVe*1@d((+`bt7 zn#1A88Mi&+uvR%hgJ;fGqY_Dkd^LxsQLRl` zf62gDl|QtlA`M9}ux48|n21uC?JQ&qHT(+$VPg}>Yw{6?AN+A}7lVIVsWB1V>uL*E zxZY|)an*IL#y!u|xz^t44L`z(B2Z5F~KoO%v#WD>^xSSJ^{RwhT@#eS;2bNOkQplj{0U`X|vY&RTIibo^n^>HNRrDeKwBS2zldJ~``-RJUYh-SsGxW}Kr@KMWf!@@n=X z@N?%!ir{X9zN8747HLh0e`a`*_RA4P+7q~w5T}}9W%ZJk^zm4OF(+(fErZ9r)%+Rs zPt-@H>m7pr*OX_w3x=UB7g~tS>jqsig|@7U{#N8fM3yisRJP-T{?`>T`hgg9=Dt$b zCKylY@O^rYm8B=M$aIb}jUNk{B^X#a!Fc^{xFMb0;;#<0`Wt?LFo;C`I-)+dnyB-q z1B^m_aWPOY3Dyk9+Y+nfKcB&piIj0tPq?CkXTAf*YEmF@;4euNj1%u7MCOTxcs3wf zI0=`elB-t+Yx=ng86gTOT`BwgQ~w39(t6_)A{(e@DI4x&Da;gI%GQ9R6pF!MO=lPM z#?w)SQpD2Z^bf7*Nb+~Ebc0ddiEbx1u#AzS3}%fk<2sblunxQ*tkD3)CeOVJb}N(* z<9fo@Yxp}@y2g0CA7QT{?4}yx&#cj~{eazgnMrUmaOYY${tT=-3wnXc(LGoW^SXJa zb%^Ad)(OUI%OR5jtC9k(g;!+Nd;?T0ag&Db6%=S0OQEC5Iw-Dt2@oW~WW;863Zv^# zc45^`H~SgY0a2lb3(f?x&r2Ooo)xd=4OE(-yw#RAVMfG0eaPz5LUC&5*{`{9_IMH* zbHEx%Db%zloJ&{u^^Y5GD%6*>ila3CD zAsY^OElzlc1iaG$uO$Lri-I>1@cQqwsPi4E15%5^HbYe4Y<3VO)NolI>S}xL7dk5Z zSzpCD(oXoo*Wtp}P-Oh=FQp{Q9c4+fkn!=K&?HUprRl?QJMT;8z6Xce>7ABci+UxW zfO^rb^@~VX3-K8;>X@TNPp%Cd%-Xm;DOoQ)05_b!;cx>toWfb=R78|PBdQHxv`)uq zm^+~Gg0_S7zz(>6+*y*f@m(E9(QPv>`+@8j*jXFcUki81I5v>D$kTr=9|zn^^ig}^ z&=%zm-bMGk2G00CwJ)X+_Ce=8P#@tuv-59&@#!UG3;0B`S*~)KRft-tRs!uX)k_X0Om^~RC zNO9Bq7G3izT5s+Ng}>Ff5oEbqoc(+Pe2ddVIOgPaexv`kpFl*UTeugqVZF5Zu`OFr zz;t-pv>N>*z~f0RCu9-p$OTU6! z)&5?Dv{!ZkOwKEYA|xH>B9vQLtjaq!zedp$yLAC5dTy~!plXrR`-^hYoXav1iLqOk zFfH#`>?qs;=}K0>SknlKnvgbjd&NVUR86G4r2SDFjs31Y#?mNnTDqf%(0B6u`I8sT zoi^65S_`9Tm@OP{m4@#jcCQ2ctTUqQ^-*PT1t98*X+4$3^eup$eolPMrFhpYE!=@81BzSBoa%B^|K-#3W10T{>%ISD5A+`>^ z4A64x5V`9GML4L*ysCIR{1y%>wcBhse)mR|CLnxV#do+$?wF~BUOu;c z#frcmv^O5cxgF%O$Gm2+0!1qox_}B7tMCmKo_?Kte;Gm!eM{8y9})UMp93oNYp2HVJKePv zXz7Ull9bLKV)Ym9DB2pG%I8j%!G@3AQFM{$SrOnPGjfoO+6B}@BRfWq(h-;y2rf+t z%%4Bk+5-dL6qh-atKATz7Tf@)8+#nbFn`hH^2zLM1p>ji`L(Y7#nvCs{O4&afu`Iz zB&Ato?bw-}8$P3=D*rt)Ld^fvNkRASIb(y(Yc zYgXBm@)>jIv?DJYA}X(3WlbG1XF=I~EY(VEvB>J=5U~vnl~ht(43EyOJXec4A0uHn zs-3O*;{p;?@M#tmL^pbYOIv2$ss&Dp(_J!~&r*kS}DW)GNzo&%GI(m>2_(6eVTIO!Dhv znK6P;f(vZU*EYbP668bCjQKWWDg=tkW|fu4>IxCe<->r$;rbYv$-zyrnksdOsa+6H zu+tEWe@01Afy(mvlc%UpsoC?QKqXQc>9spe0ZY~-pvYG6mIobFt|91Rp82AvFkGOX z9;loGhxxV~iD(3s4c!;|)wz&=iUi{MJo12q;~ynBAYSiIFRYmFCS>~MWeZh|PdiiK zlTtim{sOBGQCzAxdF13cX%wJ{ZH=xz=+m%_1Rh8YRL+|`XDajqNFz?mB2rx-X=H8y zMCTC-XIo988d6m4ifM`V3&l$+*U#)2a^O6MglZ=m7&y5r=E}00%jPez`cxEYR7;GR zYYX+LG?ILNXPQXTanMiFI-p0%&0FLsxdSwF=!`j&=Pw$A&8btSo0N~>PSvZ_Oe$CM zra6lEv};6FJOE`zjvH|S3C$#Oe{vju7!gc#o=}LR=k~5-uDQLp>41|74<1#_W_fZ* ztoH|GD@QqSa3K{TGX#;G!!mk1=M8CX=!l$aNJB>aIZTS?`y;@C1^zCBuVj#Uy@)(V z22_U5)_Or%z!p3lkibSCv^by*$L*f%q!&(}H+jm8@lmvR_zr~2>*Acu9!j73f1#@o1@#625xX-|S9d2IJ5auFm&w4!P;P$s4onOM~ z$$&s36le4DLdP^;beM(?J8Q-*VisqnO1XLRtO_2IQ;DynmOQdT|o^1ZqDgLZ0e{%GP-2KJGN9Z=7~)~*)dmtsfJiL@vW%T_k)|6YJ)p?Pe& z$jwiB%Mp*wPaVEFqBcLh>PIVM8N9zwt{dF$E~bmCnEOzS@#~H#%a5}3VL8*P2l*;` z1uZ;k2N6o`FdVXFn$vGalrf2Uc7mp`sINyu8O`4xu@G<^_*t5G3c}b-No2(7<9t&PK&{QnC>ueJ;-*$c;u79dLwL>MGQ*NzVrdmyE$4rstCMZQ*S4SaPrJV6xhw z_716sQHB8A+1Ra-+K;6J+E)NBoB4IW*Pf?55ZT=GgmtOWW6bS3|NP+yw(Fq1xe1~) zvvy3jo?Sb}Uwc_*&70+!I*!fliX9a*a0Ip}m`JDi+`U2`SB2osAHhA=L2eG|=Nq$G(@Y%|{&jUd{*h6M32-_Vn|FQ?b7>8!NJM zB`$w}$(e;YqHjw+5o>weAGZ%@_?onP=)WfID$qWq(<^6~cFqb`7&gT z&(O5NnH8tv=Y{xLo62=uoDYwcYHU>u7Ume|UFPUdO96@fDFuMzK!% zi++X{5dB6iude$))Y9xrdZz(p5NRvjaXA6REq2FM&O_XE6({O!D0y*6>b6*b&Fc@2W=r@tVdGA)^bmzHL}R)>=}`X16{*_--z7Dkj?FE8?6u>Q)_8*c ze(fX!r>q;t^!X9nQ?phDzN=dDomQTLt)Gp3h5;ISK-7lg{3XqcenubK7hRPI>@iS|AmixK5n@5~2XbpL*ZZzwrf71Uj5I(jTHN70iIRVfr%=P=7)vb)k24%0&phijYgWSbYGS>zV$`d| zQLim*fXjhKBK3OZ1V_CV02@&+0b)DK5{)HF-i)VE!`sQOdd1|$%VwMPvUsug&*8E7ELJfy7o;!Kb*>|@>QL_53aW({q@!t{-dl;`& zI?PqvDNzaGoMA0+%=g{+hYJy0V( zR~=)r3l+7ykto!#79+8fo}zwYzX}944q)HIbJuzLdNWj9Dh-rl3+FlOx{dNGm;2uh z>OPQc9R(J%iN)c@k(6lu4PpxpHlG}l(rw9}{3DcS|DtpYL%Qt~Pn2%EYnSZA1{9-D zPep-$RW11!eBFivMloPvmrM1MgW_X~gX&|7gZUK)7q4OAa_`Tx*!Wz%#Lz0BNkGdJ z*gS-|hE33FAvjAAt+oh?cN2RHS){6fZxqZb{1KT@g$dL^R26W-tXYK}vI_fLRoLgO z!pt733j3;-?9$3V~; zyKe*avAf22qXV0BkMXhyA?uiQGmWywefU-Y`@b=)H~vFvH|ztR@@?czW?Qx?w?|e$ zzMX?Dzg}{?$RXbZ&U1isBJ%BeoDXi*Z49untNm}3CFGkZ`2#$K8XBSNIOI0;S#jKY z$hZg_myDzzvH1sz>{gufzPdF@qqgcjUKPzxxZaPl-WQzhUGL$JdRJ1e-wZSpsrT2% zI_iBHuo3kZApV20M7>4HpW-Rh@ZFEDddHMQ-4>YjvgCTtpCgB!$~!7KBjQ9Y5!C#sjj>N#`_%wM1n$gX<;Tb-p`7jYuj4tJaw<~O33_vW!?}Jl-%}6{#)z*@RDMS< z%)}ArgThy3R$ro3oNFmGI9i(@Mr{kU9tR0kGE>t#8u+vclg1a$2D{`h{V{AD#>C3% z1BCzzUNAm~+7)Uzf=Pk3%S^B1I3)Tp1~g)DpM^mXpKu5iI)}$(a_4#0>N>}syaxo- zR^wg)^$7u0=M*HQt;4J1`ivF6<*ZFQt|$BB)Z!Usv!-5h2`NRIV|El?URY@QzGM`Z zdpU7?0KwX1~N>x)CKS5^BkC3o4@kb>z*`RtA){<@jB+ut<9l;YTXI5n*q7W@b#o*}C&5(_~73si@qg0H39uEWVM(+G_daIaA7H1BkzhM2paDKC7+pj&)3n@tX8_ z;j-v9z^=^>U|BB30Dvsi%lK_#VUKIjKMm7hFtg!E7=|TjZ>dPvm*8{6(&_Jjr=|3* zU4nV@A-xlOlkxKBN5U{0bzn>Zj6r-=G7h#;VOO}|YhhQ|n~JYHHfqVKG!})7H}Po9 z`adWSsd{RDpc!9l0AD?|wy>*SfIY|9jIGrc=IVuAvtBH~{^`Ozr9YBW4Ssh8ov3!w zAsG535`!cX$;7O%Yjs_E0U#IVxxYbKJYd-NKobhWr?&VYv(p~1DKuQ;*+allJQ+EF zqmRkcVPE#&9S$^IQL)Dfrl#(;B0TH%u5~^YZEEGrJM-y+^6u`pS6mf=`gNxZ)PvAT zw;6gPtttksD*G>VXq^85p|R21covbNh8Zw(IIJq&4YyTAS<})r`hK9XR4>jG`>j)| z8~u8h%f?)V2q*PA0tI9eW1}pKpwq`N@ z<5Lotp8A0Nb;lFe(&-_{Ldg#_5{X0{zz6A*U}z4sShUX%m7k<{T)$2X!s#4@Z&`>z z_$Jg#<}!ZwdtrG@DpXKF%zn%2Dv}DvKyPt=Ty%P_ARlH9HRZsGAuHg@mQ^#526%}N zAoX5Wm$mF3R0uUN24BhgFi&tveg8UH(P!+$IWQ=f*6SjLF$SNJvZ9YHHY-|n#8=); z7i9KPqae&DAWT>xrflXHEn!odpILniYfq?Q&39_+4 zXhRH)khB+)@>`g>B@(Cp04#~`jT6i{0;kJj;j}@u=CuMRzraba$Smep@|P6%59<%J z?H!aUan(EXburJ}r0+JaD?&n1?P1lS&X-rbZD&F&X4RxbHb?m_!6j>ARJC-CBL4eV z$cmnLo1>x?r?`+H@z3oGBQ-z z_q9=Wl`8v-?5MJ<6nVoPS@sh!ZQ#>jizmDORA2E6`!O%;)jD190KYZvXus$wmKb(l z>}-h6=vag8B%O^75MO86Es*b?MRVQGT-K#22s_`*}nPcoq)8rS0~ z)KK08g1zIAZ6pMd%!ORYF#a?c6N`Q>8DCKE|nQ^leCT%s;M#B*378 zC}E>AeowNE$(74Ct6x|4E3N}Tp%2;f-4l_|_|w<+eD{g3)O=U2&2YXmj<5>5(hrYl zxX<`3#YYjJPI{WR_uaF^iyL4?@|%b8Y}otY(9>F)@gr|@$$d&oFQ zxrgsE-_|=dW6Fa8|5&~d55_b5p<+Q(NlUlZOGW~qbG-!IFIKE1FZ~A4vNjg@#m8?i zi4OpO1qp5O+Rb=>xWMl(?~kHqI1~5ZWeh~h-bwS*%QJqeFVASq+~8{*xgoi6_=fbx zBH3Y#^JRWtc}L_wOFkr(=YXBr?L=SN;BP!}LrUZE&bWyFB~$0f{wCI~uy%?_=mmc2 z99S6>;N+U7_?>Ini;d?%ebh14>YMUe)fw|9&A4%)U1vg~p70A`yig^bR(&94T6IfO zxex^G`Km9DLjpk`u5FEQ0tS6L0qS61)+!-841Ac(r0N-K6#~zm0#A3H(q)~*TE^(j zzd%0Mch`w%Q}a7WZR%C@LQieVp-Exkb7=nSk=j)6InbuMaf$LnCE724fTF!3OFd2z zkL7KvSFgkG3lwWptztL}B5YgD4fvnL$LW-4_E5v&y))WH74-fZmYcO~9oQ$hnpq+9 z|B_@JK7v`f08;fbL22a~Ca}hHsR)h2x5*NC^~)?mD?eUeEy_B+cBe$55lffymx7VC ztP1pwuf`DtW5qD3Nld%bq_9$%gwhqQ#&t%EgoOrZ4PRd&tF6ZM!a8TD;XO=}pvEnU zrL>i9&;_}SEyc3@FWM;IRN2;Gq1>~4Q)PQb*px=g@>h>U9kX5()HU8jQ9%(SwJ0j7 zqoAakU%p>#fo{k}8>wb1{H@Rg7PBQnfFM;;(#~$`oWVl#jUd?pr2u^n6Qe{qxOxEc zZAdaM5vcIN8%;}ajgZjv4{{32acvP zoh>NUFOvvb`5;B8U27qMg4m9x@6<)lFslB^$!`VbH)1S8|r>xXE@gEP@1e~pP+ zTMD&VR7BRMA3=7tXJ}*oK@iu32H~v|vMA zo7D4475)Yx)!g(Ew!P4J6#n+Ei)|04y>QiI(jNTuT4@j7kFXhc`on;SyY6?;!STEX z_YT}mNYAUI*43pbn|5twtQGjB#ZAH*9RjwIR#&L8NAOCju~TOiYll>k=#spucw6Sy z@}Qe8JJj>jD*Q9TqoGTSgDy}1zDR3}E~}7+S4Zt6Pr3vuVZH<|X|Z0jA~DF3agRxk z>t+{g>r_de0SH!tYhM zd8KQ=aMfL`^(clQ9%->(6K$>oMKS}pAnRUH`+hP&ioENJwWm=uFHa(5UXN+FcLJEB z%jT3L<9dK|UWe544i)Y~crs;z2II9g(2e>fT*t9qH7S|shIHB z7WTAebvGlUb5^J3bV8<8-P#)t7XhFHb!cuf%?3cuDGWr2wNYV5_%jR%*jy-W6n&n< zgLFe5(uph=ZhmL}X;`_2Gn0Z=Bfd*vSw1W6b;q(aIeLUV8WM(0op+ z^*;yyiEl%WOP^#haGHON1E(@ioO&GvPF*1%jQ96gIOTid#QD6~|0#TYR;I&I)#3s= zsY2!EwZb)WerREev0yQLmB4GVaEQ}MK(5~*7CpEhlatW=Kx>76LsDaE;T09|x`#Sn zE&O;@Z#DPmeyF!VJKX;#V728NI);I>vC`@N@29dO+-Zhvg4d70$~JtbJoPQO!r@1& z$@Gg_s{0=iP4!on{qHtdzQO6MxQzH^M#7olht z^5UD^jOzagW3K63McO*7_5!c`eOd&sh{gWl~x;Gy!+Nai4IIQ@UTo z=jj~0F3N~CZ%9a z5u3H7G`h-?M#e>DA~St%-O`#Ygr1j-q6N;_wv&7(e)a;}(EOuYTbruZBd)tI$HHyb|C# z0~}Q6m4bxnqLEED{Yze@88CgS+}+&vw9kwA9%{F(;#OfWmXvQ zEdKr)MN?+^-XQyy?2VFH{ofodFH>gpeZcJB=sH!EeIPTiFW>A(5i%m{Wg#Q#cS;#C z7^5p?M5+^paZd|;_|?_X$yuv#IGJHQ^udvE1Lj(qkReG@P)Hdf_+d9@ctVCe>69Vj z)h4{6aF{ij!l7ka?a*9@NSPyLgA^%U)jrP}&KD^g`q;9eBT%$u!<2VPo^xTEaL9&% zNFt;F%au}K9~S*W4IP;7b0Gy>x`RHxHEUzCtsaOyUyovfEBa)5bwO)tyCi>a=&VN3 z-`NAHO&fneBf7POh<=B0r}Vmr{w0v;qL66MxHA?ip|Nd;ReGnV)iarJ?m*!n=IGP-Z|YIgLkOHnlY z){_`0Lk-OsCnNL$yKm_qsu4LGGhAu22J;!^|HqyIE!gZCSy+dYUjzhU0%#m3y2pdg z?jf4<1-um9Bkb%R;?)DdAGgp_ow&Nx*zmzYapyTLPjmjO|DC> zt2Umt*BgbJrWasEM6N@q=WITkdugRAm$Jt$V}zp&xtQ4x>mr?%t}kI^%jv+WPjW#- z%mGAvb)}yxm#*@vE7MgRd3Pki^Z^CEu86#fcgnGz6z-IfO>|23U{t1)Ke^|J-ON9S-#ZWb@YH+eux`Da{!T80{G-UEmJ6WRwq_!4at zwU$&nYCoIEHl)3Y6(2U(UYM;S8Vo1II2x=!@|2h;S5pM;)C2pmEEDc07HIVMZ|6d_ zmi$lSH8$B;DAgWKHtLj!Cc7<)xOZS*tsw4J5ciEfB;Hn=xOHHVU|_w4N(+3Ho2Zl% zmD2StO0PtEX@3j`R$1+O?5&#C@E7pR%;bos^{diXFGg*EKoJp;4^{&YCX-6O3$BLR z88*)E%~bs9D*OZ@TQd^T7QVwB_--ZV$b}X%M?b}tAE9j(%EAn4VLcuu0*fg=L5sP} zq-m&*F$(Qzx9;{vCzp&u)j|!wdKX->O>v1Bt67#5Y2<`4Fv3Yrm_7?Xtqtkv;fmJj zD-ffYfZMhB&0Dwv-}b%4sg|(<#&Qe43CtX5d5LTOMqem5p@xIdg&G^>m$DoDJ`HpU zQ;f{h=Hr}zc{m|pK28x>q~#*ce9!C`i5PKq0LE5x={y5tjJ3JY`UEj^8yUm$L_r4C@um~#~MDj)#==Nf^~3y z&&xd{-vW8;hZm-DtVHYM#rn2qU3S0fu1o&o(RDc@>#`U#3DgCa0JA!$+SQp0GrQH; zLji=<8H&hILo4hWj_PbiiC)!FYw9O*zEY54jx|QAc(&Kv55FtwX1)Icb%o1s-Cy(Q z!O&ug%HROEPQ6=K1*zH-f7t$noAx7skMdualX~ACb(nU5{Yi zVRi@dX!aA)_3gG5Fhj;VfOa(Mh}W$8K8SsMR->K-2(0gHvAM4YY%GpOJ&5AG>MQwi zs6bxo7Oy`H@Y2+HWHU{Ts@+dzn$E%ne7?p#Rxk}D8*AT&S7NlP6i79PZ#xzUKU<2V zdtta*`Ylh!PEidPL|29mM8UpWX#A@1v3P_hMUyzIWNa zicW~xiWuXmlfqndl}BN0NTR*eldg|%anp6plhJg&9~K{=Ig-fKb)?8Kt^t=~uH02h z%dtxSkDt(M=TJS>I2CWXYuWh6SpJaTN5A$eph#J9JT@Cz?eGXnWIKE=b^$&Dn}eer zt^s8+efa?` zjrgV|2$pqC#B(lI1ulNtTovG_CAfa#KN1vI6>o?C%}q$`yjK1}KG&)Ej}f+)hB@U?1o9k?TPSPjAO;<#-N__+AuJ z@<-v**K~1Zey-(F&W7#<0xQ?QHas3fR|5R>bL0Cw_9!ft*W-?2q0H=93AsFGRq670 z@H6ZJ@``kM%ru@ZkF|NomDSzD=dlOU2fZld@_MXkb%fW;<+s!WQs1BL`FQbqcOM>$ zg_&iDdsfB2fsme(x}ql}>O+@4mk!nhv}WA$0zLCyO2qH+wUlkHKYiy?XO z5#*okb}Pc~o~YC~gpa8Blnv@TKgg0q+wIV@fHnws9SR?gus1^c8?ce+pN2;(!g|8x{*#80{eIIxKi}Zaw4I%krjS6?FF!MPX zKU{??RQS0H&v{e7H$13!1ln`))DTBlhWBstUg2U$7`Zf`P`{8*z^f{KX!r7;J_K>KemTPhKwG$U0Hn^ z_9=l+<9aVP&vo|nUi|aDA5TU3Ztuq~6f@YNZ6B~cZID)u93EbbUD-~Q*(|@mal9Y9 z@@34z&=KXqIHu=hcV0F`R9<}POFyI1b20a0aLZ1zyX_<0EE0LAo5icK?>V4(dp~xe z5CKR~A-?zHb)JCf{kT1V<9k1j2T2e-ihJXEKaLB{vo9!5rEc%XE-HXLPapHgklI`$*?1Jpm&J!we^nBly%r)Ql zHYadG;lZPk-j5UO{qWO3AJ18`9d;5jor7xTM837SM}>?`bi+ z^1UsCMj2%MO-ye3$biaFr1#^@>VVc2w|l}9<^8xIDv9)dYyi0?VKR!eRtfLNYEI(i z0K&9rs2NIlO;ib%_v5F5zVpi7BA+*?_*W3N*WSgs@(WkVo2dT_FyzG7I>!qq`b3*s zl#iL1r}ktD+${5!MqKT4w&HvwGfM0ie4rS>t2@hYf|yY z;<>%_TZ{QV=~su4_QL*v!HMGpgrwtL2&KKyqNk_vP0_Q5Mu5?Cjx7M=m<@S%Z_=FI zJ0dZp2Vq+0qH*65t%a^+1&p<)vG1W!vL zTR5H(gYRJ@sRVqFbJ3#8*wDSeWCJ^F!%DaZu-iHpEvlec7Q$nMg;3TwA^RXJNc-S5 zuafEI6=@%28gKjHO62l96Di-gk|tOfVQRVHHvWVfiex}l87%< zM!s&h*){lGfGW*FxKYKQvQ^pzS3+te+Ggdoun8`QO%O%zMEC-pZM$GOdSxPZK{K7p zF1Qn!bI}5kcEQ0wlWl#y3LjG8KM+#9w<4rnaPS+_F1Q#WdE(D1{6d9iY?JZVs_^$J zJfgzDcKQB(6@IG1lzJI|kqYOk@NX(?Qepm^GTm|&zM{gzD!k+^`TkB7KBK~SRoJY; zli!xkL)u%zDLbCs# zR>4Ck-)$9ip_sw3!fh3V`)n_(pex&nGFu{6L07(v6&N(4EPFAng6_O*h^V|Vtb(qb zk<$+%@0@;Itz|=|cv}VI0TNV*Zx!tA37A&F_5hA=6^sW-5Il-|<5>mcLi6kko>oB@ zm>5<;SDK8yf;AGb3c9mJGH@KLV7!c;#*Y|hqPgHiFjsu5pjXazS_N5OS_NI8BD%3> zWg@MD5>TX=j3j5YRnRkE6cu7x1zmWnZ0$W0%?n1mtb(!*Q3Hv~Di|Y;w^h)EQPi1e ze9I|WM5>rpL07tnwvBBSjGrr>RWM#oPhN^=6^sWgwpGxTD~44tB8}&nXs$G3&~KMj z(4Ad&hNH3yCJsm-*$%6q3o@;OREVSJ^{!;DdA+yUfRhOi9*wjLCf567Sp{84MaT@n z=gwgnDjw$z5oe-B>4=0R-ZD}zEAP#KD}3a+{s9>w z2-|DdinI&<02p%8+s!enjkXI)KiM(Of_VZp+bpON*R(`HvXY6InP3*Y12E-;Rr(%? zXBKQ#v@+?p^F2vBzY5Pl*k0P@>Cz@R93gFj#el&{<7|Ya;e!aJP0*^ir-4nMpS|&k$s6~^YD_H?!O_Lz$Vz*NqbV<-e+DUC5?70i} z!0s{jh)4o>ngiLg@p?Vq(=f6e@Uu=IVOrT^G3?Qp1GR&Io!&RmJ%h3`vCM%P!W<~l zBxDU_{b&uGxtqK$uSjbk(|B70HSJO4%jy<)zo108ZF8V@h_HIbZ^QqAIZ%6gk6X?y z{s(MGh});)zd=ZQ;B<(JL~ToybItbzH2=L0dtlLLiP!_Xpm^GdN)SrX7|SNA_}C#h z2WmMeFv@UI2~bv_&LA2InFC$fd>ZMJmN+gXtCY*}I+QR4?gwOBvK|E8c)15A%M_@M zf8TDe>G(Yy^|=LMNX4JESK0#CL1ZM_Uadjc0dem{+2auoMrhjtm!U@{Vhc3Wxom+4 zkU1CCiL?a{1Db5-*(!Weg$EE)tfze-ZGpoO79!nU2+0qdRrrkx`+O+lXQ=Q`Doouc z<4aWdI~5*MVfKFcKA^%|RJcurM^sq+kxX~L3g1*=(#JA>gbIJH!WUKep$fw)Jo6Ko z{u&kDr@~KE_=^MbeSr$6s_-Ed9yH&7D$~tG$l-3SdVUk35A+GE(65~mS9WyQ=Aoe@ z`bttddxzCmXbOBfI+f3zDueBwpefJ=K7#{elrg1;MsAEAnO#|ZFa?rH|9_eS%Td1D z6zD=Rg9C-z6u1mIJT?frvYjZiC1MJ6<;z%$@gmBc7t<8z&dY{~${WKJ=*k&6=OFUV zImgx78r0d_6c`VXphA38;0vCBX$ou);P|G%c#s6aqqsMoDKIWH&%WSk3Uq;qVG4Am z$uI{*#eQ=kMC zDJCPy8Ep#m%ojz4n5IA%-YQ#rO@Ur8+GPrqb%+{BT&BPnX}nE=E{vi~fqcuUSVXFr zra)J^h_;Pw3XGpCo+&V1PETHnX9|o5EVe1ol`DoRFd~hoDbSTh4EpUd1-i4#&Tv$w zz{CLwB->#MbU~&mkos`+eBPDJHJ|r37jPos!K0C;z{GlgEK{HhsR)@N_}n=xbIyQtlh-Fbc?Xy-m@4aUa*AfcQRubWz| zbp~3z+|8_xSep(yIN*8}zD$Gm>OI83&jp zC0}0gmA+k_F#jM5bbP_To$dpLyAS0j;cmdG8Wa}pm;}DchZer#H(hAe{oD3Q&|<*5 z0X-XJ;=}%N_rs}NJVb)eOPG(5j)35tH{5J5eNm&M^x%@uDT z29DdXF-9bBFDfreGu6cr#rwk*hme&YG8laxb-0(= z4)AccDc#Gwd!O=iBiwz$)M(1PscOukNH|I{=3uAfsC1l zX-pq9w$GJo;YSQ)mX0ez#=k&yt3vNg5dO5rT~#_-|5A8S=qFQW>2D~9SvX{CERPVy`7qhw zd!y%VK%*0Tp%J_pEmMl4bzd5GdBuklCV{bH__%m=k=w_`<>)h!{%xKoVEDBFEsS5? zNyj?UYsE235HGz}Tmu&&me-0>z@XQPa}XJ7Xt>kmwc<$>=-_$y^pGqseer;^>D%KQ zQP0l8@CA0tXHNs?SM<7&&Fh3RMQ6}&h8S_AArDV`@BSZ1Fm?C>4*PNiL89=bD5 zIAY$3s#K@iXX$9sSWbE!XXJqg$Oa-*4%9w^$DPoMFWoY-UOlf@;d2NnBiri-JhxHG z$n-<-4UgXkaJS$tI@9R~JX=`duPmD~cm7mqi)Z<1QPISbN|48R5XLJhIsG>jYx_|I zFLoJRRlF@9@SeU>7A~~ON*^@80fb0Cx)F}Gz(;V+t{F?wIwl{5Zn5|%2QE%5K6)51 z$VdN%^U+YlW6NB8bS(<><|FBc=6ICC!yiq@Nb|GEGIk%P-y~f%;mKEtJ}Y|bhm0@q z(^rk@U(bMJsj%@{war@%w@cpAmZ4po*MP6kPKev9;=e$chXn0Ci)$s|aBNKf4rATd zID6~cB5fqX>u}G)Jr6g}ja`gz8Gqy6iF*~&$qP+Kg@R1yFNRt}NtUFw03Uhu>v0aA zk(-|fiQKUc-RcL7EW4#kt6`nfqQQ|gTzvOnwpqv_nN6YSp+t57&T}T?EZZ_qeoL!x z^IJDmK9b*#KwRpnaARf6=ty5Xv5Gz&Qlh0C0nI zDzIvD!1xBgaS~p6S3VrX15O?sgglE_j&UozJ+;Vp^(tW&6aGykOmRC?v;a^)0(wLOia3-fB^ihEw8Bv*Gfe;dCumgl#>knPhAJeHcf|4IgP>$t z3Q=%eQuJ|KFZ%%J1;CO1p;+x>Q1XX;1Vy_Bi+v!L%ai4e&j@{>@#J7}QslcUg z71-hiSStbIBmw&MXnKU_?+<1XMJLfn>uQ z14(#@TnP{aFE7JJK^{f|SJp8Kii(PgiUNv?FGNI*Eb>rP5JV7E^rFrh)F@FS1orz? zch7rvvy1${d(L;h9G2dl>8`1+uBxu8uI?$_X-2@!5da?u1WH@#fQ;`w{gF6=RZ0Wt zFrHLDO-aMFAP&#c-bu+piL32#Qs)Te8rW-r`v_sb@*v*f40?{iFe@+aJ85XnUsdDK z{3J}mvN>-{-s{ll)fnZcf5X$HA)d_I;~;;2Jn5~E65C!sT)F1klfkOC{FFwV{4H=v zHQ}@xK(%R1hTv%8#9wLi6o5gQ2z&75=Yi$2=Vvv-@Ze{nu~*b6 z%W+OF*>j`^beYH5fA_iBTl$i`>3DxrXZloi#hY%FY&0mJ5z9_mtID8v+R@dEwX1k9 zUz4>sg>P*vKJJk?a9BMn3}>~|GhL)ZM4I)%7~ zG=(3NmZm8>!*HMz=RCEfJ(o3rc7?e=_e%WA6Z$wQ2PW&y(@7t*ub=)K`q)!V&W5K3 zZI#?~5>Gk=ZaZE_CKuN5_YwT~q=CvG;-Peme!Gc8J}*2g%lX6nT=Fj4eFJOcV{~3J zFm3yXhAECNzUvMns=vhpp?$KSj^vH2jN$mF0srK6#w#DPYWdn*Fxa`mZ>?k!+ke4< z*_Yy|dDd4rPwbp!dnfLk$~h6G^gt7>mJzrOz){+v}H^|D1EKdHaiW&Up}W+ zDovp`OfW^6fwuz)rg+%}qP|%@6i*dy5Ifu4`y3;pcxeU6i^?z^VOl6xQ4jgsyPv?A zi^KTI;rU#{`g@MGI7PZQM#Uc(aXWRDOBS7#Ydit<>OWO7me0Z%Bx*;XX0W%byoxc? zVE05_b`CEa@hTwe51fG8Q1ug?E=uP<689*b$w>-*R^_#m%y!Iv4FladxrtcCuPB&D z)iVb1qC|u# z$zW%=^WWp?H@A&h--gofJU92rKJTykWbEG6xCi??X(Z9uenw|+$hh&$$}NAXl-K*s zc-XI0V>(uj^$o78EH~!94uWKP~QH9owW;kl+VIt9zw}ZQ=Y_i{#s@DUG$C+ zcAMUh!(Z|&KXaTWJ(`WulqXObKftF zgfZikF31w1xTSI-`$F^Yk7#fYDAPR#LB=?xDZ5b~=fdT_fI}llY6<_#adIbw^-_n* zy_4img{L)e5+L?YLjy)qW&6#+bloE~xm?2l>nFe2Zzn2rdXt zJSX#gndw!ufWEH|(D%X1kUcAugk2}WWrY*IuT!z6m(aqZU*=%ZKZKxY(6dbA$|Go` zS)j@q5WpW8f_Wc;T$+?i6KrP$6Xj8>s8dCFEV{44HN02!&CO))FXJy2-D7%lE!uSu z=&mJnhr=@vJUxS3G1bItCx%VnTEU zzAHzezQo!6FvW58XYV!#1E78BK6#9;G-Xz{>510 zKLl6x*U#a7;v{}sl>5+>yz18YUXJhdn$O%MyqAfGN0#EHYQEewdCU9*-elzm05V7) z&I=~d!?OmzMG1{W>%OIbtFMLFC;#rl3#CRGq6>rX;qv#N7?1E0xV#-yE`WA`ylsIf zt^ofqdE28*{#?l0LFGF{O^otZF+C=8i}iKZqmDw{3P8f47Fo+!#$-)C2{$+Sp1*-? zZ>(#K+6RbO+901Z1@pm07^=J3BR48ju15%>5WerNrnewp38oCZg!X#Nq_*)((VygX z&6lCLdZ+gW{a%VP=-%+R{rgj*);-pC^U*H1+@E$`@&bgyK*WPeF+xsUlnyE* z@LgF2Cq-3b2VR+iuD-1)cS&jkiqjvP_iQ%Pj98VO$drKx70zZV&S%6v2QvwIQTLDI zESYD8!EGk8LrpeQGraCWx0y!2YLMh%0HNDVXN{+x{0NgwvzexhH`q*fpf=e|@c`iu zyhru8&BX1+Kc|uXNHWd(Y<)LD9DG5e4c#qHCxN=KaSs7riVw3*Q^!`%HXSE$%jBsl&{@D0#)u+iUSevba6C=nn+p zPZ%ujjW?P!g|^b8bm7RP3S=4rnMPGfYhw_AKQ zE^DNJy$gH*Yp~LhE>-_B)8!nOoi1m<`~%1(0ErIs&~N4#t(W&;qS2W7e6*)t-iV9- zz***A?#06l`cUhoihpO0w20UEl^-B}{2d1C^>-N1I|}Qb+6J9KdN@Tcbjhvh7f!MF z)CG61O;cXW!}pL@moX?Gp&*r4fzuKi-1XKG7`WE`+N);o3-X{T7t8|7tmO zOr-mHX#Z8G2Ru?1KKu`KJ$R-^qKPR!cfiEyUR+qlQpY5zK`uK*lt>>dJ&niFzML;m zauwStLOK{uWy-^IEn7=s-4Z&cEzu?tHW6*ZGBpE^M4yDHaUv>nJs(a0NfF2X8xPPm zbh;p62n`KcW!>UbuEqC5=vZQsN6N>C{@!YgG)I(2pyeVRzxnrLFV&Svge)B`t^2XQ2AVYPt|q*^MwGXqr0L-alyo-J z*C=T});Y~XwK{3D$2E@{6dt+McKIpuQyASUx+dW z!%ov?7nCG7qZxnK1RoNmOUj5uj@n7Ji*2$K<0fg*WQVq8b-LeHE7n{qk%m9QZCNJp zi8R65Hnt$|6pyrT%Q7{Mm9iMG{x7#>)d5ZOwk#8hi8Pa#w`I|Zs}9?;OwC&GW|3^m zGPO%g!Bk?~S`~6zmbonrgsp9eZCR$4*8Fcm-kASAf}Jw!ye%snAV!7o+p>t5cEGeP zD;mJzw`GNc#0YNV-f-Kp!a{SD1;=e!CNLqkWtr+Ej$^D5!L}@OGb;m!*_IWqq2un8 z5Zkg$a4gIfep{AP%P6;HQGaP$mI;(aj2$~;-Im1xS=FSKoc3*5j_qtz2)QlGgturG z?Y1l@7*TD@;(f49B&KayA?i49%Q9hP+m=Ol$)&T@3b`%IRL?TDp|@p)ZxwD^R=Adq zycBL*Rybgxw`G}Hh1iy5spGgU%T$L=`cZAmGB@YKa7x>gV_h;gz z*l}shpSg<{D|xYn7Xe<7L1f*YwPF$CMEIB;AKUhvw{>&iQ_AKF> zIAqqk)l+4JrxNT0gV+o~+n!bE`#vwl9BcSP3Xf>$P$D91ktdy$8 z`$wi!xxd1HaR+9l+?}0{EfuJgbaI=V-QF8luDD`0j~ve5XN?uzg`VJhlYntzYKkb~#Yt8YvgLdsE0-a)_j((erR zdnf(gLcde-yTi0f{4eL>|2kzYuCfI|zQ#?<1N>>p{Aumj(~{|F&8phto^SXzycCtn z9aU+p+&L0SNoX{o(uG3Ks`RDdin?aLR;-zCl=u4zH~T#6>zB5iBMWm%H)4zeDwq>WTheT--gE!O9$#9LS!ZuQjB z`>Lz(`c=@k?6|A6U(uQSoQjlR19QeBI?-=84;5ykccKR^6^z}jIC#B?jmg8x(9#+U0<$*-u?8H$Ej0QDTd3xVwrygUd`7u}nl@@veENx-Ef=sL+4RMq5IoqT;ZW(#G zjeo?tW3V)lhIKWFR#iZqzfS9X;A!f7X^*lwfuQ%Cn}LH$grisyl($uQ_Q_u;yFrC2 zypjB&$|w(@(+YVm zWg*8aU-dX1e6_CaZY+u?_QQU!19KDb^_v`)heUb%>W8h>(eg1Am>26*Y$X|K`>qm} z-9-7ed=Haa2kG9d4pOqU8iWJo&DrY2nd+#|#JU&HYEb`&vO;Pp@}@{=6V6qIR$cC| zC_D`0OF(Y=hMImkEtua`qf!&JsPG&X+;%q>BK?6*gNaINat&K+Q=i65(=%sOimDwk>a^>zE8Sdy z1z%iOk|6B3-VU1@^KhM|GIL15QY2vV{IFpJX)!RP7AGNoXmK7|%wR1bc4`Z4ALRLH zQ8h+9IHkM0l&UXd)fK(EqCVhHU{lp4*hMq|U*lcaSbPk2U9ba-kHiYvGY+eb-bW+8 zS(JL-&9+&T`nr+&y1p2F-J&b`TG~EvDRL^1Kt`2zP^AY@iFRCICPj_~-#dB;Q^zb^ z&%Lgc(w#L3*ojK*4pF<21e}iri6arR8rRiJ6@>@cxCBcNs(3d9-WoqwVO%Rb2RG16 zqr5O&WEZgAl|5OGP5vN|<}0oOu&Ao?5$zglkNlbeHVJkMjJ+vV6Vi$lNPI4&PXmQ}HdGs%iBo&u^SmjHlXbsjx@}rXpXk7_Ey8 zP}KWi$$zxJRp=BwgK6`5x^R$CB&|yKHbG|OAzWAXLRhM<;tDHiRV=$vOE=!38|mte z78NFHb1Nur z9Wz?aQTGOG`dH7nD#rX_%+5H7{#bXYjmSpE!4_o`l71Fux5BqY_=f(+%91ae-f6!C zzsLKsGkAi+6iPLwG>kN5*a)Iw4XP~YNm&aul={6FiAkCW{1?xo9Lm+W$Z|9ai7q4i zgDy}IVh4H}kThp6@Kj2%-(-uNpQapv_)rdX^18fM@+Rz8%S-3k&MRB9TwXaVg)%qT ze7GJoDWlvC?0=R6@-cNvOQB64rHM+{hhccU2^{#yrp9f}Ll-W|rTi$i&qn@0NrIAN zJ8gEud|_LcMV`lDK=lngOi(L4ikPcnnb;RjIJccfUd~41iJKlG+Y3)b6MEJr56A^e z`!KT1dOS~AX1L5+q{=(vz8J2Yz=Wj{u^pi5&nm&Q{DHK7AfdW}fZNa7zWiZ?98JN0 zIHGfKxKwPK)P-%oBw9wqpEtH>cP!ozx-6Oc2|jAj(JO&)-%&49$t z_yr8m5dezEpeR2fSxD?wT zu>In1PIKXFJJgr6+RHg>W7Smq^Uh}J;ykBn3#GrY+#&wE2j<-ndla6zTJH{x>CNpm z7SlG4KYT6gTp3|G9hj-PM895x>pWvBizPe?RdowskTjlwi~hjJy+L%?140__#se+n zaHhuzk4}$K_|EnyFnTa@u)WP$*wMx9PUSo5v$}Ww;+Cd83PcZ>?CLh@{-2!$Ih^y& z9=OU(kC`3p^mv=oqdP3-EXtV^sa1!%Yvi~LnSUB1mH`Bj!-b3fz`MC7a?HZ>oXDZt z%F5ophJF>EW$M?LP>af0!(%YiTKz3_?J{-^@EMQKN^$)~l-S1? z^|>Z>mtbufd$%`V>XG*0a|j=OZJEw%Nux)yKggGQAwG9d(d1$XmohS!tv)x%&7D+q z({x-}{;ymnfr+{7Oq7C|)2JT);-waB8+YF+-tn}Fo82z<7MD<85<=Xgemk9?qUPWX zzeuOc5_})s(IY*FvH?o^OGQaxfN1x$SAz~jmz>KyQrGi6(gc(<@F~M*89s~fS%Oan z_O*AyXBj@r>3SC<{m6z(Cp6d}=JPxdhZgJOa|?!hY$Eg2aoreJq4vt(z$hh>vP^sBiIxdg zU_@}Io$|<$cpUXnyvqxqxvDr<>JFmNUkv+SDnn7Goz6hy$a1WZNc8DbG-ceRVv=w2 zgIItIv7kET1ptHLkwP9delEjLd0MNgSa$M@()eRU)85=y;p)O7Y<0d~ttcw>=MK7D z2~{Ua-f8)~ZFyyyaTni9aLg$jbez0{0lm8%Ktm)iyX8KJtDPW&Ra0EBJ+H_;;3w3Fe)YShNG*~YH zCJojL7yW^{o=k&z>R7J)1|VTjV4gZ=k0M>3_BdhwR+{6%$?Jw=-hzRp??XG813k64 zr>^5?UMqCGLKCu<8@m_v)Jbk=DiN=C47SqV*9p0z(EV&56{f_OsoGwp3;@ZFQ=jt* z?ZBi-6LnPPwX0`J5C~pv#ysmd_pS+6fbmO@`&-|N-f_e;vg1JwbPQA}ghv
      q}=_*ruaD4L&+)2V!}yMvzE>q*r4hx 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�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 z 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

      x(8g z0V3P3hW%`%SI#v=^mf<@WPg$Xq%?c3yTl+bqg9#l!0^5m(72yGzuIwpx%4hybPsb$ zdHsOlyg!!l_Vt0u!et3<6^^GH!fw7{16n+zDPW%pP2(S9LIjrXp_mFjO~jDmTEl}q ze(Dz`DBW-$kTVx3DF-%VoV=A#8;{Kb@F@9l;mNK|RilIQKL>XIAIo9;m$qQrB8@vt zy}TXO81^kymNgVekZfgx89$SD?qGPaqUn7G?fJTb@gd$x zv(HcQ=ePQE>iZ$j2pa5ENLH(}AW8YF47H4UZ#VjHCwrzT>`0P?JUgC>vAXS@1l;;+ zN0TKVb+StX6g?)uAkC3qTr+Y%E&BjDpN5Vf5EXqJ2W>djy%V1G4cuy!op{H00C2R} z7uBIfJb}vlfWqz`t39(;_t>0vvQgf-QX@Flp+06ID}8`#n&W32z7Tj(cGM+?2_Cm> zoFtW44cag+Q28&`-%<|Pz3Xk4B*g#-wrXxO*>K>p(?gwk2;~QF+!zN*eJWLe|HA&s zc7{?aG57XvS@BE-;FqtOJ510jT2s?d(veENpk9qlCGxQULnL9B6s(VtH9`Thc+vVN zVf(}frX!)UN2ZArT_+`?MY_LkechCaI2@4#4Zgyf&^u4Kb18U4Oi@KH)R!%QGX02h z+bV~)%AiLPotu-un)F^QcNuhzb(mW}{whPC7khm4^nkNXoyKq^V&#mwVHBnK+<4lE z(z)GSkELa`WU%7qocoQ_5k)eD)1>bl4Wc@%rOoUc7i7Jcyst04rZISpR87G_ByA8) zZoqikiBJ8A0-2oU7v)Fn_$>YiJ%_Xe53`JBH+L_Nf5|=l@4w0i$Y`0|;n;2U4*}ur zp)4vvo7TLyq`TPJ4;%NqxU`EYHwESXF`-g()_(P{M*|&SRvU|8wl3dcao#-hPYTAG zI3}ZA9dChkFcsiN(Cj45rO1kGM|xvTSBxJD*LoKxR9G-xGQ_qDUc)R?-|`N8eD;wx ziPo0(;_pcDzLEv}Ti6ZRkf@8_*fD zfB1%#*u6QD{CPdFxh=d35vGW`CC#RXhdr85 zf3itJJ-~NyS={tl^hyp7gI1o?_k{7F;c0nPT&<# zk1PIrLB_Yx+!aa z^UW}FfE$>T+`6SUF(8l>HDuz>MrlvHj@dKKdAbZh1VLLW7E6z`1aDeppvc_M{=k1( zEjg-q^$Gt(LYs#ladGr%Sc{zVHCW)>EnIg|Isi{p+>5bG86=Cop9yL-OVZ;1u5FzB+2`{ zS=L^Zg{6b;R!M&wSR7EYI;L4WI9s9FhQcBtewR$y@1ed*#k?CKT)5Jq+joZDFIwFw z+c}I~MNmvYDt~h}UHN7bz({DpRrj>cL_7+d|LF0s56M5+umMrSa{dH5>05YSaVO)e zS%eJxGgpW|REzs2zo>)o_}x+qiGY9MHulB%De4nG`LQX#DX&VnKjp$u zpW#hBgevXeA*)n~8+gtAS!-Y+niX0G70Ae79iW!_uk7aDHR@(u`gsmCcjnfgTD1zW zNHswSBy(nZG;Op#Kbl=s5_5}v`&NF>4%=`~qNi|AmGYNi42)Z)`1m-9ahn-}>RwuwMx|QZY*8_7o zdf=!SA79lDK|MYkvrp*bS#?Lt;IHxQe{E^bCupzQCgjlqf)T|xY<5Rtj3Krx;$MnR ze^$>jz=J$4Uk{}Ffm6Le9r={Xui*zza>H9W@iT&(uV$PPFHwHozk!rK#z0M?45Xw8 z?5(o}z0J$xbobdhfmemAKSZSE4cEJu$nrd<6c=ku;D`PY3;N*2f!%B9~>4r!YbHrV~m(ihaze6wwkp>X4Hb8>P=C`7bx)AMrk9p=Mt(J}fpq$Q(<863r` zME9cNqyxa!E@Ic?kj-8kHvr2mtL+_7k;=*r&1<+PQfbfJ;taq!za#H&bq(sHN`xCa z%eSy8enj?*PNgA1D}69e!L=3w$e{T%1$-L&Zv&e<`16+9d>dkdTgKokL>2|F<+U<+ z3F=1eon!YaUH%98K0wO%9oG+P4h=@&*hSOQDRqCG`oCY)w@OnSP9er{Eff60rXklp zMdXkBG3MRLx&h}#RS`BqTfw={r%Niyp(NVVZDW`p8CUk_))LC_N>XK`oJ3D11&+V(m~I zaAvK!3DP_2M=e!c*$iBVY(c7(pWYX~dgWBJenYL0hJJ;-zPt4L`C1$~vmDgOV5S>v zZ?XheQS!R@RoZ$ZEAg*A{r4}4M8cfEBykWHAjL^%#;ufAC>2?3;U!-l_JDtI7~3Io+uh*OO3P|25= zNAB|0239!BC~w2rSHKb^4ygMQy*RM`M~_!j240~pc-*5^D-pOj`3o4$70Kx5}$w!+rznWuI8I4W8E^Q{QQTekP7 zdGCJeOfk~mfy<^<`E~e&-wBQUAe(8#DE&4yR>~P8~sdF*YIqbk>%Ho3l8q0mhfC7Yzy#KgD?ng zo9R~|lM_vlz#w~ny)<<{hrX4Cehts*|CknFqyWs$MMohMe6UNDf`|~jSAPp~Sp1+W z&7lCim2~s%<8?v1n2BVT`NYwPg4gc*{UfuU1ubZ_922!GHEWuY9{{VzHfKd_dK&7`QD21%eR#9x*B+XbIA(5t9-}CtH67eU;kXY;E zkBz9%^iI3(|Fr)PK$TpU3{1)$Tt4JP4>ATsfI`DLpqg{DjE|XQjAR=E4uSLeI80H~ zEq3Czo|sWyv3?Don}0t(Eb)o=Fn)ETUL&w6H=g2LxOLH?xN^S4H_IW2!!G!Z2B^6= z=pO=fvxH>HtmixCGLAXWGKVn`SBf*V#k@zFVd*FLmN9KEvv8Iu(M)2{B+|_hgk2w} zv{}BURWe0{80fyF%GNL)6@kebqIcwL!*q0UU}91%neNOT%?{MX?huamm;@PVY?og% zsZo9`8OpgX$5q!QBn=6xB<9n9GVfs!6>6TMMS3vvt>knmq?=#~Ttc$O>`rR46^us> zXPpr1`#WAga&1&IX}puthjD{Bm0P?u9~A0(rCGnsv{x7-mB$qPl8YdkpXd!G$espG zvU+kSDT+UyZGODbT=a@8-`nT(X>cvC$2JXL9bWL1aLoGFR1?(yn)E;~3i3w@t7bk( zMxyb*9nO^b6~5|~P8Y3A0d6RffGreUpTR|bg~JaPU=I7Nh>mxMG!+1i|MFae2vvPV z^HObkp4xl8dh{U6Q~#n+l9*tkx{R1zkyd8g=>wOS0dz$e_2PzI2T09uAJCS5_W5;7 zpFPvv9zyOiTLh4F0r)sB(&Dzi-h4S_G3%qrM7#aS8b$w4e=e$4#Lv|VA|~59kTk$y zo)H~?dhxf$x{I78Ve$+H@S*}lvz`Qx#X!2*UKV-nyr@`cvFwnWqLI;S^1>IRr1~eo ztpt7^6RasKPcIU2QB3KF?fQ{Msg{Kc5}!_*0b};CLK4Ded(z7M|SC+iVoCaJ$a7I@J+}!yaE7@OeAmGnV zon(%R_Xv)Lw2j2!h5fWtsR4);?G`Dz6hvWvuE8tyarq^`N0iuV9v*>v%p25~&`9xY zoHbTg8wK?e0vlPK$abw`MKjqi7eZJ4HC+quFy6W!5kf@4T9lo5K@ju7y~;B~7pqJM zAyH@%0$e|c?RI;ED;=9I*-WZSNIg=AXMdX~q1H|&i~npER>J(#do*L_McWE!CbZ3V z0L0@@{JfDh1Us3;m~MF5ie{c6WnV=e{U%|Dayw@(lQT^yiq34%YRW#p?(eq!#?WZ5 z;gclGE%{G^G@$|ndsjQgZ#It~m1&Vdnwx4KFp7STlU3|o$2#NsoD_oSch6~DygVeY zA&;R*FHZyh2X9^c|5Pd< zHnJCGtRqt8>uUkTH zpbX?ST``g{QvH6&i%&&Z`(@V-HN5iBkIx6VV3}0w7+;_4e7?J zaFM_5Ww1a`ip=JJ4s+iRf7)%tyDS!k88`7O$uv>Lwsz)2;8DQ9pascnRs0y)X)bRn z7`t#k8Ow$o-k~*bIP9;--C66DY`nJ}Vep~9W3M%V9R>Srd>Gsgy7Y%J(r9$l|F=B^ zm7FO;mjiCPIx+jfkvQYJO#75fFHIxpn}<&w)VxlenNVowEY?SJ6b0@O{)CN4lmyeD zX$IF9PQ)d4261xSjqe7AS*k^8T=KG~3P%`e&}qMbY;tW{6CbxDqJziB1^Q)mD! z5W&s$ZU&W%r#BUILAUINpk%@`&6dmC+JBc`l-(5>GS%j>%gQj>G8ewOjd3Qal@F_s zegv)q*rFd4tR2z|b57BiM~16GVx_wnB{voQ{R_vT)d+X6YIvQ#XH+k8pwMZWzCcoq z*M6(`f^fY%45TPa1x)LYjx8o+c}>Z#7wGh+T9ovTY@)*}ilx)rb>5K^4y+EL^Sx_t z;TVYy#Hi9MFSe&>X|g}fZn1=(bLBczB8(E>qw>6vs{f?ID4s&u{a@pY_nTmgqGiBN zJd`V>i7EYT7;uGds-};&i zf}B-uQ3lH!AaQ@&an@~tyKEtstzU<>Y=xs}JHDY%@ zf1N#;i2;jVxC$iaS|KCBy*2Mzf#iswYTF%Om?X#T*&IM*Yv^q;kauYIE|YY|OsAV(KB8 z)A2c&L7C>O8eEx;WLI53o#vE6|06(QQRn6h{o%jT>Et#0&oC!ncqCYO=uJZH!E>`J z(+O>41sUf8cZG3Hb^_>GATO;Lpi$};W7}_Es{AKlH2*skl-L%VIM5x?g`8XGvrLWzprl44F%u>XzEaLqg z6Zp12gS>@7J%jNB!n4SI=X0|>X~o<1^`Z-6Vz1U3SdR7-RU64~1FVir!Rj~91(86H zoJpNx(MeCiF@^$;hXpdjTtWMjX+=Y$p>c!+0&H3@Ecw19p}NE);&>`htqxt3F+Els z0PbyBAGlz@4~cM^WEA=ExwxM^Zr1gO%MJKEAyFi}rrUWW%k3~f04#D?)}8@TgXL?~ zF-6864C~~3dk~2@Gupcg!M}D8DvG?e^!(pKC54vSAGXSuERKf4jdW=;mx_ndx%r%@ zIwj{<9@yEUT`<2G+1U-V{JEQw(b7ZYa%e;#R*z_x;Bjq_>CVR~>VBg?YMFLhg%8d& z!?dsruzh@DX)ZZIe^Sa60qM1yYSmr~(#C%eaR~T9K%!)cUkhOe;_i#rMYTbbY`=4&$&*v8x7N>Ie##sn^2A*Bv_7Ojs|CwuXhzdkWr;Bm=RH~O7sfZq6(8{pKb zTk!kXE4)*V^^yfr1aJ_?&{1_6BhQHgc&tXIPyb8UwvS**0#$i%&X(3|6S;e2<4;q@ zfhtQdJ?g|zeGHriYUEu#XJhq}fr1ni2%nxnQ9 z?REf32O?>%9r*XF02;Pb_!My2m%L%|7V~gcX8I6Zp`qP-c*A;{GA7`-nLCCWrUPlX^Ux(zxXF`3!D1P15eVdLp=U>J(UmPFm)ZFM)CQ; zD7we3^QDTBB5~oO^a()o*H4kTLuv5$(;(z?IbOevL!vWJT3W8IrZaI=sWYB>6H=QAUT3msW?AX8S2ZBmPx$Kng z67ga!(cd!KxcDNL);FU5$p7YLrub|!^LF*@mrtq5MN}Eq`%OaH1W{JY1EUXwXS-Lv zWSo2&a#Hk`quCT$W+f1%4O4I`$_(=9|K8xAL%7V!?L_drk*7ycD$X{_>Ln%1jhlLR z@p#{K61HZR2;~dZ{dn>xHTxZhK2koj?QT6DzFBG5UC#R)x1YIU&9YP)`YQJ4(OIPB zch!AYvFU0;!zTXQQfbgDc_GF6JPDa0?o83woVesDwWcoPiYk+gZ~YpMIG2_-}^mq$j9S*z$`4FWXH@&TDZ_`?e2 z9!pEmT4qKz@IgX}t+aw9O-J_=rmp#0n&#YFCKZ+=zh`*fC#1e%X#WzE?;Hi=p*2MB`H~ zclAw0`jr)@D?G$s83aal@&^qpQJ6N(KMzzYvp1P-jIW5Y#_6_7;Ag5II9-E2>)Kv1 z%#`|E7UilNJ98MiZ7mNYACGViloZz`;9gB6Wi=xGBZt`}%lObtU~h-!u5~&ABaXHQ5)skVbp?au&DF&pzHtuAAy; zDMh2+6wpp-sysJmF=zC3$n|M6F&$1OR1&tme2R8eWU-fn_f6pP(Yb2STtmGsbr|}c zHB3|#m5*;5x`_ggESXB;s_#)bR-Pbf(j=S-8OAcZi!Jwwn*ik0n4ET7s)#TTRbsi9 z9`UPwkhM&^aY?PLT$n?<4KRi2*bF^J{H!qoR=7GSMO8qbyo2y@sh1;EHwTy@av|#M z%8`Njj-tQ#2tEd8;*^^J+`4wPmq zbg)EqskiaC=fOCfJMC3r%?lcAejlsBK7BU#BRoILfuj*c0Y0KZ;)bjwu(8W%pK&^Q z4lO^2qYgfC@I6i`w@Z*z{4g!E1;#yb*0I`}^Ewmh?R>_3JePZ!xnRHS1kZ*BwEk?2 zVJ?BzoxxidkXO8ZfX@|*E|EaOwIAbDEPMyGa5a!YOoV~h-<}1vrQmq|7{5f+u$u0L zrtqV3kCu2JEOAMqxE|2W(A+J2p{HHhJx$`PHrzAq+BDF>daxU|Nj|lU2PA5$>o5xC(~6X%6z-`kF2beQz?3v4;_&%dgLOnmcU{CV z&JGcyZ^!gmT29X_CO?2&L;EzL_$JGw#hR{O(4LfSF2mA-%P94kVmaQ%HR(uoki8nQ zreuQ;?9gY8cn>~qbFm!7%3ocgBHtZIJ~ zf(N?GszhhYVv7MY=chBU^m$XEnP%p%gUUIg&TPI*TXnAAUJbk%Qs6>b#0M{>q^^Q{ z2^1Xy60hj_XT*A1PnQR^J|D+XcdO{W9a34i%WvOG1MeekmG`=BxV!W6YnA2@K~tq4 z?)aufp&YmX5%?FaOZcktG>RPL3ShK9XE)g`QxXAU5joI#{fJD zU%28HeHdc<0@^YYsyhJ;2W4?M@=PM`?4?G&7SQLYgF1oG+W6{K50NM)cTnT~_2ow? zHALofKZTU3&{n?8^1U(2flZ29mLOUWWw5zWUZ>P7y)mJejQVBTabb*;pK&@b$vm%% zK*3>jiKll@LWSPV*D^vhn=cEIQ@l6DY)zj26JeLI8#$yAa`)MT9zm^zvJ+jV!?|9a z#>hr3BNOH(cEIy}_UE4xtkal0f#L2{z$ki<_e<)a$>oY5?1_-37Z=G~JGt}ux=N^Q z8d_QZ*$+Jxuer`+M9uOw3z8TiM7=L>>Kp4-c+|k`beLwE|0%$s$_C#rn)1i-I_CSo zr2`th#Q1~P@uSI$aNe`7jr*k?&lAZ7sVsGT+*c2xoDQP+b1&)~3dJb4!Eg zH%p!D@!yjTe6OBFev$rzpIkwPel=PMFyfv?#WpoJpO*G>oU;ym#L)Ht3C|S5-QL?AfWm#{2rm@%l$@$^s@`{2OkF~o7$7{e$HIcB zE11g-Z8i0@iSe_nWlLZZ{w*$fW#&EPh=f5TuXI^I0SUgu12Y#ziZ-gr8&(rZTHs)q zmJr{b)q1O8VvSSC(V0Z`8?EVS7WW)OuSm_>fo;Q7D1Y5&JPR(_a(^2V#dxj9Uhh}W zpxK?_{=y?U&x{Vvtt4rgUr0uhmHwMC?7t#-@C!H}N%1S$1mghu)345xd@vA| zX%~Hr@Xb~zaX5~$Knf9Us8gUYt)@%km=T^wfD%2q2ijWmj9?$8Y&$h-6}}4@f<}zH zpOo3%7QhbzgOHf{dLP!Er=T>(b3hZk4pZaenPn@AEsN~xAo}K@{-ch;VJO$P&;!dc z6Nh0Eg(JLnjSfJnQ|p21<{Ya{9iPIf9{&m2`hcI{g0FdzQ(Zyhu!%_+C}~t-Q%)MB zkpg^q!y6q}?%}}ad>PRpB**K;;LU`ECXWLtC%OSs5kWGP0cSGkOs#JaXO95^EkH_{ zemB2@wF({Ma?qP=|8JHe{IUGC!muV>1w+M+5ZvLVHR>s(6*)@~;)i z?5)(wpTQOQhG&Q=2L)5#{C4?tMY8oO$g!gKTt@GyA$_B*Co;ywhc-icUcr2>^*b+QRfz)q_iVetQ$`-wU$g>kz&!(S|p}&RsAT z8wJHcd`H?YUtMjq@_@*e^dJSW`a5f2ffPWuy!w}2s7)G19C5A7a6qbWxqhhBe8S>j zbatX!Uu|#*AX_U#ij90tEvpO9#@{(`~S9YEe!JrMoi&$D$aLSZt z#4!OBi5e+6fcM7$NAs4-b^x9w?}+ez+*{-gsEI!p`O$=dMqwEPoWu%xo9-YO-R@pJXI}s&Y0;CF<)@@_4!= zRte0t@h^>mKWZf$WQ3%nN#R?}ypmh?H;rHYp^nm6*{xkPLnpEEHOXIwhl(vE$-f8ycdW#pI}h9lGKI@=Ar=s z87$e*E3e!?QyQ>@I5|5Fk?Uy=WFcvMLJiav)U4oom{o}0hq1vcG-naif4lYEjodXk z0UJpe+GvvVJ+Hib1xZv-k`!Nr9QajfHT^%ZFxut<-k2BLQCVrANJFFQjuGY`6?yf$ zK!+0p9W90XK#Ah(>2GT>;z?NQ+OMW5Km9^U{!+QTP`)Y_*~We7!6$SnT zcesiP<1gMV)yleNSrHP;fb>r=;i4aUhmneIdh!y*Jg$yk$>5&)|LexG3(dA8mH3Ee zRRJVu0VBazY=lt=h+YdCmW+37kKP7l$mgFJl8*#k4g}acZ=l$5N%s9)r(9Y2Z9$VI zrs;r_z3|LOC-{ImYY*Q~uuu62$I&>@(%pN#53 zJaYYdQ~#34!=02I#Yu8rwb_=xxwX?PN2iyIf5@J22NUhWYsX?_%VQ$JXad(Q=VH`dZraKZ zNSxs0C00m|{}@KjJOj0ef9O3qe8r`RBK;Mm0Q{$|41z?B*aysr)=W&waOVw4F|8ZT z6bdu8en3-n8ZcI6M3A68T}ZknnvW(%BQ1>*i!%Kj-Yj;CXS_yC52oxn&)foC93cSp zM>alKz;Lv;Y9-dWx>r59l78awy&DDxgDVy4?P6g4dzGk=@Ti!~`p^x}R3mV@-9JEG zY!!>mO*X>^5yRRYzyAU8YVc5unS2t@Wt$*kZD7NpknvtKrlFKe*EdukM4SDExH|CyuPo5VlQ5&(mzU=x80xC3c#U% z$apd}V?CoNW^u~%hVz6$a6yH(=NNg8qX@Xqf#?p74l|AU$4GweU!;Vume zjV{AMCu*LH{^4%-;m)~Q-|LRB5o?v8GG2p%i#f4sD5oVS}Aoy#=o(%H^+8s26UPjBB2!bu@!bl5X+F=o&YnE3z>@8cuGy30s`lJY{nZgB;Gk0N>bP-m$Ts+t>*JE*{8$9gZ zT$=pXVtc=SWr50+>=aZbdY`xKNlo-#i?!uqC&t)VX;3hAD%`$n$32|#0c}`P4}Lu` z@|o{0bU-3HVr-ecea~hCp->0gtJ-bk3+&56ApjymJvxCgoSOrxx{G=x^7rZkIzN0% zN_}cyp~Fti$2`+mACEiKxA+CDaNf2AH#HXdd8`=)qFCc;+F!Ye|E8&SCT>c57d$dU zBqS8xf<74h?bPa-omHf)we$Tql*BDOY_y>nla5HyS*E(Ed={pGhd&K}Z!&YmV6=tN zHre$IL82Bf>4*x}9dvz!p3eXPk`#Y`WmZr2`XHi_v1Q>-cm1Hj<~SrP<}SY#cIWNjOEumYyz}*-0-w9Yf;@tFCh& zpb`U=y%^>xG2WQUoQ^<_6<2(uXZgb7Q$hSL3$){~oil*_>~%*2Pi#^Xb|&9TEwDm# zB*w@x=CD3egPqVbe}MSTn2ULqPC7R)XY!D)(h(xn^ER&mJoq9Ab7Pcg{sZ~$9BV}g zov2KPs6RR`elea`m)g~t**^QBDhH7QL;N-GGP~P56Vi{vAT=H`gQU8+FkNc_?W z@-_0BH0*Z=rBJ73#sO(CNz*e!?6v_mukE=0wwojL^Y8ti{u}jB-^be_v{Ej;g}N04 z{uUrwG8Ku;#E?c`6p{1kOBjI3c)eljFu*ucy1P2yjYtE*V~|oYL^qTX`Y~eG!QNmd zgP(DdR}wQs>~DRFIJy4&5y|%8NHNB|x;J8woGEj1N55mqRde+*I9Oj_FJN0T^pxR}HP=HFVdNJwgC?#a#`c5e98abrW@OfC+#>q4efrU>pGavHqc93M7gg98iLgi6MVG?z{XHw^4%;BJ#VDV2Tn8CjJ+%N zp>WR-8qfQn zDgY*GLYI#gP8(MO22)*rzOfUD4s~bE)Zd9Zt65~ud(t;rtC)!;+iHo@c>M>YEA}}x!*2K|i z%A$SH-<102MlUa-JZfV@__VnVNSB<_{UtHVZ)uyZEs-B^8w2^`w%XIctNCQkbddeF z?DC(a6F6cH`WI(yAt_hzlg^RtAgF@ck?s{B`gI=?xTYZ!cV$y)+F0RB_*;dWwN9+J z7by}v&Zo&AI6Dh1$9ij^nz+r{GZ$=oMez0slhpiV=NGKxN3H3#Vu)uptv9x6hN{F2 zBcO5G+2b`qq~Ay!JUhbIF6AZDayeC@31SH+r_9%+H$& zxN%4uwP^`LTyD)o)+QZWeY1}v$cD5z4<~OtjA_ew(=U);&MRh!pP5ux9uAFG;i`Ct zbWFKa)cIV$kwbHFexg=?Ljg!GBB3yNhta-0UOpL zJX2RLLq~u$8KYky!)w;>xV+-=kWmirQFnRSuO&lY;M?R7XK{7J8~xIT?& z!jj%&pAGzlBd7a_Z?I3eSHFIcpxOvdBv8U^J_HEg!K!{C2(SHv3nCDY&9nS%$>)By z$(9SdXL9!<-=%3=(PP;0o?iX~_43m4!#h)NY{zWaHWbmD+?i{jkfSnsXJK|eLF)xb zHwyg_n?m3)LmAs2C}$g9rbdQRbh}5SO9~&-VrI+C#0Bd^EQ8RT-BLxb5>##H@+y8*vhKOCmnVy|)HfK9_Kzt+hLa}W zmaXt+aRcO>B-%qJeC?*Dd^Xsv#Qd(m&@s03?}f-Q+;SfpDj=8pGmd-$qMAs$gPyh$ zxr16~Wdp4krl)1~Bch}1NF-bwaf6i>kA3d_t*Je!GYQ|o|5ewn*ROXLx#}#O7}T{y47$d!m!{D{lvAQ@o|fvPT|}jHN`QMR^a<8 z2tcxR+ccqh2_C`vU%88yA6Q#2J?JQ#jD{sCh|8@RYn_s6e5YBg4v)i#l>F7BR3bk~Qf$h0Y z?JUB@Ylp(vh}bYGo-(u&?lsj71h9;cS;;T?P?Fp*R{$4^*yV>@ei%Cc1ePb&P>t~$ zjxiIh{sEx~Gp11^cGoOJ% zqZ|g255oBc0`x#x!@yzOi$|+1x<*tD#Vl3 zNQIDD3&>OS5Qu55hQSgS7v~UlS}vMJ0<~N+#52x}uVXY9p`(Dq@A>XstF#$NJr&Bt zvIij2FKQv_V4gvwwX5AUt8lZ>9%(PIk>XV}WnDmLvaXv3o6M>`cS5XPuafc_fh@8% zVt-o3TJzotGk*SIg|W(EBh50SYyqurrT;@}B2HMxuE4QX+usDO)sQ*69%gXn#We@g z(SaSV`x5k=8$hW0q33mVV@oZSbwX`=WutpQpTz+UnVcuq9w;hqD~f|(L3SS(^=UYt zLJga_3MsopeDEQ2fvnK1{gQB3!J8L;Dwltm;RYuJN3wnMkD2(mLh%ucIa5 z^O_+?sWrY829=i+uq z(Y3F9`Z9`)7HLr-$62EppyD_}ZIn?eUXCQf!Mt;9-V(%q_FGRvFJ1|lGqoWFGc@xu zo429h@O{}w^=rcH`Zk-c`Fl-={;OO7v$rB@ddGQ7PaLgsqDn2Z1TL_c91Yh z+^iaoR}$Pn|4MRtn`pf%i(huyf5LC4U|ziyp=l`uTqlEC4+6h-Z0BhJlBd^}n);q$ zOd5K^sY#qm6;qYW7QCWNVPhs9JE8+b7e4|(>c0lo2Q<)FDp(LQ5ed8Z6xR&55-qJ} zxi}e6s=B3RKh?Z>c_#Iwyi_yJLHs{+3hM(0$2LuD%{Iji_e6vE%_RO#2~zX7aj_?qm@e$S>-V$ zLqZid{czM*;l390_ksn_z}x4%n~|6a`9OLtpYVT9GoJcqqi%_|F)n;`)WjWK>{L8tT0D=oh^qtw!hG6!(7?i zgVBJ{azUHzsUc+>t{Y`gQ313CTy>L8O|~~FyI2oPWDiLu6B|@UFY@C4yDhoHfi+z4 zK^e2J<4k&G1^3`4hAu~(DNIv-y720Zddm%EtYH0F7j=^L> zT7Y_A-p&Dta&lBK;uan;9hMQ8OFmcDbv$8X^*i+&IGXF*?t02?6fPw$f0oaLx=;;D zPB&B7=Gn4GBrDCV02W#X@kCPsoGh60owW{}Fb4Eg&W|S4q#tq63Uhj7L+eA6N<{~O z(+MQ4I|TfJxCKPeFWpd)o}>NH05TT99<8Y%$Ktvw|FX8~4sK6`-HrZ=n$4&X@a!&$ zR5Eny$O?XF1HE$DtAQ~ib9%94ntmr&%h9gtYmH!03}S74)=tcjl8?u?+{xU=_oa59 zA;yqcc*#99d=pRmwd5N`S9*~ zA;EK56A7dwR%59bbMglpA&_P6uAk3#2_%m^7Kb9DvT}ODPdI3yJ@KMOs?+#;p>*yV z%+v=1mdx8O4Bah$7=D1{33&u=uNwMqE0p-8oQW(sj>g+Wqu<(27~Tjc|K%7v-;1&8 zx9pUiE9pCnLoKHV#?e3mX}Ov_c+E$ZfJhAVxIkxPp5mog&svkpas^i-!@Fd$z~m3~ z-XtE5=))7ay;zClMM9fzKMe86Z5?pueeP(Wfu%>a;F`N=dGZ@rvF0Zd4KCVlLF9uA zmKP{3peEi9Bm+)Z${k1ZhrW}1v;-d&mJg6eHzNb#3G`XMYFTz%UQ6+4`~i%OvA6sG z3c5Z0E$=gzAI$=|pk^oCW%z~BSisOZ@v%>FH)MP3r&ovwoSAO1DL%@P0EX{SmpcPSvG#*SfMn+Hi`!{K} z>91>2GhsT$Lf;G-Zq~VLLoP5UfLoF=csqXb%-HyHqS;&tzkwhU`*0o2Gx_wx{j<0 zqI3rx@~gGi{I20#44@Zsx7eVK7^%|Memfr44AKe}Vp38o9eEpSbP~g3A3O9Guok53 z@w|8v=70XGs*bIfp#p}Kg@wM5oS50DXn2s8=mDauX8lk~7nL?SMn}FBy^>}BNp0yE z+{2GkNn zYGM7hu2uQ0VZ{W*_A>PY_g=U)wIK-={qf}!e9-J?%bc#z+?>^#Hxp3 z)~0uc4n}#R&Q_CGEnK7!zhd&u0-dsnw9f-9AagDtAgt2_Nyr9{qm4V;iZg_SG#YsU zeNC{@H%RF82>#39^dkguVNv=$OO5Z=eSA}v2+=5t#aP4b*Q40inzTsG=>xtQI+bgM zXrNKA$6(X=65c1vnnkhr>jFdBvaEVOc$*;X1}yI-bFRBb%iD>LM_wH|Ccj0Ri^0LQ zOc|WtOAEizOCz^|W9Ejb>1bNFK+Pe2JiDl#lZeI$?p}nFh2(J|PkoYUiza%!1UoL> zV*yp4j??ZtslWkgQ}=^);mihg!lyzquvQh-Mx^t3Cfemd_C z0A%w3(1JZ$Fpk*&0CZsz;${x5%Z)akKb#wA_Ybp+sUDZ&w!d{|_@0+I(fK!DWR0>P z*bSFdgbgwz$kaPa5ujeYAT4PBNT`~G%zwxgbKq%Se6bvVHl9h7qXERVCdN%+H*_dH zGs?^qk2k^QcdI0@w4{_^i5g#)bb5>_!=$PQQy$FMqv7VW`JH9HL6{6Y%Gt~wSx`^2 z1i~cVsls zy%wzddMh+YZ+pFunK|+xE2<(_Xr3ml6Xf<-E9CG7SoD`o;-LANHUroR5Uh+#m|GF>Ks=aiibBnpA10&S8KKt{nA}z-*<&FhO%)Un)8_2Yx9A0?~uND6C3@@wbD_vAx7n(GlJId{k$ zjWHey`j%|*98F(G&Y|*A7IycnuAY{b1rWtHyHbbUD>?g4VSlMKOnFcx&s6J%o5B5I zg$j}JO(vQoj$ExOvuRD@tLZ8BjC-;q!+CiR!6KICikY-}3o3xEnF5EL@I#epOy{om z(suma%-5I?$V5gGulP)x!~&0%fmMG!&skTy!2PT>xW+A35<}eihklHxS&a&zr`1IQ z!!T0o;&gndb*}(-+yPH6#{*MGqCcbdt+8h_=~8`4t>OJH$x`LCihLW>Zq_9NKBM3H zQdHpMju3BX=XolL#c>%LRo>0?c;kQ;d;u7AmALbjsI>)LHr#Zu1$uTWl5289$+NS~ zV51E1c}0sWXw&V<^wD2vHbHw=Gn;!)s*?rTfKTDLnzw3c$I)Sr$^F3@k(^Z04hBt> ziWf{O)f1v8Yqj;|QA~Q~-GH;W;oW4g9-#l_Xz2C}J^llVsM;0){{O?A>xXdgJx`*e zT8v0TV2F2n;&to*x%_tDfFaw~PiY0k+IbVZI)-}M{|7c9%t3*?)M&330yA{tg=M;K z0s36-bkTX8s>S+IGByxek5QuOs4Ud+j&%WMFE;?WL31*x<+{I$nZ_^%mp1vE4PCGK zn!#nLuz~K|H3BozUyRxU(`iV68}a0d$PWCC`_-a!&C~O_OF&200?`>jm(for)iTz9 z>k2u2OoQ46SY0H_W8FQUaQ)aNXV(=1eoIitB^I3ipa?)jsEi~oP{f5tn~+D)=FqGI zRMJiFOo!pK$cXw31+?XiFZy0qHBeFZO0fBXh)N)Nb@uZ~4=S4K0>2=Z~cF)8Fe}>uBXZ8Ne|; z-UTt2lKE6@@$uZRRaz7`U|kA@{lMt?7y-v3`EhQ2A_lH{MUBV@RhrI&E3_pD5OiX$ z*&>+Q`{seQ3@v1@9KW1=yzjPmg=sQvDE4Cm+0uX@OhMwRnuYNNn%b54X*vMeA=-KJ zx3T!Z%JB){T&-BkT_}M$*-kJYZ?Pdi{n890hmlRc#zRE=O`REwm6@Ov3s}sVG zXB9<-`waVSgSvcTGjMIzE#9!a!Ocebxn;PrUZ1}4075*H$_Q00I51ou+v9IpFh(3} zL32L2CN~b#?~=0BlgU zY|Wwx`yC+~#xT?QPeamYOEYQ2qGJHsQ7alI?G`@TgyGMTlrTd&twG#J76&|X6@tzEs4JdDq;C0R!Lj9F9f(RMl}kHCdcQtOt8QgA@fp`4JEGARJJw;J zE#tCYF;|GEA>fxw^4V$zQELlmm5nicp-+90G7S>24@k0)6_~h`w{6|(oBD{VY6h^~ zbJO*tomr`BGr+bSZlCIFnoa->;0HyKyI~cWc9M=|I!?W$9j!7I8_~>T)HD$;`rE&pWI&ZZqX zVTh8fFdOIx=zkXPp(m|_b`U9uoU#-rReF7F$LH8{=#>w7xne@aqb_Dl0FzK4p#yA@ zQ{vr(+YVNgxI@d>>epr7={==xLN-trbGplWh@(@@LMBEE0gt4Ph_p|_R~B$T^yde| zu@zx3NS|k)*iz7<1J+XF`*cf8_#A+RyLb*d0Iu1d(7)d%_;F|lPV?`#5f|pE*ip}# z@F6+!UO$P?P^o!W=cRI=N!C;%_Sj_^wKCHQaXq|<w0sK+|d4J3OD}#*RlrPdL+?NKbHnEhBgy8Wc3{9ujpDRXN z!qyB4P;lvVkkorby;AUci9V!9@SJM6%z?~p8* ze^@fwoQ|pJo$mPGEjF$-*3gB0J8#+kplLr++L(lMf1~GfsZAxA8f3olO{K*kdB3~W zxRy9jSn_ymrN!~yt0q;WFI^`>|Aw?9Q}pUd(MA|qF?>-C2$6VO~6r|EWgWVwNPcXM|Q`eS}~<3 z(6<#Qz!U&UIVAc}j1e%@=fWP~@$e0#6Z9Sfnc>8fB=Otd7wl!%6 zQ2vcF%ZmQloA^X886-fy+ow7yrXY*6sEs9=7hpE?>~r+Bf#gm(l<^zri@6OIX1;*@ z%HzAmsCYBNjhvi-4L&t#g@IkUc|GfzB%cwv%>Su+=iTAIGzWiH=>*FFRE;*%NvNLofS?4CpAa2*TB9>k+o2l@-DNYnr^mP-WXqD8pauF_pe?T>EhWm=w%R z@(gv(3p|i+31j=ZQC`Wra27gj?YR;HK81$d(^@xy&JO9=|q#sue9 zb2ptoooAxxpm!C?nN&v&iR@+}8h z^xe-aJt66N0P1j*pOZ!%fthH>n%cQ$VYJXXYTUCBgej*&Gh&m!LQ)0ffPylFNPO+* z=(Vth`E2dMtsdBugr#Cix73UvejiNOArcFur%O}Y#q-_K24LQYMWqVq=p|{acj0w_ zUvADtr^|XaC7L|b4woO|dmY!1(7UxL03pRkA$mf=ydvvm4QW|&hkxno&a3&C0zAVM zs5z1>OXG|M(AF4T=ly=$hz!=A7PC>avd&Eym}s@9pNkNQ0%|?tW|xoOpR?R_77(T* zGnCaKD;&~`Nq24UF|7k|?&_;-|1#4lhFr{sXAgwY;Uykw6aLHH-T|&Op0WdT_!^Q#u z&=T>9M^cU<0uG#;=JKO+ZWgse3ZT=*M@j;BUh9VI?;xg51k(jkHqU|?2%L0C^1c!sTz)f^jdMgjS+$i>|NzTGbR z%A@0AMy)Ru*~Detl&HPcV7j?jyO){R4=mWzr#v2U1P~I*E0ayFh=}lyAjPe44I+%l&qyGqP9|V zCt8(ZX%M0D@N3)NI0c(aldF_bORDnL5q%ngmp@8uMMX-mX)hL6@!?f=+3LB2gvaLj zIWSfqBD`?4kTvHU&>1s?GXe7nqnw2R+-%+&EBhd(;FO~AJY`<&`U%hMnJkY->Eog_ z`b(-Iby`TQGkd4aOSJ<&&pzfshH$GqWI5_pC6%53sT};3Z&T1zb6%hM8Q4#Vm#eT0 z0i3Gu7_cTKnqT=U%G~cI`cY+8KRP!`Y~#bEIbM}`rD{pY7tO`m2&$X-y0~6&2STns zHaF+5`W~c-^jZeH6S5Gg;EVzZgNkp*bq+j_+MH6U`sMb@&e_b75;VchR)=uc0%xm5oA$c0jd)ws|! zx}6h|R3^G!xy9STagnc`{)e^wWXQnZ^ljen&F?lddEZSaJ)j~>xuSx;O& zG(zLyxOcK%AOlZDQ9z6UqXdM}|7X^5Bm3rlPdJK%fVOJyk^Av)y7d`+_9;#h&Hqw_)Mhqk!V#)Ct3!sM7k}SvETd8g3 zXqR0zGuYVK(VYw>zu`}nUEPh9=|FdrBKWym2hW_WmEK@6u-zlX2>--F6(_9s?I+;B zsXd`J&)A^fOw;ze*;&|L*lL6cHu{b0+JtIVM;^2fv&|r!qMs?}-1s4>u!-yMw{jiw z=(aao>7H3BBJ?a3NixxmxW47yNX z>NHQ%3>3Tc_5pPbSmD%;DV+q~ur{nCtCxQ$Z0-O8T>_@z_&PAv?+ zvA#vmr^spC@eA?F-zclv^E#)U+;@Twd|jEaa%O}yF64Z?7#n$?Qs^mBD>27?Lnn0K zEa{rp{#CXhz$F5P}g-2J$gc*Br>m*GQI$u zMaA|!UvSc*URqtxQg-lSW~%mvfO)vzk{QSe7>ThI%9V(^niDlL7lDA>zGc_BpPBk! zpCfTVrz8mLTqON@I;bz9#wA}72>^aWM0AkO)eJ7yT)L&$%=dFCxKuL~)C#)#F^?oV z9n6i6uD}4RT!A#HJ*%+an{GfP_*g)=hit^=at>qA>3cA8BAHu0gLKz;nR7?LYTE_{ zs*28h0!f7lBp+6C?z|DYimold7p&L9a(|p}HK-_I6whLk7^34Uv2ofIPW|I%4NpUH zg|3uyLAUXk%xPS}jHOVVcq3MSrim!5BOt_J&l1p+Q&=^RwLc)WAVkhZ#oU7w78}(x zHCg`xqC6%{mI5X9H0`NlmcbGn9^-GJ@^VQUNiZnB+0eUwt(o~Jlzy(}TPo>yM3Y+P z-fpMcFuk_w#iglI>BKKSQ*+SodE~zqk$F_cV%1NtK0c?{@YrHsTT+7R6C0ybo@vW5 zBsaJJslU>rxRV1C_b`|?>{RshUvQ+kq_l;wM~f}#S z1#chEgV^;6zWkM~>VC?%bg(%JF{Nxc=Q#^e8RLqgS8A)Hj;}HEVl%+2E1L5PogF@e<8@uOMTuu!-9$wT&>*GKaWmoD?F{*$y%H+K7{! z0Rsm+%j-W+E&+F2w_eRIWmtij{_3D>!~PqSc5Vsrmced%`dT;k#_=&!aCg}BXCTXJ zUWTw!`{5=GCvIyeZx5b=B}r6#Wg5baLC)z)#yhp*=`$T-A7rXVyk*q8FbReaMIzNG zb)9-fh>h$+v{FDG_c6UxzGR6vrVIif5<33~{Rx`&IIn{d$H6xB7z$4@5wBlg)`Y}x z_6wqMIrldgJ*Oi`F3;ARan)w~K{!v;VIIdFo)nH2c)6UfD=unlATuv#a<^n7Dn6v#bTWBzD}YQj1Q z^OtfAV|QXw&EVyg@@ih)yktb6G6*k>6r;1{#@@=RySAH zHy}|)=9lCSoyWx{+ydM8HrOmg4QK{g<%x9>u64@1J6W_|H2NSw&2)wYUiQzeKjrJ3;Jy8QKz)GY2nS%04936ZQ5aH*n=;CZyg z?El?x#3?#t?(Jxy%k64U1<2g+Y#cmTbrP9>@h((2hD=M$pUW<6laY7DX9>)jQ1+e` zC~G6I;-aCdkQ@m9k1mnhx#4qXSwY(rL|POQoYIY};|v5=v$}wNx>ynt_jJ|GoA6Yu z)wT0^1cbveb;M0k@+9KhCJ*Z#l)(d?%Z;nLphmKA?E(G;$OLT}S=APaVc@MNv&$!P zsujLwFU4t3qYwEG&|zWC7-5DHxmWoEoO7@BzfoY7sYn1v57?K1jh)sBaaQ^v9M*yT zTFtU;S{0>+yo)tL(P?DG<2sr6O3sY#6SyDJgtvBKSsfV0#vMKNMQWzwFmC6aoS}UY z4{yCg=_1YrmJT&$bfuh#$bl!5CC=B@MIyYW1X4?6F~ zApq4|2#8C5s%7*Cti0fwt@P7N|IVtGdRiPVL*>sN%6|A`Sr3U}O7$%ujI=?v?DFfE zSTf}!gmtv_34W__S`gk#36C;TJP}=c_K@D0gT$-*i4_LV6?MYF3%z6`&MmO-pV`mx zI%BK6f{^96D!Olo-#25$LKH1|$ym9@z8adFe}G92{oLjM>lmQ2rO58I*#Nr$y0M4f z|Ch9QqagCB!`~M0}fG{kfLzKIFytBRN{9Q%`TZ;>BwIpz73AVm;*5^ zb$qh?p9DnsQ}q{OacT_-@gnyj4*LD_up9Vbn3fIHLuGee(4!0#1=$B`+0W1C1yo?# zIiA6d-hepHocb()K%%{Y>M%oYS?>4n83C)NTJ8ssW2uv0jJnI`ddT4o-g;#v30+V7 zuBuQgs|b-$#D;8lYwJ3@;~*ET6~OMR9hg3Yg8Vl>Po&P=I4Nr~Wq$HctHxr!pu^3# zala{l1{R?hJ{G8Tq03EtB!5wVI~tinH-^_MVPgdnJ9$z_YaVQHa66mO1aLb|W@fr6 zzM`6#gI-@evAuP_Vrf>-cJtTj444@kGy_6h9)~Ff!8(oV6N}@yJ){B6(u2Z3?5tE4 zrBRi3YJ3;5sW_Ri7KrTi~thZ#nBUj5=Q z4G`VG?F#OCrPUT!8zg5W_Vq>fKM9Nq5tx`wHjt42BV58lBYyo`LRV_ZN+Y7MkO)sR zkgN0#wZn+HYfaVB(cUzHQrG|f=oUMw|Go?39L7z}VPIs^S|#N3A`rHGqlgBxixQlZ zQ3{SXr%>-#cPN@2U;2*z<_(XUiyN4^Iv*|<7Co7!qG_C~q)<>-^?$0}-D~&J( zDp?So?wmG$6lwfrZd%L!iu(N86>72N=q^;td8ScYNXBWTwsDo}UYSr5SOY36wKueX zHQG}fTcAv+TH0Yp#3FCpk01X`>k2%`;ek6WY(8O2lcu-E-siRzN1@lZ0_%WEw=j9T9UqifdI(O|SHvz`6Ko8lt(eDs z8;#QG)&AYC&b#AIyTlcV_N;S{V{_NT1%VmRFpu@(*19b-w~M5WkOR}!SnO*+~~P#B@ddD6#Th7bY@)$!rcw&Jn?QKA19c;WoK zaMNIZ;kO-BGIPv_>#|ACbq9(7ega|t&d$<(2rr|Qc6LUyYU6Wj0f z8j&(MP6EtF5d0i_VCYZh;vGl!mCi^MQ=Iz{0`u0|xF;#ydmM(RZ9_{a@BMH=X+&wC zEF;b5>#3-rHQ29{k4?WmHcrK=N@;jsTX!UB?awK8kAD978s`i>ClA3YKuIpD6vH<$ zEmOHz(itU%TP!AQbeCnR-WxSoQ0){dRfN&!`+H}{lMue}&mH`nO9VdwOQp4mB5P?H zJx>JZ*5wtPGXEupnTk=pLjr@?AC)bA6V_xY zS8yGl0IB{q%Au33_Vf9=T)PHdL+0Filhe*2%hJEzn_-#8Ld%$Ps64~jew5A6R|J?A z13EZx%no$x+~K8eN39*vq6U9L++bq#l2({i%{lg@hkWwRQM%j1X5lHnw7n@eOpD!k z_tT#!r^cBGmAedpwoFV+Onw!!R<|<-8?h|nXyCj($3eUt5jLD&xktE?gy6S|8YHf@ z1}H|IdY^ufVlfKuw=MeyYvs!wwRqn6rJi;j-gG(I@Oh51r$-qo2k_AB_DAAdtGebG z=N0BEz_}I^&8|%XS%C~4$891C`+0(zqeJB4pCJ&5CzFvK1Vgz;KrjGYGGe@CI`pI5L3FdN`p@+e)I$Hc1@A@G-M?>EFap-}M8pB?!}|#Q1y;{>Jed=DSBlDpba9 z7qV2HCR!>S;!H9Fq_GC~?(VLuSq-b=w^SrcdHzanUurZ3zhe&i;T6u)KwT}v%MN&@ zE-(ta+Ht)p?X$Gh90mEQb_rKGMz;P!pmM5w2_~Exov7jROF?7`%m*&QVS?ydfbaCt zKKX^;s8Z3O3ozOr=>WLCwGXIyKwaqm7=T8F_vc?Y!q5~l;?E=>Hrr?97g65W&T^|n zsP~dNu?5eS&bD73#m`n92fT|2!()30szMhiMBtmVsH2gDf5lcfaZJ@dXM*6ZCCSOJ z$+h<3POOYP(>VbUtcxJ=k>|x#dH|^+Q!lza`j(=shBu!21c2Edp+@fxrtTL=o&6>7 zZ%_J+@GFVdcSEa5pTs~cFUmoNMJLyHTJGOgV;3_X0v42-BIP-_n@Tc<8vV1~F(Zi# zhaWOoR+{%h>|t}YwkDZgn6Q{%i)3H;O&^;g^G^WpR}*ON*(g1E=E~BRJaAK5f9ey5axS+mWE=0rs5o&z8x~lrpw@SkJA7cuej17 z1Xf}F9*-yA|3;k-ofA*bRy7%rnkE%v?ThQpTxarX^qMzmylKHV8+7yZ}SpY8aJ1bMAj$=Ee3W6E~?7) z^1EaO^Oe*L&GJ>sbLOl;@D93}MZN$efX7P@v>a~3hqN9K`cWQ_b~x1K<>A9C!C6#{ zlTy0sLf{-lTfPz$JPC)Uw3YlFh9jw|EDEWWWq60%f=J--Q%O4eUB>y6u%`w9Ut>&r zZkFGDd)CYscb#zTE?fQHqlEbZE$Sm#{F7alxYhx+czI9lh`x~L#(j4EFN&hk`psz} zabG$CmNDgtz*20udwmO1U-B~QM?erxV=1`47i8vo{7~s2bi4h483ySh*FFfzk&&VX zBxq6gnj4H#oGIVL1r;gAvw~l3fxTlLXNVG+)|kYQXb#m6uYq~4rvs#st^YT z{8xeeOqIN}O&sip)SDLr8yJM`54%{C&px*S4wOx+q2bg%($ONv5X#FkBPz_S5*g%O zaS_muNn3U9w$i_2xDSZj^^`2KIf@MM**cA4`9Cn$C-4;e&D|E*M&p_f*b+MHPBd2y zpisU_XsY8cl1JxhhuZ=S2}`9AsTr71A>mL%5bu|sdI7hZETYyO_{@OdcUQoYOEu(x6w{k;v^IF6t$<0h5L zHq{5MqRu+aFH{sKY6`iHaFBgRWUkNbqDYwV@p2FHs-80MxgPKA?EdRTTwwfz17QRk zvjitxVkv<7cT)QKz_BR)jqsFK0h+|rB;Nye6if>HoLj*xLU#eMrb0d-BVL}ot-GVz zUNFD8R%w2+2p=h9a{OH~MqE%e93H%ndx5)bc$f530tz}J)=D+`NO&fD zM%a|knOioxd-WR2gi>TZ!`ghua-No(aU^&~gONqItp>6d;YxZ#?JZ z`YDQfu4o68P^AIvjRh~Tr-qt^?Yl<)+ClrA_T9_&Ts9<38jN7Ylu~qB!X&d z6biG=%Rmw+CGN8+PbaVUPiEwD**lF;YPZ&T-#{37XJkiC3nRd0)u!b3uKUu8>%Y#V z^Sg>e>m@7AfsKsq8wIPSHAUO)sJEAB&nK>)GkVN{iPS(z-InMuqk z;_2{VE&!_w$Lx-|Vs2uU@Y#_$BG=!o<`2tLI+V|Vh~dk#MCoa7UY5l|@}AEoAZlAV z3S3XD0Cf1WL%j}AL*l4Om4;O6AsCqYH@G$`zbOt8Z;<;UMZJ8$c2hjhQmc#fzhUIW zaAX!g+nLdFg(@i}_Xh&q9B`FusU74DN!qWCR_dp_7S=dnKz?erm}Y^CflK@%2=SwIqd&tO6&w3T$r3;=IArdIHGqlJ`SDnJ|$10 z{a9R&YlH+r{h45r`2vV#w-Ocpq{NHcsMz>J5yvY6#eu=x(|)9#xkTMOLB!bvZ?Lac zSOT|MFbW@?Ift8uBY56(i6{vhBTg$=tPt72e!y$a9$}^(tJB(iO5>_jm*;ZZLFr*7 zJ0gM0Jrx2_;cuj|4Jb9BlzSbWC`Ls)zgUO~o%4o&G?;GU;T)KDS!gQ5N);mwg=2aU5`(nM$)uG0WV;nYhZRm9PX|QJ59)N-`0NxbLB7{ zNQ*+P8eFw;;B6aoKGX-Fic@?lG1BfC_Oe&ZaO4j>3z)R}wqH*|f|19|{<9HIPbHWR zy|RCi{dyWj{xG|Y>LeZjFF?@0Hvq0xt^4eG{7BOu5|f0$=A6{-n#KC^Rvso+3e9QX zU~X7*Vq&Q|w<58#as<4Q|Dj$pd&#$B^E$w3Bk3Trex)Dlg!*SN_1zs&E4gO2c!Wtg zsqF?Yd=jT~==STv@;$UbL48Knlm<~ixsJ{AI=Nv9CFI!Bf8CH`{q?*_!mBSFpNGnQ zu6-Sh#G6?P^a?g;7#ZfRY9249c=1ASoI)i@p*Fk)9Vo$q#ej!d);zk&+S_lr*!KA7 z_ftp(=Mf?Bx}i%o`}7pbHfdS482vPJcv@zRfZFE)Qw7rpmItig@6AB4jXfQzIsM^5 zVcLSOx3Q=X&OFY5sJy!yz}UbuvAiCXO)r0}urEl{ZWVU#bZ&g}26%;C5orDXgwJ=? zzpbq#!c&rnZD_7IKTUxhyse)mr&oo}S>My+d3r)JJ`p(LIc>37+_RLfUEhXNhb6PU z?OjvI5D~I1l@b5iaBhh(IO}$SEiV-2?yTa?BI1=NEj82%26$F6mPAOvXC$~S+_;MAlt{XRi-pX;KqA5 z&zujX-UJ|l?qR_+WK^bm&d0{!p|aU0%h*upE=RJ*sqU zB+=<*_`EWux>em9N)}%tva(aQ-_~br`H@K#+KiO;Tlc=7vPd%q%vb1xuv!r?K<_v+ zD!;5FZ9PM#u>|w~nC$Rb29rVeYD;oL57|)V_zj*1G7I?AZgve0i&^6cyGgobFZ}CF znt(aA)REM1wIa@bw3r5E%_r%V<@a>zJ^#xYK?Ln2asR54y#(6QbJup!l-qGr#H=77 z)@}J^?&oT$V=WJF%L*gMNCs`BQb>>Y(L1C#zY}NgWyK%Y$ z5!&BYlJ1@?e=D|GoUz!Kr`A}teu5df{2ia+VtFd=zwzkA3DIl_Jms?_E}|$TRb>)P zG6}FH(O8z&BR3d#zXBIaTt!Q{i?9#`1U>08;G#Eaep`rl?R>H!j}aK%?)`#-4uoHA zQ5!uiDJ=f+75h8?9E$qzb2;C7?`c2naC6McxGeeEZHm-unRmI{#cYRP^#46H{`CjK z90N=|bR2{N7HEv0sImOq4I$2HKdftoX@L}Wirzu4D0&m^(A>GDcNrT>(^F6+R`Zei zlaH5L}hQ0 zG(VQRd1nR7V~c`s@n>Kev=n3(ToRUg>lAeY>jp%iFvrxhk+?h0yur@psTH8K?P;K8 zG>!vKDW+9l3>5+nNu`^ZrzTejgFg(OJlTPsyGB)6P6Z<|!cLTuP(BXAIBfJd@H&)o zoM>`-xAx4FsfB{zO;_H(Q5;MhBTyMBfoJ87L-cnkr5ID z`_~(}A5iv5xsOVPoUi7&w%P%G14tssS<#X`6j zDj5D(2g{RcBLU$E9Vl~lLeMTa+Nj>Fy&a-X&=$Q;bJS{4(=bZ zXj3x#4t5c>1o?ks%BUa)0ESfJFz$W^l!UC7bqgzq8adzc7yQk92jLv)Vc(w4E=C;3 z!>bn%KC%>onSc^ud!ZN=yDvLg}ZCJlk*Z`9K&zy%G zzC_j;jTAhiV);wcRLVDE$-&*;CR;*sP2o7yk3q5NAkTQXO#{nQ8%f`dc9-<-e1`(T zK$ALH3A|v|0~RoL-o1xCH|jv4Z}&1?p3}A}YA>I|*hjA41G8e|Z*C+4z?cy?sd%*r zR6fgim#XLJhWWv&gD(>6Cy``f+Z~67qn(RwZpHXUC#9vr);~}PyfIT;{2~U6Wp6vY zY1{K)e@FfGhoP|LG1B6DHZSxVEL@6B)RhC(UDh0Y?Z*oB8vJ~U6DT7aX~(C^>e|9} zCuj@y*jgUcyDA&u%!YG<277tkIki$(hEEXOaTf_a{jSZ8CCF?{(Cq9kxN(h^WUX!& zCL(kR%(A5qK(hrk&hN9IKXp{g+}hLRm1W!)8^lE|^<|vXb<(U-8$a!B+}h*IV`4V0 zxp;tDKs`?>7M!T^({wj}kF@OG7#|=$t9f42OgXWN3qUkGQ!*H<=a|0fwqc##EG~Oz zPR+vYvfMCz?Y6zLonmI(-5K_Y^d5x#5bJ8E`b3H%V0?YRjqY)Ge6oFCRa*{B9XcP zwPe}vvA}49elK=CR_^u&-JJH!o$8tmGTS%LzF3^Lzk{~#Rd+ai51na*Z?*dyy9pz6LX+c6(teJ_-v zKxiyql7`l`vE4q}$h3e-h;eg^T>!LYka9>(BAL`yW2HJj!{c1Mj{9S%L0lalGe;*} zQV`ZL!srDH0}uKj)Wy3DS9R&%zjnD$x|p1C!H^g|?h-HD7nzC4;MPsoAyT+L81MHa zbpg(;1og38wi2_7jf)7lg!k^}i2nag@-<94HGa%~ep{%LT>M1|#G4V1r89825F%Sl z+Ave>`0AX)ag_e1A(cHkfG9S8Rc|Fz*XSPSs~@|$s>JuAJ4N<31x@3Rv%TbGV1JI+ zWL8;y_RtS_03!!#VHQLykH<#IM&kPCMiay@TkM?9in*~xdtK@ZFi?z4{F6^) z#XbZ$q!gdwTsUX7WYYa|<&7$!DFAMVRP3n(TMNz2`()tbbb5fhk83IkOET#ffBk>J z#y~+FeW-29=)u*!$Gg!J>=@DA`X0^j3e2HnFG$2akY>ymN#+)M$HezexkCpaYdv;2v z2@t(M@Vi5`6NSp3t=Fb#og9PbG%pCqTTqr&6CSoUXs zQm@Av2ml8v8u8S>z3p;o0i{u=?LV=#RFdrl9|}4|?y()kO`VA>sJIY%)&i^mPqZ$o zo3qEz%52Waxfdn-$aITQ@&;iNj#Pp%^1!Mv$2pW$0b(0&ilp4|Ii$-LsA` zE-2uVN7>SWmQB^Gr5$tt%Lg~Kbcy9w`ph&ukwFmx6(xQ+PzQCx3ID_oRGEf-m0+{X z*5jx?aw2X%mWQpa;_jTlzg8-ULEO?qq5h5ckDV_a<|9x;@E%#){^tvIO|@xi{q5Mz z{gcE635F3_xU>7VWXDGC=DMCdY)LZ`!uL{%CGQ^0#qyPcp)%t=I&g{Vd0_(w%zEK& zXfj|87a8)JJYQ1@^WhlCc*5Bn9vGp?K}9N+7T*Lh8&HdIskbsdhC__~$Jkb0!v|NT zUKLIr1N-!undAgB{&e+3D`d!}*id3?cCnT5F_~bhB9VW;p*W?EB4%T*20yD9z#T?4 z6lWVcrdDswGg?R!5KE@Of@IXiUdo2J{UvXL@m$Q;#oSLjdcD|3&+fy=CP6eLa9U%b zc;e6pq*5OEHXyO)oD2a(|FS9ox&X_#Cf|V)EH_~b?r%h@tp~Xzl8O=u2mO7z8LG+R-NA4M?XGJ!xx)#^w3h7*$+rQ z&2uJ2@gMH3%9R`|!73yggQ?$-0idV_f=k{PWSqEQR| zLU(uzFQ(*PkVyLn#{C}X!c(YYt^{{K^!w<)hcrIWo#6?Z{2k)>;}8xm?p4E#mD0u(Xle`RN0rk~8p*)irkKm)R)aSiVuccG z4e6Z`){Hbf%7c6AsL!o38>X9tq9+`&N!S?+_MOE5Wka2Z86LuemeP_Mp@@>X+{U}< zJnYl_T?cDHpkW|_1fAhzU8lLHnR_y1 z?1NZeWm6D1$S|#3ldHz85p~LrlrY`fzggB@p$!WdcYQv&gbpYnCOWOU4D3uFBN4%3 z&An$RHj_72t%jC8n&?IunLX5C%iW2mGVI!k_tCrh78s;s!+?E!85?N6hc`;$gpSBK zNcW?_+b2|w>N)IWW|0#5U++y*0%}bKwa%0>oEFd*wJ=|`l4tdZyj$_fmnK$QO)5Sj ze7|uD;|1Rn8$&CCuTExiZ}1lwjeySh%J^g2%BqZgjXAHqY}s3XI%AEmrycNz9IcFS zdg6t}Jzxgjg~?MCW`lm?mvBTC-gNoXS;zv<8$`kLjJ*fR2pO)i5DlBfcF)kj5Mb#WfYO+j+pZ+P|j_F);pVH)Ag1%^yghkF*y#3JRA=B){;4DW(U8=pgqr z%&wf05!P-zEKwfte?^S!a&~NvK3B+y*V?Y^MM)REqlo94+X+daeD%2DCOp_ixS4#x zDmWIi_H18B*CTDW#%ZGr$Y4xCmtm&6A;XM^TellsJ11lEe^+6~a0*~T=zDhL;*v&f zULUD+c56 zeY^5&=Xs!nwKBR#V8Sw4(M|~dOHP*zLg}dJ4Vs$dm0f0%r|Y_>c1wXkG;GeH^3C>0yY(n5s$Jj*)PnW;3IR zg8c1+aJo&=u9aOh+xvHPx4J{bN~DTlwh22$8{Ggw?z@#l5!6{@G_}7b(S}Cy@KYwW zk;^1c@U+hs61edZyYT$5A0@CXN8W1ekmqrI{Oj}IV}248)8UUGyvp3uFM|EmX6Lr~k z=5;Xl0$+!GVGW=q-jzTuDP+=PPsUJmj-_pz$HRfuNqLOT$%XjfYU^&h)Q%&Zv30*` z-1xygX;-)^si1E=n$uU?Er@?x9mdjeBad~A%=xn~`z)#T-p&w=fUClH!nit{l0mFx zP*U^Q*4;#15n6zYH!1&^8x|WrG$~m>I zY*~wDXAMn?Cz9+K_)4Weu1$%Sn0PGM0P1^cOx7N4QgVYLwYC#>U7)>|t$x~G8VU;g z&lCH38S~KmfFGWtW>`-d^UZ(YQND_)4xWz&BSq67GS>4ys72g4Y!g#omSd1hg{=ji z!4i{)fm{d61@UvPT7(~F%iw|ZU|o^bH2uYl=!4fE{0s`|S@keE8_!x(p~%Iw9+e9*Rs7Rq+!cl~^@?`U z#;f#`ZRIm^USNy|)LDIIoaiRu69gyE3d(F>x+Ml*n7vlhtJ!rF1JbVdp2dWgG}M)L zD>_Qxz)h`Y&&d}PLX8||D-;-$#MvY>iMRIdpAgDq3#y97nvoJIi6Eq)=uE65 z%{dd{aF1-A$^AfjZBZ!;xLMh^GZ~3{<*ynjSUQ-gyidK98|!;5ca7cE$E}89fmY9w zt_IKqCrBo3AQy5~TuZ@5Q1XZUj+bBokNfwd7ae209+Y)Gel=7YD)MaT(u2}4Q*Ty> z9{GE;^SxFpcpbJincJaRsa^|kK$$Y54AOiDx&O;+N=9*oX`5Uu(|Y0iU=-NFRN zU)h^RskC0K;tw+D_Gg-kbyXbwrX~~zpRdFS;r&vKOlM>{z54x9JRHNH+Yq0=a`@#v zRB~1sND^CF*?45ZHNc=Y@eHTVJ1=(8>4tjeHpn(I$EN!LW7NfDyJA6UG&uw^maF21 z-J6e~C~F4cnHCUu-KJ`oJI{L^>0d54FB<3;f)&*0|D30wg*%nnHs283PS?olfblCB zl0c$Pj!2w2HbC=(yIGkoc-AKIIE6*zTZEe>qSg(>^hbbHc7i4Rt<7B9wo2(&@U{iG zrjb#L!%gL`iLZL#E;kYfFzaDI)u|nWhYCqd>6#4?_GYgj<_w(HXXQ6;k5IyBLx9rw zOL?=AT{x>OUq0%a;-&W)^e*}p!X3e zVC=*8(;1K>%&JY|%3%d@F;ewW$GdG!9O*@kjqkfD27Zd0v;Bx2BPuD1FDgJIpC(~Xh)rzzR6T4N_hvw4<$`6@`Lx)R*OEvKHNJX(8^zr6C& zoU8n|@O~58dZ845{qXcbA9_mCe;Qd2sOCIxKie5<chPk}hDqn-i^ zOPxKENiifF7No1#>O4BP;&MQ{b8EXtGM1!}MeBHp6Yt-5W+pOONcE{ywN zx77#Lv)SnhV-Yy-8}T_%^umtC2gtsJF0olu!(Gu{NvtZRJs>%mFTPJ98SIG+tM4P!F7&Y?>G{E z5rTKwL(xy&4GD(Fnbx4WXT#k*oNEC!2U`TPj;&O!V%$KNg;%LrGeu;!6*0`Uig{eF zDn#`WYxzlf7?Uv+aP`UjmZW1rASC(onuu&-Rpt3*7*~Q&ZDVC?8e)VuDg^ zfO<_uaa62Gcor7dDD>uA0S!DYU_RAs}uKGC`nhl4Gl^VsK7h-BIKD0nJw zsMiZXLw-DOe6MgC0A}1FWsgUO7rdHAy=7siAf?HDjEtth`}Va^p|X3UrSf^vn9Vyv zSWyI@o3#Q9NOU?5wKAG?kz{%Jwn)Ftb<>Bc2u%~FXeHr(S()MmZP5(#xJ{-b)eWF9 zdcF;nltQ(ykRCR1ArjDW*{W>Ovwk}Fufb0&q!YNfzc0)MqFZULMx^KjxMF=`7>XW? za38z1ffpPX-9B`@ELnacLwc8`KO)2RUdg;EIP~syW#qXgHFpNR9ox?CahG{-qC+{; z%@3V-6hmh|XzF%6B<%cIl^xNyr83@ts8LF{sVq{fesFWfe>oAQPW^7CFM3{a4uQZl zb@Bc*mv`Zt)#7_Z!704NSWoPHG56il5)c$3mY*D>Gz9N_{q-zi>_(#&qrX%^ZE}^T zinatPYp+Q9q*bzDvhQ8#Q%)4_u8*%+@c_Z8`G* zH&9KTNY*5%^~^mv*=y*E#L@5UH3lx7Cucz8!zE8%+j)5*GyLwsqfN<1O~4Z?1RKHc zrl&KyVY==IN2Ni+RW4?8eh}^(l@I6<=}F|$WQNTOimR@!eorC01lySM4%PD3;FAe) z1h?_O*=ed!5zC0?I{|uCh#?_~Z=X9u{0OLz+Fq`xm=>&FnW;~+&CojF@ZlVG1kEWA zfd1&q(tGx3lsdcJ(?GeY<2QrXOMcSExPM>v627S#yr4%F1fIUuG5?{vTb7yq@T_8| z5T`g>d0Ps_sxvQDFryurk}QL5?kM{GbW)*q7I*$iHA^ha|2nySakYG^)n+;wkngg* z+S*L7ZK{%}ORw!N5rIcygHu%Fc%|Mi_0cq3V^I+Ix7pfr;Ag>dbZ`3m+x{~Uder92 zjieT)o&^b8db!}`kSQ0l(kfNT%?Wew0-tvbUds_uf5th8!^3hk{aa+d5rB%Io5PLb6i}-t*f8Q zYsS|;Wr5i(;3}YUzbsJbB_&EO02hQH-9b~rsEL#tCj~9J)8vvHqAf6F%x_3OxY}f0 z`$pZSJcKI*z*@~0j8Wq!yaKEpT~lv~vkabN2KXI_F(#?BG&=^s+f=;t59+d}kK41z z9^GUJYi7Rwa{vxV+S3sZ6l24&HG6&Cf9|_mI*y$cH3SKAtHNwh_{Nd0I~aX@ezG~9ZlCXiU>W@;UoXufPGl5Uvh_m`)!|S{cZUJntB;L{GE%Mdoe1n7j zirMaRl)VSW@4P1eYQ#G>d9!AxPoD3y<$6WKLIJ`x5X@RLyeFBSMQ|bTLR)aOY&_t_ zctffX>v-LI?^myp4Jy?Pc#$LW$J6?~)3%S3QoJqO&Z}#33{8yk044}l5%ouB4Vi8x ze`&F&2WeRinF{Sq2b2%T8Dy1>A`C>i5PJV5neRxGhfrW`W9%X>5CP_|{Tn~B0f!#% z9iDeB4j5>`$c(X9N(@qg4Om<^GtcoBr^;*GW+KeL`YheaOHv2?yzXX~RoSgCyoKtZ zmPWV9`%xk0^is(G^jMmR+cxjH;Lptlds=IY;~*pFSwNErgYYxR6^jfagc4h1Fa?~W zDpb%Dz%q10^!eQw0y|^k0%+VaPs4gXyB6*-*MyeGgu}5Hi5Lm zR&7qK!bTxw?$BNTd77}eZDrOXIu$gOd@g7w3g@r7DJV`adyG*c)@JpGLGe0d)JZ>; z9Yg6i?}M##$f25gujy|q1dp-a-Eel7nqgV8mQp5$+*hxN3Qcy@&IgZSs>5DVE9P+Y7|p1a!>@KnkhJw&ea^e7hAGCmeFERssZmPiu2qC?r8!l>U@|N zW#8$M_qeMFgJpNo6kc#+LECcYd5FAjGJL5wF|VJ0Sdf<`G0q6WLK|}H(WUZGv(qJk z!YVS>ptMipHq>n=0Rj=a{0qK{n~DTOF7n8h>C~MR6=|YL3(aa??9OY*yH^cK*%xFM z8aGrE4hayne(h(OQX&&|Yge@I5R)AU+htmW&d;ZgB^+Efys=+{JI#kzkr`TU#0#KE z9hJoB5n^d}daCKiH_kbuc)cM+hV16#Pjo73Wr1-<3|*d4D5alWJYa1~nh5~If;Tmn z9BO7OQ_zsH@C>HbF!7Ra+kaq1o~S49KRC2CRQDxi(@4z|X}KYVainCNAywp!A*pn8 zPnsG+VLWt~=g_+A=tG(r5pYcDIVYPmQ;lAwCva%njo?2y&BvDtbN}d$uL=yEtlcDj zHMz;)kWDNM%t9YeOe!kw$AhBU&@U_obAXHt;o%|X39r&3Ep$G|1@Uu zJ1;LFqVDXF5#xhZ9opV4rW*U;afZEXiIt?DioYnJ|DS@at8EK}$o7`STgf7e67x|S z1@)I(U6X@lOUMiWt;P~Sx(k!e3R@>f*ti{PX$ImEY$ee>?5Vc#&Y9)qhYJr>lp%50 z&#^Vv)HbRjbMwm!{=Rugl$zseqthi!Ss0xw8XVs5S;E%kh!f!f>`_4Y`XvV z?-jh;Z*!WPM?0PaF|E0XMKoD(Aa@1fc-j6aCn<0NaXaQ14I%fK`rWStMCiLuX(Ucf zz5KIVFtKo0FoFEZ6*_!pa#u~c3PJ33&>t+(!+T?>9!!55Lcv~hwl!JDCZ=Hio zuN?%U=0))BgFDma)n=eHDB>3MYV0k_B7;;nJyFNAXww6ZjeeJJv)#+wPCoj3@OZvS zP6V>#6md>FMkMc)%$6GhbWXZ)(rAUsRUaj9@@{*loJUL%(Ib%NTrboHEdgB&f0K7n>vFVWNwKJ!3Les9k)Y7ixK(n6Txio#?Ij;` z`p9U~6Y~dZzQyN3NVmg)^fOM`I*f9=*t9ub~`!-PGo zAR8%Cni%Lha#o+uzSjd?qKxQNVkG25ITfWmG{YyZ_&?VwG<>C1kwG9EQN3D*oitEu zbWNV8@aIebp!c&5&x0AuRJ&f{mOzY*l9044W>rG5mJJtQ@o|ievQFtgg%jSyMC6U1n2uL6)fy|S$gNQ-_@2tm2REOCsKs9T3#ou)tjJEEBQ2c zaWaQct3?LP-*0$~3Q%VYY(WyCUqOC~PBFCDwCifFPr|5b1kOAAqDIZZaJmExyo| z!j2}i@rLelRGHOF^hr0gR}NTiOtFYUA+H5%r>k1Wp~jS09Kn7;`&m~cYm80F?t0wE~STL3-40_B#Up$)tQal zz<+Wi3Uhc#8cNSQ;25n<8!gPtKW*`Z${v9l%F(4|>-S?IBm%pmt7#pjOTt9EkV=tR zB2SOz7hPwm2?woAX%QRNf|KcB1v$9RgP+=7nB>tVx9L-x2KhCPDijj=2+$Ak8?3b= ztoNr*fW{_nz|%ti(Ru?bQ>oouc`R?ztf?Sp z#sTDa4ONuF6rf2~!)efCvHGq?tyPfUp3``nmT~v=-a+x{L}hD6tXN+?OBK<`z9pow zVermA=UEsm4;CiEmwpNpv}s;+@nY3L7Z1|3sC>q`QEne~#FM#?aU9#CDCr+<))V(P z=HtK{8|Z{%aWLd~Nx#3YE3LOof}OtitVcLhx5^n0pzBIloLq=uRM~rt&yKV z(b)p*`FaKm5B(|Sx#R%14`i5Jr?Fl!iR2kvx#@+d#3}*d|3tJP?_f?FWBe$d0sT-} zLH$0zcqFo5C9aLqOWQ)Kkxxi;P`%(?F##-VD`yGLS-wUwrZ=G`kB|c~%nX_U!0{K+ zm+QFqbrKL|ONCL4!-^O*#y9iV2sPw(H}Ug3QE$Rnj2~cW(bP=b7dlcwd+C|yf^hRa zfU+;orex+7k=diD;DD?)A(na+sQ?mE?EfUKC)BsoK!)Uz3xL#p2D?La_LrJBL5=SN zJN>8pVr`KUj9#+RSrgZyggKxWhiEElTaq+Km1x^XYvGIALnBS|dOgJf%zrEqy2WW@ zv*eI}hU7+0n9)p_{&_BdN@iP++lx^#m5>P=KxrwnX^78ndkhgn*zLtKD7fY!zjbHR z91@dR3-1VXuG7%-3Spj*{Z&3c8YkVhI$yicz&lB&Uu{l>S}KqUGU85OGzP!+iPwSm z+i$td?*vv28%BkHMqD_fw{TZYBU-u*TFG@z%fxN5&K~bD!NDh}p2yxE{D5sW8Epz^ zxtzz5%J!mu$ASoq4-O-qwIP|xGZO>Ey@Fp^>u$D2{fy-`j=rWu0}2jDOlUDY3s@#` z`UEeVT}B%^*BKGpG0@8%7fVAJfD3!rigXA-`dp)XMBiT*cwCV}L-KC;E3_NGDO$Tb z)_edx$u+Qr>krAVi1f9A$MRmmu|b89j{{)E^hDUmgTH$iPUy(@pYmK1`T{?*t@+OT zO|a;rKPORKJ$HN!0H19fWOT4-)6hs@Ceq(ujNvJz-N1w)MFC_r6B^Dh+Jju}4IJ93&_oku(m)Mm;M&NJQ<=b&M6d+NSxfbL@h zDxzi$+p*RGZ3N&MTbe5t!!%w(^gno7*wPa~O`fMGP}A(8iGL-+;g{6^s4ORL$Rs&1 z;?MSEk?;3(!pf39^CVnG@@Jt&0%ceZZ)UPq%8B?}(&=|tif3aG<7Y6Wx44&!8T5oo zU0_qstbnn`#Hfx&wZd`}B(mHVj+V4|{Ix6}7jyggUOqDpBRD z@*p&!_TOb-RrH{GnWgASNATFuwTyz7RGCKUbTprRmu=Jx58lbdx4`QsPJaQ@73zsD zj%KtexfOSL)4NMC=}~5tWGUYfCJFAEH|*e+)_`w++3B*0NVAlVSjIXlEA(Q1JL_z{ zYXV4f$oI|_DEsbZ9{E{B&8dgYX@RxkNaOH1@yXqX6bN)dlDX{e6G+D9454yQ7vbs7 zS$fZ{OS=)jrE-Jwj0uMc9%%peQjXRn9W={xFR&j5%xhqP*~0VwCX4sc8FVR(GaNDj z;DoKwzAh~{h1?iaILm){zd(lP?21*I~xcY8r~ zPOTU<7K_eJrXNaZslJIvK<#PjH-=lYSNHM(E4003P=Gb*wx1dfm_GGqF4wLk(-%6w zy9>okKuvW0WqJ=P@`Yp@tD?)_4LxvyCKHVs0U=4g-wscmKQf2mc{hRV;Y#`g632gi zv@U&B%bM#bMseg9o)eDpGKTDlx!lLi2FnU-x6c2x&F{gG zzrGmFvS@m9V)vB&DHvH=WWe_=5}=bNYJMgd3kQ?NQ&D8TvlAtj>3+mGw@fIjA;%SX zl}He1mb^Tj_Jbm{Y0b%(U}~&Hu895~9I6M{(67s9h}dd%ILykyVfNKjt?f0V!$%>r zPan2|68<~-pziG180zM{?7O{XEr$8x+e^ufgv+F0OsW=xj(BZZMb9on9eU=OR%Y)| zdK!6Nm^UeYN);T$F!}2_V$BW~key2;@3qWaeoM8c$Ws7W9wl{I%L@w-sadllOs!*; zWUflmTvm+6BPD0ZlbExr(r(Clv_i;=xsCTG;k&3?OuW2ivp{G{6UKv5t){Q$>a|vq zGFplvN9S!~R7xVndHe!rf&z8;@gy;@!}Tu{tE4F&bN zrbl=zW0#@?0+mMy$siT@V zaH?#$+RSFU?Z}5@Ihdu%@|sYRLqtRj4K0v3Pp)&ZU zyeJ%h6#e2SI*kyUv7bmn7CD2CDRL-jDOu%fS9dsH6KExIT4DGR<%#GPQgY@^1qt@I z8BnfwSP8ygczCd(WY1nL%`_?{wwd$hjOH?4z!d2wE(nEDt2ho*w6{5k#I!FH#FpUT zTUFE9zbz}~SE7`ywddXJDLo?hVx)e#+dPYi&7+|(HqvRGMWrD-e;}yu^#VK=yg%AJ zO$hnFgvrzF=9D{F^Y@6j?z+7)CXLy;?7K&$w&Yt}Ak&dF5-^maBuxuey$RG0yNd2K zN`ngCP7jTs1=>PL6d_1l$2luY&o^N{wF{D)gx3GmLq!YnDHRosr6bG0yBih{_^m}5 zT!p*2H04_qVBx!H`}P*Y_E;!DoiT2?2-U}}WoYlW)$HvV)ViS`zHlZ0{V=svH7#WfMJR6tcd38KPfGk$@qa2~=Zv)I9ym#)_}ZA=jWkzr z;Eg>d8R(}?2+XC=;KYevv7lJf3Vc_t%d3a2Kt=#fWvYes)KN|OMvgh0XPt=VG|^%f z87q&GQymf7_w7KCrNcRra2w;Mk-p$~4q)+3x^WSjHab_Dwsj8VC!0}xJIwA^c4YtM z0vHf%HzXe)`GkxJJQ=YBYdox5qX4qVH`oR2^wpN)M?3rz-d`&#l!ml>A&u?y9A7Yi zCT5D~IA*AfptfWx(ETh7N$*ak3QqSdX=NGyYo34**!y9>F_)rcXNDGMe)1mqqs4PMbh5 zd~f!hyjcnRQ)4gdlIm#fu5K~)Vfno1%XzH&?NmTHR zD}T;BUkNK7iIt>_*Qi>> zUi4Z)ke4YKWGBK33ec9$41CfJa)>b(i$z#GrHI8inM*@Oc}xx`_}H zu?y60p3dY0uvir6S;{PcUFmU=U#+3Ix5N>@D)U!X-#Ma(ixuhhfqBYCLh@<}cludE z8={*a>N`!udu}EB%}%X^cB?|Dc?seoT|bZitL4#y1!6&JB}$+5w4%STT+i-^c~lSZ?D2s9PdqEIC)+{#40nopwxr;07obg? zLBU7AJP9TSrDTJ}m)Edl01N5vqMfRcLfiIyx=a$Z99mggMq}TD=iZ4zMo_+x_UO)z zhD&m=MX_i-ebQuLHy%s^=NK&-W@QufaXcsXbv7vBIso{|kQLU_G3CJY z1({A{7Xb|C<#^ogpI3U18eX_d90AZ1CuOIUfBbVPEwRWbS7mkjqLp~xfJF^g1g(N$ zx#spTLOexpTY=ns89KAh%P#+MpnwFgEOJlawR9qFi4;caXQZGjfDr$-Qp~o;UwT3X z36HV?rr{!TAuqQETRj88ox`USB@X9UYxw+xykqS^YeM04*;B20d>1QRIr?+#BXE%^ z+`U5!Box*^h!TYgn*y2|r-NXqcAcxZZjtkh(eh7`*k_o;vwpjIbmJyKt;3DP?~w~C zkswqz)c|f%jGS;RuCb0kgrm|ZthGMAqtFH?|L4|lIgOgWttu=C82fr=C2{*hCGH;7 z#t(v|g2nVTr9ppBz}ett{SC3^-NhI# z0}DfaP8lf=MehH`&*|rAIPkP_7y<;i{5R4eP9wX<%UHzRvF)8|`h_O@R5PcOZ*jyH zj;U6^Xs?H?%1TjrC(VX@rFL2Z+`Z!;!|g)i&v};%PliPJg3lnLrtRHw$zJ`7=vJcB zA>z!<5S~Eok}&ZngUTFe>R^G)vwv{Q2aR{W3|@p^(T`NWQ-RW@G3sf4rlUmN+s!Dv zpiQWcauD7L_1{8-7a5<=De;wdERyLel%D#23R(`Qd#qgP&IhFK)PN7ih5h;r;|+Zi zb3;?!G1@X&UE|hBH)#|czoncjdU-m^+h0%p>f)WWqrJr(FjiC@Mpfi{2hS(>0}Hl}atUlVNdJvuDSUXP6ePLwhaf(BH zh!X4PUc2}rEd1H1!+d?}fUg4q5iOm2N9jsMtP~_>WEBT_DUrp}M zgPyfVVBf-JwG}3Tj@V|XKyosq$CGYUNc)KQ{o*1o3t;-&h2)%EWQA-5)+gb1neQI(~u z=ziS=LC9rN#2`~1;S*)wI6r10SWeuUbcBbr}%DUk) zyFtmbX`1>hXMfs&&T2>n4e_#7YT031Fk~TJbm;NM+rLP0<@#lLz6ZayL!FXN;2r4} zk@>}&+=40!zlDcRdDlLwbD08D*dyRV5snDxv_yWs;PVUv_U~p;^mU*hOwB2#4DLe} zbK!$W(i`hdI@7VP?SrubC$}E}I6%k0g})}kWop;tq-kP20C|gvYoqHPZUwOCBnWSx zP3xVDk0LfHL5m-3oQ053x-#GHWi@Deg_F|hC7IRth9ra40~C6`YhZ4?qbokU3Ai)b z%sBR5F;wBxSO`F?T9|=PvSpVuyp+QeO5s9!G^R5|o7g6X?SYZm`Y*R5@ACh&MEO^q7e4X9a|%9H+$Qu9vF`ADIe?(>7Az*{AS?ED*j#~J&p&lcl~=VM83^F?Y&k)_%ZVG5n%wM-yu_jfqcISp)wbUd>kQVW#5MpQ*jRjrw3=n_VJ)X5 z2l`ZWZLXyL>Qr$BCH_RgPS%XrP3PIt8wq+%R1;ajnZ=3LQpxoXLMKSy1JUm<$|#ZC z_;1=2wW{h5M@dRlzH-6}A`-{zjdj;y6Km_a5wCgST6g`fr6RtL0S%=cJ54^UdE#t2 zn%>~BiO^NqRdA)Q~SS0p7pC^hSGNIXs{xRW;Lf`BmtVfjmgL$1URVqvYb3D`WUORwI456d1tJ0%JiACLIK)lUl-53aM3O9Dx_W_%0Iwq z2iHX@2Fmp#08wK%Ce~%5(F>6vc>Sh?As?ICNmU^?zV4@pGvi8*-gmV)%97%8lQXem z-$bWU)mcwsVX(~S+P<0YyOx!XKh0W5$k)-?p<(=7>Do43kk7jy0#d^C$u*pU)|yRE zy&>go*2tvTO-p(59J-E4v6hPt-2Q`}KW^zN6Q;DeTiJYJr(sl-zu}174P~umrU>Qf z3h!F(_;fwyp7o2AW4-W{Y zMv$0JMUU&@Q_NA4CClffF@dv|v%Z;l!dHyESLoNGo_IW%@4IqXwLcSB<8O`>(lB*B z9Q;8H3CpY!<0vy&J;r||^!R?FSn8!QgB`i&PThjxlO zcxtA89lqNJ8U+led2t@bt|i~!{w~$9(V14^5^y{>9VW?Vl(Y+iE^khP(1D$JWfhvqY z=E+gRDam$Zl>+k%gCvsMT02%JvC0!upp^p-qAA9Uo^NTrKf&B=S>&d+S|7Nvz0=6_ zpUD6=U88#}9_X_Z_U74ptzR`86972aj;FezDbo|%Mfh{Tm}SfYxutZLk#NGt&j;>C zwIifOwcHbn67A7og0HOJ?;LNN`(ddePu)~O6?JDz0n{qEHl0bc!#;OtsA$vK6UIy| z;zmvZ%g-lOgCFxt#Xdrfn7=%ie~dDtSCz;gs`6Ja&4xbY31&`dDU)}lM7f+}(lFLU z&DzCyi`2P%Ky@I!hKI=q-{7UVWftj%nMYcAeTB=5=uFy@p(=1lI`_xdr>3m5NRP>G zOlQKh)S!JzcOikZ4!U;p578l;O|0!h!V0i8@9f2L9Vj7*DbpXsxxA6&`2rxE z>wx#JaO;GRBZ1oq-_f<<)PdfV&RT^2c|}Id99Fbk@1|^|e*8~AG^|Q}Vh&1oP9xVc zM|UY*4}%r=f8y7kq4Zb=muLVr$Yhz>UJ=1IwC_C9|PEMKG{8PG~uZ?F0|j}r+635n|9;~vdnA@$IwjD9*&tW^Xtz!$OrBRY9Kz+h^R_(O-#95KOECfC- zKSS5Q>*2NXiiciqhmD#phpPP+63>~mhjB%7%nA6KzJiunsEKfW{dT1Nv}TQTq4Bj6&Xb{h_#AQNW_VQ1wW)WWMs& zBCjPW)}9G1zw&xT<@9WC>HqM)3|P@_*S|kOkrZN5dP@%f=>WB<-(d)v2k1y_ZhSlx zBwU>lan=)GMMFm>JdoERoCfLy7~?=I-6|@&LW_n_BYDSqmYDLHZSg8c=Ktm{`xda$ zvI=?|u>}{13^Er9?(`}`fTOpRvc%hawd9WskcJ%Q4n1R!Y6hEiY*U>L(FlR(vj|NV z{Jn#ahgv5rL;Sr8A&4@kGl4^qMWY!TwVwU*VLY#w5c0~lalUq6q!W!@f-$milnmG% z?oNUJEJ6WPH9>`zpsgzu6?~!#^#fuBKXc?nqWvd?E0#K8I)J^(#CCTCsF8jU(f(8T zYqV&;{|-*L0GyqPa6wcZV^;OiSf-a=junU`IJyG)b{ms0jD;L=yL89rY#(%@>$*mm z^08BwkA8r+XSEcyM#C+j&vff`@F2AJQsE;AhN%HbOV>Rta34$k-Dh5OkBxAg1&vc^ zqGM_k>&Tl1XhjUX*v+xb@H(Zn6M$YyKMWCvGI?MjL~S!F^B4?RX;S_1;T~66c8g6A z!bGE0($%HRS7*y0crOYut&!{v)UIRG&Nwip)2Ds_ioMV)^cRh0dUIexU49+aS{Ra%VNqzdJ9@7 zEy0R9%{4zK>g8xQskxKJ0{k68BMQ8@DdizbKeP0nRO{}1@9HIp_;5o;(E;+SXE7hdEzcn%fCht{4P|X~!=S+niZsT>-E&Y3ZOj}p76Uo*ouop&` z`k|mX8toqw<#*Q=&f$CYV)9r3U6s6E97I0~l7%SV)qqns$@0YHFu6ts#vX)|f!j)8 zlS|yG-RLdFuy3{6dxI>+#`(|2dbyl%rc1xPiE93MgxA-nj&1 z9tF@GaoOS$!7>R$2f-wfAL(5$%}ajN%`I}`of4>UoCu?k6Ktr3!ohwZ-JKIG#u z!h^#84f+;oHPT+y3+b;tCU}u|8JEI-QW2n^DuDr-tvj_5;MPHwivN0QMRv*$bY$Xj zg1S~2?@~`SOBY{_9t9BWyw;xg$#NG}E$N8=8B_?#Jw0-3h)BC(quB{Z`pSQ4AYmN^ z%as;8QOG(9O+M3`3lms}q|iy$n|2@Jt_%W=GrR)mX!kQce4!?l<`Tp>O_5h;L--oZ zBEKnGwdM?vNstoPPF2KnB8^*ReI<)}<>)5C-nLj4hCN$B9Qvf{VGq*%g_PTq+k)T; ze?TIZ%Z3iOX(kk4Ne^t@sw;AUy=4mqFX>%?|IQRfZG2Z8fu#a&R{4jjn=6c__puzS zb}ty15Yw*>HuyvL|0ZEP8M*jy$9N9M`rM&zV_veh%^@=3#O8v~7qDoZ5Jxz;0pSIj ziT^F32&tm0wrW3HmslRyXh7(;O=-@ADkY z$*rpky8j)?ka7gPKQ8f(v{;gc6>lB-8oOrw&zB$LDVr951wcnTcO=|iZ5Jg6IK)fR z@OQzh0D!zlaPPr(ajQv!`tu=-sr8YIsRKv|0+}tchS5jdRlUOl;$PEz<}0~jIHyCW zLL`Za;-V)Ieuw9O4(qJSqB24|AD@1g>(SDxdy2Uxtbyj%a~72$;nfexdri4p_r9bC zxl=|{90Bpajs6Ar3aWg@dyQqhJGdeNWmmTQGVqR&pAU+Z0k8ow)P!jMDr9-g#5Eml za=lx`${Z)Lg4kxGvPCP(B5-C%f0dxMZ+aw*N{{^yA`!a!aB)3H7rO3GG9cgu6ZHYr zv+1s1owb3+GKQeauS?O&7Huyv1CU(x>fthLn>wIcHi0EcN3;+TNztQx`tb@=p*+); z0B^!3;#sRjAi%1>bbtqpf#Px|k~}4(@)wKAqY6kok1D^;<$)y|1|;oOEsMRm4&Nm< z3btpfF$*5F=FERM3~yP7*1!k<+owR7rq3AoOuNBlvyS{Z3Ig-w>p1!0Y>1W?(vF7G zzp3N-htm?U0-zj>U{_{deH^?#$*G-&BK6cv*bs_ioDT`+ot2UZM}QQ))d?E8oCwc= zkRM>G9F*b~j&QKFPB5<-jtlflo!w(~>yU@;Eew8thTJQc2?S<}WmGuzptOOXYdU1n zg9iXkAw6$CudwYpEn3n?S;l)xF^DjM+@;G*9q4TC!GXA`zr#KqHIqFMfmW(~eDY?E zkUi~)U`waevmlZ;W^Y2(E2DT~O`YOw!iSI2jGNnr_vc4c?C7iA>MINt15LbuZp$<- zj}!Da(&gxi+f^_kcUJl3LMTJ6GHc)@s%+}1cit(03jzC0$@Puz*`K_p)#w(~tz{Fn zt+`8PjkcF!Br~RPv|Yv<@Bnbc#dwj)8wZ7O6hnEyQgy@aca@|AJc}71XhRwi7^wV2 z*<}V}*rxs#>6rCpIP`heSRE3!mG}CZ`+^nQK$`%dGQRR z{3x1c?`08PGzj6=<2km_x-RW3X5wnt*!YNEih*D=&1C`Uqo2)3unSYU)y#$B`HQ?U zZNIA+7QM6+M%=OGMktw~t}z!pm3_%tA|4%Hbel%wu{UoB%y?K`{o;sb4%)mY!2|~W zuBh4%4P_`poL_50&~SFU0yPkw(yRU(3y-6cv&i8u(KD}1z!B;!s2C7#nqY)?F!>*j zTqYOxg!s9aRmMR?)c}F#x5RSB15q_g!1BK?NwyA}t3EG)b9z1@;(b4LZ`+$Dhp3=o z=~*pFW75=9S3tDeDQ1=nk$*;40A5W5pRoV)iv3!aywB$ZsIN+fA*!;ukPGFpT&Elh z2|`u-Upzby0VC)zsu59Bx!x$`YCrDO7>dZl9*+7OT@KV1wUOE_CSG{WKW}*RaC@Aq zJ6AqBlvzQ6uzD{1KlO*kYp0g6ZnN}_2KXkus_M@t-EEL+8 zJ-Qw{7uoEw%cV6PhQO%Mn(e}WjRhA;SHT?PCNrOe(&DR#9Ed=t8p1s8Cg((7A?zJ1 zzpP5o#tt)lK8!Eq58)N-z59;#`y#vXIQQJ!Gpq`0vV&86;HP~`rm89LCf3~&o!`M! zHlt~4bZ7qddkQEu=lN=e-`PslO&HiIIt~ObiV9@i7o;@Rw*v~gE)FGUe=lztdO-fc zs<86x2#$zoW`8BL)xN|KPL@_Bi(P}JutR}HLv2|1zndXX=MpVa^6lpY@eA#IZsgmW z7`&w4uGbFAOQrV-49=4)cB4s!}ib#JhzFZK;N|iPCGfcy-_0Nu;Fj>qq?20a_}%d{6K{*RM)Z z(7~ot7>vZyi5Hj;I1bXqZh>!(ha70PbOCM%oeH7!dj1VXZc>{ppG zZ~%g>@bac*3r1}p^$(d-3g~AJeq`SS$PII$5%E`d`-w;3-4_Fv1h6!v%i(F0awi*w zEn1?BHl^HnAH{#fc^AFjK>PGy&izMr@eE|47HU#?&|O7kF8Lzv59*@EHxlcj#sb3L z%&yvW!UsZvgK?aV^uc^%_wO7k4AMji0L*gSQBm~JDMBS4#bG>Gr>ud!bOyCkrFQ}i zCeCO=BMxgB_L4vd0Z!^TQdc1JU*G;X{+U(%Z)W3F5kwH}q5AJ>`RjCkh80h^WxD?; zq&_MwRJcnn<&Nr(9b;vr0rE?ZcRFe(Nbo`K6r5@ex|{?=t?F zdor-@hVpQ|^`h+pXXgd%ND3m#xn!>WY!Tkdiv5JhOd5D0){m*xB)Zco_xP_iw9oTyLICrV$Bq-o&|~KYtKIa_tHk@f+Hl{}T}yD< zG%`R6kGiz4GnSJY`=d-4h=n3~2%K=Yj^(PYJ@4;7QB7P%F?j&gImOXip0djTtx{;V zJggIWk&v!}pJw09|Kfbakh*9x<5l{bIiIO0JGHR$!t;HKt?xI)bNQ_NDi<);7ugq>LHmOR_r{HV~NQ zXceJn2(^#>3TJQpI!42-?@`et=J*kWDYmff3JMsZNO7mcmw#JQ91g{caxB1txCeVN z#W?xOgkM`I3M#byf7%?l6`Y^Sb?Wc}VzE(?;H9x(>cR|`MoI#^w^a9Nc5LsjFr)bI zie(O3C^56_0*1>e+g%MoS9?*efGWV05(9b@QbzI*gO3w%5<^;DZ-b<#V2x9EJ?5(7 z_2s$b&?p$~Sj@6_9XO9X;+njve8+!h@hNjDzntiEGi^S13+&C&0!+D=qz%JRtoAS) z_af;MEtr@R_U90tM;X0KlwO^Dni^AEp{E($&U4*IT;8bayp>H$N`$CgSeNUON#{FRadq3dkpaPY!mP75`0m z*qMOiA1>FKtkte*w70jOdqu&d->pK5XEp5I2Z4pmPTB`L+00!}sqF&;+pv}&OEd&d z|6DFWN+M$EeR+|++nDxSPCnJj1+@0U`tob)BUnX;m~`V=6X7tSE!cBYZz*e0^VOgj zq!P3M{2OESr(B->YW$B%^(T>y`eCO2eV^IjHXN{lg$loDrCnfwZlML9n{q@*L%S>A zw7ZHJH{6YcPc-G|%8xVU3h0;|o2V!$x@aWmSglCrdosFvkarOXyjL`!;_3AkD%l4h z1zp&X>G`;j;+yVChVd=PtjwAIScQM|>HXPMr-&C!^BU^y=c>i;@c!x$Ijt(Ur?!f; ztl<-PQo{j7ysth#;3MAfq>;E1*$z8IA%3s`3axc6xoA?*Ji@?6&$EK-%G&C4E}&4V-aA$9rY1i81A5E+SrvAsH&7)I_Y}1;zEC1WgMWVEVeQWUAKZ z9V9?P>h{@w7noJ@uiCK96@7(_hZwRec?N{h0}5ne+^oknv!D0Dw~f7pU~riPP-vle z>D~hI^6+I=!3(X892d@xk|Stq6|3aH?7!hew9x66*$)-D%p6Z{HC2`jYf31RREsBU zl4}_(($AK};d2oy@JWt?L5^W$+CqnW7{5zE^AFY`g!hMovXznK^I_JNvLjm<{BfEy zS_QFlr*S?88DQxhz&)O1+DpqSiD~Xw5#CTyfjZrKAnJU9$7=vt+O`^!;s*ZrS%aIS ztbWR-yE*$r_uR*g?#y?Pp#$G~%!GJdc9l>jRI0skg&v# z&CbFwipHgu3uN7g4a|5sFLwf|Cvo}z(TKv(4McnwI{C}eJ@$&A4Oeitjsq*kEGPM6 zy_0;Ll`cFjc79hEC=u3mea6?7)Q*LH%)LW`6D#`t$rc8*p3i1hl~2I#h5onF)Np8t z@pkdUWRogN)-bWSMfv-F0$V!6k0tpA!To9AlI0j*OS-`8cAveQSlOEE^-~{+_kjSd zOUNog4)tm8i1akd!fgKJ-83D)A{lFCMGdbj#Rm;F>o{1k{{z=4$}<}Lj72^gZzPLH zgX%}Dg%ylN6`x2le=g+TqhSn^=83BmKF~m5pl2g_+L>-?*$L#Fz|nD;Jd4mQG7)3? zm5eE&`A=88mly+UVnvLJF{YvrSc^sy2|zY1Y9(db$F!78Zx~1 z^QnavM?b6|7+hW9y$Vb|97GS{Rn%CZz?hX5Wb|T;6#u)zNUEmhrdZl3QlTOgan{|SV8=fV)kf%&&kKRk-!`!Y||4o@8` z{OmUE4*O(raOdwyd@L=ja}&>p%|p_yDLV>ofB!J1*8(YYPycajQ_-j@t2gIgmtQ`aGwCBb zM!zOYsvyq^$_ZGiu61RZAD_LlpO%WN{`EZx5r$27bcHtwpz>P=us( z199(0-=gThkPh%;u(j^3he;IKI0-_M4ghCM21yxTF17tIEF&PE%?5#gxK>Bofn8g6 zxSSTkO~c!7tB=7Kr;(L(T;lTJ6fK6lxC%pV%UiV^gX)?54t&-Ny>+kx3nmcS^akP~ zEl5YlinhdNA?aK3JWWuHM|mp3leNSatF!cy$vkn1Mr&Xj#W(`-qg1xAFAJ!0=d*D= z;HduSlk2o)&+Ngb0PvZi8BNK{VE@3$8p;o~AD17Ln#uAtTS@Au1|)cK<+$okB}5nnpQPq}0@;Q6g(uqT|ngaA#tSjiK&6m5!?SuW=M-vgR}1DQJ@s z%6^twX)|^4>$;*eTzf3%n*<3R|D?;M?M2E9AKxKR1`N#OEkeib&V=rS#hDzy zmHk%LVDd%vS|y|Mw&($*zfl;rI1J6)l5+S{i}mG%0KMqv7~5XEl-Gd43v&H9L^mV5 zfDV0Tzbdr_&D$y1jl2qlmYRSDc*9BqAgfosti25nf1{NlQp)?Y!e84>JKxx!DqClW z^0Wn}A=MusMZ%~{^X*f$&?V1~r0xXTug($dJf=5hldrkqv|O-H9}hr_R?^X1tf9>| z_qDqSx@ik({cTX1o5VWks4^o1#XKQmok8~}j)cCnis6-Gn%C1z8dPc^_f$cxXyj(c z{!<#H4!M%r8Uy=)@6hq0kh!$EPkQQFl-M}nrO;n>4N0F=JP=VaEx@7@A zKLls{w}Nxs4;o&3&gbA-Lt`NLYw`S(FVimGXA(Gv55BK813Rnu4EK5;w83;?dA*HX z6(mOHPJ*bKQD@k>b@{YY#h;|aIh)6eJmlMeVqXWPaC?an$@@YBa(dp?D>O8p)i;BV zOpjFuaj3OH51hkAM zMZT7<;c*@}j%(;>wy6>UuGqy1*kK10R?KlXvT~kU2fwF))g5keg*y67I7GkbU^sGZ z;4PpvVvV;aPxZN73XZ4-lB;t0mh!knI67tM$tWScs#UiUoA8SaGHFI2t1D^!z)b&Z zoaBj$71?wuF$FOr=rahH*iqjWx%>wPJyQ+HNZx3LzSIRAM-ag7WW6~?ZSq32 zHrFC|#)J6fCYe~4lKx>_jM-*V$V2~<8T!RfP|myYZ%-TbBd zZMPghvQDT=sBCcD=&`|r`6(!-bxox+@@X~0Eq#C%z00DE+BwfPsM9O$2ue0kamP2} zMQ#W=A|m3OyQj@{&e%7X7{_y%5;1m;)!`wi8vUC3AS51jDdLT1FUNDq5q`D{4`yKr zi2;{Fw!RN3(qo&<1vP1j%KdG9X<{875O7&2Kad>v4MkDn8xLZ3S$vO?}Kh$Itf79Y4S?)ksMYAUV@~7q>!9a#{)~NTb zkP0xuGx(y;YamY4vI`u;EVWrkgem@)i@Fs;iA{=?m!G|avW!}08Wq6xYn*w0uktL8 zSHvbZceDBEJtz-Q0`$-;=W43lD|P^?{GaHQncOQtlT5LBh|Erj=rlJHo-y-;jxIMlkaWr<=>$BG_OSC;uNicN zU5jU#ilLXxXbbj~?}j8Sr+3G|+W5`LAA{VpQso{~McJtiZixqv>iI@Rrd+!MhhcF| zU0;TIS_KKuGY{d%5Od*gwi972ud=`(K%Nqjai3&BhrKR}kSQ$9{Ujj>4eu9S)If}Y zQyr1r$3Ms_xXv{+gDGG>HJu8?Gv4OVqx-8>;JYq_g)jY#3kT*3+fY$iKX&}Sn(^V_ zz`9V)f0}vf#y_=vR=$b_u7${4}!V@h%Y1A||DA@TkMruZb&!Ds8VRb?QjG=bV zT-=D>d`I(7bL`h_BiTx-!;6=BB%_VNI+<-Jf(^qmM5q^i#FB7ZTPrX<`B4oL?gBd6 zTt_B<-M#9R)P#@&z(dYbYAA9TJslwU@eTLl6baTdSDykNI&*SPwgr4pN9YN6wQOts z6S%yUkG?frI4ZOHio0-@jNAA4|oRUpD{>XkTBgW0P~iz8y-2T4Con96a0}h`cwf@ z0FoH)eFYU;g60C%sVlz~!H6SyH47C>VkvMGMO^I0SLrm^n|T9JJCvrY*(%|i3~)J1 zWT=hhxZ>Bfe?^?9QxYD6_vOqZvjH+fNm%fh+UHdlefEh@>d&h-8@8R|Or7TQ2K~$_ z#eH9isR7oArneH%v0-30Ry~BM=L~?~9c4jY-t~ApB)5f;g#^E6OQOMUDhQABx#uyK zo)+t*3WVCjQ z7Qq(di_-9N_7F2k6UIxTYU>m1b1{=Q;AWNoZh)#F9G2a;LIk?w8rhF|-yr=r2k(qz zOY1mC5MFAu6+)!s$RTU6kGD0C18YU zG-#ZZG?|{qN>#4bb>bYrBOt2g)BL)IgOSwHGl+#s`fu0}CQ{zP#{JOZhZ0gR*qMR! zU1s(cN-u~8SQp#0r(?;6v})adCg6}3vbzDuVuEWDf9R5ebI2kw7t*)F>tXsE~-;*NX-wSM)ri3dM^ZS}_06l^XI_f>2h*S*~Q8Xf8Ww{qz9-7~wei=s^D!(FIeB zyvl9Z;5=1*b0d6*y3@WNW*dKv1D>lx$foHdxq0#iVb9?x-gU&zn(qhkyRjF;;Q_fx z$-$o+LIr{SaTMdtmlj%prBG+-%Hi?_8vV83&dxz#?oq&yje31QuN)M}TtoKt8uJS| zSjW>tvnm|WTL@c%;M$A!?MTRnO3e&VAO7ytY^-xFO~4Hr(k_yysmw3w0^B&=jZ-);j1l7x&i zt&h{^&9i{3>))DKYlBe%EEl6z3}=S#0&`T1t&RCszvy0B-7QDQH;8<7Bf z63F+Cfw?4vz})y@QH8MjMTgcgi%te+ilbCZ7*#uJr)E$4PFmY zj)U0aZt{)7;%)gU;sBm>wh0)X^2H9pqMd&e!w=M<(JIx^Y)f3v8K6`dW5FuS*0ivG zNl(z<;b+{Exsf>g$dD!d7Ey$j)Vxpb9we+}L#PAA$TXMh2r-J;wiT!L4 zfKGiIOKCT6yL5R&gW~odjV5R{slVRG^q;V4(8xw-hv8+&BOIke%Em?P=k?T|U|t?d zpYUBqkZvfk7*0V9?{1*e_2Q^Y5`L=4dxDyLe9a!si}WMp%A4<*oh(Jn5O1Yd^I0yA z4(TR%Q&7gtlzX5ir$SlBbxnW%^jqFMmjIiOn9@`4KVbyPStm|i*`^f&3=(y1=xSuK zbdsg#Cw`tLL6(PJINr0uc2*kgtkRdsP%pRk>$b>&K5DE?$LaLWe%?^}s2Lx$CgZio z8|xL>6-ecO67#W4Cp(oq`^{*gl6+G>YQG`O8r9G(5h+k>@YRJaZO4Fw6#3o89Cnv)m? zu6v0LbuP{)gcO;~q^|Q|WzQzQc4heWU40Q;q!d#s!qYYa;A)yQU;&R)KFalmwXyrWD9LN1eZ%>oY7>|5{MHBfl zO_{Q@A}cVUuoO`p;jk%>dbO}2BILPbN;3UFlBj=Vq&iO+?R~Q5N7AvR-|v#yeium+ zGc9j<^bE2RzR1`K+9eH2WTu*_VCpc}TH&#p$;hjMzrQ${8>>6JC)*+!^|p)z?1+5* zRt6a}_PxEnK|MY=Y_+2T!-Uav zX(VzBMb~-Z4EWHGd}0dPd;B*IJf~3%lnO~H@!D44V4r$`-en}Pl-XD9wiukgo}^x# zfn)+Xvr-Al;U0|p*=}aa=pgGAf$b{CP~kqeYkfzpV*=!weqIbtVz2QA>89;dY#Nt%>CM1=x^Wejc0GCOFYN ze;}tf_#K;YZJn|O;&sK(46O3ObjKPMi1^X#-WtKpe($E-*v}dD8p@CJ<3{A=N}>-A z-rOaQjX>bsF{HB{HXAJpGqH~~yI%chbwKCC7P54Tl&S6;-l&6>pZRvtMWk9QWneA} zopR==@3jFDPi$$&bQRcxf#y56#owYqgb#tYAb2^) zAlO8E(W(2CO{BhsycV^_@vnzYz3-yLH71z<)Y!DqJlIQN3ZW~QYD&b12hJycucCV1 zr>Kl@o@}OXv!6$2$T@MZh+q6r3zBfweB#h!b}<&tz0vSAOT|nO7e7#IGpKG*zlBqo zw?59;)m{iMPFfd*gcO0eSZ>7~I4OmthRRP?yRF79Yp@T0`4Syd1%`-uYU&V&6J(qZ zPQ&;%<-3V>Y=|iBqY8HfM~211CU1Ug2~3-F?%?LkF|lENMl0@Bm@No{*-Lf^^<1+8AMvy0*}wj)~H`6^851K zT9;*ctqrBVHk3HLUfUqnL#elvk~+NN_IUhFu>ZL;GGeyO8>WHKLh5*fl}fd|v8 z^4Iz;2*<(9B?5Bwh(|&^V8O#rkk{{AG`N_yEmq>9c_PhIX2%F7mjEYJ6s@A)Qox3A z1N=PQTdn{`2w9=id}!E4p9{xAgNe!p;N22?F1b;Xc;iW)PPu?ea7IB21YP!NPd$>;WMHk`5B*>ss4 zof*GMk^96|Qf#^NDz$n^v3cejQqu&(L8NCgW+WkVgy06%lF@42?E7QoY-SWfW!tM@ zi%r3jYEV$|YTmnOf<9qmsdSif zZ4MPoo6L4<(bY#nbP3GiD0`RWDv~@SxguIJ=8|~|g9-4|Vkf4ym~TzMt2bDhD}kT{ zqYItq-kuv^%LV$Y{}v=z*x8EnpJ#DvOn~xsmcf)jsPgO&{3gQ}c45z7c@rVhf~5>S z3>(VV8;kP9weN5vdagg<-YXni&a}D!Ghp6#40G8qkBELbuiTbgg?RW{v-hmFqfFC3 z2JvcLls~B;aTxbFm;H02i~ASKxK}Y{uGo_H=Uluc6{`R;c=_^-x50ebu6yx1fB4WY zTm`j@;ud+ynbnKR2b?%~4~~s=8efn}tdzSa1w#q@jq`EFc-}F|R+ZVH*#;VP;}*U* zPpwp391e;l_@uMfujy3~D5bNkW0O&-2<)N=)bMpIoOu^cBUwuJz_Va2Ej+>Jkh@=n zwABIvJ7Tz01`g)Z5_Q9!j9jtTj}x?mQC-;D>39!S#46vJ_A5JLS|cNR*svhVjM&AT zl=ZZ!-wH+~o!W zbKTENmK7I^X|{%eEjXu&yHgGLP6w9UNa!;=syxdw1gvXG#=m{*=T)PYBYxr4+Co ze`Tde1eZtbdZ%i36X~^Ois3i#6FX1(IWYRqfs4+Z`>!XZtA14x z^V3l{29P~w#rX97Ho)Jg9!w_+>j;L$_t&^Z#vlC)%)r9R=|yKM@SNA|W)mH?Q}LGl z=!vtis%pVpY&^ABasc`ESU4I5`U@!;7(49AAPJ*`L7n$0GNLS@{u;14(U!c;qdCH% zY?}q1sVf{Ix)SBE<)|NN%wg*O01@s6stNJ*!oR0EUG%DY ziq47y?5J)Bu$Jswf;4~K-Q@9WZ?Wxh=z+$xssoHWr+7cMGFiJJWC>P$GPn3SYwGmW z8aj!JH?z45JP&UyvEyp_J)H9lieW@bw zFD!;Ry_qNGXVVP6P^DoFvO5Q9`GJa2&wc-ko8en)s$M=4IpxEE2w&fUSDp86WaD(L z2?%X6E{pNMh*I$8|1_97q5w~Oj;U*(l(>sZA&MKH;R~&;ZBsnT{2eHD5b`zPAi{V* z-y3A+#6dxhgWJ%?J*@8|dzNAeRQy+yng&x3b2aq^%TFr`vglZ*41{30hpO(Zlz?CW zlPMsx0h~GVt}`I;P;>lioNqe(o-Dl9ABt2mkpQOqg%=%Gimos&YMIA#$tD3U&vvkz zm$=vRb!>^0!ubEtYcADHP{L+&DlGC+Z|E*F1O3-!Omyx?)02lQ@mBrvxvDVIWp7D9 zCArJdgz&$*W|E#2Sgg_^4Nzqes;|Zjh$eGCeFv7Ke^ezi?oGVN<))g0S$NhD7lIy{ zXq$JxrQ*|d*(j57(i4l|0TFh(qC^)^Gn{({?);!3Wasu}-LD`1u%fAVKRY%aE27i! z`=<+|DTLS%T^LjKVu#Qofj^Y8cro)1?7*9*l?c>5adU^QC$5B6Hw3T-Oi~3UMP3h< z;RXz7aVWdw!U(dnkn4`jesXVnDU3d1qx@07+n11l+j7{)irRMaH9nywm$^s$JcFWP z$;2N=U+^QgIOEySOP@;42|_uZbLdsdU?b~JD{(X(YQ6p}ec1!`85}p!U{IAwhb1tL zV1U<_(`j7Uy6kUUwi+^$?u^9hTuD=|j*-H+`Xm(uzh#hyOcoRkqo9_M_h_}2C&~I} zLQjL6H9hktZlo#q7dNrZJ2xWy=5?pWSSpk$fcK2xhXuTrqfo-6cF*E3NEA zxaU7LXgo!QwPXJ(&zAWI-Ooj_d1L=9Nc3*q>lqeebXuvV_}oN%&KQ)0TLy&5>#6QW zYbIG>E9TKLfl%}4uo=hG+P9f-@cJuw2zcdklIRS$@j3>npo&=H+%vWz=WB4?6!^sW zX~Ui@{Y-lSN!&5#>z>v6lTbWeZQvRs&}hrtQSQ$7llqElwl|!nis!KMY3&WT?d*%oc3`Kzglc>mmdC_>Aq)i?nH#QDkorcCjNh`E8{{rqzvglOEf zdU7{I?&~LPaXckT?jNxGjwnQi@D+MtPb9o{7$dZbp0Ee0>lYCUFf??X_Q+B1L~Pn z-v*ll=B_`xwGP_Qw;qLB{Apd_WWvWAFP}ihmpG?4XRO$W&~Pf$M%mDsS@MJRo9{Cg zB!(NY*O(9V&Xb&ginstwzBSE7WNm|vffcCNirhggaDx5E=m}uaT9fD!xE0C%KCIPl z3lx9dwU)yQ)dak(ISiHb`fL!m>=_LhvqLMRAlNwsnDru_9H#=A>v%ek#}3M;J}IZ@ zWfGT5*#GT9kHA0sDO9h~;@raqW&kD$HHq{R0|8#yF+Taat(WyEGv1!ce)qh>f?$Qh z@#f}tLGmK)O|JR$*11sAvUagkdmJfg2|Ec|DJI>MR86ErwJboX%L0zBapJ48xkt%c zMx24KCtjJz{S^CirMCb@Q&+9_BO*|VC!u}4TN$wdEYGww46G%bGxZ}*FeAS?`XWcD z!UaEC2w6>XI8bPh+94t_SRU5gz;Py!joS0ZiQmIR=&TCh1BFv$JSPJQuZ%Dr0Jk`0 zxQtn&hDSHrZc}si*1H3voORp*FqSAhDO6}aZ2R*HKh03h$$tRh@m$wi2PRy(bq?y5 z!z0@wr7;js0Tr{@ibvh_)`kgQ|6L2>bHA+1?d1=cO7$ztNY+8V75}aK~o+Y!}yl z5wP{J0%(lVKIs@huiL8R&xFZr6xk>PSu-^t+TznRwXw3T^|j+kQ4$q5vI#~F!slvz zE6{iPJCWknc?W!@*DwbXL~-TRL4d%N252mf7C%>VIe0MDe{rCMwv8?T#LIdU-NQXe z*Zf;Da_4=&q9lft@~6bn&am6#00}%GlscfZc<@g!hzbcG5Hq!obG5<}8{=6x3fxRo z$F>AbCGqnN`=NYPw&5BG3>8Mk$6t^C|N@C>j3=xQAw#fihMjXuL&eVy};!^_I7Sz7C>1;&l-)XJuhxb(RM1NZ-u7-(*C`OTUo>olR~F z<0IF{o_E;kS?Z?G_EcfC>6kDIHHyEa0|6|er4o)#YEnGQX;Iilz z8%QGWc;Ja?x@o3aDGCDyt{h;~vVNR)C>Y-=-IE+pB4d?W;;!nIO2UljxHSKrGGLR# z2z-(C>S}G(!4K~lo39qoD7S0HapM_eSJ|zW33&Y$vk)GEDW9a?r39o6c%zcPTS5Bt z>Yy>@<-RLMx%TK5eJ)FtVXC;pDUOhyEv6%B`Pe%_e9-f_yAalbW<=+9bJM`eaE6Ab zvFtr!Lg7&QQ9AuaP1lRHWgrZvj}c5&YjIT!E82%1E7NXhSEP?#K%1YNl>>3~z-Oa8 zyfg+`RAeGvPO@?Il_K2x!4^@%toYN4da)gffk9m?at~b{`{KuWg+t-eH-aVl^MjY@pTaV#7JrZmCBI?H-Zbn+WN`=bjwSymCuf?2@z=@1Z0 zRpy0Zqg*-#OHvm>uJ$hpV$jyWEb}B?=n-1+J(lT&CNf8q-ro3jX2doW@L|O@b4VU2 z$*}U8!rVYgL_f*Zq$gGac9iLwzG^o$=IzS}^H>c9+K|eqzCJ5lZ+{N+qg7WkHB(){ zbhe}G^biVfGpTW3oJZR$#@tN@&QH=2kyREmQSFG9|B&K$QO0SbhhlFa{_03lO0~A# zHiX#4X2RtP>jn?g@JUpB*Ao8SmIdDv}%bRvA81~wFkyAJgEY7XaX|o-d zC;_R%jSNGN4c3m&{c8(Wv-c9m(L@*4uUa;!rg&JDyvXqgWgEf^vbtJD;^cieWHx23 zxIw~e>v`z8Iq{1ax?uat0>CL?ExxgQG7U~Pgf!4w1JSejPG$YliB@SyXbOB7nxB`o z)1S|toT^W_Gb{He+LW{wvCqT<$}nMC?ez0~%>Z2uT@gG8gW9BLQK~xWzm+u9>ymA0 z&{iiV%0DLH@}30WLV**P>ifqtU=7|Z6y8XXrQ)@WLy5D^#A`bj{IGUDi=vcM^{rtA zV1DE{&ml`D?Vr2wLHSkm<_t0a%}7^fQb0>-LnAtDYQa;r#hi;)khbuLK|2Tmt)fwH zRoi-DV#nTWeK3`pKqmqYW7;L(W}P`3N_Qw_!gSGJHD@Pgbr{&vpSd&We31vX6~mtO zyZ^0a`aeZ-o#-R!VmGCA%=QYEK7oc-L*TIOFrlf0pk$n}n}o1>iIGDDZ(GhbJh$^G z4l%1WDqGCpvgBqWH7C#KP{MENKx7E9-TO_22gqj1mP1kO`<=?>m-PH;Luuw`Fb0~c z@gUcxuob5R#fg79b1#%p%t0r~8=HwPc8sp=5=Uja%5G|D>{G|^rsZpFTK9jU{ zpC9v>P0H_uR{w>Jpg;BJsX)AzS?_Zk=mPuD7~t224x>l^o=pA9zjhN*dJ(imx`9rfuUfZcJUtA2=07Jg`*)1Y` zf1_snLIGHarP+H;$dDM@d}d4rBj?#v=yaIfa~NVgOfw3w04=&S_|~IAxCOtYvkE>3 z`8cC$%61Lwzj)1sH^irJ%Shh>!l-0OgfAeT^_5@i(Dd8M5suBedW{B$KIi9Cm6=`} z{{ltV`*i`~;A`-PTKYO}>^nG*>v=FPNDT^E@)D z!;sx^K$Y~u$2E{n93dFa|7c5~!iyN<=4+lA*PlI7FWYWe8D3rB$oRwLu>6E2R~6SVEVqwY`tuHf-wE*|{VqLR6ITF!JVo0omm zYAtt9e)hBnazsCz^8zzSj1&!gBQ9^gYAs*b0X@KSR_Jpt|0?NjCLxNhXTuU%HiViz zrlAyw0CX4GcQ_<(SBl37ik{}ky}||mDoSJOXLsmD_nQcoT<=evO>va2;2qcfs#-iw zW`u!Ic6fs;+hqEDCKfL-&fXAVGHE3Y#L6f97m>^RXPnIH0D!R%!*BH-a0+}6jTJBC zBW*8kLx6D@wF}9Gu-yf)ZA#9mrX#V6M}1$sXkbVOmM!Q2*~m(re5nJc|{?U zVg4dp%-q1T5Hb5NP?|+9O5AKs(l0d+0g4exmK*#LOOX^`md+YbzH4KtfcU6T?IBwI zNxOGD^0qAL^?VOJB+E39eUHJ3%ZQ5j`dZ+1@w=szGCwflx?iAb2hEz!u*po^i}w}j z^;-VK$O$@wWhKYnN!=id9H-p-i5*-8U6hsMF0LD}t!Pl?s(qtXUJ!wwNK-nTqANyn z7@XIVI-m-#{~bNo5+T1Dct-D$Wn@18&H{o0|CVo9ERMS1XV8tv_)gwmPJQTMT2SpU zEdOQpynKE7SG)6Mb%%d21C(FsFSP~D<^o*azuh!`k2hVfrC;QNqFT@)`wI*$F= z3C-dm-p4z;?O%ty%rH-34{NPE=V5(4-t8Kdc~ z`F*j@T(>mm4y}9=$aN@q_kBR3X!|l%3EU%^Lze}mLUz}nA1N;QP}8Y)9Xxng%jU#6 zIIYmy+$TuO+jkCYbh)4V)~PQ}5g8<=c~#F6S+(UaEFX;yGb${v*cFhafpvrh?zGs3 zp%W}vF>y5GM>}?vdjAnS)^zN49y*_knk>GCK6$J~(36o9wspjC=>p%l+`y@F%JF0a z$1CvDXI($iBj;wg`138Nd|Z&4zu4D@*-$wo-D73g8tRY~|14g>KREvk2py}#4^&UT zGCtPcvhJjD034}K>PPa!r+NFYk{Y648ohy-;a-0zq~vF??UO+6AHl94W)uNxi?+Ah zU)_$W;EFn&C68GFr~g*ZN0p+uXBE1@7wwL=L3vP96z%RPe`ZtnxUzL-ZiuFKA8#3g z8M0|tuk5JXA55DHPMH7wqRVX_v73zRB)6HwWkx|g>V|4Cq1UPyUjWnd!gW}r8YExn z8$`KW?MY8>Dx^69P^#^wf_YUqXb%n(G$C$f)uk?z3m}2Ua{G543-*Des_s7@xQOK+ z{q>81gvBAJtfi@-Z4_eGA78&isI+Dzi4y3)K$7G{2t`NUu*H?|T(tnGuscUYnE(h% z1@rCO9Q5p}9cQ0izZFthU6|6X>K2#f1SRU>!l57spMS$|Gs|gaTg3=N0KS ztB!yA#T%14jSYnU&#Ltc^|URJnY!W@1-0=9 zMAk@tRG~P**{g0NfaLUr+(6$c@<&K$@`FHM% z4%{$4aIs5X{(aJ6wQy$baC|cGiRKq;UeP_-J@>}oyuv|{LPAr0#i6V7&Lj$=2W-|^Wg7G(IojQ+BY(ZXv~QY zSV2B6MY0gK8loUAG8X)%*^`-m?IbV0<9Q$x;08_kzs(1Q0x})X5`q z`rS;NKdpz;%m_R~`U(XkdkK76I*SvnC;btEJ#u1l@G+KmFR#hs8M4b@#(^7~g0i`!C#o^U#ej@cM52-wQO#@R5 z8rocsw6dFQlW1QtZCnj3YLk&J-nwkAAESC*z5_0xaK*TbI@CQ7 zNa5ShUXR~YI6bezX*yEESh%nl!?Z+VcYadkOcCAqGE}3z)|)}{BOfgC^|p4-n-nZ_ z;yZzlWE(h1YDtj!9LUTmiGxxUWYT&A>A$%Ll~yh#eaVBB z9z(yOdi(UiwBxAYU(u!JRfaaRmye9j4>Xk+g>gdFTu^g#%WP}d4t`eC1H;jAS6n3* zwRapBs#w5%Gl;$i1pki}5PJ$;LHWOV)i@DT{0)CKlj#?ujztKAnkC;Ovv=)5CbdZY zviv(m)D>U(vMIwu)a>Oi!BjLZaO^M>#`xii=yPVP%m$!_g`6ARr|)v06MPOb7cKze zsdx1D!=_lAw<7Ykvcm!=E#4*{iC5ez(*Mc9!~OVjrg)C0T*$47`dNG7L>}b_G`sN) zu-Ajoyd$W|3akBIcgYc(g3#_aKeBfTTy;Z7s*D z*Zal-P; zndNQ-%A_S)4f4}=T)dC&29Dv6n34o{U`IeSlP&UMX?500_=iC@%DS5fQ&@+e)wS{h zIVLXy6Ith<;cdQxM>4$t^Dt*GI#!y&0(OyjNndJSg1~shH>zlZ&vYDdWIX>y;YoLR zw;s?kMOW1t$+>L!umu$1^G5>7;6rBWLnM3e1(EUgjkEQaoMmw5lJoI03`1#wxd1b< zAn7|X(c#f_!}vV79Jw>LniH$%OjIGeS<3%6M`3(kG~uw7CN&AS3f*(o7VAV*zgCe* z1m20HG8vJSa&(oFTA~Qz-T2&tf9}l-Qn7`X&9^OpEkY&{AX*^;$OQWxB`WnNc~R_suIeacQ5m@OD@VjeTy`%Na+GUslVr@B*{L^IAdc-inmb^^hEJw8XJFOGU6d@DhM zsL=U%)+3h(hoK+BrCjX`SFR^yC7F(beFv(M^cm{3k+3@)B=^>SGE2(1+)Vl}AGTK6 zOZJ+g99o#oUjvRMo5jJ2oLd5$Sna|5bdYKrMrXi!#v+gX^;(dvcL3&`B8mms)?obu z^#@}y2za+3hURSC{_>R;O7(yo#uQI$r?Fd{LWi}Iw|YnaX54Qv-1|Pz zS+qCvAT%$RA7<>&XCJ8vtmjsRtQdTJoVFrT9S>?yvh})eqyXxK2fkEq&hiO#^(e4k}Ph%_LPu|LaO9> z6#mb5S|tFPN4UHs=L|n|7e2+>t!__i(9fBZ0`f#LRQoxa^5^Wfx$!#A6SZuiYwHLj&i3i9S{X%LR^8l5 zixupDmM0U*{1hjO&(ON)VjG8D`j8pACl?=#iD9^jyN#DRd#V!d9j|R38F@2wZ(3s* z!2Z!%7eKW%2Kqkx3R;du17-!ElZ7f&oqTjfjqB3jE!rXRb30BVkGKs<@qIHt1I&~Y zLPHx6?>DB2<@e>jBjw?CdX1|n+A_N5dlU_bSjsCXT{WcY(5?NVg^7cou4j%CSmy- zpfUe|P+WY+34%%}G-S&k(^Jg&YK-v@40GL?twTr9-XYrc`t<{Z<9#C*-Vr`6A5*}y zts}BGR_~4AF;7zjK?0FP88k~h58rtM#i{`Yhy6IqZK;mH=zKXL0`mpeIaxvBDqZKo z_>?TjV8|Sp47H5(yfEMCTYNFYv9GO+T708@{7Z6u(YYji2I!>Z?!CmucDuoXA{X1v zYcr?Uis<-K=0H#kk)t+S_8Fqcabw%Ju2uH~w4KvLgnKu~=I-KdBxA0Fkw;gU-NQnb zhzf`HOjErRW*%7Y1RHZ4V#3&CqA>n0O#t89bnani5_yr9^Az$w&@}QO{jmHl!yw$S+sSAlp36N!T*Njv$$ZJgP+Dl} z6v@y>i?KKDZ{Sd4&*Zv)-7R)BV+6lj3wkZH-kUFw?uC8j^t@@~3OR%c(byGn-NJI- zGy7UHKZKxHU%V)@4VTiB=L^vh1JXPRh&bpBkVoXf`T@VENF-u%`+DMC-#7v|%&`gf z<-ni^_qqlX0*#{l&rLG^n-GeH*4&=cG~2`4|E&1=yEbgWTZyu-I9=(mFr}jOyigaf zbNQ_5;X17og**k8!+fVec19yaUC}pe#8@tOF#-d2%m+(=k{yHnRaL0KOg@>zC}nS^ zOBP9k3}*yY6n}@d+3cg7bq}-H6C{{)d66I-7=9%FG_9Ad4nt=r+yscCRbt)>+s;s- zO;uC;P9gz<;QcI?tNL#DDs4(!YH*A{pi z{T8xt_7da-Yb6w;RwDQW#QD3N%GK4>rq+yhEM}Ph9P&!NjyI#@C>)0E=ZIX25{I+d z&)A~L0uyh;9w{p9@Yg?#-5+Yq?ZkWr5SW5a?%Q$>O89BRmU&oN&pF5_fW7gsIaH0i z+8;j2w<+Z&7h~1mbv_UegiFtz=b|Z?1~|ZO>_LT*bnz`;WB{OdI&BOb*5?IY_DBCtGN$VQUw}ExL7gP?3iZ?% zxj{?}oVTd7Pmin7a}i@!^pGs^kf&>7XXS{sjAF^Tcz5#cNC0v8a2o)XxAykfIGCOg z+H2khf7m5if@QHkZPGJN0+(hxynQKs$ZVAB4-8OrJM%;v2RfTguZcp{u^IGcy@*Ct zPKOa&vHLT)ltj*>=z`2qP#kN<0H1PDO5HV8$5&e2o~f*cr6i`ZgerJj$wV#PDgA+DW~*3{m&PPlZPvPez15v5eM1lqF+Nr0xa z#qsgn))qMLzk+@Orj7fNNbUWM6N%Fj-C!*qar^&o`WB@BuF}5T>CU};fgw2MNdYRC zlRB(pQuya?3ik)U^+#6_J3GZuvdQdHj`L@7u@znY07|Df5Z3E#v1b6r9ScxRbXsC{ z#e+#*dB!%~(b-&MlTz>OaVu==)OuaRbDJSDxuXqPM){6^c`R4bx9x4RMmx0MAK4URkPxx*CKHBQNUIF@ADc}!%WpB<_eWK z#)q(~uEC|4gqm_rBErF*s)GFdix%AtL)-I3yRtr~0ZaP;vn#y=Pc*lJ^44Mt7T<5g zoxSO~EI3D2g&=ZS?FGz{>vUz<{J>%bm(KaWHS!uV5ObHClSE*RxqbmX1C!tySCr~8 zn4Yqmj+y2Th=?LR7>Qd6pYpC&=!p>rzWI_>Q+LVFANCivwq;;`^jKGB4L{1TK_*!r zOj=D}q~St>=++Ip)>Eh;CPtVr^f&-i{9LL>jCV~mOrPReXX-CxL4&}>B@X@!Dn-H| z)h!ogMPy=B8H>)!39oo7!E&E=M!3n+}2#4GolU;@~ zihTT(MTp_ArXCoJrzl=Wn=|M)KOqTN5vs1Jo)T|p%!Cmd1w2l zs3(!t7uCi98^%CVUjt}AH1db%DxU7Z{ZBry6pNyxK>%4O04)uQlZX7LGWPu+GcuZ( zfcUDSAp8Kl0+_zNqQs+P5!9ZUxZF6f-YX0wVkYJ(TY_@8fl1!#LS)rGT2ydDlGEmo zEUB@~3MrbyPW6eG{n=Nu-z$w6a`POXcAs0(1EgfUNtG~I5?lG8EVCYH)HXl&U*5R_ zqeEpoG&N$_P5EwN_ebv`Z#TYd((9{?~xx+J-!E9a4?m+lWV?|l39HV=WXNT0U^2yb?bDCIu zvQOM;t2_0=<5DxVcH!y*Vh%x214GxT}daenu zxU!@ol4Tu$P{FqlyA>_S)3ly!%RR@BM>R1j$S8c#er}W(#w)gKQ-TYs9O#Ey9H17j z8=3IoORg=H2c^YJj_m*A zUU^W}fy39t`H6)ktLq<=h4;0f2ijZ(J9rc2HhG4zE^beRN8S5UFggTfjB6P>HcG(( zUbneT^f678&(V~khD9z`R^DpW&v3w?M19dZveEtQZVmkfQpfr*vcV>lW7Y%zW?flauXTg>1qgMIJ=ZpHLXZF3a{2Ns>ESHY0_9ux2L z!{gGj)ptjZvSXRZ6mcQ~mAyR2Z`nk$U`+y6?40T!rHg$PV~|WYcX~KmG4YhT(t3M^ zS=6-UFM>f;9sc!x^{yR#_yT78a8`rbxOoLlODCJzwgqZ&t3A0_3+?p?=-}oB@IW<{P%mQTx^0W5OW~*`G;o{AxW^;+%sF0NmX7dNR_zWcHU^vA-o`Y zi{-h$MhH|xNy*l5;IeSnDb&8r57&=aJi69#eIg2!})S*isi^$M6yIlNnICgdT4Da|rh|myGl*F95?vsViku zB2uN7*dWkw*ET9ZnyzL+1&7;HJrhI1n>Xd6qvwuz(QR){-Lc<|hF!ELF_;D$SM$19 zb6}_be%v^uJU~XGN*n=L8_`mTl6Pp`RPFG4DLn)I5%$0AcVxHaA$JCKBHC(4wHh5# zv=OcHV46q9_{xX>z_H=I9WTv4vYIE!uHhU|+d@Kz$;dCf(FY3_e%U*MV(D|7v*Hc0 zfezLzaAuEk0G~_k1SW0g>(3>i#PdGB_Y(&ndOMPN_&=!1KP|IaA zWnrk(qdf9fH|~&P+c`;*{~<*La{o2U$P1yvm-k*ZkXzd%jhRX99aG1K_R&|L>4_GU zB8*7{RoAy><&9*<3t86p*1txHV^sOi+zYD_eHG}TfcTa$sL1(h42Ao$TDBxa{3uI| z??>pK#M|+4>~Vo_t5*L2kBiI1*P@nBQ+SsKhs_CqKEI9)(40hQzQqLdN*<$?qs2YK77qQ;E?$w)JSjs49Z` zvfT4TArnD6IdQ7d@S@1DD%SkFx(G)5JClWjtgIr%V0ly{rF>?J?#kbRhp`DnPaCkr z(iT7AE{uQ61wO?gF*20e>CuZb&uJ{qS)YabZN~Fyw-nqB;*rqft-c6#W;UU%TJRvZ z7+X!;Z6vvB#Cd)BRtx=P{1(2e+xAj7uW`)YzY7t(vMAYNv(*J~>{>XzOs##VKu48alC*{ge|CUyQo zvZy`l-X#sb2NAHZVgpCtHL|3Sm?D45I=!w_`a}-GAh~jVYXRQdafTRfoyO$51E|&t z-I`sVua^KHA1sZrpGo^k-Cq35P?-Vs#Ol1tmsZQ6p4EsrA4fqk;jyA5zuOig z1get(z9oCEN#U*_Pt=LXqYEPPz{$y$DE$9Gtm)8Jog+WCL^m5i-Gb2A41N)EtWIOLGs!@80}$vW%l_I1%o)vB5h&ouJUFI*5cM@b}v`+M?m z&fr@BUTFnYuQXcu5`QdD?o~$R>Zldp!24@{|068e5q_H#7uLiAoiZKg$XV-6pvd4n zyui*GnTM8i7BgI7$>@|9i?K7 z1KhSgAc((OC0FO#I{vu7_H?Hw`OkUnbV>_ksI<)KssC{=`u%si z6pO)mXa&ZVE>I7V_U2zs3O_0PFf*gGe7!!GvD}H#thoJ(EJ)vXNi=R1G_Zd;Ya6(Yh~i^Qm5lbz`eLl?6QE6E?6#&pN{@HBreRKL5{o3tR^A33KEh%X;W+u9+jB z-7g{nGRS?1t}={BSsJJnfH0e6ywtNeSgC7-iZY@Y2`5Oc>t_#yXb&kAu6U{prx z){B(?&)}BFAA20(W3IW+zK2w?PeEpknDprrfH>LT0`Id01hWO;ux-0cDsk1sS$NgOHp}0L+t#*5p_GUS)%6hu`XmO!Lp9M$)F{jZ zwQ~JA)+dKqmK#p1k(md5iBdyf5`t1Hl^6sq0?{ZtJ`(N1o7Z6-x#`^syG;Bqex@}o zikAnn#p;b84DOmJPj<|7sUu*C%u7tM@Vxi4%9gCfOJaXaO+Hr);cW}Bq)V)H`&=zL zS#B?`4I{Mz3=*+X9gB)(x8wjlKdqBU(@$t_DBXH8Z5SI_Bi`UHr9|xlA$C5FMbv~qUE@cP9BuffsKCKznBKzj7q?a08i)5qE0F4LUXR` zwGPo*o)-mn(tsBz`n9xyCLD~D`%SwaP37BPikfI4y?_nYeWU!ZGt+5bWLP;XgN{bs zeZ8o7c0#lj1b}!vJ!v2eJF8~xTHA+KIMKLRPAG+DSBqWfoL(Ij&UuNCR!<_}AvA4V zvL~|mcsLzO0u)MJrD!mS2kE%*%Akv)6$;rehg31g4s z^a9R6118(~f>E`-=UYO+Rs<^q{p)eeX{?+s?~>DOwBRiH9cYQ>2dOxo!l&yP4D_Wl zZYS`Sh2pnZU1LOFh_j*&APoKGFbJNgpAy}ppslZ=a$)ZDEETa{qh9`~_R7qML@#G3 z@H|w6+sm-FbK6s!?Xrffq9e^GjcQ3KEqC#U(nJ>EO6P10NwxGs-o;II`QKHhdQD zO9JtLq*^~~no&B0FJ(#1vk&l~ z*(z%KJ#Zr99E_a>X?}z6(FWEFOju&d9c|1wh}QKNqodvAe(3D=tygP_Lr9&4!?Owwk)25i78AqR*ziRdyP(OOOzpss!6dA z-$lqVT(`jk{gcCNdgcEZX%DmkKLp@CX>7D#k@=d^{<#!|Gm`X-)8_B?Oe1xs`T&=f z(fu(iEn`gxfDCmTXp9I4Fbe|A#Bgm}KFNB}GkZV$d}O8_B8 zHSHJ0^}|{6jXZP{bEDxUft8h#WAJKUjN88i`7&YBLne3>t-T z8vhM5?6imT7ik-J__o5=F<<%Hu;4Vl2l22q;j_nqshQ)w*Wyc(G71v#)g^j%pM-MY zClaZ|h}j3N$wRZZTXA52?8a1k0DxEXCJ5eCR1>)$cPl90`zw%$UL6}M9PcKP+o2WB z6T(=aQ=VrvOsbpHa<4Lsi2kFm=auMakVs?0nKB?bWQv>zf#wZF2;3~^o+GJ5Y#DIM z=@sQA=uTGKnfZ7Bj0x<{&&SNmkcOY37y~0(5pSe0sukeZ`IwAg#c2u-HE^lE8o|3) z;vg3h40A9^VO^;q_l|rdLCJqm21JHwP_oFT>8Y&Nj(zD*#EfW#yHyK*CBB@V_?RaJ zU3&jAzl+z)+Ex;4wIpF<#BtX{%>GRe#F&H59ri>hbwsh-BJ$8yRnSm^ zVgp7!woXzcPn8*JE8Uu1Ig+@s37Ko{&d>cTtJ2c>a06?`m*BbX8T|LObqX<;vRR%N z*hu<8?5AFVRRFQWvaNMEpGT{?kNc*ZQVGUeV81 zhUIJIBI5oE&AEWAsF%x+s~Cvq`)ax zk`>1f!A$$;*N<33G}x6UJ3%Nc*r&y^|Jh->n_9W`{u8db5Vi<&rXucejeiZlK@?kt z{l@o%lUxJqtp%=cYa(2Z_>ubv9|wl(58<96uMW#eS@kvwwYcVy-=N9v`JjY-FaI_z zs(9ua&r{IO*91{~J-k2z#!35IMj@@(iF4RxbsM%-UV6FXHyk%7N~8vngZYU~fGAE8 zW%tynw8Ga@>n>7kS_y4*?)gmIs8)0uarZl?o|b^n7jHzn*sW%9n?!&fxs4EZ;e*xA zCOqz)Lu+|idO?@#c+S$PYkJ}|yNB8ekapyQz+74De}%#OO_&L6Pu${(93yqkscXsd zK`Mn0^__syJoDg+CX*GjQv`HX!0HU<{~@p5w1^;5zrH9D&(K+GJ#gEpv2Jklq@+ZT zSCMI>VgD!C#n!}{CvHAx8k2i%L+ug5`xd#weY4E-w{teP*3dnjbeh?{RDd5^tG zqSg@pQThB*6Mw-&b{oP0;dYr4Ry>P;6*7t);}BGW1qs`e6k9F8PG`_MWRy%t78kFj zMt^tzFN%JZ)dRyBRDHGx6 zN0E9Oe;J`xua``9D&U?NL&oTrRTz6fn*BPE3Gey{d&s>9-ra4H0@2;*6!-?lawx&s zM`F5PE5V~?Pb}7^{r)-Wjf0Z^I^DwQPOQiZ!N8jj`du!uf$f9>LiH7nAN$vP?5f0cAju8wSyYlvXzr$q|Bs#a zXtgl-63wlW_4j8~{2Pei0I%;h2Y=)p!cMV`3XbL$D2uJ`ZjSl zm`aVz|04jz|8rlPo!Q(VE{&nOz+g9Ks#G*qamP`xv0eEKz7=Pi6WI9JoCf2%Sy`AL zUKcershED>wOHe`u(be*WksD51UxB6!f*wKINihOU@#xKTnT}sL0k!j5^fzhUKa=) z6W!eQeoS(au3+)%V~)^dCN65Ms-=JbOdrdRO~Uz<&RJ2B}91ZJSI2MO0S(qha zi}fXhe`cHt&&k&>$&j$7y6*Y^JL+8m`%Fg+Bwox|QE)h2*eXe$S`x;13fZ1zgD%|y zXaswnL$e&uOYJpZd(KBl_)x4%g9r>;370~7LK^b8tMrAK+E!}K%0w^H&Fc6sZ>9KW z%Mq!uDD>%C!vXylFH-c{I~8Wt@EM{z_!kJzpzWpwXpVAW528)a#PB7 z9PK!L5EXMoJ36}R`|G&uq`Fn)hY7hRYw*L1#C#`DNVzG~vK$qy=*_~DU6yclyH*Dm zWy!V^?V1c_I#+BAmG0c}m?b-Z5vdDHM++#wG}nvUN1 zfVr(8Oimd0%zjzC#Ffo!_+BLts`M-sFMa`WxNTI+3QgH~4t$}_Xx%))hEeYaqVwwU zA~r3b+Ly29O)4vEtR%xEo48{R7Y0h8{hr}5vY5B)z}p-FLGEQvEy5-xHiDn3o!tyFjLS~>AlWOa>&X{msVVk4t|-dcG&QGh}AiX}aKaziP6M4ILNw_$Rs z4#6kS!~NO&P_?<-JA|vYxicKX`@I*^y#xH2Q7k(;6Z%bXeve}UA~Q9Dno|PoCuRH@ zs*xfruop_58dxox_`p`;zdkJ<;z~0N#|*)xXh8{v7>zD!q|3CCjq!KDdvoXV< zRxkp2z+W98jDvmP&t({3b5(3>4|=%*0$?0{CB0T6I+T?89`=Jc8^DkihRyv+#QhP7 zp#K=>QfL~c2)uPrGEh^b{6FV&qaX9EY192GCXjm-IMYnKdcEI&NYF@bScNsY)wicV zLkQYcVtx+%hLcCJ2T0laP}KjP3s@&^q>KeR2(R< zUlBJ8Ka6Nny)p*JF)uiQ4rs9LlS0dSVsJP3U~#us8PDSC^S>=oqCsfmn1w+Ujt!_g zu$(l}fQg5ryiwE9dK8DhcSC6Q^*FxHGnfXGn=VzpmNvTxx=?Dln?n36=>{|-S4|&a zRKs>U^!I@kj$8%w1u(}h^`qZLUUfn|MLW-_Tl!yUPM~@?MA{y*`?=ih&j*m*^2h*o zZIqA5!Tmk!CyAg+)*!kqhJ;JV-HuXpwhA%1tB2)_-1l7qqjM6%NHuTlkb&^ckI;X{ z;~NbwvXnjpG48^lYeqt#T<90=a&GJQNoIH8gHh3Jcd2q~4D2-XM~4xp2$6Lw@1>v3 zOtTcUb6OU)DAG928n2+S-jxA18EXB)ERp<{H?-DrU^I z(%+j<&+V4t-ioL@tp@Vb%O(V-qEhQ8QWm<`IoRAb6EpE31Y^u$(@;PZz|+bzP~ccK z-%Xyl1+sAbm6hhdtR35gS)yF#5QBv3LiYgMyI4fD{J@2~y0gul?_*I>K_dU9^;WM^Lg-Rr)`mYBm zJJ3g*GUG}D<5mv^4M)cO0iy|e+=}N}p7q=qk9uG|)yct0NLt7mcYdpIU$8@hyWLvY zFU4P-$23hdc`9--&(e*gPwK*$RQ3>r=7Kp_T?~DXK?<`40SgyEkkT3+N-+9jG8WOw z*~nSK3aiCY5Ih^=4Uo%Av_%~o3+ChR!JgMG*lEySxz`TT&OmBI1MM0rnmU2l{o_rV@Z8r0HlR*ST>LZ5j%KiFpOE z^DBA917(r-ECpx)n5~OQ+2gB`QODHR>|Bs}_jvF+laehpwK_;gEuY&Mjc1EnqD6lastNgWZH7KEtu){UMR^40*?^G;*Iz3B3i-pjLE2-sznI+i8U$lM*YZ;@PavvVr0t5%4fwQ%?a<)2@l z+HjI;Ij@tFL-DI%K@N!}yGn2ETi&+vnvs<+Na8f5kAC0r~STQf@gm@TNF>&5SgmS13_=wfoR!w?TOX&lRk4 z3~>f+z@VhIPM!g+acu?#mN)YSs)sBENU+hMGyHIKj_F7(ubgqlkNhoy*aLKz5XliW zt?W&@w+XRVj1-1|pB-M-(NDx=Nte0|6CFRGiRoIMSow6 zUXKy3k*f+LHog{lv6LL+uM?rdG;U!2z;o;Zg276m8k5D+`%xX+< znNkbnM$ana;cHR9k+#Rjz(Z?e%*EA}C8V|29cHMTL9ElcT<^~nW;TYpBNjT&QH-I((pTsYoQ z60R)poOTPCV-zd{t>WV2H9M}7c+747iws(XPPUT0pH8gB0b^Ewb4R*88?;boax`E7 zn{@Y-4&E~RfR5J|i`M5z1kWc3qyTKv6u{@0djU2$e!pef2$5 zN?b9dTqI9Whyr<|U?t*}$#u7mDiuDjO!lCZv`is+D;0i#TS~co+2n;7K{AvTbBSS= zAQNN~C(rfVQNwI5jb0dMCn=tdv02Tl(;VhPs7M+6QNplCH;Hq8jGs_Fd~R!O%TK)gS1R1|<_meMINY-y?CB zBj481L)v*zuyS|LAZ(1#SC^JZjm}^H%=Il9W`eOF`vl18rF{QOAXSZ9<_Zs0z!C3u z#`hhHWRi|9Pez9WP7~Y3o1*}^W)D`SeGJek@zZM9Fwj%T(GMjxy%|t{i3L$r%2;Vf z-lvnW^?1B1QpBfv&P%z980HTE;SK8e(XxZ#7B|%HvJvXjgdaC+OQ*2I-zhjzS2-a8 z0*8?1;lvs6cj-*Vt>C}_hq-fOuSY^np(J4>2D))ooY}Q>pcCV|w2Uv(k#TCw?&tJH z2b42nG;c9%AwrVM51?uv{WPr_w8u!ITR+kyg--Ql>i+cfO!eGn#i8P04dD?R@;B|k z!VxWsLcIlUJDgH&guOccfHV9KHaP>uaY4W(n7-%{gHM?H1rCE%83C1_O5TQ}F_i$F zunD>lGdHhjxSVA3v3yDTi>fB?QO%zYK{vCX=J%hL6T z<5D@%<}VTw=|CvkeTdoC#%pI}E%>HnG zXMbe@40NZpi{(=KTd7FCGgS^fig?kx9G_A~aj#}SLm6}Zl`b8TYW)LOE6_?j z_(SwJm5oumcNxx;%Rqv8IFWnf;J{Jjyt-Q$2D6kxyJ^bYA{Wwf$}XQc*zG`kH2d`( zzsFWDqgi#W1(8Bu#^{WvP;@PW@Eb%n{q^~n-PSXg-!!d~xBpp8p%AVF-KoO(*K7*` zm3SHKntFWRv-)V6w9~K zlYsYqws))MOSI7TtH*uD+BBQJ4EqPh^Q*^rBQDzUIkAB2n1}}hkuC12^%8v^f+ujT zU}Tp9nU%skh`YH9_nytfsSLdnJK-o)@%ORAJ`vM>#!q~x6k$#B8eP`T!Mb9P6L}!5 z(ar+e4ZC9@UtdD(9mGNlr(%U-)#n{K`!?nT9r%_3!Azf%Hv=t<78g@fzy6#M z`6>)7P#2;u(jwq94Ttk3&f zKvHxFIDLofDt;_lIE8#uOTG~BrC(RtwZPe2ot?h3LSg13fjFRa(%Qra?tNupd-DpV zCBkm7(B$&}i3l#n6c0m0-y+uru0{JBYZzqKLlxVOQB$JO5EVA} zFa-JY!KT98F}NjzkP-rjpkWEoYp-wA5&DqTfhP`v{5iE zLU?6Qb8*(6(n{uM4H5<7Ysn-_D3qWm;#LlURv%gco#Z`C`3VSfxzL_MWo)Zzf;tjU z_{j4SvuDmBM2HuiIffcNr$51uxtoGRRyVS0mp@phL~Mn)KsxP!5#$VB#eV}NYAvvt z^TiHb8)uSsQ>+t=aQtFXy0oRw&gZaY`e>_eMFFl_@2tH+509_E*~c=UBSSh^%yyA5 zgCd|mScQcgLtMt*k<4KonYhJt{5mCDH5%AZ5z(3EYMQOaOFcl}TPII2JFL>bG&@23 z1BIEaFVkc}Hv1GvLv7+F^%>a!as~TCPoV=(gQSU6Z2QBp^R^~E;@jO0vtxgGUtp_!_D73!IV^6fhya@!fUmK+0SV=EslVBIVfZ^Yw+9 z{eds~*1-_#c#n|eZfU*{+P=I`C#FoO+z4#5%v%oj=?_E-rA9)7X|$5WWVR045=8&V zq8oI@&my}FDUhOm)Rdp-)&Fwm;J542wWO;TLPE~9byf{D(0zxlixscF{<%>q!%|0b zh?`#Yo86s3b1h)5hchhHY76)J-r4(DXPHqj~L0S;s>$x%a*iQorAW4h#pe1N zm{%Y~L#VGAf!0R{=v)ilYEH%cpg%wQ!`mV@DpT^)77RoKEQwx&Y6*ZfK_`V~Rm6wu8(PcZfG0dON_-#Q~LH9zQ}cZY2bb(*wYbBbpp~DUzq{) z+%0a+Jv;?$=cli$;%H9^WpiSOen}~S40ksu28j$#QdeE6`c-oeO<6*%>UwJj^M7CN z_1x9DnT}7|c{ytXDiW;V(J>RYJV|1MD!hEUSe@EE3qOe#Rdd*{;$Fy$dDACpD=I;3 z(iD?aN;{pj)IYG`lUd&NsTiaU-|}9;tG*RSA|&WFN18afKk>?J>}~}%>DK@=hS=xM z)^jhbg?c!Sb`c*R(LO-ccBzJTg!<(0k05bgV<~w_^yxpbhWyESfSM~A-$;VUTqHXCVV2k%W_dRc z5Ps^vp6C2tabm@2PcqDJb{d|6XR;UxXDki8TCJxwbbc6o6_;;Fn?ytvi=)Gi$93Z( zUG!gWsWhqz==u_{a?K{!05Za0DM&fwjm0|H!why}-yHMN@bO+AV2%2-8?N#rdd&C) znSyy$lY<{2!g|4mRxzl#VbGE+e`MWrF<}YKD1pg>^$D1@m1WJ7z+cRt$vc`~gi-+e z1hBE_xtkq)SsqIe09*62Sy4j6UVL*gSq}5ik%=$J5%(dFxiN+1E?z|09{7#Ixws_p zlixfzO>bm=0>3u$uuGuXWn2q^h6Bt)3&gIlf*;@r0x?B!vP~Fa8cUx`KN9g!O$NJ9 zPM5W|CY${yP$k^B6F>bPMJf<6?7MOgX?<(EAd4@MJ&Wg>*{^UqsL5#*S0e>MGvpNX zLExj^+u4HK0(g80rFY^wR_#w(k_n_<&H_`;j=VyU02Hv}RD+0Zlv2Mz6p{I&+{_O5 z2K-DAZQaVIM~HkbC}epLNAK~6i}l3(QRP@Vu;wZo3wqNdm1`k1vOypKK5nX!O7a?m zAklvz}6pwF*H`_w>UCh$D{Bl>>m#$PqYPv71w zO0v4`N$=YL-;Vr{sc(m1+QosOU#8Ju5Q^2I4yql~$O#>0&Q_-b{qE`qS2kBywQ0J# zom+&vqy#_f&qCKkRp}lZKBu~x_0sTWFk`LKpgKza(;-KNP(!5eNDQdAv2v9dr^AA0 z9^MkxJJ=~>_{(}B6-}L~p;7b?KcsD|^!+jdkTM^W7#c2k(8I0bw^yvu?f@CR zQi&E=xlTAvsk9Sb?R&4VCPuN&a^pq2S-TYc56f#eEL1+r!8*v5co~j{rx&C6B^xe- z6vel7CPh2xjP%3LXsLr8kQq$}oUzY#zUdKGxcknVKPl6WJwgZnR-2OzyeXm5@dA7( z8MOw@K!&P=z6p?HKY&BuN7$LtF`)9_-zgUE^&M(Wu5xa=DlyQGQJ8yK-Vl`@Rok`C;y)0nJ0yINR*AYK$h94%htT&Or?{wNL>!z=Ge>M_tS&K zX@z9_8z_le-kgQq9RS0~RmS+9F|L^ck{MP7nfY?~vH7#plPUnJ99@2zC*ZfzR6#fA z96RYpwtYI#HONeDx#EUm`fH zrV)H3Zkcb8Dz7tNs+vlAnyN1bX`}z*4Z;1BStF8B9k_Dbe4tMmrIGoY5cTj}S<+6KlL9^G0?+ zELxL+r{_EUy=v_nxCqvyFg14$M_oLR#_^`q`3U<;wlRPSep7E0-DeFT!q?65kC;nGVvomVm>0K@|CfwDod zD|z4|P$FU*VFqJwW93{Evg=!FvAN5dQ<3r)OYon`y zyBhZ@%4kKJn(l9%DjcBz9O9l4^zW3u#1^a#q0u1HV!aFGJuT^qprH*4eNREG>dPS> z8ixrXx+m?bbzd-!M*TdvpEuu# z?*2JF`BzrmjGa~cGAZ}h_eXKCf3}P+VQO-Cfe7XbEB44K%rE|yHe#Nfn;h2G5RM4V-7f4>&9xkEn(ggG$Pu0r)0x8a`y4_!Tj|BETj z;x$saUG`aD2C1QorfYg;Wm;*XsyMQy;{IUBU>hQfq+nx*Y~l%<7SWPK(?85gi?Ntu z+!tUQ2q%0IdiL%cWZ&BmQnkHEG?0i<36#LAaEhsarrE3Yu(iA~>@xD(nDYcueQBL2T ziQ)2^_yrmxqrM#Eaysd&6fz?9lX6L|jpPu-1t5CfY>L)oFdUtSXvR*?uGhEal21yg ztx2-sA$xj{x4bb^d%N`TCqW@HID@tS^5+U@aEV#G>;b%3)OAECYR#PuB^=Y6E0hW9 zZLj7beBR#faX=Xz?)WRD^44Ns2lM)fIH$Ii@4dN8uJ8jKrk*LS%?1J}Vzo(&4b*Z$g;Dq_w5tKyU=>+h+_++S+3sSg%im7NU|7 zpK|*t{2Nn0Nv&z&QHMv6bl8!=r0nBdhRW*)?Bzewa`A|;Z3T#Uh{ifx(~anly+@lc z${X__)jNq?a0NJTsC%vAlu@xR(fUe?2QhqdE_1Mr=F;hV2F6`UbJ3Lr6sOtFf&m2e zl2;yqoC!8{cW4zxk$4Z4tB=+#R0o(g^i67@SYf67!CoFev zM%IQ&zRtPeZGaXbD0Jk5YPEfR`4aw zekFsVERxm?%t&9`j-$q5mYAomxQD#^-FsTWxRpv=Pxg4Dt>m;b! z7Oq>%YK?B$5UnB@6iQWV8+7^7t*m2V`fWoe3 zsy?PvYTehs=Z`#ZoPpgci!HW%A-BkwL^H+@LQ>N@QEPmtt;;@=S*WF5#i7f827H|X zaAu0XPH{^Dr1m?n?aq^u))p-N^m(GBEkCh-DvCXxW7n<};|}0|a@dX+ZzsFD|m8@2z;Ci%G8^z#l)_u+hs$zoZT`bH@d( z5V{J4;OkZTWtN`9qwHM`!=|dp-Ut56{Ce{W8LLPJaS)`#$QHr?ZJx|V<9R&O(Mh-1 zE&ReyNFze$=x#1eTNPt}6P#K8)LM;5y>}AjCz_$ya5m#SpYKDNu%nJ^v@s)<>jc$D zZU3_DTByPHzxo9ZBzM*oQAs10L7Lp+;f1G`J4th@BlgnI2+NFiW}160C1meJd~Jt{ z-m@*-W<^>Y5Iw*3Q|iq?vc3Y2;q}>)EfDUgYJu8f7qKmL)^9qDS%kT zWP@4?+nrE7%-vf7LJfBzHdK2$_0S!Sh`EAZcd9>bsdS9v=F~Jv;p7UjLQ5CNI6@1n z$bkkt3?4t2b7nm^zjrQMXLjBM@p^7#J-u>BY)=_-~XM8HZUsy}&&OQ`qh^Fa3mQ zPF7u5b%pOJRM|1nnw2 zyERDoXpGK{voUlTvrfUUR1-HMY*FHe;*rh7vGp*MOc;#_CKo6 zKNnxvr`mF?bFwNFYXwX4I+$0TN$VGFpJHe_)`xM}j@iP>S3(%vX_< zb*FhQ-wtQiZ++MjF|balpssYohI<7uR`1xqM%TMEPW>*~6;($st&n2@^D=YAGDI5b zQ)^xi*-5_4!GsjiJtkshUTXBYy%nCwXs4N@RjfC*&PmH{M10AoMiawpp>uG|C??-u zqAlP@7cpblSgZIFl3YD7ds-BgR`~!B2=?oHq$QS`RfUxG_g$z`&c8mklQg_d!RjM(e!8%#=J4&@=*j!+KLT8Vb`)gt+Ew* zwz7m+egu_z1tPhJFRD5fI$z{|X<4vdztn4C3Bj*MUW#+0;L7dG=&2~)Bn2nrS3U?Xx62Z(n0VZ^r5E7I-Z&(sCDFd)uo9mXe{+j`k+I*JQkkta4`mMSnY ztZ8ZUY&ZDXS|Zt_y1647C5dd?Ba_mC0Oj2dzZbV2>5c7X#jf}64xlC>Q&8t2wmg4) zKI1E|gKG5?oK9h>LqEa;r8)L9%%kd4f_S{`Qd#=c42SmC*970-wyy_RFUCO_SCMk_UQ`EtJZn(Egiv}+{2Heb=v#Q6YR%nplEQ4lS_)EcJSRz@r>FjY z^#r&=z514vj}FnXRKPitW(;BZm2~0)j2_ z+HPRtg1k3O74r1BJ@joCq7hX3Mr5Hu0dRr!14#~_CFWxiKEz_kw=B4yRVotv0X9L4 zCZVtPVIRW~PI@3rsu+pVI? z_&(ckY=cv;B_{hZI-dC5jg(tg{F+drp$B zD)lGLX%WMsAw%YDAQ{HPZc^2+%03U$Ecy6OipHqf2uG1Z*}y^iI`m- zPifuhFxh8!ry6i}&s0SWIsukP+Ue$Tp`v2kRQNl^{W6t)h_5&&y+?xtuQ&XJW6oO1 z)Ni>M{m>$i=|&`_?ieP*mPXW*Ce^m&!jV5Q+Q{xkRz`nl`oAG4o|^(BR}b>K_frXl z`)WYrlmHCj8@>{3cLaRs+>;ferKor$Z9qdYMxA$e&|*5Fe5m&Z*K_pQDAo!!2Hq`@AMr!n6J$wrbXj0p3 zlPtXMDYXzl4ggd;EmOj7Yq48^rdQxM{WYV85Bil4@dl)?%{-b>H(pq2FQvULBS4;Z zG4fhxJQjChLHWn*uH*e3azi)zZ$oj(^!NX26H>cBt)8ILMIw=r=kQ%|CkpT_gDW~$ zmyzn$rJz^?V2&DS!;W62)eOWyA*lq-u`2Kg={|xYiJZs#agE<==XX;Kle1ozQm6CR z#`Cl)y_X(H?ZzN(fdDjHSuFGH^C=UIs=RAw@boZlG>*p((lIriaaeKD-qckj*RvrQ zV6q^IjIV2B8=Fev=k*ZX_;1OL2%Y-=dDHEHdtB2lLG}kepM(sy#r>eANg6C_-y)ZWKDNA#x#PNdVoj4Qs0IB-a3=(PyH z+(<04UT81QDk)keYDq{=Z7PwIElAW{uP zSfbkb7dILalB~??-D}$Q`r#j0$tf{8#pYDP20_xbwomfPAG!5B`>g9ux-oeB$F8!6 z{=u3TA~ofG0Q?>H69f}ofkct+XFYd~IUh(x5n8ffJQ_GCSmcW5&@%|4En~c-{NFo7 z50yn1DwBr`W8sn)IF??c7N%^KaDoDui&a*_B&4sQG6g zTwwO4SLz$KATNI^X#Ap?Jlf8|$GNDJ_CSZ%@F|vK9rKFeDov^!!fGF{dgjV&CYWrG z$aUJ+Gp2s2eGjEM&9Nmj6c^;)hANcuW*X~P)O;oTBO8D`r#H|j|B$*sBJ~P7BeOdx zIe=DT2T>_4N+_$$AfC8RBC>4~cruyU{B&Er*wuFhX4tK@rKa+Q3U>t$VFjX?NFn?$ zsQn#}LJt$J`YKEX+gSM_beHpgG>-W2$TLC}h7g84MA7A~2Iw%e9U-G)l13||@|o3t zg%=LMB-)7!!rQaKV~P4Q=}7k72+bQH4#)x7NQByuAcU0XjDH=A$=@BU<^Ozlw80`N z+Rh1b-{$;QvK`(l*~(w*kc!6EpOE-U%rI?~c+NkAaR924tEy)q`EmYnS&)PJ(b~H? zrc|kF7d5CqOBC7JiBgww-g8$^T-8g2X!_>7NDu;SDX`1-R<{T z@L2$kfus3yvjZ-tma`L`Z}2amNlY3H@_oWyuAgx{l{LVXIi{+1o}aB$u3SKC=&V)N zi+I=522w^CX8WRy1+ll!L#eIp5dFPVWz82KN~X-66a#oR(3G0C>G^GUt3p!ulELk1q7}@rL~$2!|8@& zG`%0bC@K94b}js18daauaKT<+j`=<0R^#tTdZ>k(N{XHdjtO-*#y9Rl9-Yk>ci3Wm<(0d^`p05o@?!zm%jR>AG|RdulNXc5b5d=lE@!NX9|Vt6!2I-a$25tY zs*ww1wsv-s(_&>nmOGo(#>>!F%E{`sxueJ=FPesJ=CpM;UqA!btVWNvYT6W1Noywb zSb0*->HcVL{s(jvuXGUp!Mq0!!k0zDW&oeI5Y%FTyK$eF7py_*Sx-F-S?iP@s6;%> zR-!s>4`F@KIG65e6B#NyAJY1Ee!F0|>1V>FBr^GBpU6*t0K%$Lte^D}@sUAm-3_^z zRRcx67l1lGkU2~C?Y_|ntxZ1~V=I;!4?YTo023qEpXu>>;e}S3Q$^og`+Dd%s~rea z8?$bk3MYbk9WVsRNuDz24B}Ly%tl{8d<^KAF@$zC+wX6TATnn=KOo>bAAe$Wz3Qw} z!6a@D!{hGe^qU^r!3@Eq(%u0@hkrt1W0t-IdWGW2LBHn6`?(=NT875upuYBC!$e9+$Rsu{9J1AZC{&7Go)PO%qGdyHwZm zXIlahb5CZ|q1_XZ?B67MnBIVGJE;-BO27v4F|@`~RFGv~$P?LM9Q@xGg@{C(8J?7` zlBj3L1##eEddCE7LiRPRT=mPnP?3IDjf^nU6vIUhCOO0|CrcqEEGI)}X-!H(+@&-!_aO-;xE_z=1H<4oF_HY!tC)Mxkaq+a zDW+4r(io-Nqf0VMZ9BmI5?{E!a1_1oNHj#^R>w=r^CZm-68EXRGG`4`g_X1udh6=G z&~O1t?*RI*lA-C%Ej!@^{n+Ymr~E->8UvE;;Q5Zdc~Y%8R1;R42zZe5i29w$>F7yoT(Rv zvG8ol%-nXl)mw~1?-KP-q#3=i$R!gLz`P|RBFi4Np%-xsDzpJdc_ulBB7Y=0CStZu z9)SD=%-shN4Q&a4QEurYti{NMo5`gLlytOYL@$}?c*5@NgZec}%YaYHBNrPvvw+p1 z|L*_nw3nL&kLcFb>2M;@ud(5f-Ue_nS`;T$^c(F$y467ke)#egn_gwski1}A_$#!b8vAb3V~F4_O$DpZDAdvh$s&~?G7u8om|i-CI??AV=ejs;)h|Sd7`-^UzQ?yrV*_`$-YLel zONIHSfM(+hp5|kieT&dh5N<|@sEyp~?YrGS{`O&xz9`-KWwl@v;e>;mTFUDBnbgvs znpQljX1-l(r42uDa*s9U2@}Q*6Q!iQ$IjgWe&S@{ivirv7;7^!j9yLHumn%Jv0qW@ z6=P&scrRX%c*NlR3TOF1AKOH_t}79P52bc!p3{qT**+zmsW$LXtH|Ly#JW2b*VJbtk{lj-c|HU+8=9aW-0>SfRce&U+) zI(ETE@MfwQh zn79J$8Ojll0issP1eC=TfJ055*rc5cPAml}gBk|E&ROdfL|OS*Z>5{}zmZDt7i>RG zP1ZWo*%R#>R@OynV=v##Kts8kOS=J_gLx#XQqbY!Hm)}>DZuZ#WJih zOa|ay^B@p(N`3OJJO?KAmy}_iM0KCQ;|U-HoT_y1UPD(Ii`@NO3|ej8yGlerpRjX+ zRhKvl+oD$+`ba`4845r2?3`$+h+Kc7M8L&w6`6a3EHg|Lm=zXLf@g%Dw;^$9>%F~s z)AqKYY;@y>@xaYH(PlLZdq|UF|AAclC2pHDAv~eiWzlSvl-52}&!To}rPZ_$Le>JR z10tqN>QuLeh@(r5*_W?o8!@K1>^Tgy#sJH0()qpybxI4|AFIuRp<4#zEmz(C=5?~s zN_!2#lFi;WY;7ji>dvfLrW3^0)3jNp*FJsJJO><>a_k36rmH@UyL`!JP;=qOX{5;O zZ)I+R@tQ3D5tz@99G&3-wfpKmccYCLkI32io-8UN?Fi?_?4#M*UV#2G>c}QCJl%}@ z$rk39O+wkxEJ?B1>wZREuRBg0G#dPQyE3qz^U_=kYR#R=>Lf1*3@0gt`ezTaYbl~Y zb}THFQMJ6(3uJBl;d~saT-an*1k#@yIz9?IozW%3PBUb+Xo7VtwOWqI{K}=&+INmU zUPX`RPRnORC&a#Sv~29&&Zf-8GeF1H$LIOC2!Ka*i`={xzr!S6X41ghZ}zqXjskUs zBTj~+k6Z&urtPL_f`J}z0_+psP;{Mc1|?c#Erj4y6kJAv*t^{fs`+#^P8CboNj|It zwjmIQjo#d24x8Sp+sj|>VL7!;D%*yTv-6Rcx=--Z`z>aTjH&v$S;BDL+66Ss?S{D*Zjg)S$1atHH>Q>8e&ZMoD#|9^nsxvIJ zrptS2-t7ru_egk+x80;JI*k9%PV(dLnFNhOjE=jpm)%yC0(QJ)?=n`rVhn`@oE2;V zjAv$dDz$XsV~H#4+bf4QfID0Lv+Qg73EAjyIbk9o#1ysgrcmt~Zq3UUd~Ik(Jjhhc zxrcACB1MvjgF)*68uR>H=fzGmlV)@f>nJg6zPXnYBfHZRg!d(C_xXP-roW6mSgTkH zY@V8{CAmf35F^be#|uEF$3`)z9XeP)qu<~ke9cZhZZS?3?WJ&ucu3YxaRh6Oe;yi^zcIl7p`|TC zLi7n5))G22+3lkF#Y;*VcjNhT-4;mZN1hf{l~~tFF;mU z3BFYcOV*{I)d4l~FDgM|!p)JYJc2vxybB-`Bt=_MMZUhl&r)gQuNedMF<9z$JXM{RUHY(`$8(kzuo$NzcvWRm zay^A~$racpxoI43lo!*15v06JkHNxi95r%S?AOH+;Z_+Y9j7%2b^m;-MCL@WoH=`2 z%Gb{}H$;6c4fdcjNqBlHF&kKT431Ng8920eOS&`hZ#sXzRy2=42`q(Vbb3|*a4xQke)96dFn$7p;vB$)d5hZdyxF=mdp#%sGI+6-fAgxVpgS0J$S;&)x2 z6%5P?L6}jJ5@VqwOk|2HSGm;UdWEKQ^J*KPC#<~9VF1rf0=3QMBAF;%+TGZouCTQ^ zB-m3~xnhL4vuhne3aS2D62CANb5Xvud;YcT=9mhCakUGlDthWz7BQ2CWWe}AF2A{? zKX>?QQr0ex_$u-)Cud`$9#H%NrN&EHsLE7dm~0^M)jrFrd6@3$vD~PNB4d;rRamhYeAbV=a&$ey~6^725>FiUrqn}N(l&;YIs_lEd*%11(yzEv0>8UTeW6rD{Z zWXz43O{9eTX#DZXv;*EO26#?W+cyP37I_h8y_rC`MDa#sk1=@1Yw@3)em3>-S%1_- z5XU4dkEaSH`J@XnC#Zx{!s>cRskxzur9?*bF`?_ma|BAltq(jzgCG@hq6Rr4NDa~5 z`jugU(lj{dW*h>7u={CYJosaXXFOp!UF z{m5w`wdl-TIUS)3*m+Q-EU<^^+n2XxC^3{A-aIsBs6MBUV2%)HY-z0-{!D>|khXFH zL}q!}nj)=qXKD(68(N?asCviKXb0!!>Ta$8ef0NS(YA+Hjy>I7CTx|}T|)3LJ`G0( zioH!&+Fitb+u5uV;FJDF@oo1mKa+O*_x{ydV+9A_AhE4P?pnCI`Yw>qb;{J9I2kld zfecLz1ApgaO!KJ@b7?J`9&kcQHT4mK+%JFrh|fO~kmc7aDMlS$a7|V#D><7w>?5YO zF0o>y43E2v8GrDlh^LJRhj{V!*7GD;7UnkZUdu-M${yp%(^?+#YYp2 zbQYwzogo8IY-wkeffmyG!$JzrN#_d~lgIz!=48m?S?IzE;O&iwz|4h&Yijue$WnCkVV-d--OgY>NM{Fr9Az)9~tofpJ$+ebR9 z6CPGx?kPK(lkVNDP$ZI`T%%}ITG(_H#e37*lwZnidDBjS_57}!A=?ydeK!$3j;m)e zjeVsCcdVS_;yzg=g{uHeg#ogQ@VHpX&eM6V+1uPSUr9-C_b{S^6|_x0Z2M~ka#F&# zWF-$}m+GpGcxL*c-WJEPC;i=-oYI!U(mY&fWL%Y)*OeoR_a;paOWVYz%7`T-C>+<8 zuJ8{-q5%G_+v@4_cQL*0D)Mh7)UU}9+*@c+c{` zNt!_=V)qGps|dMHe~t8$c*yap+M?s==IS&{)$IbrUHWw#4wnV{*rX^c%kgGWACBz> zH?Y&c^s*toO%mv;6x|D&W@u%=^f*Mlc8gd{t%k4<7*;wV-jup{!X+GB=X?{gnl z4(KW{6ng^90z>UvVafC`KAg`oU7FuPHz&PvvMvYb~~JqQpJ-wUK?Q56A_pAKyUd&82B4r->?(P+Mkjf zjluFf#7l(arB9UgLx?|$<@$>AqBZ!$i7}}b|9{4A+s zl!IibD$y+939F8ty1_G@Pw&8c4nIt~nek|6=J8GOd*41lF!$DSJ!U1zx!w@UQFaXO zoS)0NRytAK{cF>#2hTQ3$V?P|J|m+xq=J5}E>N(MB32ti;l z&yzD%k`MY*15oPnG@DIgyS*-8(Uc22DH1ZK?QE&^dBo0hT7n&1E`;WEhn6GY!fEcv z;QA!ULLHl2j+s3*jhh%ryXaFZQfjHp%^<)1RT~@1SWty#;p|*#$el6#vLn7kL=`W2 zhJ%zN44k4;$TYRfu(IpJDdu7b@*XFzUdR1Q1KT4eQ6#8EN6{}`{Hsl>>(<=K)i+@c z&)k2ryn3y4g)GqmqJz23XOm;h!|?J?MwC^HLjLF+y7+lXF5;6QsJ?x(7fFZ)Bb>g80P6(w7QSDR3~l)BYj{iTewj%~tdkA`U{$9D zd9bFHxO+ zg)q}z9t6(%+A$`mQgaawqoDCHQtW-9mxtFwB-X?VsNJr@bD^AU(=&`DVW36V8e}Pt zsAQl=o$&~b*dXp18{@p;`XHR5RR1=c|9;;c6Bhu@225;!q%;2Pn`tAcR5;M;%KQUv zj0qDbWWR2)6=`=}-ut^%fRMQcSh;TFCzOXEr^njqsibd*$^dRTR|jW;!)J=~Y> zzI0MrGc~-ven7=Y%kt|!EA^+x9UW+(qhSI^3>cV1WR|&d%yc#H4n-uJedZ&BRh7;) zOl#nn)w4g$Z39ZBKnPeS>%R#uquBm#CO1rtD-Ol+ z?lu|pW0L;JA%DLx_GF&S6%A$_GP6pvES5W z)=oOLfMp71tC}hS7~w9!kumK+?gr^Wdql~=^RPa7Pm1#m`Wgk~+Cncvpi$fhmw46` z7unvHjBDB0(ZS$+eJBd@dqUF#|M~)U9<22qR5ZQ=Cn5x{E&#?(8^>qX0WI``aKb@x zP%c5)7~PG=kQ) z(tWXU?j>Yu4JI+Ba@U|}@Ar5aR)FEl^#2v{{5Ep*Fpb2=Z=rn9&H!tZ@4pm;DTpY~ zBLTUOb1rhxI`)2qQ?+>M4v8B-w-PNkVqn=kNSEXyTT4jYin4wYZC_-rHuwTABfBOk z^?)+4tcB|RXSfp3R3`_o`DW!omW0<;1v>}MDRYcr&HP$*ASQ;?mfE}0AWX_-KQB-0 z_sG#9Xi=M|sLmscC?c7Bz8I`k>8Vm!PfE*OZzha0$U;QSOk4um-1r(M!F?ScD2Y(R z$~8kEDv777Qg>a8XM>PZsayIy@NpQ5tg_SQ?B>^(E`yPRJU_!~>@V+~RY1PRb5xNXNx1w9?(xoououkJ>=7x>>>^ zSLNPjh_M%5U@vra95WI_k~3#b-U+idwV>ILJQ;{i>R8d(cDW9P|6IGb6kl+e>dZlg z^#149DuQISloh3cCBfg5xkf3`^gduBOf12k;2xBzJ&86~tESXqk-Qf$p2$3Shqi~K z9G2pxuyy+rZztpiG=__|6xNT6Rl-k$w@WRw;RVM)`WFrs*SN`UBQd2;DUYBOslYC6 zCf$osN(p6Ph%*Gqd-zCaP+zx~FR8cS^U@n8+D$>`n32ZQpdOUA{7!uO?@q#Rw6n7m zTkE#2*5%O>?os`J(XQ*X+>P0c5UL$jT+_Xju#gX9n4-uqxD9H{K2#W}KW{^xjoro= zJcZOTL*$OU1M&Y|Jc)U(5woBs>gznPBYIY;dlf#xp%*U_S1(0s^{oLnwp(W5r$c2u zmB25>A?#@J=+E`<+=_-Xr4fc2MoL+J*4gTvY5AKpn~=zQA_Rrv`Nx>V|1(MYBzO7$ zvn&gr+{dj@;>Feqr<+N1?vZpm~c3DXjQdG-G$-_>#xuM8z$h2;K%2>oAL9HXbVOk&%u+XO#Mo+04xB|gmf`{ z3^Kr+?l<720YCjrVWO|g72y&tuRNSvH<_j_b5StvuDLQ_a(UQ~1X{}%`^S4(+M#oE z1(f~b%1$)Tgs101F4xho^STQ8lYBEl%RGv%Qk5-jQRKPE&Z|J)AFslb5N!%L&y-&f)lLo0iP3E#|lj4a=iSioJ~+QBD#@t zXsK#)8BkGZI-q@}0X)*J&8H0IZt02V+hdwm!F|UlZR^;^7m{RGg48;%ZZ=klx4S<< zxIm4BTK#S+xoHh;S`Nr6Jn=F} zmOfr4$l*M$IpP6!bpyFFl(THn&+M;D@hb34&#P5fMoxza_Tsid+hyO3s}zYMJ>W}` zar}IpNkSch_g3?FZ4heu6^t@(-(G(9PA1Hon}1Ws81Csn4ZdR*!set`5@bS7ymYS3LziMDn~;)&g)w+S$~==Z-cxlS=UYte zsPEfR*}N!u&Arxo5eEi#OQ6eq{gBs9A!$;yo7WlZu~st^T(}^HtB;F;*x% zooCPUs9B3MrE}%2U1cee`XjU1R@J-I2ikv*PP~m8!K;~pgZjy#0=b0UaQ~!007r7K zD7<_yge0qHLDPgFF36%x`5Sn6S|Wc+SVGB!POLimA?~;TkP?}B_bu?pSefn{qDRw3 zR@#MbOkY`02{PXRR~%WJP;NUB2DCPH+zWv61O?4a%-t)HQ<*vmAAY<3&K2da-nQ^W zHB%W%=u$)__xNutuZDteJZek#8^l8JqhL#*KA zAbKxV);p$zyz`urajPc{VzG28w>L?AZX7sUv!eUifxZ=!&&ePkEI8R@>Wsg;$PVc5 zh?`7bFfn?T54cYIms(mH1OJeg{Bz^Ga2~ORcf+b6nxQg2pEFtn2pIB?0SK6{Nl<6a zn}{5AB4M`bXLyBuCg47GK0S-4(!*ek)fvsWE{Fah2vi0m=BL#U)Lx`Pk{AWk%}h4 zLwR4+gfY4xfb!ZKA3hWUEKas=lH!i5=(3^o3yX(e>ghn;5})Afh{2w23q&@gn14@r z(*6-by&bW)pcOj=oMT7d4&BhH>ppBcC?KxfLLH#IBHiiFsIQ)rJ?xCsmkWan4^}Fa zY4@IR$#WB7Jh|KKDC8q%?iDzs&E&8^2A5N2M8h+DHyY{z-0?)S1L?T49rYYI&}T@l z9WwN>Qp(Lt1LIg;22CB#Bhpe1H!SqF)d5;9>DH7DXI|S9R{5sDK*MVW4hV=#;zD)&U2j|n zb67(%mWnah67#be0%W8zof=2?S_OQrN?*Z?=d`4j@q?kTN`V*Z@@^0467g31niWPu z3!s(G&}UE8!goAOtk|BD4gN%4yrI)ZY_jWR!DjtSq7sS5Z~DH9o#0d49Ky^{8Hs=n zBdu5IlqF~iRM#`R*6O{Dc=zu?_U zMx0;wd)bAuRU&x4^jX${?*M10KTk*nTMNCw841$#3H0%)3&#G5pOoV_vya8Mm2y(Xsw&*Ex!aA=9J8L~9mx} zMz+gkmuKC=IL3pW_#rbFjop*p)=R~J}_c5A^I zc@H6^D8dOOGygetHe2*v#Q85&>ron6cOk5d?$J4wW9yv_B^WldX;R=8ADvoklYV6l z*Db6qhhfd*+2oFR^(u<+oZgA5k$H`NUUgc^N#ZH!+uUkC@dGrZ<~J>wk)B~3 zZ0SozM!LJ~8(k4=zeYm^>a?fd6RXunk9Y0ay&5cfM<56aTqw;s2I>8)hSCVO3v0Q# z2#qjBWKh^dP0z>|Dy67XXPNa89FfQ=STTlqbux{oK-6#oumSF#@At~(6%BzJr(MNe z;6n?D0{JS*T*-H@^lY}PJ<2rWRw)uTmlK0Y&B5Q`zp7SS`fbO-M|sq)iDbgHpc`` z)2**KUHpno!x5?HBhp<`$H5n7$M$FF*)tmMo;X>$Yjpx<<`KA_i<&FY^$5d}I| zC#mN+apA&OPf%zevU~_$=8v4pe>=2HJE!50= zM@EoFIw;E^dJF*6@2U0Y1B&tpDC^w6DiRId_{w$nwIZ`*Awq&A3vMjKi!KjI$kf`T zE#}10(@d=NR>LVG5GTfg1_N@WDDxQY;J;gAOjMrx)-7KNv{Wy5Ylc^C&Rt75IBDN2 zt&4IN4he|8T9qGvaN>aX8e^G`jo-s`r920obH zqAbrWnoQTTat0pG_QItUfIPX>$ed{ea&IcdzodiT`Yc#JEO<`kGj*DL&7$odj4`G>wGNBEQr}!pcW4BYuh_t~ zfJk|q;UigL-~~H?9bN#On@M3n(Ura77V_ak<4M*ka7|LRdSJVQhlxWf^>!{dxZX&c zKw`^w*7HTRF^rvSE6!L)ifnI0nZ*tb<9ie?=<_hvm-g25Ckr`1p0D7+J%0lT?z^Y&6Z8rf`j!aXcq=Lb`T@@?+cm-@1Sy0b%eUPnIkLgef- zt8lrvA-os5zxC}y^n^`lIoju7+_Lgiut&QzO+4P`Trp9ON%bWCk|EDp3VCx^j!1x>EnnE3fF#iVfi3Y`JQt>O6M`LDB$*K4`$4UY z&>YQ2JWt+Uis;w80K(35M{8$?9dgxM&^}fihPh5K=LpKK2xreYpiP1WW-Mu`4{qo~ z{{>2&E-?`zGsrbc&jzTDoj?ux|4c!7{RJy&1wq+>UPHPp_b*OH+dTGH0Zn%hG|PfX z%Ocke$p{+9c*kPlYxEJjf&fHep&6jpa|X%2invwy;VYH3(J9FGy;ZWI6H{x4yz&m! zCd8tfR0Jm6l7{y7diiqm+z1w{3rdw5cJM!F_^Pf~YOgMskJC9<|l$)+C7erGj9hnwue4^tEVZq+LE>eS=CWBwgd(NaU1>i6x2*DlLDZtbSS@mBZ zx2E~ma0P$LPW1b`CyRJg zoM`?Ga7ZLmUZo%Muo}!4uoO5fgX?g-CW`YG#lf{W8Sf z)$F|bD6lkNPFW&W5XhJUV@*$sCKSFWT!*Xh_1B>jQX+FKVT{*Ly3SW;b}MWRmGJLW z!GjA=dN6oLQq}BY!${u}qcp%g;zEBW6Ex=?k3s7qHy~wgU4fLbzP=#hYo}hh!FMWE z88*&{G;5Expo{y_?>`eHCdtbgh!t6pE8=Yv%r7&HJ_N}!TXh6<(ZR+1mX|B~paoZx zM(!c4Ov*j8S^i`SoY7@#gh<7gPE$17a|WxQYD|3hOzc>TJC(%q11iiMV3n2fK}vHv zqm&2uc`Cu_D>8UJ&Z5|nscBQ$B2E3Hfh$@gF)CaTh23lB8hT$zP^(Ssk~}}g zuwqHISt0=OE>!ZXM`f$#^_>PKmbFKyL=!lS1#oTWngY;TrV}Y`Ke$i(*#Ef-zjA-8 zvHQ@v{|h!C3Xo+jRfI%)!liDTJZnZb2!v8-g2c#aqKq&jPqi?=!XPG&(KcRu|I=4aAQQPGSr9 zdtb2zvaJ-|ka_$Jr6hjHp|D|XqR$pb$9`HW5b9&Q!)_8C*2ES8zR^kP^nEzv8*L<8 zGl@4!TLXOCIrgo-hvSMMyvZiQ=>5dn7R^AtkUp4V`Jf|kjXCB|k>V!5O}Pu-(`e1} zi+iGWpM#gbmo2q5PpDjaz(4P*b+dTA@`eDy3!eQmxvQg=lwnKe*XSB}0h9zXhMz^O zk+(M7Ocg@^3DylIl9k79iSW&6GK=e=62)bp!TrhnQV1AImM|~{mszz#Qly_1iS%a6 z%tYab4W<-ZsBL7CVZ(YNE;rSQ4?Z8qK?9Mq2K)4pcdYh6dME#7&R7!JSR5UE2Jxla z*KWup&4)fPTR^DyQ46%EG!@z5n8DGmIUTsLN*hQ{rn2J(oi|K4k>2|7dgH-C0&8d( zX^^KB!z(J{Q;30Yg$Y&^mQ>#x3)Q4{(@SQC+9(rDAu5FSm;}z3-4s*xzQGH)_~Dw4 z!|iE6DY_Fek@`eQspPe)ieMSVmj9u!4iJh1H@dCPJ$sjWsKk$eP0&Suq{CgzmdXZN zB;iAHA#*QK=?(7?@(0ruL8%tR0W5-0jF_X|Jn1)7dra}+By?e}Y}!$*Ot|3ebwvA( zm||k)Q{8;f$Ba1Fb8~W^%pA{KVUDn00Egrrfp?J?1ow>js8J2ci-LB;g44}yCTa5$ zEV&sUnxg2=2ZBy0i@w2LxRt{g+PX--?ECth3&aa9h6kU^wv7liz=8Y)k~QFOhIx3H z=4krMs^xb~7Ldr;N7nhSnD6ekDfxQ1$-@$70ftc4kf-wd&7jGhSoRSZD%L;D=!6m2 zV~-!2nSn04U86N%`)zjA-nu{S84Qc}rjS(lSL?qZak}_m%Ydab$w9*)Lcm9!*FM3v z55U=vCZF>f{k%HR(}+U9n8hH=TxRkcux%?mKmdSb64r$LiE>of`#2$?)a0jz>+Gg; zL~1ReeDzI!e7O+vpY)envjvT9eXwYU{5Um^k*X%$IyLMVH6~=D?q&q1D|=H;=l82i z^C2l9fNhT0-Lko1M`g3z8IKrg^*~+U!Bs_mVM+M<&-i?{0E*8 zYYgcv2X7`0nv?njs)G8{ZKMtfXOJx8-OngA=)xBcc^bgcBbCkCbhGi{ zk%&UnIzYWk-Dm_QV7n!Pdgo1Ke%EQ_#(?(ncyJQfJ{i=ZH{aP(ZN;sJ>Fs<*=wfFe zgkTU%V8x|1O$My}A&VbTAUMTSLF@A_zmbF_=<^yA5&7D^Abv(y{S*+F{DWG6sbYCb zyKv`GD0H^n@Uid&PeGrcK*^}s`Qs4id%p{Me_`J{E`;jlc+NShb1jix(RB~9;8%Nu z=mD*nbKe0|ZQl8?%tn;@Z#05H09cXm7qc<-0I9XP5BJt7W)3%kjE^HMcrV9 zA(U1qpuo>|h$Qy&et7O8y7%342A;Wl%GkTw%oED(TK{3h?JII8z53`*+cwm3s`W{d zVltoZ%JaH{wQVLm#+z&>POSr9@PzR}Jk6{2CTUZrv%o{C+I9H_XlV-4lg?X5Z~F$3 z8j^l%P8CGVp7m_FZu(!xUuLT0qqove_ZDzOdq~=6YcN~8GqVDhjd?|SI;ADWRNcWJN20L-4-_uT9Y^Cg?YV;qxK9ggCsTF z4NS*46^(Nz$H6Z7U3R$6?l|d_(5X$h-Jp=lN!UHu_4-2VD8y2~xXhu83LKOfQEpBfH?O#DR`kp+-RtFz^G76GEDSH#~ zI`aQgK#NX=JX6F6L{tH6>DmuYzgQ`|lVvQF%Q1xkAteE^6o(m!G$ZVN`OoMvulz~# z?4LB>Csbvn1O86twU#0Bv$BJ!Y33_zR2{F6HeRDV7gT3&7{IJ(^#R1P?lS^{+Pyrs zW+}DqN>_l=EX1KF+FhDeY!WeM>sHv;oM-ExZ8+@;(G)9W*CrwPJv3b4!v<@j$gN}i z_Unb4Vm4K!ev(Hxh5-NnGs`f*hhdnt1omwg_3;grA&)U^=!*xX(wo!Up6Tu-0$TX9 zEAvAJ37*>v97Vn6aE#W1;#PLCaL%!dW$bz-ORt|dg(OgpE5!5EU-rDTLsEQ$33aGK z4ovP)lr8#gc4Uoq_s&R5kHjKF-vUgCat&ulBOS$s74eRzTd5dOu}_p0bqogrz-vO1 z5O+?aZ^)sta!yX}RQR^uy*81ljUkm{D%EpAN|(CZmKNJx)^c4~uy#cI#J`zib zjFk8-{edwmqqoke-Jwvl*7ASA_zHKcs)c)d0vZBCn>>_NQu&mIo1nZc#SS-gNHEe9 z@hAi9F8#14A!M-aTort>ZSIQSF`=3lJDzE?)6~$!Gw#du64Qt9;{`~POvYK!T?=up z>3yK^%)Xssh$278_y8^g!Nu;C52GaA?#;sk*qP%JvK8EyI*OKt(0#pumE>%3aYq*5-UP`gc6~C|0f2_gT7C3#d}! zOb5ZMoRE#gG&i{BDE_&SIVWPG>bx3xAt_{{@7;#g83u6S7l4=>V@mRbsw5 z>M|XgF@E$F4!h-5u(=-0I+!l7)? zA>?#=54bd|KhuLH*1s|44x9cp-oA{R8p;fKvJ4^Sa--FJ#&{g@kUeXL zH?BE#cy1oFeLGVpKamMg&Ms|Qg|Vp4Pi9?VKywiJ)AH%gXtT->d4s1Z1R0!wJbVNb zyl@hYcfmUN00|myEWP*bceYd#gBGJNe`Pf=I;1?(jhzuXBl*xzV{INtu?VJM!2j-9 zG7$MItDI{Fbf108U5gf-8BL15`l;)B#7&O25(FVX3C?JPOMo8!;kcb(F)tmzX-G{J{gV!%fSIc-XvR5(pw4fdaAx4>!Sr(STz&3E`OgMlg<~+hW_M-AND|#}fEn zBn9G$A2WC+ACexj{M!*DBoEP7jng<;UeV#677Gr;V+FtRZxCh7Op&JNl1l7vyAD#{ z-Q(sLJcColBKTYU_P58XX#)B)U3SUIfNaZm_savTWuBq!F)`bui1_iICSVx=>`1bGD~`W$?ka{zp2sGR^?%P}65>#?J?f$y zX*A_hm0=@h15wxxKmN0J(Hz$le%|W@8G;Gw0lOi;WnNjk6Ny(E=}?b0c+LmIefq6! zDgx-Lu;B=;#cQ77Q;s^7qVtT~em7QX?t>&O^pBQ%`HZ-#^QGw9G#^zDs#zs=ndU=j zFM&2xNpN6JS(@I%R}WEdm~Aj5fvzf52AkCc`mxg(fZn;y@^a%!0g?ZOtyEBPVjv~` zN&I*sph#)W63Tg)aNJA-qltpFU_mp``DJic2& zXKV_Ae|Dd>;Ka+d^?JRLS~T+ID~Hau#Aq4;+fm~7dbABGHHE$I;$cW=PFxw=4n~Z8361pn}tq43{KHBrBoLFB(I;g znX}67iK9;PhQPV83yn_~i83D|OkF{k@?+JAcW8=+ZT$Z8KfJE8IT25rFbWphTUCgJ zx)Yfye9XUZ?;#aSdL~5B%dbB8m{5!hN~Tf!CcgjSpb)nUp!b>Zi<-CA&)n+>i>i!@ zW8s-*D$d|-lEVY~3u9&%oD?i9=x4Xv6(Jv_V2;i!TPnoq|5jv|nF@d@Agbh1Xah=+ zwIw;W2Wzlgna{g@+L5{y!b7F-K24Mo{{kZy|3@c3zsoX9`oDz~09RT`TdsGbgvD=U z7}5Q?v}ULOj)kef5TL3$ea&9>Z!a7h&{wqsRBRE=aXk1{vYxB~ea%@Nvet3=#3`}O zY;4US^Kw3=rXbw?k%}e2-qr8>05?f=m}xEcj}9JXH!1)h?>DBqdM)*x>5t~r1Lw4E zi+IdpuQFn)8rV?%bQZw0RMM&_30^@7tPga0U$GUAq+R_MYX$magj%$liI#NLQG9~s zue)KgP5T;bKW+|0R>>yQ;V>(fZMpW4fT3G_z{C5#i|$`9rwreDU2L|(V&Qsn$`2&- zC5cn%83EnF*AIooG|QLdgw8QJ-B8bbrA8=~Bg}b@@`Z|r`3B&6sghTY6moY@nXqTK z$s^SU8?pr*F3pK~Lb2QmdQVnN_k_6KGF9i{V3QTtp*ub;Qt3~{nogbWdsI4c!2>oO z4CWTmDCz?74>?O?`CZvES~LAecKvRG|K4KIzdpv${sBSRa-~PTm>`G}hy?5HuLLP| zoIeNB+P4-J{4fqp`6h3~0K`9Dt{6Y|IUAK~?42vWS;(I8-P^FyJbpC}ns06uNw`&< zI9uL#|3eld-ejp>NsMQywVmY_6REAcUQ*rJ#F*|eK(aeaol?soEreg1mCBoE2D)x_Jclt5V7U`=tVMh|J0e(pYUmNf@9K7v9nNdO9Xf&71{i4GarGL zZCvI)F6buVhI(4z)L5y&t7wSlV)xyxKK`6@SNf4u(JGHtcZh<~J(ExiW7qFB9M3^8 z)*Z`(T1ubjola8~i5hQ4&FJUYo4qihtL!idLMcb+#8iwDNeozx`bdY}W~ijf%^81A zH-V}zg|P@+EvR$Ds7zz2e-to3nk%)|m!{#-5u*?of6W z#-@F47d&_rD~tR#d!|`IESID?)lP1=xYMpU`J0v#WoETE8B3Evzb6@zwmF;e1prOH zlgjKKBs37p>>E_@$1zw31hLskt}6x1K@S*_J;H^FgK{^9PE=(`ng5XL#iNLPWTNym zc;6ylW`i&`kHnZM%Qbd1E@z9~3^Wq+(Re-Pk5sIE_K^W<6JyMgD(@_E)$louUT?29 zK{U{dME4`2Inwi)fh!u*AeWWjSAjc(oBuX%9l$}HEBY1qK5zbZ4r)!g8@b3cKFBK+ z2kA?Ec8d)AV~@NvV^~xLvhe^x8*J^lOUW8$sVHf=BXdfSMf|U!<^wk+ts8^|e=M^u zI%6v}6op{D`ox5*16K_#RV7pCo5oF#=8KfK#B=fa#d5hf{u9yFn*Ma z#+n-b0xm0b5r?#@0}v`<5$j9#;$TJ0GK;w!%HJk}lB%vPsXsr;Z{_HD;plChQoY5R zq*IiVdmXxWhb)GITK1tJ*@WBBXQ1>&mO`sXCQot@8VbAA2VHfO1H8_hgoa%Xs)E6@ zOj$RJ`&8I<>dQRC)T)9K<+A>1g;vf^3_}ZShfT|>sPH>d=|P7sg6kuC_ER?P_8T7! zUjoNKJVdJmO?!meYgB?5ktVXCge9?oeP-V}UtqodK;As#1~AH&&yd79h-xe*V+Uq_ z=XCky@Lx6j4i#`6`Q+lHlsdYBMS&gmI7nq}lhb2L}va*e_H z6s0INr12O}fgOfIt~$Xm65~gMIBxmbu#Pn7!gsU=eVe~>Qag3pTH=;rI|0$y<&+JH z{(XXd`=uGCcBrp)22}HGv8x4Htia0D%zg2r3nV2_lE&nc!y>lfRr!_Bp=-{n9>L7f zV-4pIFA7Zkc1quCzuUSyK$J&z@in({c4#~fv#Ve=h*IfqT-9wwwmyCHBMe~C0b}D92C-d4Ad^mdz%egcX zqbATbgJLW^%#oX7ue@+;DZ7Jvr%%%iPGM2AzoQG=hW zot*TOHXi4Q(o7#LouynYzNrWVraF&Rj@A!Dt#$2q5(7E2=2mVg)EoCl?h9$_Bb@Y^ z_=8CIx@P}oXKM<6oOM?FVd5+k@VpQB*rU^q7=gXvP!h$P_G;dBhJAn$^vHz^s>@tf zJ+9hre|k1zS@8J=_whEYs5@)D+k|@-@v-Ijk5Is{?#D829QzB1 z)(`%lmJ1l(0|YXy2@iY0rE_wOfo9!aLQ<663YM>1Q(w1rS>qaI3N<`~fAIk}bP>%- z57Cs0MA7!zGmmJzhB+nqqCHAo*9sBcmr0heob&=jG(?L14d~lCz!o3G?EsUVwAw)* z>GWG%HJV}Moiqz>J))4*|Scf*V0ckzi;8zZDkz-CQ_gc~*3pb8u8)yQ? zBr`G%9i?xXYaRRsm(!9kcX{RsDM@6h8Hf=ZK!U5&Z7IqdYv+AJWH!Pm##rpFzht(O z*n)LLI}Z?E&*)jPo-)syO2Dr5jyZ;L& zGXQMJ+qZdUDs6ZMbB$Jt)__+Tqb#cC3vS#+W(uFAR@Sl*$=?fw0m#JDF?J*DZb~_W zkzQjf^3oHG^5f6qSKDclJ31`KnJ;|WwnhU4t!a|qWHp3jqDOO33iYlaoqutz|EsQ| zc#lP)7)udH@|z>wP9Q2qyeGvw-S1!=7{bvez%M)R^i8#V-1U`{xe>mfuG~f_9r8I6ntoU?xU{eO!BxfVm0sf8aLMVUq|Fx%Q4B2+UN@w21AElMTNzN-D5#A zbI|l|VJ=bAbg@YuS-w_O7Y=hAn)Dx)>*azD8grQ|B#Z2l{Q?6zfkz*( zsL0b~A?Qsw=#^o6vJ+Xz#KP9O;t2MetYP}7bV0c?U1myWBEJGFp=;&`0kw6R4Cc{I zb=Q6SrBbvXWT&mXfMpsKau`Z1IR7E4?wBBp2ibprUnLCZuRR~Ki$Q}ernh6MGHo>1 zGFw$b`5eUsGXP_n6i}a_r)l^cC$~n3-51WW!;{L>bWsG~Q2mm*6;yzJl&_@z^s2`h0oltO{l3)pn z-&CAS`u=D^r5c70(JzwQULmksN4{>y_GYKd;dne025^`+V?05}PAeu5Usq2CdW>go6C@*VXX$OS=2 zCvahjikp)}gd|BpANtIz9QC&$Cqr)3P@m`Ffoqv@);t1=^xW8g=z6sgcgF!;6m`B8 z_BOk+WA&)xtPW@P$g1pa63i#_s1E^Wipp4O=svE7_cYkq5bHHUEE0=kOf@5%YdSGb z)`1(>h97ScDw}>#qP2dr-E0X-Y+VAmDPVBDmDi;rR?5X5Y# zltyr`+qTR+1=nAh?v$=U-d&%_)uMI={Mm-zvuev*1R`?#f-Nz)F zYOYVrQ1WKOqJm}NX``i!nqRknlf+n)zSR{n%I2*sO%b*TBwH?ynZX*I-)dp@ur3A^ zp{_dpsZI3!xE4Z&T0-3~1F)*GJ;u#v!N~GLkWHSQBI!PTg5%Q$km@ZeY|CG)q6UhJ zW?R$QJ=Hp01SU?NYmI6`R(O{@WU2j*9NxHuqEs|2_}rU*pw)Li+-g3q?+VW6caTKE zfN2<+Fo8a&#RA5+Ch5d>a~{{RV3g24km{arJQr0o0KmUpHJI8?^FAFbErQrk15 zwoCXg20@}V`U@>=rWUNThE(#?qvg>BR&Of5tIcz6oXgShHK4`~j z=W>S74uUB9kz0*mokKVqGIkqNsJlmCq{SUGuIoQ9Y+;QXiA(R0x0p|pq>c~igg%&0ela*le0GN*yy8XFf9k6H=Y}2wrPip zJv#N(ZdFs+gDa87X$z+j)ppR#r%MJ-*Lht_Mw`2ap|C`i%kpC|EFD)KJ1EL2uf zw9Z5pM}jQaTNat=jX?=>r&mW1I2Ovg!GM2!9{-XZo1WGn8)h$C-{MS#up<);7%+=7JJ!an~0P$cJ@|p;QXs(8#JxGfM5s zRjX}?i@wa#EU!=Ur#_@HQtW~UjBQUG1I=bp`p1m6SM9kA%-G)}F$Noc#Qs}upc>Xc zY^x*Rl?n?$D8$a+aMj)I|Ga6D|J}YT1(~2nCW@}{2P<8s=?OcxOZrFDu25yzl0|fH zb2IuZDt+Vl{DetCWC_jdd2+)0`08s}gsxPOKbt|h7EcPLOo%T(xF;`)3}MY<_(x`0 zdr*|i1OG-^<<1OF9HpQ(GDe>&ibHCY?8>+n)Bf?c$_}9Zcu2C0p zZ8eTd=jM*#hbr$>*#K$x#Lw;wf6VYq;X89Z@x%Q%AzDWgt~cx)q3-w#E84Sp0jzU) zrmLf>fWtjNl&6;_hgAO*;AS30O+q&wX~jD+p!|k?D3S%+rUc}fM7Z1{4s_XXiphpG z?E%OyUjc)4)m8Pog1wpCMpv(GlWw?F1=RHrw$vhuw%MQD$Q<(&N#Q*_WJF7Z$O1Mo z=}z8x8B{wO)2r%FkCOX-#;XNkigONFrPZ2*5>N~P!~wN@xcAygbR04m&(`wYt$Tm4T$ zNJW#5d4oG9odJV_zQP9))#6?q`W9m5y8t>j9sy2Pmc=2zIph~zWFvXcO4mv6NIJUvu5Q!7Pr9tmUYNBLp48c&O|C&#ii4^Kqb>I z#aC`D0u2CDC!}zCyoB~D&vy4f_~Im^AIyV>RP~I|Ijhxhq6WQ&k~tVfV58*|{CGTS zqC*Rx(|ikPm(j6jOabrQ+qIj{{Y1WVO(4AY?wbSup?3P7%^e+$yEHLwiCs&>4f82- z&;~Z5$LL0*-UQP#dX!1(NER^>>G^{3gHn#W7o%ejIjbbakmc&BSqx(nF2E@dYon#$ zD)Lqfw{z}FpPce}55ssuwS+!}wi1RzozE9LVcn7=6;Cg;5G?4(0dIl?D%`s_n+kXhHtveZMud zFl?N#5_b$a8zrKY$~|9p;(?V0tBCz2}XbTYi*vNXIP?k+X9mpDD2mrwb5v9#t*c5Tes_cOgE1^=aMS< zEx1U&l-^Kp(ELqIgl49Z`lhp$E)@07Gx7X>2IX)f8jh{Nuei)-MfT@@;Ce*;V?JbI z5uRW9U}$U6Bj@x_Kt1#q$dUQj5c42w&Bma6fmhT&_5J|78bxkNa4zDkwx+w8qcRx*{7eEtP$$IRD>nyr zR&Ek&eeXH)H$o7o(4R|vL4r0R1P^m*d_ zZIUe8bjU^lslaI#H{Ua#Y6}GgM2F9+1-T3adWJMJ&{fu0!%+Ys8K56DTSb? z(-LH;Z8OW?r-HK_A3)Ui|KUHQw%iL%|EZqJM#_nwzUH69Nz4YpwCgvKEJ?L%G54D% zm0UG4*_zI+0ttxJRlB3F@`lgka`;vL(!;nfNm!d%EPPQmPV zu@=;R^YJ2tHg9uAl&NLgB%Hk43{wpKnXhAHb zAT>2f#HjKzC=d$=v@7p?ib%$CkHn;{qdoFHCOjS0ghk0~2*#xi#8s2#*4zEIFTRGu z^kcRfgdXc01}gfN;d8AgIJ>uPdc3(U>S_A)CnobNi@`5N8)qL_mF=o8VRS}F3H9nf zF`1vkqXfNg6h4HMe=a|apD(DU4blm6apL-ts)3?nBMXwo*AIn&NjF% zt$faIW#&h_8@(}%ysK9-FCE?@lWN677e_Ry(XvDNTAEghd)<_|zIwV7vaT)Fo4Dq< zuK|#x*?pp^#_z6Cf(q}DT7`1I%XOiFJh=?7A5YO3gOpvG?Klg-Y1?lrj7C<2M`cdPFP>UA&1C(++yY`l*Gt z^;)m$<`)&7_HyX0#q!{BRo9o|&1VpmOe)MsZv2E7S_yVdCUb0p07F2$zft4iPD!Nf zpYF4n%FD(Vf2*m)Hi}S`WWPR%Ut01OYFD1S;8pTB+F(wCy>Dy^3(j(qJzkP>vJdQL zU2qm)zjo5AmLa3vK<)Xh9tn{P7E5&v3iP~8JY=4_z+i&r=>KRnli`3Ymy8KzpJE4S z^7Pc5w^>w61VS{(O3F@PitR((u-LHEH6p&a0a3}a3nObB$>bFMI-!4xnT4uNDBLO( z1eI4@*jG{F@P^a;)GbZA5Z#^#IBsq=@1%!3uSJ>zq)nQiEiBQ$+q&7|b55QEgM01s z-QyZQ!G4gd9=B&bZSGs4j| zDHUUAZbXo4&uIM22$Ut&7F(5!Rny6K~PpNAMqA2;HFl%~)_7t>4@|$;H9aNclMR)5e<;fS@H5E(0qM2*;b4*aA zg{zQVNnO<;jAb!j<62m4+jvKFqK1@Rhi` zrc;R?r8b%b1FQLz32!HZbzbSM$)hfll7tuQ2SXzc~M z#jQiY@j7fIQyFKPOwEDP$8A1PvcAoMh45=dE7Mg zu8x00qX7*C?gi0g;Iz-!>he5QMKnCx!?)q|Q1@T9lTNo}dE!y*$8}xbb(h(`j}X#t zfl^>Ma;@L8-CnnI5%!E-cCpAX4K}6q-QrjTcgAq&d%mBRKThJ}n%69Qd_`j5Hz?$sHg0#3bq!#x9tY;13{-PcJ1{zdO2UIQ{zREClo}rE*G2yX6Fs%2Dx$%hh zq$s&8Yxq~}<4emG5l;m%PQyJbC*^sV+Hy87%dkbcvu#6)8A%u9adal%L$ZK5+jCL? zd^ybH!0O&!7;nec02m$mr-OKX4FUh8M-WfSv$xoCq zefkO;H!_@U24tp(9l+?LnLV)ZpGv;O?*W9w|EmwQv})GvpgmG0p#IF9p-{t=$gy4U zb>;PA!h^(xz$onRb8=twIl!?BMg!(~2InH%lt$v^x$)##&)93-X(k%yvPUv_cP2@oN%)V(Y;^$vSf$4)NihHY9N!#}L z{d6K!Y!=1E(zf!$!EzuXc^HXi6S296ZP_gH`B~-IG_60ADqsA;=cIE$Hkq&5GB)W|f1>InO&#q4(Nj>Z;$j0j-A4Ti}*KO9<#Cp=-oOM}Bq@zfZsaT*_#O7-b_pk(!RdfU`zd~+- zCr85lajqT~IEN6Kruf7b`;j4;rKu51hI<6NW*JS3iyWEtd9JA`BSZoLM0baxZ(ESJ z8!EM;(CjFwUFk1aUvh3q(>oCACPhz_2!Yiu`Kbb^%e#Ukhu>fS=ccw!HJO5EH!}JX zCyqm9g7%+R&LCNjQvu3eine(dau#*l2Se=t@<8y+| z51kjNnSzOmPf17wQ^?}gkP8qfb#pa%glqSWY_uur{w9zvN_#YCZ5ENXCN_($b}5#; zn)8T=51y@eszgSbBXuqb(0*5YCHr!W0qpBX6XIV715Y1+-47KeC#G>+Fwm23?0Ux$ zBP0NlfozsjL87rk?$SAYyR=j(VkY00w^N`0fcD~=T_~0d%&T`luLy}sDG3lr8Wt~cjrMO>cE*?w~!N9paBh^?PyU?HWDD5 z+*{X`O3~`(Fmk;wQ6;W$xz#c0Y!A4tqvv}}5_`0$@45$%^>NZGfn6!+K*AV3G0C@z z)h&FeV3T2l;j`0`B|K?q8)U!liVs!@*$g-;Cccj-0HM$?d0Y*K$5w!t?oXd2IQ<=agARXcp_bn}3;=YBBo zJIh4l9)lX814jI%C@tB%$``=bij?tfaMib|2UdgjC&S&DBJ2{y8|X02e1Gcx zZ7OV%tgB%1#1yzDK^ej6*lv4@Oaw~DTC!LXr#C1^2}Wxcw*$&3yq5=urz&b-$K+lb zetW$V>_K08Pm@R59OoZ@S3OHPNW%yxJfG^+)p$_1gRe3ktZL~czcT)#OT*5y6_$;5 zKp@ayBIPB6uzC-m6z6mGp%l^1+A#k*$RHJ~mfX!_Z0gPo#4f~#!@ZX?rE5prE2O%q z4U*@*T>9)AJw2gD>%hYe@|v`RM+y zJ`+;g`1e&4EcN-8ZgK6@n%3`#yjyi>3>-WS zk1+mNc*B@xiWK6e_Mn*uL1p|QylRF;btb28zJ&@9?9|_k^7qh$*w0Rje*QC?01W*| z>KOug^wwvm4O0qSl|48T89rNLv9^Wn$fk}-UcTE?ed`Tybr%cYRZdQ?BS+eW&JKav*k4*4`3-QqU@nA7Ab~Kl76a0lsAAyF8wIrI z2bZ`p9;nO*t9XBC2e>MkK2>5?XL`YC-&t7;<>e*Z+>be*_FWJsOqKaqZkjiRk(acu zn%^dqKI0=Zkj$21M%}O9L~W%xM!K!;nhA3p z0G`sj#!F6xpnnr~hGgFrkgSo)lG~kT`LqHKxpM5 ze7X}ALN_WoNqv)QaPt>8>A}2yLMm-GbPLv;9l+N<8*&n}3B$%?y@K>S1!uA4hz;(V zXJ7l0s%6XLoWOohQOvazj_@W%?yDYkdUFxZ31P>z-C0phZ*6tC;WLx+TZ63nAh}G< zS}}o-9nv#beBKEUy!()<-z4vI__5p@G4#M=`cfUy)z{SX_oiriQXQPSl(B;S`xP^6 zz^a%s8JUCxRdk_D@bM?#g8)lp@ySt(e%>iSubO7CiA`(KQPnli&LE_35^d` zZ1BM9Ih!zN@7?XpwY-eu-vAxVJ_4y{WstYh-vd8{`dNew`@UXQ`gO~pu=H14{3Cj~ps+8Fj2ndKExjP%y_rnrHwf0FrIAnwl(w~Q z)=8VK?``anTx)F;A~`r7Y|oV#zwy#F3x?zAarCc5;1J8kNeK?h-B>RMkqm!YWV!c$6S9Rj0GSX#zRbLuCbaQr|XnHfbFj_)Yd`qy6Uu(8N^U)$(6cK zDgpxj_`d^0nmuuw{Qc_c*1CAjgW%u_iYh}!S^T2!gdUpj1A%f>lG-ESviEU0Dlje7 z>C6ERiVm_KlXseQzwp|ZMU;CqOgo_qTS0L2{J@<_rE&5ht2k6!a<~%DlOOTvkp5kk z!bea`f)X=|d^RAgUfR+F`*vi6Ywis%@aEWz=N`!g7%KkF`~+}XEb49=k{+1P+f}&? zY;_BquYnhkyZB2wW05?L3Y}dtBzn1P`o`G7k%y?YLhTxj-Y_Uo_hz?yh7(Z%+K&WG zJz$TohYlhHiabhXqCQXrHG%Um%{N0$wjn}VC;o+bi#qD|y(&!=FV_leEe!EyrP`nQ zLDo5R*N^+2rrTpAB%K_3R~d)8ik2|(oac(^rVOW7ggxjsgSF9pnpEbF0}(1=@D=`! z3VDt+d67JD@&>Ud-BjlThVAV2u)L5Va0L6(Jp2nRxyUqPar*6cS|%oHYtZ0$B|QM# z-lSP3+WXhG^}~GLfk}V+XN5#FC#m8F=vbkJ<(1}{?(D(rw5F?h*e`sY!XaPa2~WUy zas5E8heGh)ctF}V=z!;d?Jv-*!6*!cx2I=Q+`?RIgS+uCq3k(!zEA9o+|F&7lMfBU z$p&A*@)P5J&&b7E;(;JP&mSk$YK=6QJV$+Po^!v~aIbcLE1J^8!n_{2ZU4J&3)Byf zIf`y5Z~)~2H4fFYwDg~e%d6H((1eisSFqYmZ}pvWeD_1{!SH{pRRV*fqsm08y<0@;N1Rp8Bs;=pS>w0X%cJH_U}2QY|VM*^_4OfJ7L z`|D71ciJI7-FtWZTafI}y!ULq8>Q3Ego*5siQJ)x(6KOO5b(~q%~ymq0inwUP;wfl z9gxJ^rPR(IRM|~Xm3=m?G*QhI|1e~!NjJHoijeu7e}A z|Hig|%gBVu!8`^4wIDM700?w3D(IO1i3YiG6bhI@G)852l~rh{$V8UeEF_dZs!uMk&I7znCP3AAg@uei{i2{N_Er6pLA z)3oV5vQ=kxsx0RZ?zl-vh>PSkngxrJJJ%FF3tr-h4qFjEnB`3T0{ zwKEWZj^(od7hd-FPVLDpSmMzO14Ot7dZ7ol* zd*mjO#ZNQ8YOul2PQs6Fs0-s_A{`42MKZYNL|yG#g2sFFDuQhMcCv~Y7Ac?i)HE`5 z-k2j-2M?P#(HInuJ>vjzA`FXdAl+e?;5Tbu?GhuK#pHX8R5E*r(>h9lMx%`LJY3$GmRxikwG)KW zIhMH4@p4DLZNh0^w;!ADA9U74WmadBYeuXYsfe}06oA55m01`Co>%#^`<zXJz^F2S zI0|l!|8xorI)(R;3uTG?%tCO6Sd`|>k=o#fa#Qa=Dn>!YVeZi*|3;VxwNA30ReRU4 zud>|IK%bJ~-}NB#-hP8N3T7XNA$3muTQ;ROht!ust`aJNLI0Nf5maylz>Fmq0QAC; z4cKkssedeB#2D}u%@uJLnBZMzlvJMCO57WKca!mA7|!b^-y}opQ{UgzBF#*)T({~- z9mPP4{f(Wkh(~py1uFH#IwmGEVC*kDHPOnkrn)y?FzE93d&mXP9__)zt&mPD$gKp` zK&BQ?t^>*kFq%XC((D;I=YouPf`fL2ojD^Zs`%YnU7RNjuGy3On zoYkPSGsIj#z3GB8B@Dpag0i9NH>VSV%s1&f&YD}tkr3Zc*0h%l-as69ku)7O4?z3) z0p~q1VN?e$&DhxCZl(b^Pa*FiX01yS0-}PQp)rLss}@o(epK7=@Tu)cI)GcQdp;Fa z2|>TITvq)bYQUcZKM{d>?xs2Ov(GicJ{sbrieI)6eFW{;-Hryb@*;OsU%f@ZD(kE7 zqyGLg>{!wDduA9_H0&eTf$PAwJq5wx#j>LDjaMBBbRedl^gBr`> z!S&VavyJ3ndzR`swF(?Bz)9J9FqVsMd2|A~H?H)lw9~$8 z?Hy(gh+-|m7%q+fkVKyU%&5~EypA1~oqq-IVYgWeDFmf~kAhXC-NSCz_+;2LgD&)1 z-ml1D6>jRCQsft_J52Dsr_(x4X@-N(YRm(ezTLYu)cksQJ50Q^TSAnPMmR85vX=b1sV4b#!CwpNf;gHW-oSbCuONN z2;D833ff_nS{y3tBMz&o9GR6J({B0|ZiP`Jeb8I?L85FsbRFCKp`D7_p`Vm7mu?Dp zO-5-_0eHiEmVgj-B{M|EBct{+kBvzVEDTRerkT!DlS>C_f5K00hDAZWj{x0*Ar2z$ zRgqKbJaNxyfWkAG!hTYC)923EUGRqX4i}Qs4UlR{I!crJHU?ZblnOu#-9qh3c+6v< zUP7hODcN>}|8y$jALEUc4V%Ryjl!ZrZIe@SZAR*}Mxl!sj`$a|R<$>~#rX`s%W?ybkVeETbBzuzO-x#B6UVYoIE7uoa@ z8&38;C{QVvz$Vu-)^(NRUL4D=?RV2RS9z;NX5;CmgU^&l+AOB|5tPY~B1nCD$}i>8 zS|jj#;VS2*T(s?MsJ-t{_CS)?LKiLGsFR%`K@z*{GAsgKxwI}nKWK2# zJ+E%h8YR-zc^BN{j6w>RE{|6{Q=xFBkR@!1RYaVxB=xsBHd{iv|A^ru%)Uk4DNs>x z!>o>cx`rC)!JW99o9YgRT!js4-9^=pg}T#>iv2WboCdNxE5gkDI1+5NT+jMrp(?>F zJOOK-e@Gmn_xuJfBv6!{U`(aDJ(>Z^gC>~{z4vN_+Fh9dHyQ2Aly8qw?~hWslhl}c zpzq90R*C+j&4xWse_yY&JHqQ*<^Gsp*X-o;32uS_ASB;O51NUYXfK%VsMPL6XF5 zB~=476$QIk1)<~cBM=~mUbrX&cKFeaaHr2#z{|l5oZ2=FPNCuQgTbB%x5;Qlw*io! z1(PoSUX3IY!LGhhvAOF)Ma^2dN@d{ec-ekSCT=bS_yo7$3PH2;BwwtvRB6V@YR7p4 z9u^}BWs#CR^rn+eiIYgBDs$js#<&jK;EjK&>%6rNBt2ErxN49i^&}SE1Zj5L}I-<7MC^2H^zVFz? zo#}ZU{zz5dk(MFgRb-MmYP_T;(&qX@TyTirDn5%FA)V(|poiveAi&eyZJG`tvx3p` zFOws6H~S45z&LcqqDQdma-DAHTB%Xgz{*KJ5~PJvzkOlH@rV0t@S_ z!c6R^*^Z!1d@_OI(+70U|Y>q8fPS%I72hSw%kZ@=%pqive@Xm?mI7Rdm;?y_Qo z05hlp>nadj_WC*rwVyzu-~qS~7}eXH1!}B1l&pnas0y2%S03V`-3!`^a|~!^XS3*} z0=a0N+M1p__nUXsrkIyt_S&q+L$vmF;s=KDauClPla!Um^HSB3U;Xrp{aQjo!9E`T&!85$KnK z9yl_=-?|ym)9@v?4|<*j7h_X{qdC|Km-7yrIB>{A+_9&W^LPr8{MX*T%CR^*^^2ex z3s;q9UIkorbV;G-3ZD)tP72k5ZjuMRW!*?xH+Noh>_zj7ch}*NJF`5gr(d^sUyakWOsvlf+0qGSQRkOv(dPZxKC`YKUq#+* zO?nulL|VQ>KT4oaj7Nuaiha`PKpgrUyrg@z9R?^!@aN0W`8wn10v*fC`SPZDl7c-C z+ELkMRggPd5`KX4La%r-MEq!fab<$^oc!~j4S&~Hh=CBK`U!lPIZX!>NsNP3X#9r+ z`-HW6Npu&(`-OF5NK%-&17A&c?WGp{s(v655#`NL(wr};-{arwuAn>?vkr>vVQCpS znz^?EG++Imv|rnMC8E#U^`A+CSced#;J=a+2q8&ngG>^wz5Ks`(kb_r%Rdd`7iS-- zAUdH`0sTo)MiKqjh${=pT6j;kEXYV%2LXRl&?bSHJ4uogeKrtMX*os(k7&Zy+k7Qi zIPjWsFGPm(0(ho=zV?zaU=Q7YY#M+&7fDv;V$xDtHYJloYxF6ioALfBOab7pLq2HfUB;c zgSewPxWxQlwLS`RrsIVH0Isfw<~>$fKjvJE@K)jqZ{5N^j`b=R4JBqD1wphZQk-jm zgX|xaeHxv??2>Hgem@9xp^Rd`oMrjNn>a*b5E9o*DF)idYf~ATXP!8iQdphqQ)g`> zS_yR0c`~ca@@~*^NR|D z$CcV7px!Ig)16N1^(;ROj=*7#&eOWZQ}{dGKFk?f4m;U_!7LK$Nkc-(eD{{_GVoP?su$!XS#C891Hb}Pya`gjs|ph~_Le090r)bV{tzs)`!7zEXec#_kN|OA4Y0`dwMTy$RUVBmhj4LnVWzap? z0IM`f!JZUnh&Syd?>nUaLE&7?wYb1&L~!;)=(|HRRZM(2M`k4pMbhHlvW;iDjh}|A z7TX)$wv1}^XqRO_%M0K?Ot?OGKHAlt>;hzw5&|&hZ0m-#_up~s2WkKPt360BgO9wj z(Iwm}ULqX@ox`V7i30N|2iuljs{2f?M$HvY~#fl^=5+i>s+`Uaw(;P2zl%mtlx9rq^EsdGFPYPuQjT4CBQ#_yLMQ=O_F=RHte7J^VGY~aUC*US zo$=+W2&w!P}9E@Se=dj!A~nQ8A=&D!HufnD^wT_2a7Tz&7k32_0) zd{~N!<=YkaLocI{y>XMUiw$Em6T(?&Q*W);1s2}AM@f6oktre3{LsuTUEe@>d~uw> zgQV$LnOcXTTS~~{SVOQLC5UxT#87ea%Kcufv-<6|v4DocTUKIdqCob1ONhWs3{u5r z{CPaGAq=|uyj3n>Qp-d#@uywiruu3bmZvBhUVPKRL|2o;!dP;36aLAft#`R8qv!aP zqys6X9l}k(sj#n2WNk20%B)!qWvC@>*cNqd!6M#^pZ!Ng55WJiKz2UTkfK;Y>drSC zmzX^Hoe~u`V_xQ*k=PDW-gVW()tgFxB@~BkNM8XZHzhPc2Mj}TzX|+JW}$1rCU_ur4LStSVg7h5HA$hQiuZoUHrqR~^O3!8hc^_ZPUGwoLJ ztwe3(9yccA4-fUwNe%soScU}av4}+YlC03SC!hS_q&o!%quyP$g!S8j--P@3T6%J^ z#@W1Lu&08O9PV>{wJ5Lf6wA}~5t&`?GQUymn-6(LwNh-Fz0!bWCZXQ!kq+DYEml>t z;Moytcp!R!$W1*Dv&&fQ$NlG4NQF8={eWL6K7T{CIaO(RauCYph0(fOMG zn#QE$3*B#OBek@MvRaPg*GzaySp}@Y7_J0iVsTuWijAY z2&azjW5G5S#2d;^WT6g?T>8Erv&mHRKi^xZT>(lQ52g2znxuk|Tv0s+C`fcOrMONm z%UB0?s7MgV*wQ_ZFj7HNV)SB?ro2qjoSyU)(xF6f8w(N_bp$10Q9#>nW0 z<50axn!J+3+`cinCow_8D!UkH5I8J`v2vmbDZ3DR>xNhl@w*znp1|D%21rBXbcDoZ zVM|~Ibb0js>zdmS^UiUa%$!H8`&+`;E zj*62PH>u2W_{N{+J*!_v5XW@7ND&i?adKh*l75Ln$Hy1rinLu>ukYm#f60hf|J&l` z>tU%H=JH?)rDz3hVFYA9fq50mNsXxlw!;;35_WG8Fsh2QraEgzF&Nf$Wb)TodO$m{ zdkKL;@&(w@jiL;-IO*cZl9U0Cy9@R=dwE+Bi!g3Xv!lMF{whlKo1{aa@W<5%AYB?v z4Ik!~4IYD5!FpB{qDb{KUEteZik}N1b&SPgLvjUoM3wcPDQSVK+*ji4~7Q1T$!q7%W#NiNW^MhGIZu7>z}|ONW{?fa=5=zbj3Pmt zGhB{D!|VZ9J`@M!?X#mA<)5{ArivZ4udHokt8bffy9S3CUooyM%my8;hBFL1%T`l- zD!04z3X2WJ57&&VK*o4fIo_@uy?h}+?Ew9`0isrbOJImG|1qJLX?8i0{0k@>akmNv19WI~c$LWe%seRt{LW)co0PGeSKACxu6I zH)V!)#_&D2LKYS=cjQ?KEQYccAQWR%^+MZWF~&t111{!1`BV~xnJ1cO{i<-%Fm1jA zrHF3s>lJii+3Yq&a>ew`YZ{7}z#N>MG;eFhW8XK~FeeyQm;wc`sy)a(wYk2^ zM089h-W7i!niIrxsht%r8XV)dCE8s+qU5%#N#Q9Pu_<5LzPLPfyt}NyJSrK3*4pau zPM-WJf<8ER&v;vkP|zqRVuYnZj2I_Gi1K^-M(YcTV7y(p5>ilxQcOI)-62v2EHmYM zW*Mw2p8-NxHwpGCC9jRAh{owJ4M`GoirbkO@+>k25f9g1jXDuwEg!Pg{X;F*+-6BJ zHthXPFuVi#;jH66?ATq+ZD41P@3d7Y>ne&iaCdD5*5zPg&20b(T+uHN0Rpf-H2a;w zuC_vFC@od$+8cj)DYLO1LN+(Qhj`IcXj)MS? z_zGOh*BuY2^3D}HfRvzpX3)K^)!8uCdcs~vEv^QwMb@tY^u}?+Pt9b~qzD76x?v06 zqll}}`#m<21%%n=%Qgn2PB=z*Y&%FY0MN`*tgXz2?LnMEiL_^EO64c}g;vpK4xx#h)!ti^$*;xt6j_M6b_m>`3=!~NKBWb0Zib>T z=P!M8n5j;W594wD%%;%hXXJaRkOL&d!Er9DR+Lq-O@aTXHL8Lb6d53@h zX0#D_wPpZ?HqHc!Y6k+bvWC_Bm1j9!BnI+!2t(x;IQgbw!H7GeE9`ISvjI%yYX7I0 z3Z0hax+Vz2OfpN?RrlWpJF#3n3CJHh;=0oQp2*sz0k2{XCu|SV40dUUQCzYhz6}(S zRwP6_IuqA4y_KWATW0Mal*Q9sjHQ;)MXF4a0rdz+b-t|! z`(!)n*}$>a5+gUoHN1Lh;9j%_81F7+kM6bmj_oR$*GwDNfx75%fO)S28~o$i72NN= z!G#t^d%~OpizTd-dh#w?W1=DmbyqsSpP_31+!h>1Zkk^FPu=Erk%9;uXhH_d8P zP|ROU5XGTeFd< zdn*zrVm-TB7<lHw2^olwuVhSUGSlzv&(#}uz_$3X<@uU=(}9$2_x;lqz23~yv?h^ zH>E|jbSu_dwv6^UT-mek%m~OB2Nk=vE3c@o$w9s1;^2s~T1}*bn;#0d8$jj3f`1`j zx#AF3t-5lHgspv;MfkC~E2uASlx|p--XW1^e^UY-HDDt}#b6FS&DJfgLAs$bE^q35h zUWYQ3Jkx<9&rz<)T??E>? z9DaYa`K(7^ZIMr@4$q`0{@x>xH-hNZ5d+6E4(~@P8X1PYP>dJ_lif!@M*T5Il z) z*o7`7PeBIi9R<^Yu8njc`W+GuHPre?U)a9K5WS7T@lPL$XYp#OLcnLbBo^OR5L=f- z7obV2L_IjBc?w}d$z@bn2Jws`pZ<6yj;-2R5`zM4=lM_nI|4&3p<`6)yEqMB6A#ul zAsR}x`169E1nv)xfixxgJd!EL0O;useL#V2LJG!m7RRa={%~+hqOV7X7j-u~ot3*QH$}Db21JDYIBzaDiNdKT)bIqah?RHUJib7) zk-=oNH;$lFmx`kiJ^5F?idK@AetFRZy8akOez9>%ns1xe-1OGFf4Xg(l$9FC!J--y z{M>C^s(SkHrBHP7Q=hJ&G+Z*8IJtD=&+H%a90@TA^%J>aRJ`>+Wa#r}zzgLA4lGXK zYB|Glv2~e%^{d1FdxLC%`#(^ku;dCxGc#y@Xg5X_?h*;M81LEjHvzERIP#))=baVr zY=etF=Gcp){;WiIwGgw3!Ak1$S#4{M4QR!eS4Jvv_?RiUoN&1 zBGPd)L`OQ|!aX%279SK+O{EutfMIsktcA+F(r^f96H^DEJV*{-=^mRxxU^s4M9p6u z=4-0;nzC+ZOb!u{?!TK;)KTn$B(H zmNkg|xrP*!$^kS=EF9Gwi{Zu5H}z^%qUjwwy-1YiP1IfV;_Zn*klT%}=z4>b6p6qH zi}hNs1M^gOp!zDMkm=W?oS1B!W|ERe>Y$4t;r>j9e}o<;%z8C#ICLv!UzichGy!f+ zR^%_cx~K~D4R*Z=SFk+w=yyHiaNZ2zgxGe!cUH+u-N_Q`SS75UiZKgG=ZPXXur?bf%G z_Om7kJLd3bsCxEHSumpuoK4*$e>x-?p-ua?DjaxFp7RAK?gQ$*vT9 zOcR8+mi=-N8+-sIUz%&wwSISew?1-a+umNKRnIPJ8x|Nl%?Dc8`-Pg7pIW50FtP=? z)dQlYJ25{wpj(|xS)th;9?>K)8Ap<#ad3KOg0{rH&vHb=-?Bi)E*Z+TvEULN#yV4x6&oa|IAs?D42*uV+2>LdHU z6URhhg*W>}j2zG{Uhv_B(4}krJbr12!>>VvXRtvqvu&4!n91|!}b?o`X)HoiSBK@=0&z#Yq28+X|ut~z35RH z*wys>BX3$o)9G(dga6LmJdpq^w*n*)?N8jm{1SkWkc&a0a3&{XzlTQ)-fq|f}C(t^CaV8|BOOrEUE3S}!clh8PA?oq63 z5J&yWZBd$h>uaduR%aY*;CAoG6EE3a`Q)3|<-GibBs&0TpEC`+*e+`QU0b(B`3HrF z*B#xAo>UN(Y!TV_C+kDqi+JWa-%&-9lweRrZpH{UYD)9WJ7Y20aS%WboSl0XA>Rzq zaT<#)3AS*%_Cei|(;LUprudEkM?2}H@kD5B9Nxqq!NMh$DEM?S|Ne=LUxMW~YdY)B z`3(v9_Fac-sfo&3EQ9a)FN2IaMSqd&Z62ItRK$h;-flI_O}VPvqKy-n?%r&=2^Fld zq>00zcA~$dWFKTalf7hr>&ac^0&%2RTt^^M2UaL{<8=uTTMT+j6H$J`eQX=X@X||V zRmxF1{jEnn58@gEUz5c1S;s|SPVs|b7kE`l!l!Nj^KQo4Aw;Rl>zm1Kh z&X?eSf%pBpdJ`4Pays!cIN;of2Pgln?2PG7TxLWa zfPFGsBJPA4ywwLJX|*dscQo3))}^Xh8%`Yw-dRJ(Lzpne8eh*iA^B(_ZxAXn^f(sg zJD2n(>)vKx-wsb4)f<#1XB`k^2Aly(!^-qTS@SRv(&?stSo#`h}{`) z*sswCt^LcQ+CDeQMb$=jTYh7O9eek+Ya*? zW4wDEiU1&0oI;w|Uhv3gko>V z8b!{lgKW^g-gY|>$9|bb4R1goxWX*J&AyjPfGpPr^=U$Ta6Jx!okm8Gs5?x?dJACr z1j0;uU*N&IouRZ$k35=$Hrj8`K!g~)`&-yc8_0rdB0<8;76r{^NGKDOnAnSAbtNIg z7JvXsSN6b!K<@?y>A(t%{*lEHbp4=_39YdJL>ql^zr1M=zDDY^B!VOO6?Yue-XFw$ zv8AP%#k-mFiebO2@IaSUxz7WOkTJ0Hd!K9YSGYF9(~Dy6ZYzgu-EzRg*yKj1d4ZD^ zwB>AM={o04qjFjjkTR%`fAxx5B(*sjVf~7)DU{s}kqV{4Y?IjX_3SJuE;LD+T+?j< zWiihXD{cA7A&{kNhCds@^^1In8Sg1czRJhV;N^MbV0#7yPaBK@d6%Px9{Ew#HTsn zfEFUoWW#}Tq1h)hy8SO-XYx2A2Z;pi&NL+g8$ej=4>9w;j^u^69Mw-)?DB;M@Aql8 zIm9ZazqrS}Er&+APa{}u73di}#6TtHrAY;kby;XiAi+CLukor>k%Dcs$+Ta6rCJN~ zMlKs4Z{!`WPE=MM0o&@d9-d?dy*}s=SkXQBB(D04hGR^yZs^C_9cb}y?q<1n0#>!! z)m{M<&pEX>%keJr?(_@rSx!t@>y;p(+Rq_!3`@9L>rPqHaw8}x%~qC!M6AbBcIp?y z+wAdn5}TH$EI`P6jd`;g#q3YFu0`wE8&pE9I`rXmPoDtz-aUX8A`|nVIU*sWH)xl) z+C8?8aOC}+QFpujNj!O4($bg*nl+2;MiHyjM+QinF(uIekDu3*-Qk z@k2X@?H1nXnmTesiatQk;T6@V>X^(x3r9q&1l=b>AhAbr8=p-7Cqd^BBOk7>e_eIb zTjfFq7@g&1O(ti?O&Z$`QrFpLfV$B?;>IT-KDNUk4`n>yd`4L03T9+3j5tDvcET-d zJp~7noANO!!WYZ95hJ6tBV9fCv{jX424I>>Sbyq2WJDb@fVh7d5naJW`We<4hbBF7 zt8Yx)|D=vQ7xx?di|t5beK4$1m~jpMM@rOG_XUcUpasBJCdXl{4U-vs3df7%Ip#p1 z)g}*W_nQKlh(RvCcPFw=P#5vQn-0~v67r75KQRp%H2PlsUJ^pV!Tx!O4E>DfhU5GHlb)0= zR%<5{^b8ok7GM}m_|yid`4eMPoRbxK*Xp;?NRc3O;f~^AtmVHVb@uHjF^gtQLSN0f zgxTfOz))OXG$v!e8rw2OBSEID@?_&){d%*BiFK#N{`#C>aqIWi#CZ zb2D+(jkPvvP{~KjU4DL`#us$Q-xzurlU?bgxIIl`$W&p64?%pYYRkyO3&okj7LuU} z*$BJ8Q)q&FVuUz_yN3t#I{R(r>}7Nx*{D|T@=~pJMQ_{%?_`+Xoh2@cg^ZwcqUG+ ziU{bk1M*C5jC@@20h?yY3MT0pA(nH}Swty4Uac>F4oou|xwn?#^boW`bN-xc->hN* z6Iy=iBfDW`n0({)df(l#*r`$tahy@CXzXO8hYP9_G*2+ zvVaRh{=Z~Y$^%oi{mq#|d|85rW!Z)GbHVwxw$YIScPKU&lv;4+#SdQkGPd|@QG%QqPv6B+MqX{T5q3uC|Up zkc8nFlOE@}PYK)b>*1vp1AGhjE1{!KDy=``x#?a^cD8lpB|rN@ms(!5YT0-v zCJ2G$0mn2(1}!r#9Ukn@o0YaIgaA-v{OAhvxznrS=+SuQHNh0Hl46G*40XcS!J9;VCD=dZYa#7)Vom`hs0348@lkj?5_x)B_|7v^gbKH6o#I5vqYkAygd zt2)oyxUtwD_V>mqFF7qO1nhFtmbE+#uhj1P0$e ztVzLejdvsX#Ys45fyR4s7$boG4i$av?R~R)5~?N&>`rw?-?ow|t4thY{^iXTST&Uq zYg<UQ(5@9;YmH7U>`1aJHoS zeR)FiK}OuOE?0v)YE^0g2Wl8r2hdeyW0^Y>XLd5x`v{67UeKQY`rW)uRbmvd8uv-+ zh*X1rG6acA+Hg_^+tOYnYoOSAOl%pHe!s!vE`l1DcmPk_I6w+Z`}4E38JKEronhmR zHW}__u^s#k)5A@eWMdC*6Qm^EcKTW6Sy;Ym?hZu=m0-Tn%zAbt#C_D9u0C*es(U88 zx8oI^XC+!nLpMnhMAER@#5HYGM0WJNqq&-z=+4t{e%Fi`$AT2(WHpU_7>8I>Y{C{` z(GAF^AEsa|2LC{-KnuthNrd2mN9}gV61n+E6(NUn*kkn*bB=R5-X}LvRiqD^a(a{-EoG zUmBMK=XxsUvUde3a;#KV^?7WEG)8_+4 zr^T|dO&pC1Nz}r;V68#79r*H7c_Vn^#>!LZOm*cY%-?<%4ZgEHb5&Kq_u3+vfvjg? zJBjUVK=;!GivbD=%9BR05d;g}Zk^^5iQs=74WiMs5gsK@%hFVT(-zQKd3r%A3#5l6O0CnPGzWbL@hoh|+3PH%aGo_Ff-@bG49kSYq zvFD}cNN`OPo^={3%4RSh)dGdCgW#;aIdr~{wIsp*LfKC(bZGo)W!D^JEdl&phd?T(i#V#pN^FsF?MpwY{_Y(j6w ztHn(=V4V5h0YdfjtU}B?3DPNv z7Y0TvA)WO^F8B!h%*b${PI!u8JpHP_`@zvob5qrbdn=DHaQxw`jkb4)$^`)THtu#Q z8zMSxZ9g+POe8Fe`Nryx9z=TpQtPI^SaQm(t!C8mO`#t9UI>dJCbvi3z+lSvi~?@9 z{%{8tcobWuSm#|;VotHeVFafe2#al2FqTeJKy{qDW3xpWxAMABUVcGKUU-oob?#78 zA;5<>+_*+%(Rn(7j2apEE~u2YjGvrmX;;9YhvYgJ0+WvftoV(HHl%?;@0@^dPddrU z%WaYRUeBJd7K-B&wLsO}Tkoa1HOwv5{T7m7J&JCf1E^L()wD%Gf&9{dPR-q zai0B02x2cYa|CnKUHZtrNPVs+5Ri7=TtBd?LUU@NG0kig3Z_mTHmsIihCw?M!Tkm~ z5I4{$5Qn(raZ$LD<_>@g&SW1!OZeNDz7!D*gJ_G_Jj28dCq~xM+{jNqm_c1^xLzwL zF&RDK3NT3eTGQqmb+oiiUeVcVLp+YYrSj_80g-~oA!WcMY#sujCBNP2_hDpD(Js#V zoRmU!#&r2CEJb2UPwyOiX?k6Oah}9}d+v)Vb=6PBSOqx!fkr_-xe_u1DURb4?qR`Hhd-tt(*5w8O5os!awW zy~FwiFinps<2znV$^JCTSNBIJnAD-F;#MOYsdZ9`+xgBpOrQ+;iwEv;k%`1;UP z0O@5AN!&#l$KB<^iCQ;ap)9}9E-iDTtWK)}*Oa^v`*}k082BleAY4+5i0JIS#Vys( zo2xuw|C162>jlK760orA?z;b73W|MgnQ{u@6JS|;x$imI@G=t7pjzn*;Wr5r#~if; z-!U0=E%D*D$}}f~!q=H#eowN>wsN(@FG2^D!sUD=?q&C#aP~CnT@^JIaUy;Zp$32R zI**X)mlrSXadg`tjLM~_!f3?jr@D7fY=5Jast&#=F#FJWe4lYPRsLUgYdsb z>^JOu&_H_BL-{^?lyEo*Fq!e*;jDDNN3`>ShtzY1cuKOJ3mA71?^ER8*$~5vJ*YGj zXPHqAXf;3C%i}espZG6-_5Yq?`5;}*N49VhR!i({hdKbPaI}<4W;j=coTFYWC}N-E zf7HTc2%707J{)BiE!m(b+l>AttZq4qPDFl<_|^ag$ME0cRYmq5{(aLxjO?{1p8xAO z*H=Gby27qufpH;!%FCMvc^{eBZDg0FEsJ2g(psWm#IY8(=gZ~Dna@(%c`HAVuF4bI zBqN~+HFbl@ueDm51r+o2JybnHTMM67UGjQ@^BF<#Pd$ylZ+elH8NV;*2t9f>0h808 zF3TRPFI}#FhapohAI($U@oCj2I!_QZykT?A?g{3vs)NwYi)3+U?wrR}F)qV=M3h4$ z9%6H-aw2QdNm9x!5*SwNZ`mSBKnf+owB z7PoFD&xG-h_ODSLe7Eg~d(YuhanO2{F(EnQ0%h<-5K+v7EdpBHh!A!EE|SwBO~ zrE!?g@z+FWKYulITiNXgeLso#5>Bjd1gzV5PXQ7Q8O_nP^c(@p8aR*9A}hEaOe_S)|s*&6V?(jc+A*V<9X zW5O|E-eV(8=A}8uKt>Ia#ZHU7+Z2nipK#a5N>y6F=vKY_C04&Ds+MuXz{SxC8TtSlA*A>}E1DD0(1}$!HUTx_CzWq;~pr|xb_@;9mcYK@1a$S&$ zV=@WzRZEbbWg$Q_cuvuk=8eF^^>J9)(_qwJgFH}wY26F>Gj5zBfjpiPS-6w!ON=yC zdu9O5Cc71jVs^fz_Nj7|eB!xt`GQdB#P<`+r)p)6vqr-~qc$DSkT{PayMFyqb&=3z zW3Qytk_nHUO;g}~s}G!$-}PXYu z@SApyKi*ED6}GxE8oZyi1)_1jm?r#7++{&*8aWl?MSuW=(1yC)BfIeA4jtR_TRepn zlv{+VdIinARuVn zvLFkGP!RA=U)V=uoku+^j?izt(%lF?)9u2(51}d3MQ^d_KXq{4NA0j7g4y^`&3ZMr z?_X?>;5P>_$^mg|TV=yAe5MbY)KlBPCfa1(YzoO>zq6Qaqbmrzw*-B%yrZV`636+^ z$!UJ)w8^u0qHzsaIO(x&bdC+8>$K7F!nUTzx0;Xm-j*y8IRz%}LQm?AX~o%@K!f1l zQ45h75zL4_fg+RnQ(@Gp2h1u8Mxk6LJMm*|DOG)?cWyUM%?pdeya@{O zGbQ&AbwuX!WWdwO*E5H0*I|($zZR8uAU^cCeo{M%lJFX+9ZjB1Tg>6`(SL}wDKHsH;qrAPv#Shm2QB#@m?!^2e!vh>BEg$cY9gPQuSt3o0t zmanVcO(N#|r^?H}x>coEl<&V7!xuZwIJJ#BI)JzLMr9ZU(MYydZ;$m*A zT%hNZ-=Hn22`(BTnSrrgpR*3!&hQSh0>`jr({Yb_xwzjvn|3N8r*C{N+qjdY_$a(O zNr44YRxlj8!>%RZREx^a7eTC|-}=H_fYHOLbW-iD>>`QGlOG7r+8#9h$i@1J##6>C8On?b==Ev3bKLk?7GN=&BRii8A*qW%7d$w~Wb zPaZzwT2V8Sce8p&Ngo+$n-*F{!7y5o54+pO#oo#nX|DN8U#$|M+?X} z4qZ8CyjTtlZ_!+QBjo3{AIsBqEoahGn+PQ(gt>^!Qw9#?EQUF!l{J$Bi^5n$$Ve63<|(Cg`lI>@5LPKA+`fO(h#heX zq)kR90bgN(G0gJ^&iiJ9Sxuk3{_RLuhKdG{q6t?tCADt$;-(^btmLFDDP7M3s`j$s)(~Q_9Q%Xx}R%QF(I zRN!P{4%Uqz(*c&ja}zb0vmZl&=8!;!ZJOSav!{YHi#KNZwTp?=RaDBXi(C({N}pz?rT7{S*dpl{^FtB8wJeA6pS-;D#7`$g>LBZ=R zr0H<$+eauIc-v$qp6B@I`T@a;p3^>D-`W+IS-NgDgJ1BJ_|L>jD8g%2QKpxb1ilht z6(l-oefi|&+$uQZRHVZahoDJkBZT{(k|hF3p?wKy3|ad4V@H>uWsLc7*3xOUoL&w0`G0~Dm(=DxI(r; z*}n%&A58&p1Qo?EYQpG)eEWi20mUvm7LyH4>)N}8WhVJ~ksQ#lh`y?biigiyT`UJE zrX_HZZuwI`;C63RF$HBfSKqrY&-m_(#b-*jA?7q|__>r2SkLOMdDIp@js#8r|CKo9 z>E^*$byQ$elW(byfA&rdd|k)uZ9PQ>v2@PtJ32MM&Jg*&k>-uJJA(BERUxrVZ&bue z&Tmg@W=Xsj&fO#n3tCOO<~U()H0BClwHgCMx&YAY6a*SM22z~ea3s3o2{**LnXkB~ zRR*cz`QCzN4K4#-E5={e`NylSgIPMH47~|p4Ri>@{N)wsN^QOIAY7fIV?{u^@udYH zWB%a_6p0P;Vw80r1%)oMhqC=xkkt-Z7c6pebvUM}U8r!&?rCdNQ7RA)md@;UxM~fe zZQjU8Vq6Od_nzp65;pEl2Q?gdL7JGnI5!-aMY&=s9>Qv+MA@@LtMKF%lPw;iNC(d5 ztPzB|qoL2B;|aQNeR$hJW_2wtNAtp{qsUIhLca%|=gh0y(r$1HFu*U@yM==@C0__d zC!nfBw+tj7vKs2Qz|r;oc6}KORtJS(#zfn{YlO4$*T10hy)J@~`O@{6<|qUZO`ApvxAO!gIk8T&l%*KSHIKC>zbs}uiKyNaI8 zketPn6^jJM>OLyQow|=CJ9^(^1mGdHx`&?VBH^AT=9CYsFq0`@V?R>5erSc+EXVYM zi=|>c)gZseH3edDf4K;3*m6Ezauq-C@b;o-$XMBo46N*KP?P6}f|*l=Ux>X^sATKIxydGR z5@p&49)i3KMHr&I$lUA|6w5eIUWSSX!xJPKN}9EYowxz@A~_ruUZ2W>$1X^)=h^WKuSAxr}~A zpH&@q4b}y(92aK6+-jWo=}45yeL4rsIKB5SzOU z*1FEXyg&{n$l3|3d6wOSVt6Fp!^4Q|b?dgg5OQ z5l(T+cjRT=0yBG>m20MjKhZPtrZ2TqUSj<;`{5#6*h8VZ{Rx}^5SMVZrsDY<$S_htT2}RfWOF7XZnHGqtx6 zr`78ON=1o#=UM1Ta(qa2h2%CgPB|s8wG7sy(@1Q)_lcwx0DD)U*)jrj6^0L>L!t9U ztb@YZLftX+NGahN@OjuyxPH!6Qj4K~^;`^-g!*xOON!kcBdd#uLDT72*yb?OKqMF~ zDuNXQ@5jYuZjsu}6X7J*x^$q$7f~xD7!qsp^+D$NRg7Lu$UR#Puy&lu`M!M_X0AwN zT%Z=x5G+!lToc?~OxSJoxou1o5bS9T34sfXz#6l_YCOHiUf9}k&vbTJ4b*|_%p~Iz z`*0@lregJ(Jm=VMfYKN)Ypr3<|g<~ha?txJLTqTJLwQN&zCcMXP>>I&a#5DWe zjj5S=b+X(0X~+T1F-GBv{?du@&`}X?gzF=0$YPCInBdQ1%QG`sb(@c>WdGP+$kSKy zuhs$2=Y=+$*KgJjr^;ckOi`U<{=joV{9li;X@KPc&ecruTd89omz|HijYK|;J zy3jl!q4BD=oHM4u&7+U0yd!=SC?AsdjB;x`O_(|MJ&Jx=V`}VKw6QuaQN3!&XtD>= zS^?Q0N5IBA=pDK7L)oRkOlsB3j`SZnMzQu_Zk%}@{OG|kfnx0uRudgqXXQe`24Tyw zO%CqLTIsLsiQvHe1~6XVqQkR%#GrM{i33@A1^dK^nwOBr;US4a3zHUKH)LJ0r?I({ zb&ZLzu zUa<6?occg+`;$4?rBZ&PbQHDnxn$oE{0ndhTS$XzM_jAD} z>2nz$&6oEMC-xINfGs$SP#(E-F~6l~qFs-e2yC_=1*`3^C?mO$)@A(&wZE{w}osU-N2C6 zmeRLe zU^1cdn9k90w>zSR12ah9O%nBNLa}eQ9bySI*jS@^putN6)q*EZOn{9CUoht-KqSR$ zTi6?8R|vK6>yQ9=v zPelvZ!Tw=n)e0!T;OOGBqXfFFgUSnj65uQI!!2moPspMM zYy@b)8=s7{psKLz@mPND-c?B|zKGY-t-Fw;N!DM^@iD?lQO?^pI^Dv9xgY>#v+lz4 zxb9Eg)%XbTE5b$RF;?PB!mx?+U9-smR2YzT!Z+y z-dSV0%WiG+`EgLZ(QjH zX-=U%ahPK2=^R5!^&)VULio_y2RZQCs((9`a>&l2chB9)b3itkA&LNv4mSW;dtFjC_8gX zFw)+uUNR}^wu6s%$?LU0;q4R(XJd7sBA*wIQcIrdF#pITdDV)s&)5u-G`D&vZ(0*$ zr1xO`pN*3ElI~)Ukz1)LRt@Nh)G`EyICfJLx0w(r*XC_ZkSO*<^KlP?EAsnlZ5OF$ z09(kb4V;RVZ`I@pH!ls0~)f_>0sXr(<`T*V{ZwK z5bb5u#w2oD;I`BqeP%iVUC8zRgNWHn~hV zzDXhcs+xm>U8qV>GbJK&X!p0~n<+@WVOtddp&4gh>JrCL3pmu(f*pnfgpOPomDGB6Znw=6%r%|94w2<+lq-k>n%SBPJ6HNY-o*0 z6OCOhuYA@Df^?pElUKwXo~5b|O&Fg!nh}&=va6_@e2oLdsMbTYNwN}`GeE!RCnZ*{ z{8}_psHPXdk}8HgbID#vrJ@R-Xl_AyTG7h7(i%%Dg_a$$t{E>z#A(Sl$fpc;oymYK%@ z=75}z8K8`U!REKp6z-ZB0xll%Us#=I@hWP3TjNgy3R{NH(HHKnpVrMlEg*Wet{9;` zGLq{1`4MZvz)v|@*qCo5fpW-LlnrpZURM$Tu$#qlW-YT9skUh-XTlJx_zQ$?rjg9> z&aYHU`i_dX`apz4h8Npz)-y57Sph)@094ae?@|Rxeb^k9L4K$G@PrgDtj!A0e%x7z z_++_a2tmra%yN!AK zQbMRQ6s*aM{NAUK6-~y?!gD%R@$;;tgg6lUxK7=89uGdDDNQC+RP{gyJ3&62bPTIe z5(f}KPG|vGmg)5(yN5Q?f3zJ|z~(Ubz1#neL6qQ&dPIzhD^p?7%a@lkN}{d5@&Lop z3KHTuU5qf^1x`M%?%J|&D9A*sTNax^8^BRPpEeNV9RB`KPLG?99+RN?P#PI65+&C#;u^*0nOBa1 zN3=t&sGFT;THH^FHR;jgbBbNKRtb`D;O~2GZIq{U5bEVBY@!;}lBF9rjyPPh%fa8a zB!6JAXBpT9!*k)Bu#Mv z?_hgy2gFWuCQtU7xB;$9!xRAtY5cpeqE(P>=bj|!T3l>==;Os0$rF!hH^?X5=@G#% z?Cuajh-kth*8fOSAvoH7@+-%Z^K?sI65x zN~peGLMCSzJRLu)g9G6}!R=A#-VT4oqIm`!WZ^p2e6Xo_jknLaoe=*=VWMq7X8H0W z!iQh**z9nUHU{Wzp^YWPI4&)Xz)@n8`mu1?TjDT|IWg+{@oo8rwYi*^3EaPP3C2>M zEks-7c?dnvT0|kt#AlR&H5lA^>Ba05^v^R@vG^`Vcp7Sfwasq_`p;Adk6i=EDs51U zVMjNSI2BBC&p?85Ts)@6zq>`XL`Ay^fx&f3-U%_CzdMJ&3b{; z6_}ZPN$2QdRk+iZpy^(P_FmPpB2HHIBBwZaw?1OQ5(Qkzo&WTmCO%}s_15b~{EQ;W zz&Bo#uXkG$_QXMs%(W1ps^#5u$3%`IR2I7KXb_VTSJ;^UBF)HidNlJ?h^-1IlK`nO zw~nT9Y~z*}A@Z|V%{h4R__EZvCFUv8hs81D)hjg^yY-)B5Z9wHuGBmZuj_8G6DgpC z5L-^v&Ao?O9si&d>llSqN?PkwsVyN6EQV>${#rkOYd0A*6ekWTU@SX2=E!Lz!+iZY z6hfFT{U@iMy|+EsFs6H9st5t0G!(t_Bx*2FZqbTKG;D)jC84gyIB*!jc;D84Y7Szs z3=PL>d^}_0%0i=Z^4j(>(mUb0agCgF-0tClX@-wSm8B2St(Mt(DAe7OL0P+Jn@7rG zQeF7;6+o!$lOzF>GK%t0RCHI+IIPfJGCVHucTb-|o(j=^ILPx`Bbij5N`lYuEG(K; zq%2JxeU{{z>_bQeu?@Qq^B31Wn}e}ex&)sTapadyvRt=}$(Rff^hsg4$MFpf>2DUv zW_O)hx8(t9OJ7<&BF9)#LmcFEl>LXPJx&O@c8n_vD=}6<2Xz^N?CM{0{o&2kIb4kj zPT^!^BN(d+(9mEMsPa}fCYGf&9U;C zfzm--x=6`i;*T^Dk~9qT0~gi_k_sw!=fBAZ;-fOCUyz7lM>>|ee+a0yV}=<9=g`j5 z=gc~Hm*?o!4|Fvt9^Kx-LrqlZYiGW+%~&Bj;OV(!VIRxRX?}{`_D%^#Lp9rL-PM+A zfEKx+2{=%4Ma=$8umeTa`&+!HW{)2B2t*>J;46;g#5t+RkG-Hj>{jW5v$5q>B8)#! zhnURJ;U1q-)l&eL_<&3h;pDF!S)i#R1R`e7X*J1DrP?@g0l$KfeS}AhspQIyF`X8H zo>-J?STTbLjx4}Dn-`tJXh>cB_SD8=CpB_2)ZX6xPKsP0njWwcH3s-#%oRz;dwh;r ziXDFtuhkc!Cv;nm>9o`id#oPa`A?^sk-ijub8e!%rv$@?NVDu=^bRIQmlR=g`;!(Q z)O6U-3;xPZd3**=Y-7p2rlP@EJksfwi)lt&!V-|@9*&3@0gtIC0o{dU3^^LtNfR0q z7xaoRcFx{~xA4QB7)x{7H21lSEIB4H6OfDqZT(A&= z=(mA$C<$&y01Qa3n*xx802Yib8fKfb9J@y17x3%6jJYMAON0%6rx-jRp9inIqL@=@ zv$xDP7`EtfJF%R|WUt@W$1m9D1)(fZI5tID$CoJJnB4w;Ch4yE-46>Zqt_>3nz0Hj zG6RD|6B9M#{&F#{fy0u9LeXiyz-gR~>bm>ciK1lE4je}C(HFhlI<1XJXf+Og^izhK zaenR_NFZ^$mp1XEbC;87*5E2+06076N>tATqs>43rGQE_eP>vPK;#0EI3D`R`ZWb+ zlhdl+tv|Hqu-#j8+sbGKIa#z?PF_@!<6wFbCN0$KG}vMfiLTEiV}4S~twxdm6V+LJO(6D~8;>41?MlEsUh z*-(mh!OWh;$gy|CUeuYaZ0sW0kqU#lQ0BR&>rr>e-j9{|`UVS1bujjYAAuw@C8CxQ zqB7NTEEuX1t>4Bo*Y=tcLO%@Wg#&b1=hGH*JRL5qNN`)+Oi0Rw;X0|>=|iI_+K03_ za=Qm)6qj6uS#?asN=`(17ASxu5a0j9WWz98ozLNB+c>uVv@8*0&ZJBh$AaZU(Xr$d ztKN>D77$@IjV?P;b40;Wceg|Lu>=3|{vunWVGn+3`QZX!e~A*#En0s>9@vi%gkWu} zjRyIvfxAzWzDQs(3twIW)gAnyII1@IM|Ocll_ubiMXG2TtcitviKz?|y4LzBqGX2x z&yJ@WSx_d3a4p^?hn%$N7T7Zz{S_oh-=vIoQfvAtaPG!&U+Ff*d7*}+6o@wBGJ`uZ znz2Ecpa2^iVWHo}xV)!dxUj53(!S^;(u@jgX7x*$kuQo4Ej<|T6K?X+=--Q|VWMqi7=N!A z!l6=kyPzKY`=jIq;_fn0YaY9T*u3I>7cW`I!==Cq^v3_>o&5JOWjU>SZP21F<~v&s!qCmeXCoGlGSTrcPSrA%dOfMLOSr?e?kE6Yv zP;p+cmD}FZIV-}7(!1rIQZQ(^53||)!ItSxf;6p!fOQx%Uj6JL!W@a?*_;ht4gGll z$yD3ZphNgdPfDF)*VP@+&emzgFO=nAF}j++$C@1dAOs5Ka~FtpNlwq<0nHly4R%|^ zRj$M}3|rL~>rqcRZs6o}d^9j;ZPQfvdl_QaHGq{{N11QA_N&xqhv$(M?YJv;&I<1p zE`pGh2M7zAW}!Z-6yL zmI4?|t~oiRyxyAOo4$L^y2Ddn~n}C;RF)^Ucc8U zDf$2KpiexXUK#cut{PYp-n46wEthwL0Bspj_d8=Qzv*&e;2-wNP3{o2@FIHrhWDKl znWtA$I3ciRBJZY+{T>WN^&R(~lf}XlH$+r16PDS!hGAg!PwVda_qy0Got5eAbfVJ} zvx^)KnHZSqKySK{Ox(oZOv+{p~aG- z(2E#t#kQ;WyakhUM6^vpZ=;Ho;PHti=qcN4tS$t6hsa`eK(4#UIvRYA&9oK2PIj`m6K4~-i#VM;mz_eLE<|?%#b{h5 zG8l22A(sJ1_5u_6K@bp7-FF7TBTT{}i2BghP4Kld5b=mUr*Q(x8HRB%_VXDLv~t4l zsCtmUO?*`Fg%y~wS!MwK!S5EV0X=dRh2`*)=A^r@ zY~$p3$R=UxG9uZJ`TyEWQ!qC~uyrD%F%lRI^6GS`oMvny3-^T|OSA(Y>RmMMnWw`B zP8Dvg(tu+M$WNoR9%~|mmq=gcpJ*M%iC4=n zauglD$AiceV~6wTj|>^sHAi1lE@cT(6#uN?mLVU^Ue0Eq$nJCC8y}Cb?p{ zFHLTCT}X?Ij@Q40xjUc9F9JH4xqj3o{#@HeFG*#rTp&-;zbXdLL0okA=;gy}NBp&$ zmye8IFF>iEfpbH1@OV6s2As!2YjD57 zX#X~B-#bH|0Jr0ZAOXj%?E7O3#|C$caT0J`WA+c{oiK7@_5H;>jA2fu$y7lb(GuLh zX2_(sJ_`-rzk`)thXG}$R^XU~=rkW85}jABh2!TYVL|X{V?#dl+`SseE`sR-VhN(W z>}G^og)MtSG!6+vL^f>a98OMSl`E3EO4I%wSsAPafP9G3yE{ok*P7O-WJ z^FPCdBUogNJ7uC;lpWfS_f;X`TDm5pE$o=KhWh&Ha9zjz;a}X7EaXPp0Aq{YBlmB; z4fy2C@pB_E)EEGESCQ!l@_e@P=jCbx?M(Go5@jjtKZ1fA`K<(yUPG=J;{sF^2t#}k z(&Ew#Kg;uhqkpSg1)Q#w60`r_{M9NDys-htbhoV}=n3fgd=xrxPEYlfdryU3tOE{B zkEIqyn4RvK8|Sd2c(~m*k`Gjg!K~?9lUU*0@XV@U8B|sn2K#V1yJ~FATSa{lqP8_r zFOS+<+&O~|&KSg)leCj8aTWq; z4?bQfEe#W^sabdBJ6t-RXL3%TdNwSi{sZengk!_MdBXT}CgI}wcXx-g|BEpml;7ie z)b`t}42$_W8~l*x&YUijmjSosI+17`s28q~|ADtQcGx_5f9e8lMJTZaPB%OWb8bZoc-Fy1*mCV%!fy4vYk~LxJzA7A70KmUY^h<+tAr) zu$~fW(IprC#JMaBGf_bhNnwx??k z)VID{l%1)$4dish!Gh${L~-%kZ#!#j#->fel}YQA>Qif{ce+uC8g`C!VFThqFUfNAw1ORfqXvvGF zu%FtPu`#xxV`~}K@BX*gYT&snG3$~;Gc`0&0AzPyvw7#O>_JN+i@bh*!Dny<0>#CU zizDmn`2_*D?8V@L@Uh2!UbA?(PKLLcR3MVL#IhrvxB?-1l1izqq4QG+rDRFdy9ag} zsVO=Rz*PJ*)wVus?%3pTH~(~h`ye3ixZ=<(fOx3499>Vz?{N%^_LJOWC!8=^7CMNX z8)M!uR)z4pcmOH-z4f7elI9I~oLufN5_<`F-WwibBZXJ(6iI=SX$rdO*3{a2i zVvPkQ#NA?Nc$Fz%5_7`uyE5tktp=-Uwi7MB(oY`aJ0m&3;V^+ikDVA-D22D)9m-Ul?)k03|&CA;lo^rYf%G&Up zy=*Ss3Lmykve(z;xSuro_ntvaZ{Lfxh1X*H4ZzBF6kRQ>p39n%y)g}OrZdx7YYLzQ z`nrm)Nnyhu5SnUMm8kld`~K)k0>nQ+*Hw%4Xw?*hCQ6eQLIQ5U{->~f?02WzGG6+4 zCXOnVSAr^kplJW`nh~Ik>C&3vd`!AzU~?WqXjVV{qg;{dAM1NLh~wHY7TSnmXdibU zbdOM0sK?*t{eefiM(;5l6|9KG;37DK zkzTnNM}rK+3QgpQtw?2bErS?% z*|4^Xbg_+hbx-UE)hHEk+)I6qXhLV-Hy%gL2-tuI5~K=-)!XUvKn3%n6W(XGu!NlJTrodBB?N8KohFjwG9KoXExnQ1zvNB3KUsFTFH0)s{H_4PqBo!d5$BVg zxYb!7o2uf%L<{uUk_qjlwGeaJmm<=w6|{;Yy)0W{TyG$ot!Hs2HF%(%HMmVzuj86y z#5zh7YJZ)%Y3*gKorAh=!8R<4^@0kfuX!dGce%Nt&fCM^SEMZSlvv+%02@;(^i2s90_MqrE<8(y5b<`JlN+iqtk{39*+#lEHmy zyzUxh!#|Aru3|?VHx4dK9SxPGO3V4qa1|d7PwD#!R)efFnD zFdK~rMTuONZZ$EkRj*O|4DUjO?VnqKp&{0;rRB6qxk3MOE{q#zm;ie$YQF{Zq8<1o{O?tR62)VUU8~0?t2Kp zsYIEgmjA0sMpf zhW-lehx>Mjc(kt-xISdozvR|2TQk*(iUV-fzZ>*`_;ZU+IWDc?14eFQ9+VKadDO^X zXw)xMhJV4a$okbd`E{kJF?d21l?y=@BaAW+;PvBex3ny0jhg_sux=Boqdx*BHg`?# ztby9Kc_kponpmhXR9k=9rcyo-W}b|hPcT*bvP!}?p~g23@NBz0%Q0#KR0+t$ImDDo z$MNeHfEn=-1Cy0q-^x1Ko)L;H(hl}4p+gm)E7Yz|lbei6*T&y!b;3;vfWXI#sOD$p zuU89%B+)525@ijDc+nd}P#@?wYjnpEY-<)ZeTZe#KKjfk=7m#dqaqg4X7s>RM&5`G z>gh7HWCtwLoId7rnICYcNDO{yPd7&#w*vxBaY!V^@I!!*lNVj(TP1JtR9f0?F) z6y<)ix=Y>>(I)?LvxOyJZckN$m;`6o)YAOlWJ1tN83s_G;W#vzPh8Eo3`;}A<3LT) zq+gQWQ9Rz083|%e!M0%Y%|z#@P|k3(KBJ$DnVjR_Z}(WM1WcL$8y+jT!CdkVd6|)* zf!%X59=u4FWg|i#lMhF?t>_u9Lo(&p-Z{H@bZvqL-vX~;f>k16VMf&ONDo@gd^FMQ z3mbc~mkedScSD86X@tkBCuAd#ad%J&>J=Gx_Cb+g&4r*_jsp^ci_{yA`y>euf`MB4 z+jKIQQN6N03A(>T`J+c4F%$13#l2&6E8Wb9l(`aaxfe_KK4`h9s$^VNmsy@mvsu~O z!X+gH0c0B(YJDMmB^#4 ze#b?88AQ`~BjWwkMY66sZ5Q|hphi24U$EH1z=E-JdEK-7vTlJ#Zmxt zfzb%5L4sLMAS7ZwaBAJ9N2`xYZ7NolMEHyB_+jKKm%vDoKxyZrz1@IEG9`Mh(LPLW z#m|u#$KrU1E~kt)?%&S_3ek1Bwz=(x9GC%-!wvI5 z5uxYi`fKV_&-NU0Vx|>9Q!zS~q4>`!I8Zp?7^&{Fu#bec|056Sx#BMkQxF-RidSNvkvpt_GpTr%~XaFssn*Bd8(o=x%XqY${F_f0~bHI)j)wM`dda=%fvSQ6&-1tMz=gK0?C{F z%=tOe!X4W z0tbT!gpXd~gL$C&>FN_A)*p3Td@6hgVzblvuY4|y#fmuE(Km@51dH503!*cxss63X zOj?ni@ar$MGI368IQ3-*R7@O9M0zX_q*QQBNR}+TQf$1%yK$t}9TmetTA9ev1c>{m zkVuxrnQ+B_G%&*(Bn-%DLvO@Zdy!_velS)6vhIz{bp(`(wqt|jic3sQB*aLZ5}3AD zMf(j8v&$_=0vVe^>$8Su(yLerIAC^}hLa!^c#fYq+x1+p&B+q)G!8{49c4r7FIC%W z?|-cldBs?!jAiwQqk2ZN*GB6QwAHZ>|9wIa%B2ph36q#Q+k-s&@OQ8(GdtwcHa_y9 z9~$_lzUup{x81bOX}nVcI=Rz-1b$L)t3NnMcG&aVVllX^AarLCCsK3Je8ue2qt_OR zormsCsDitW`MRr$tVTvXLf05 zb?@{F)|P}a)gj0PA*?+)=c62QWHUbY(JG+pi)+UEMgt&op*%t=9*;mf?CEA=4OG5Z; z7?(}UtvAt-JW;U#;)UDWe(pr8du(?hXQCa5(c^JnHDf|!)==nWsb7=f2I@nEk$Om| z5NUMzkeDIXVzJ=}bf$vyBAd(nR%-V|2~8!jt*uXDyRtO|U^0UBgWKEezQ4dT))zE2 zL(OQdg*)}eKLBUP7dt2bLIw5J;91Pmz;>K|w!#v9zepU^3ON5x>&hZ(A?!#K?7(5) z|4#;arkk47^>N#5c11fQhL3GsICBsrm|?!xv5n;Ci)7Mku$TQY{!+%9|5+SolQ!DK z=qh{2HW-I0UtEx!UvMZglAJZg6o_(8g`c?h@Gx`%RPw_Ci%hhS$IW@(yX(-5^Bt)E zK?C4~W$rTDYmKW!MF$xkWG-GneV5DS=3tZ_G=HwmvZgH~GQYg+!9QPmN#w1&bm33I zeo|#2WM>>R?RT)>x2oUfXeXkw&?MXjV@UDkJL}f%MUDNga$BU$$k8(_RNyc}<*{GD zUrKm>k3tB#xccxvT*NMW{F( z0F%r$IyCFdZC$8Ck^!DUIN-Pdq-{!@+JG9-jabczgiZgmGOYC4^o+*n+Rn}f&A3pF}CZ(@ak4K2w5pV1ph9Xvxoj(>>5Ep}5=*=-y zEEYwjs1!{p^iR}mU_s}Lt5a_I;{(N#3G$7lM5+Db6>j9FJ>ITyDNV^hI+hOKOrinN zh<_FcmRNLYi`^ds^F4OvKlHUyFzPpeJN{pF*fU=CXb^(hHdb#f&3YW@#$Gce0#^7r zz|D^a?Nl-OpFvCbFm!3yU`=S^#mh(ES%7aq;q09H$3SU6SKV-J$`W#_f-ps&t4mtY zc>~UXwcwaE`G32GLP17ytSLwe0}DMUw&4Ic<=5ejAbSVt@+xvi=tgD6xJQXb_R}|A z79FYxCl9%ZFDhQ+y+RVolTF6>UTBEUn&3Wyhs*qLHj%Gn@*LJ%1oS;oy4rSFeIgd<}J;uz7L8IT7KLK33Lim6$ zQAj~2%E@6GHcRz-tU!M6DV=KWLmQt_A)3+&e0qx(M>1IhDi~Dp#ErVxB%U8CAidmb zLhi`3_v^NA)s+tMQ!-tQ)OPHZ9?&ztSR9SFTY=*+gDCEvaWb-~uM?D*Acx!*ckOJ2 zW%z=2d87U6NzteP+JzTACP>EXaSATUvQ}ftE%q=xGAwT2{srozBT7!4@2wZidD_7? zKfad(*=_~R_f5ZSibIYX+5 zy!@VYEGvE5(3g=}LV6PSg^Q`tGn$TZhQR?Eu`yj4vMvLF*-whG=Zvh|XDdF^W;Q$A z>AE^$y}DzCh71~M`Y#cy4SfrK2yoHq7|n5!M6lSc-Vly<9VsMM@Y2Yaf>BFOWqZhH z({O0UI?fj*ig6GES(ggF~9atWHQLx6ak?M(6oL~vl9HU%ZP)?wUgll$TEKEQ>EBdvTchl2)3~} z#9K-}{n4u5#4}DfBBuU!mSP3!*VQEm6t$OQ(uwE&3I@>Ee%JFE;+>ZVu@g5I^S*5%zTT!}4mET4m3-U-`+|N`|&Fvwsk*>)heP)G5o#4Ir7N4Y_ zWT#^I1v`)!!&qnt9^rxkJ-7tnHM1~c+c%6lOU9>A;I8AjCovq}C9U<*^V@YK{xZ^z z8@3et0C4jOj_Zc}fpxnLufxTFO{wu+nUNYNDhUjj`)tQ7d89?kHjt}17o zQ;2_-0Gqs3gy<*GdlYyywLiKE&%Vfy;_n@|xX6A{KPg5?VIU>qiu|qV%ec(GU#h|- zH{TR?{H0d@q20nXgmIkY@Fb${GihpBPj8>7U-nMyHu5^slp9DjES;gbnYVh92X+km z9DczGO7ESZ+XXXO8%!bY5;{<{-z?TgL+6upJ@n<_^%M@!{thLVvgiDG$Fc$MWRc-T z`hou_tLV|2c>UL*$rwXW`2lQ0RRq2e8DR97URax4{&$;(tv`xya3Cel_@Siw9SER#5?H%us4lmXa^3JE%#KrK5AoRA3S&77#0 z?ZUzRJ^6QiNeAd}(@U_tO(~+|D;mtG@cc#{V`7CYmEs2cGLoujgoR9&6^Yq_=$^7*mI%r+1(o~WYX7tbv zI$9|j1$0?0m9&;c+`LoGn^iKqPd9*N4T`{ z5Y;T8s-8oLhUppb##A@c6k1*?mB^i(I#~0D%T;0WHQxNcDQ{l9#t~TS-pARlGd8cn zho>fTs(2VtE_$bg=#fOrz|g4;%b9UyM3g6FHfQAI_ET;8XbO zN7|?-o(IWna2|7@mtcF1cs4nl&Pl!1>B&zo{i1x2No05QFnGGTFEJ|iK9%}3UbN|4 z3$JpF_G1klduw<-T{2~%j?sWZTRR#_teung)@*U=E{k|;1j0d<>Ck-|YxQ-nrX*5B zBxA~V5w?m&T#luS!9nb!$||$}Ii+VTQ+Lv_|nowLefn6LOF`6F>*!-)z0j zA;0%~d2lc6OvL&hcSV;ukB>%}y30D9c17Fg+04h0&lY2|R|Vk27ZU-vQHPzFOOf)} zJF5(G1R}tFun+Yf8HQ7ctO4V7Es=Fw5uY8eb%|oS#|tX%lXe-Wq2qdb@PpxbzL9`8 zsS^_!Rf7zEIBX3jT7Wqjc}2wIBhb$Y+l8gYl!f*-u(6$;_5=DpDA@OFZ!xKcU8MR$ z{Q02JOV%)MH}*i{NOBvU4}&0yRvO`JJoa=B&Oe&=Np-g2kAk-tET&MrY=poy_d`|+aG!ZoE|_c$}?kvCTy)^ z3GE67MLwhewT^gp$QE|XNf)ROcMLO24$0O`uw!M222sixZ_B~A&-~Vb$!qse9$LC< zqFleQgoK0K^nN!BX~sLo1_|?;fzG5TQJ<>SukBY`*|)MK6j1{}K{(q}5TjF8ow0p& zOnMXq2J_Rl(u(3}-#_6&@(i!vO4c6PTAcTI&aMkOG&v@(b=pS{=#rtQk18&85w86= zrJT}dqx;IK0PoHe>q!vT4fLV9)mAManhy7yYFNvWSRvrw8hV{19 zjD>lQz*Hx-g}v0=?6D1f#s(=Y>W$W%Ja2r)EX8A8D0eOuA=(0oS^MKE2E?+@S}Bps zkf}cN+@c@eYTMHEL=xpV;b{jx!+%9v;S9|76ealZPU1wbr_Fe+o%DwM*8JJ)^{s}B zuJ_P@?US{6Jq7u}_!|%o4;CWgs9(_H9DFKYWyyjJrM_B|?M_+QVCI6~s1vB9q?NQj zkEZ8kYnaTI6+c3b?VSI=sj5a9=oM&I8B8O)2?C;;WB~k#K?P;$0t9dfgA3oK*1x#F zwo<*`n`^-UOcEJ6Oq*E{+w~LZ4f^nt244((`&@tQjg#k8Z zjvuj$4b#&Jj=f^6h3Ilq{0}WCCB>KiIVg=yO#=hRmKJYLoQmGg@cg8n{eDE;9hY+JyYPdgJ^*+bK+R>+@VZ(v@zC1*@cdR zo@bt`9;~$;!A=S#&c8B;4ytm%5k$8KfmuGx4P$Dlu`nfgTd%QBk3yt{fJzBL`srA8 zGx9up;Q-n_Xtqdp3-!~Ugfb($KW!pByrY4_21f-h38;j12B?GEMN_7JZZ_8RT3}pW zpyUJ|yK0fe@dsd`j{_hZTQxZg0vxHT^Q=}Fc=4YPVNFuh<^VXwSZgd1Z$vlSEvKiW zWa@P78%g`q;Xa-T`JZ8B2se5(MdTZ%csN?PSf;%7FM0z~CvUaF)9kvMLLMV^4|rE3 zqx%A{`+grwS$Hr8dZoOrGOcaqhuFI$0%&4Cr|4X=w8><42;))3at#|a_r{6K65~Tk zJ+sN#93nNm-&94UwNC{+C_tKY9TTwTh@=2+taNvyL}d}jJ5ij0h!ijDMA6V-9Ntb@ z5}UO{LKU@XmIe_8ql79L3OYBA=#V1qw>

      @eDVdD15M!qIKhOmB@{^IZ}(9gt>|W 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

      Hf~6Rh3c< zcma~SFkVvU@{in8hxO~tg$S>>V|_2#iy|_~zwJIRVYTr}g5B|_#j1RIc`#x=YP?wX zRhSlHN28vCJlVkb_Ke{Y_O{+=8ph z)NdzB1OE*$G0N}(#ekphE%3gUL<7{uhaBe#UIm6?$dZ2))uAEgrvd{YLp|GB-_PNS z@3Y?ZIoufXmQ5lWgWV#y*)-dB&9?aw>{SR*>`wum#^p$eJ0#=Tcl zTQpQJmaI*e!&GK|kCRNvkqwC68O7pPvgJ(2VzRG4Z)I4mSO&_}jo>r!=bx>>z0099 zKl+&k^jlB3j!$Yv!E3#;Nzb;(Y+b`P?GOVjYJ3Zj6*L@KUJL^OnP)bT%N_52fs;JGCb*i=G7iUM22yP(CXIbqQ4$iOYKf^7a<`82e52!N z{nR0-)m<$`~oMgD8^jRfK*N& zXr(Ed%>u|sTB@SI>J`<@5HN-**!s^BetEK-6@!@9Ty7Mza}8x{BeT`a{X*7mVBy{= z(iYVjahI~1Z8%wvSP<;Ahivtz2IKmBLLg_2w5owHfj^kXGd#~?1GNY0dew=)x<e&)QY4jFwP7f1wuhG{FT=Dr@W?ou81%EaM#k>YEoI0&+?W~4P)hE^QWe1 zNE|aKa~ko@_FbyG`0*t%t(as)V8ghWDD7TTrYPV&!x&qgilP#B< z)|=!y&ZZ13kN3y*hC}-2Q%)=VIVw&dGwK4z?jfu-UhqlRSDyRRFq7t~ia64TXyGzT zQxj+qBgspcL4;c79%s6zx6mjut%T?)K&!91h<7*wc)mK>ZSdc6S zON(A?i6Z^{K0r8EVtJG!%(oY}<=cX8_jR0I4sKIBdvKlj{xbQBYuB36v@EyXxo*58 zLEGoolSiLN7+-w|P}txji-0&i7vCU;3vXX}84s!XwIZ(I#4TpoLzC8t{A>wPHt3Xe zHQdPcO!p}~f>CP)kFkHHrLAE`O7gbieFfopYr`)oJvtzhPP}lxiePj=^T$xi2*B4g zi7G|YP%6AG`PL_2`zM?u!1vxKdJ5)LV6g84WSl~K-TxOLJ5))?%Y>+jBkuLp5$}ctj_DGxGK0uAqSH zzzf-*hwSlA0t%bP3_t+=et_TAkR^@cUUQx}i*=UprCsx4yfl02k^Pl^c_{DAfj3iI z5q!S0*SO?Xf;i8jIXyLu1p$lhUCeipNY}%;?jFx!4Y~I<&9pIWC^aG`l=LYAZ zzeT5W-+q49od>tXvZt9_j8WO7)e8JGl$q!Lyl4S)MajE@r(SAQn!+%<2TR`-^a$aD z0^DE{CaL&Xj|#qK&H;(Qpz~#23t@q^D8$6#P*XfJ`c){p4KQ1(>b6Mgc;Jg-u^L@ZJ25-2k!T0eg}KeXi|fhwete-go} ztkE{Mt(=CDAnYG=EKMcthx)>RQX#bQlTD{>vtf-nBwG|I>SIcgERl+&c8wY}1rmX9 z=aIDC_|Fm?YD4Ytil1LgX-ac?f4elUoV1V(#7X+i22SUVGDK8`C~$N&#=K5rMo@s_ zsG>#fxwgVVZ7j%FMx};Bcy=;pgK0D=8$Xst%m@reHa6(Cx~V{FE1PM{VGCp7>EC|3 zA2+=0`xtU8c=#0RQ-^X}3-WP%H8y8=X#A|;+cFCEn|Y?ojd^)uy}hs!g`WUVzXqP)DL^}y^DdQ_&kkGT&h!j{4Apv=Bck$-O}7?Jl- zwfLXu{o;lF8Ojs4ZUFXGH(B^5bOyg5wtL_8nEGzl-Navw3ml)3AL?DfgsWOb&OTiexs z+C=0w7bWC9#!!$j{4fq-Xf0;n`Y8YFi!kbb8egO?JuJ%}|C7oHDl)(zi^Rsa;hWJK zjL;c$9WAVpwYTbB>(M^sf-{Psq@04a{n3at-EXjXIpkTwoEx(}?e7tNRuivfO zEqqUG8q!U_j>i`Q`T4otDMg-1`)Pz*BToM2%wjWCP_?V#kGXEH+ zvPF)$@NW<|8`gFBhoyd{YSz5z&J{Z%g{UfzW!dUpE$8-)zj^rXkb-avbnL=b0Ujrn zQos=2PRj7}{T#&ryAwV$m-L*yM=f$3fq~#d;I7|#;dwL*{4Uk0fVLw_7yG*P+y@uK z5{szGpZrYDKCO#AJ!B=gZIu3IcRo-+sO``3KChdY0W8?0Bj!Eo3irJVGE(;wBuq)muGkcirvPf=mm)=&wlO}PcbLN zQdgm=?tERaje4KciG#Nk$K;rHQ{q+6m&OKy#B9H*pZG% z+d*nPGg*>_4;Vt#d!9VHvlp1r`>y)ZG&ii03j^)?ygeoOTjmfXN>}0ooK{Vaaz^F} zOM#88MvcHmVAZJ^Obl@jPPLcrTfA>vwV-+b;TUML{#kIPqptck^iEvaqUc1=-bo>x zE3lbi%8FuQLG6@!9#U!+uY4?MQjwUA2U3-~iDGS$*B&P2uaD5^kcMH1J zXT=aXaCvN6a5KCf|AHo@7#rTm_{Va(;Z2(o)_H!82<`!yG*=Q;J>*@iihA14+4^5+ z<|i5qhzZ8-+fhJ4#&CrL^0DlF%D~{aO9rYty%i3b47t|;fxLFQF6S>CLx6(61FS+3 zaK&$Sl68|Q;CaZg46kP6?v@=9 zL#Q3%bayDIGH%|y)~nNs!|ad>Jq%~9Lho@;vj?js5r|UV;O`!DD1pKkb62=J)q(BZ zXsEIE(~6Rns0!dG>KvA-qE!XUtAn_s_3EZ9%uTg55429Or<`lZ5~vEw!w2*Ens*RE zv=hr<+aL8&rRi9pziIn*+Ru?Q2mNPFoMuVnkxP?PkO|bsf8gk(W313+ZUBqxOi{4!|+cD4Lf$?>Ifpt@6HW`j(u()4b<3fg` z(7gwNRh%qFS|PdF{33!^QQDTS$@j2IB@{FnaJ=#vFr;oRxPI`Yj?8H1v)WH%34;HI zkXYYpa-{Stkur zz7uJUL@MDC7V(#g7!))4{676cLYiM1VV1a?mgD3LK9zBt@=>;OPQ3%pqU5|0Uf6;#58p}jNyXX> z*t_B3E0*eO+vw3R6W}v(7zD7+ic@k6)8n_8^Mk;gDb&ZTxEPxEaaZj_VP!M|2=Q=(G z-iHnAd0%jk@NfndLKpH^JP3W2+xEtw0RsSbda!(Xj+ZEv1@H*N2Gb?#Yz2vow2izw zFIC`1UjjC=!^_Gki1Ce^@y^jGz5yXdI4N7!w+eB6S?_nieb@KVm&_s zJnm%0TA>V|Ggpejyw%GVaPUu@B513*MLBKow4L8_-wa@XQ5Ws^$_B9(k(kBOd#n&U4C2njLRyI7> zZ?Nnw6}Jl2v+SQ`5-VIiIj;LkkGtMb+B~uKipsDhqBaufh_iHjCvt9MkzSOw-V_g> z1oFw_4ramvS}DoqRs6AYHdL`AUn(XYCti&7c{_UwJw;wAX0ZJ}`G6pG0hs*Mx_Y^4 zM(k5akJ9#)ihG?8>#aqsLbU^RdGnE!U3E-h0P&Z*AMQM-3tF&4S>8AM6gSjgZS2=u z(&h3>oG5D~*j_P88^Uy_O{-5Cfg88yVBoeK+5ck9Ln4eF)-ck>nMHg;r@5Zd64O{( zCGLD7AA!a{X#WA6tQU=0Diw9h;Q(lChn9mvy?}pQXWz&Ne7a6gFwSn z<_4Rzz8ERG=hTj@?;(t>UyR#=irGbXx90@wP+xg;{_DG>tJygDNp9-a?29)$2|^Je zPXwlWeO*cCr7Z4C?bPL<3kp6JRhp11@Se36t+EmPy{#=E4^VRjZF9rH1Z&X{VY)OS zC1OIDXw>pk`^=%%ilBuV-jg)Zr*ljHkppoqk}C}f;Teb|KBp)jm3jQmNI0iH%Kc?` zJze@$QV7gpk2z>S+=bMaL~#$=S%ES0s#>eSO+8bb#YKQsVavHgfq+L*m4(?o?<1`c z0c!ZO;yDc4!vdD=3VHcT*{E)A)hx(LEA7nZdLVG4HY@02h;23L7A+f9LWH87R*Wlq zhYy33sQ*BDq~5zq0srESx4oh%^VpoR`}<1KCVT}XDlna#iH)1Hob#jR+?hG1WR1%^ zqpMM@u^?_^M!bQ*Bko}{ip5hH$tDNxCDW`)mX-aq?zny&rz%SB2SfD~=4q~w4e=b~9fhpnu;)ew#yBWfe;h5A-L9NZ%086X+NurFTwn0eC7y&6H# zViS8puV$?(!rB-0#tO~)%3&>(^2)gv@^umDCr5_rxFjwJvy__6?ELrL1ikVoLNBcX zO#BgMHZ5AZ)&0Uw^nDD?_AB}ELf2;I6)dPqWzxzB3@OXcUR7f;`d4}oU|ARS;Zou9 zf$N&p;xCQh#NHr=*7WY1%S@LZFl)MfrzzvVRga)Yb$YLeSr3_cCdk&n;a&UfMHySz zQ3qogEd-=4);D5rz43fspH(2LRMu8EV5TgUdWdXNB4d2upCI{?!OlofGe!<97LfDM z-}<|b?%IVw1EzSaYttTrHD_12#t7}k=GJOWnH$kX7rWiPO!&oy(TIMgT#OY(c%&j! zU8Cuw8Upq}{9^(PJl&9}T@p|MDzVJiMAe6*vIejWt^EnN)OHUwCd@fK$wF126+!Yl zT$j9#b?Jg8*~J0VW3?Bi5AvrYH=b5Y(1(IJGFCD^v$ikM-rd~M&@eZ~$n{_{DXsHo zY`%!?p&&P`v>csw%iYGT;HW^2#xh#hCE(my-mW;yQ6KTC8f4Lzc z?Eg1{(yRCas2-%x7j8ji12E{~n*VOYpXku>$_B&Z+h6F$SmMdprEN1{T-A50V3Mi3)53hIK&OVy8$HlX*je!R>{|L zm%?HcHjW}8!X9dFvDm|`tC)v+t;Tc-8CO>#S}mT>E4M)zBEjV^&##oAGbS2UXmROd zYRx$}@V$O!rkW;mRYm>>J~hWFY<_&5);AeS!|gv+VV|HL^>|2q4tyt0R5xpH56pV` zw#BPzirSyg!14 zPp3@t&{l|dp{qiRsK3^yQvK@wMrqQ3p2XnGljD1645SOdR%;q{K7HUZ^M2;(sTsCl zcQjOQuaR1eH;EjnjOAHOzn;N)fw<4`;KavDu`6Io)&ra>#QsDpajBwWAfM>uXR)e# zjY4?h5Mg2NIA%9w&~lP=%`*f8i$@m4!kfVtPDj!CL*(aJ7UGR3L^V z4?t&`$XZxkB+%R0*!u{-pDdbG5W0SoIj)8Ml{F5=N(}mlU>y%5AS^A zSnOjk*4g;Av6@>Q`mn!^SLxX8CJZyW6m8C3-J}~dDTE8-=dzd=h579SR5snPyzD)}M!p7iCPR!0(HV%9z0GeJc0Q5f;GXk=41tb!p%@_S zP$bS%vvzRn;h0Wzo*Fn6mb3wroU)~bB#7T7Hp708**V(^SA=bYWddqYt%Bc8Q3*!C zIfT4%Lb&_s`_{c!uT>GOh2?tZVJcTbGN7!xSnrJi!pVkSa@#}5V z%^u?d5S~$uQ1BWR5+E^u%i03=En$ZtUPl}Zl{@T}UnQy$J3RJQj-1Gvk0WX^ya>0o z65eOVy}%u}!b3@0=Wxhx@llF_8KW9L=>xx;!hN|X|gnQxC5B*j&X8WwX^DM0QaSqTHQ1$gN< z*VNvZWp_Bcx=J>2*y^^T8e$D$Jpe?e;6$n1YOH9LdBamuaAn#!OY0_oG^<5FVFwkeTuUV?@B;_9o|gWE_)Wvrzoosn%=}58 zvlbNfI~tM~eFXCm0ZW${0LFxVF;$lZp^uY-IH$f_%w0u44^}IMkY5&kNV# z6Z5dqcaq11F~5lTb>fH`7Z#C8>pkl;&|gHpjiErkYc*Lr-flLa|K0eGFiy`oh;8xc)`=o%v3NJn3;e<+Z#F zDy$xVlCon@MDwwlEl*k5!V%~`8)NR_psk^*k|qc?J)S`mP88ch(?3KP&*f&!LV-v& zWc}buYvCDw{Qxov4Y@}+Osjhy4-!bJ%rcnBCPRd5pey}nDSMsmx47uoOwd!dGWnqZ zIULnTL1Z{|cqQdo1az6NSQ8d+hzuOE%XlqKc8&OyQ9_?(T5w@YJ(dhtORGEmflOal zaFWk$^%>2!q+X96vd{A1c2O9?{21a3I#T%?@42tV)eJP*Yv#u}7=eWFnTIkd$OV*o zXEj>1j|(MuJj`>}8b9}V&K|;NSjUnU_0!=oLlN-I6U{}xE@`v=s;Uw`vRgYdHI_&2 zQe$p5`a?Omqv)wI!+x(t`kz<85=Ugiv&?=PpHxt5!ntz}BxoQFJmx-rmnTvoby%^C zU!+)cL`l#`9r`x?__)^wB!AP4{J;5HOua-?2BE12?kB$8P2^p!pjT|9f zsoJ694i6ig&`bQ=Qi(Skuo*z+IN|emP{d3It`HIFSFu`gu9e$vh~%S`m~7J&i}R#U z;tozbbltb6<>BmbzUpJn5GC5K<+0PGozQ-`P2blvsUBFwGaJXJ8Hy#-PT%%{)0P%L zukc%LVKV@pz$}Kjh$%OaSaT(B(k~05GN!wwq<#v%5_u!h%ccC?cV^UuNrShx1DPpA zi_7g2YK21U(^??+SSMFR(7Z$4trlM?LzJ#ywMO27$rA?Sm^xfVqmU?7i$MvALK1A@ zZe?=c;jTh|TO$8VGBjs!u8ellrTNp*DD4#j9%I~D*#_5i^&OZgA11kP*mXyqTe|Ar zzqfM`f0k&^S0ywwJ?RJw)>)n@Y>6!TwN9umV!iWy?kB9joZ$4Rrm%FKvIvar8}7<3#pNQN|1t+9g{`*^SU~bJXuXGkB0-iW&q>23 zw*Hyw@;BAm+Jm|PICS1pako;)mnIpt-9{_72F2L2N)HLu@N+|vqNZzhiCk^+A@$BP zi>JeE=)1E~Ebbaepq2W?Inj6TkqvbgJk)HpSP_pi(OCIjy_ai$8poB0@hm&{;ST`Y zp?U#jeWmN1j0l$S4OsAz5_+iTmNB)l7(2Kl+(>{sUg8N{5*2YaVD=Cc5`nS6iq7+Z z!mt|m+5>rB*X3&^@jvd6XjQnkp}Id9g9WNG>Mt2!SYz*WwRH9>*I5Vu{go*Zx2eAY zVgJiqYKLd$y{g@3c#x!w#*HZ|*p23@g!~@xEYGOa_I9%hiUVd_5w!iyJa&}$2NZs zFx*^0aLLRZH?W!)_)G+OV5kH{mM<_3QCPA&ocC$X&9NF3E^yA&V5D4naI=hS;Z<{(Hw=j`CwZ#nCwxG3P%>%hm7?Ws(m}>IDB)o zVdHI=e|3u(a<9}c+9D#hbXzh|H3QbWP|fr7hlYClz3$+1Pcjxim?EdE7}uoj^Z=7o zZ=4!WPF`B@zOn;yx`-<=F@OO;5ZpnXY0fI;=}{pYsp0U2z603tW9hRge(XHWFCG}B z_})Fq6X-P_H?vbiKqqA^Zp~81)oK05Al1@FJN(K$zwv>?A5h=q@L)i~7_w(pkdgjj zcapd#9>#ICl=8x>q)p?8M;wo!UnX9zt;WAO@=ZkE2I(j>Rf$p@_8;U=S&t9J0UBXZ zW2-~N6l<0J?=rd~z_Y93Bo0ZS15GqCL{T~HfWi{FKoiuqajb%mY=>tokOJ&Ft{a1C43E3O_{%f)=&lp zSZoiBhK77(?2-`iXFZ0KA!VMG`&hS$C(%pMfA>`S?Q!DOZ8&ne67$I%W;3?!1lrb? zez+?Jr2Hv&rU+%dGS!ojd~%TSBm`r&v@fp8(-s!-p&zWMwMc0HCMl>&P0$4Q{ez&+ z8;uVht!&`H{Ew+kvQ-I9oq?965)ztcQcmA~UTzU6hsQ&NYe$DWvP(3=c0Et;VpigydQs4dyUqb$HtOa7?vL^!2 zDYHc1QGR6zeT@}vIhc3V4Ho}-mG{K;i`h1`zPyK%Yfpx0LM}m~o?b+cfIq(HemT4Q+$rtuU^SN5dc_!u-8)(ayANJu z+g!;ZoJ3`qT#jjiyXh)kIb%CCTR1-C^CRyOnR~S5Yr#N`i6P;7y4=mD9Q9udtb^TR zQY;v~0Ko>^VWS(NNZjX&^hC$`1lMKG=B%%jA+`S9TL#_?YPI=P!C2(42LykIenl}q z-UQU}<6hapuYj#G%UIx%#qCE;UE+4#{64+uZ5Xe8YoPP0PVXr<3bZ zpjR~)%@~s=X*}1cu&d4U{cCRX2c>e!IcDP;kirySsF3*TSdjZ?nghQ$RD>vo1T)Mnpip0>k@OSggBXV7AL zlL7RWd5JP8l#2gQBv3z+nW<(Q2 zijq7FiJf!w*J9?L*NsashFd;F!VCY~t-(}mCd24MqlKPAF@*?B(i(FY#>>G=@9tn4w@)7Xdk z7gg0L8!Lz7MW;@4kW@;8)ic|1_-5Y<9XRAk^QdGh*xdr+$HeEf%O=k0DJ-X=(1?(X zbp6Nm*tt2U0@FEAlHK4`MQYCf3(v6oWcEucIO+eU!d^Ft}`BW>QlxD_I&!m$FeEVvUp@R^16QkrZ*x)6DEB zjxrQ(ugC>VIL0)CNsj9xH6Ifp9C@f0g>EP5h19-$9Fr|HHMMIwe=L+NnQI50ro)zQ z{;G=83*npa^aX)lSR-K5udLfiUFQszB2&NYNylwfRdG=5@pZ}p^2}#jNUmez8&^U%-VE@sawOiwO7W!? zi_w3a#u*Y}chzr4`^ChI@1oDLexam$57}PQL_&-M_9M|2n|^WN_y+$M-g{74vPRk_ zk}$)PVYge{i~0dsz9ZgEr0NYYMs5LU<$}4};gJR^Wbh6$HAymPF_}sBJ*8Q(bNFO0 zStS}HZ92Zw>FgdDs#;FbMl$hZ3-xahrK&GHfbx(8a_G2mIA}bn zFFWXijK049qTYJwEUa084_>;c*Mlh^vURD^VC&{JO46Dz=Yt<%6ov*-)f|#f7gU)PF389LyfYS?i2lGVT(u!>mQ`iPF z7zzTC74+|&N;75vk84-cQ$+g+V{KnLLA;Kd&|;V`uGx;*ITX=d#|YzoqttY+piC*~@p_KR5hV!vs-sT2co` z`A%)nN$qDELLEI9>6L;kRDfJUW^#D!qj01l+H&2$%v}I8K+M0-Qdv`EA%bp-NzU-= z4a2!>&~>Qy=w;1kN;dkvvH=b9x%WHaYk-#kBdrCWdJNNYM=ENpLF8a7kPtPepZ)Z5 zNE*1tn6=X>#=%-&i{B>2ypk`7cLjfJ!6};Ay6{g9;4p>KR)blxMLtt(`mh6F` zY~s<_`H(8lpbb5;sw!a ?r&b`tSC0zkKshvp1iQcbIcUtXaM3E~f*nwb!rY8<|Miy$C2cavMq0VKiEf zP&qt0@QNOx(Uf3=RzSk!)x?JNvf428uN{jGA}JYZX?f9r)NLJm65Z&O7)M%EUq3- zrNGP}EL4VNMwPMT0p6!&B&EI*TdPf79mt7D7!N!68~U32T!-3x;*$Y!yh5CZ4T zxd2fF&)afIJgxOGHNP(SpVhphm=0pCj}-+{MyZcYvkZ)o&t=B5Uy#LutlaY3j>tC6 zv?i&FXqQ<>TVqr~!2&#DW0N5xO_!7%B&`MC+x^B|B0Ln+0BFsK3`pz|A6|3&zS%Fn z!He!=`hfWI*N7_E>x_$EDEvwtTs@iwS+1`dTdcW+Uxm<6!n83vuDdA_fcLi4kx&6O zPF|AEm;-aiGzYCnxa03?DY2CD59=bvC>~JQ`ZnwP6>lO&12%gQA zUja`Wl)g(L&u|}OYpoSLCE@pdjT}zO<(GCSpoh!Q7N_9TqL%^Fw^M1QuX5mH^9W=^ z>8N1P>Zx7_-r#?HW%Ghaa~|oGc8rzOc2rR42kpP&`efp+pkz5V73A_oK3{AZ)j=vF zBOV~n8%8-cgq3J>KCMc)Z<-dtl;A5x44Hwx%Hp)`E3+m!L`a zZm{&mpB+AHf<^ULGZUIX8GD-DVAJQ^YAdry=S1FBZ-ZpV)c#v~@RxAclT`ks;Rz{X z2u^i8Av>~BA#EvQ4`LjGnefgD)>kW)612Bdi;Bq87s)t8M>w$U$WnjFSNjkm{h)-< zL#w)+y{1sL1tLIL_J<2rv>p3v2l0jbYe1mP>6dQaa$Ya_ASIhTUVK_*Wd{wmAj*bfh_aNOcREW9hL8U=Wew_thql z(T!zo`5#QcER%O6XlzuQ?WJV4HK@`quE_U=JvEYR+Bc4m0S1f#+PO7u<+;d65zQshWR7(=BLa#xZQ!l&>M~cVrR1cr`C&! z?C?|5a4&D&`T>Nd&HaJjyo)M`3aSqECGBGLmPzup_+-Q2Ku4Br#zt7V7h;17|00}# z)^CAaUk-T7^{5e%qs9~m?;1QzAWX01aNemDTX#eA{dd!A#I1<0hSGCC3&a2OaObcK zYY-$bal~ZQ%Aac(_d3EHR*lB~Q!PNWk@6kM+2&edflwZsMK&-m3*o}Om7uKC#3PVV z03O7zskwrlpnQCE_RGV|=}Ge|^8G^4Y*h(en#BJKhVsWTDmTpc-4-wMMRA7GSQ_(( zzJ2{J;m#zA$gL5Ji_mtVB2wP_QPh+d!=7qt2>QNVhZhSZqrmD(6Fe=caq%{`OHfQ5 zFx9@*HTG`V6DI?ViCoF*Uh@c&SR~wGmL)L9uU(^#iw(q!+ZjMT_@f}QsMr zaRPHzwhg#e;u_R?$1LfYQ)uFPQ=22gHYd$T#L3A>~IYl?(wiD8h6kEqNyDImv=ZF)Y?Bv_6C*#h0bjyms$-xR3 zWXrfzPHX_bpD@}J5K>M5$)O{D4h{b|d5Recv`pd%5p7ZI=zPh)s<%|kA>yy1^s8aW zbAZ|VdoKPU)vikp&Q5&DVeS;_&&CJBhV_JacssYYJ0<4F!3`xTPL68~- z{~<}4kuPU4{V|n^W?xJJJ%AEA5d90B;qacnh|h!4R$wS>jP8)d zMQ6Kbf3;z=WBASZzSr<#15@@}`F0;R>TsR{7Qxah6C3TQdAE{GZP^wJsm`X~Gl!

      $A-# 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

        *d8LpI+h*JWZen`S)bC6UQ5$R-*Q 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

        fBt!jJWDOkJnbi6W9`ftgsUgT z13xy4z!2zwW@d_Hy=#2(mQhtx7D!4SAM+T_5ks7x`u{2x zeAFz^PGRw$7M_;&m}Dsrc10t~m%=q`#}HaGuMM7jM(ud7XDZSE-k#o5A_4WKCC&j4 zpK@%xTch#-X?K1$kj|4nDA}lrsISWqLcGZ#UxYadlx51K;J1@SXo4nKY_`_`%W1FA zbh_8=);u!(A`oPa&tMJD(6au-gh!>Y(`Nd7fq1H(U2m^3)8d?`88;8SW)|G2YG3oZ zWJ=-_!dZAKds;q^+uER^b0Vl{NOIzY)Gko5K_F|27o5QY?b7uK?AeHELb=a?UxqNB z)TNjDV2dCj9^IYsSb@AR+?<9y7pKPEkSIp0y+lK-U~0dllI}kr`2{Nk!EMZad!<$X zkL|8yYJYn3;4V~QAHAQK-f(1%1GkQd|HbLvLaH+LGLi|VVya@#SVb)tED@qYtATBY|522{vG3!5iKWiOKN-4i?XG5 zXt$z;5#t;*5Rj1x(QDs%(Q|$o3o66~1nLc*Jk-Bw9|j{N6F42Egd8Oppw;;oUZ=8d zok1j5v^IF!NB$M}tE_SRg)P=jzp6SLx*=F9$Qig13G)o@mX{49%8^F}G*yJWqAI!E z97}aJWn@I%T?`|*G-j7le(1CM7W~5LJn7{METK3VR7sflEKZ+z-(1g`gUr^$+Xhv4 zyiGpAZ)mJ&8XMi*vOcCTbZlQ}#H0%`rE0YfGOmq_)%SQW8${P&Wjy2sio_FQe5?+k zE{l;=UdMwyceVmyR0@$#1|X5LY#2Yekt$0OUA=lh4=jmXQ;Hu+ocWu&R9Fnj=* z1}WKzJllZ`T`Tb|nw|}Cw%y~$9RK>r`L?U=D8O)XaA|SD4#hpJwD@U+P+h#vVM}6` zGKXh016_R<8io6`L?+=(9+!^S)KRfrE$=riOGy5~khE;aOTOg1^uZOlB!8j&GYGK# zOqL@?>4Q(^xB8)%@JyMXVtF^n{T^nR=-0}^xYtnB<@l}n``4qaOgu+*YhQ`pkgt<1+$ufXT5NMIj zh1kw-#1@v9eiVGKY()sjpwi6-({~w@&%0!`z#8#^Rfj=5!)`^GnItw3{q9w-5n1aS zJg*+C0(s(U>rxDvOWHrv7`5(|)rQ90Hh)8DKAt2)ksunZ(Gvz%tw_t&(b}B|Hc7*5 z(=psX?D>shNf~#<^c1+L?$JbSWNkLx5jxcQ}i@3ntR^HT-3!fbRrl?ou-ObhGiyxz8%$+0bnYbLI zeRL$YDsYBuOn{~8PPwV@2GPIuj?z`U)An&lI+Lv&i=#3^wmrEwRibruaA|Zw%zhVj z`TS?Y-LN)~;QAg2)Ohua{h*F!-yCvocru@ z-5i@>JQG@X;c=yP&_5bR`=xH5H#Zd75^OJDP8#F@o!3$*#t;uU^I|MOCO7x@TS7xETp1;yP|Fx@EALCM-d(0J_+lGxs9sTI8%;YLg?o zT)?y-QJ%>4!WSup5Hg2IW^*cWPka6ry^TtQeng}CCo2 zbF4sMRU}gsf@)TfQ{l%p>jfCi%nkIQE|J=&3pWy!xZn&KyH*dMNQOV98(iM#pPks? z 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�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 z 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

        Ds@sw6_p*XW`Yop*WpSs4eA+1U!SG> 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 z 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

        5Bv22pwCbhObb!BUS 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 z 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%0ANPr|q&p-@=Yxxc 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

      L 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%0AFb=_1t&2Qa2%$CG{%Bgo-U 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