A cross-platform framework for developing spatial audio algorithms and software in C/C++


GitHub release (latest by date) GitHub Release Date DOI


The Spatial_Audio_Framework (SAF) is an open-source and cross-platform framework for developing spatial audio related algorithms and software in C/C++. While originally intended as a resource for researchers in the field, the framework has gradually grown into a rather large codebase comprising a number of distinct modules; with each module targeting a specific sub-field of spatial audio (e.g. Ambisonics encoding/decoding, spherical array processing, amplitude-panning, HRIR processing, room simulation, etc.). The framework also makes use of highly optimised linear algebra libraries (such as Intel MKL, Apple Accelerate, OpenBLAS) as well as SIMD intrinsics (SSE, AVX, AVX-512). Several examples are also included in the repository, which serve to demonstrate the functionality of the framework and may also act as a starting point for new projects.

Owing to its modular design, expanding the framework is relatively straightforward, and contributions from researchers and developers of spatial audio technologies is actively encouraged! :-)


The framework requires the following external libraries:

In order to inform SAF which CBLAS/LAPACK supporting library/libraries you have linked to your project, simply add one of the following global pre-processor definitions:

SAF_USE_INTEL_MKL_LP64        # great option, but only for x86 architectures (using the LP64 config [int32])
SAF_USE_INTEL_MKL_ILP64       # great option, but only for x86 architectures (using the ILP64 config [int64])
SAF_USE_OPEN_BLAS_AND_LAPACKE # good option, works on everything
SAF_USE_APPLE_ACCELERATE      # good option (x86 and ARM), faster than OpenBLAS, but MacOSX only & slower than MKL
SAF_USE_ATLAS                 # bad option (x86 and ARM), many LAPACK functions are missing
SAF_USE...                    # please get in touch if you use something else! :-)

Detailed instructions regarding how to build and link these libraries can be found here.

Framework structure

The framework comprises the following core modules (ISC License):

  • saf_hoa - a collection of higher-order Ambisonics binaural and loudspeaker decoders.
  • saf_sh - spherical harmonic and spherical array processing related functions.
  • saf_vbap - Vector-base Amplitude Panning (VBAP) functions.
  • saf_cdf4sap - Covariance Domain Framework for Spatial Audio Processing (CDF4SAP).
  • saf_hrir - HRIR/HRTF related functions (estimating ITDs, HRTF interpolation, diffuse-field EQ etc.).
  • saf_reverb - a collection of reverbs and room simulation algorithms.
  • saf_utilities - a collection of useful utility functions and cross-platform wrappers.

The framework also includes the following optional modules:

  • saf_sofa_reader - a simple SOFA file reader (ISC License).
  • saf_tracker - a particle-filtering based tracker (GPLv2 License).
  • saf_hades - for binaural rendering of Hearing-Assistive/Augmented-reality Devices (HADES) (GPLv2 License).

To enable optional framework modules, simply add the relevant pre-processor definition:

SAF_ENABLE_SOFA_READER_MODULE  # to enable saf_sofa_reader
SAF_ENABLE_TRACKER_MODULE      # to enable saf_tracker
SAF_ENABLE_HADES_MODULE        # to enable saf_hades

Additional options

The framework can be configured further, with the following options:

SAF_USE_INTEL_IPP # To use Intel IPP for performing the DFT/FFT and resampling
SAF_USE_FFTW      # To use the FFTW library for performing the DFT/FFT 
SAF_ENABLE_SIMD   # To enable SIMD (SSE, AVX, AVX512) intrinsics for certain vector operations

Using the framework

Once a CBLAS/LAPACK flag is defined (and the correct libraries are linked to your project), add the files found in the framework folder to your project and add the following directory to your project's header search paths:


The framework's master include header is then:

#include "saf.h"
#include "saf_externals.h"  /* (Optional) To also carry over CBLAS/LAPACK routines and other external functions. */

Building with CMake

CMake Build

The framework may also be included within an existing CMake workflow with simply:

target_link_libraries(${PROJECT_NAME} PRIVATE saf)

The available SAF-related CMake options (and their default values) are:

-DSAF_PERFORMANCE_LIB=SAF_USE_INTEL_MKL_LP64 # performance library to employ
-DSAF_ENABLE_SOFA_READER_MODULE=0            # enable/disable the saf_sofa_reader module 
-DSAF_ENABLE_TRACKER_MODULE=0                # enable/disable the saf_tracker module 
-DSAF_ENABLE_HADES_MODULE=0                  # enable/disable the saf_hades module 
-DSAF_BUILD_EXAMPLES=1                       # build saf examples
-DSAF_BUILD_EXTRAS=0                         # build safmex etc.
-DSAF_BUILD_TESTS=1                          # build unit testing program
-DSAF_USE_INTEL_IPP=0                        # link and use Intel IPP for the FFT, resampler, etc.
-DSAF_ENABLE_SIMD=0                          # enable/disable SSE, AVX, and/or AVX-512 support

If using e.g. SAF_USE_INTEL_MKL_LP64 as the performance library, note that the default header and library search paths may be overridden according to your setup with:

-DINTEL_MKL_LIB="path/to/mkl/libs/mkl_rt(.so/.dylib/.lib)"   # OR:

For Linux/MacOS users: the framework, examples, and unit testing program may be built as follows:

cmake -S . -B build 
# Or to also enable e.g. SSE3 and AVX2 intrinsics (for both C and C++ code)
cmake -S . -B build -DSAF_ENABLE_SIMD=1 -DCMAKE_CXX_FLAGS="-msse3 -mavx2" -DCMAKE_C_FLAGS="-msse3 -mavx2"
cd build
test/saf_test # To run the unit testing program

Or for Visual Studio users (using x64 Native Tools Command Prompt for VS):

# e.g. for VS2019:
cmake -S . -B build -G "Visual Studio 16" -A x64  
# e.g. for VS2017:
cmake -S . -B build -G "Visual Studio 15 Win64"
cd build
msbuild ALL_BUILD.vcxproj /p:Configuration=Release /m
cd test/Release
saf_test.exe  # To run the unit testing program


Doxygen Generate

Doxygen-based documentation is generated via a GitHub Action everytime a commit is pushed to the master branch. The documentation is hosted here.

Alternatively, you may generate the documentation yourself (e.g. for the other branches) with the following commands:

cd docs/doxygen
doxygen doxygen_config
# (optional) to also build the pdf version:
cd latex


Several examples have also been included in the repository, which may serve as a starting point for learning how to use the framework:

  • ambi_bin - a binaural Ambisonic decoder with built-in rotator. It supports the following decoding options: least-squares (LS), spatial re-sampling (SPR), Time-alignment (TA), Magnitude Least-Squares (MagLS).
  • ambi_dec - a frequency-dependent Ambisonic decoder. It supports the following decoding options: sampling Ambisonic decoder (SAD), AllRAD, Energy-Preserving decoder (EPAD), Mode-Matching decoder (MMD).
  • ambi_drc - a frequency-dependent dynamic range compressor (DRC) for Ambisonic signals.
  • ambi_enc - a basic Ambisonic encoder.
  • ambi_roomsim - an Ambisonic encoder that also includes reflections and source distance based on an image-source model of a shoebox room. Multiple sources and Ambisonic receivers are supported.
  • array2sh - converts microphone array signals into spherical harmonic signals (aka Ambisonic signals), based on theoretical descriptions of the array configuration and construction.
  • beamformer - a beamformer/virtual microphone generator for Ambisonic signals, with several different beam pattern options.
  • binauraliser - convolves input audio with interpolated HRTFs, which can be optionally loaded from a SOFA file.
  • decorrelator - a basic multi-channel signal decorrelator.
  • dirass - a sound-field visualiser based on re-assigning the energy of beamformers. This re-assignment is based on the DoA estimates extracted from spatially-localised active-intensity vectors, which are biased towards each beamformer direction.
  • matrixconv - a basic matrix convolver with an optional partitioned convolution mode.
  • multiconv - a basic multi-channel convolver with an optional partitioned convolution mode.
  • panner - a frequency-dependent VBAP panner, which accommodates a source loudness compensation (as a function of the room) option.
  • pitch_shifter - a basic multi-channel pitch shifter, based on the phase vocoder approach.
  • powermap - sound-field visualiser based on beamformer (PWD, MVDR) energy or subspace methods (MUSIC).
  • rotator - rotates spherical harmonic signals (aka Ambisonic signals) given yaw-pitch-roll Euler rotation angles.
  • sldoa - a sound-field visualiser based on directly depicting the DoA estimates extracted from multiple spatially-localised active-intensity vectors for multiple frequencies.
  • spreader - an arbitrary array panner (HRIRs, microphone array IRs, etc.) with coherent and incoherent spreading modes.

Many of these examples have also been released as VST audio plug-ins under the SPARTA banner. The following open-source projects also employ the framework: Super-Hearing, HO-SIRR-GUI, and CroPaC-Binaural.


The repository also includes the following extras:

  • matlab - a bunch of MATLAB scripts/functions to accompany the framework (a script to generate saf_default_hrirs.c, MATLAB versions of certain SAF functions, etc.).
  • safmex - a bunch of MATLAB MEX wrappers, which allow certain SAF functions to be used within MATLAB.
  • safpy - a work-in-progress initiative to bring SAF functionality to Python.
  • safwwise - a proof of concept regarding how one might integrate SAF into Wwise.


Suggestions and contributions to the code are both welcomed and encouraged. It should be highlighted that the framework has been designed to be highly modular with plenty of room for expansion. Therefore:

  • if you are researcher who has developed a spatial-audio related method and want to integrate it into the framework... or
  • if you notice that an existing piece of code can be rewritten to make it clearer, faster, or to fix a bug...

then please feel free to do so and submit a pull request. We may also be able to help with the implementation if needed, just get in touch :- )


  • Leo McCormack - C programming and algorithm design (contact: leo.mccormack(at)aalto.fi)
  • Symeon Delikaris-Manias - algorithm design
  • Archontis Politis - algorithm design
  • Ville Pulkki - algorithm design
  • Juhani Paasonen - C programming
  • Chris Hold - C programming and algorithm design
  • Janani Fernandez - C programming and algorithm design


This software is dual-licensed. By default, this software is provided permissively under the terms of the ISC License; since all of the core (non-optional) modules are licensed as such. However, including and enabling certain optional modules, which are instead provided under the copy-left GNU GPLv2 License, will mean that the use of this software is instead governed by the GNU GPLv2 licencing terms.

For full licensing terms see LICENSE.md.

Note that while we do not impose any copyleft licensing philosophies for the ISC licensed modules, we still appreciate it when improvements and/or bug fixes are also merged into this public repository where possible :-)

  • Add const to processing inputs in all examples

    Add const to processing inputs in all examples

    What is the goal of this PR?

    The PR enables processing of const data containers by explicitly declaring input data as const (not only as const pointers). This is an interface change only, since there is no non-const access to these inputs internally.

    What are the changes implemented in this PR?

    Input parameters to all processing calls in the examples are defined as const float** const inputs

    opened by ssaue 6
  • bessel_jn does not return expected values

    bessel_jn does not return expected values


    The function bessel_jn (spherical) is described to compute the bessel function of the first kind and its derivative. I would therefore expect the function scipy.special.spherical_jn to return the same values. I have been editing values in test__sh_module.c and added print statements to bessel_jn to see the behavior of bessel_jn, and noticed that the values returned by bessel_jn do not match the theory. One discrepancy is that bessel_jn always outputs a value of j_n[i]=1 for an input of z[i]=0 even for orders above 1, when bessel functions above order 1 have a value a value of j_n[i]=0 when z[i]=0. I'm wondering why there is an if-statement setting j_n to 1 at z of 0 for all orders, and if bessel_jn is intended to match the theory otherwise.


    1. OS: MacOSX 11.6
    2. Compiler: Making and executing the saf_test executable
    3. SAF performance library being used: SAF_USE_INTEL_MKL
    4. Any optional SAF flags enabled: N/A
    5. Other environment details: CMake

    Reproducible Steps

    Steps to create the smallest reproducible scenario:

    1. Add print statements for the arguments of bessel_jn to the beginning of bessel_jn, and of the outputs at the end of bessel_jn
    2. In the function test__sphModalCoeffs in the file test__sh_module.c, set kr to an array of values from 0 to 9 (step of 1) after line 709
    3. Insert this call of sphModalCoeffs at 714: sphModalCoeffs(2, kr, 10, ARRAY_CONSTRUCTION_OPEN_DIRECTIONAL, 1.0, FLATTEN2D(b_N_card)); (can edit the first argument to change the order)

    Expected Output

    Screen Shot 2022-03-09 at 11 00 37 AM

    Actual Output

    Screen Shot 2022-03-09 at 11 01 37 AM

    Notice that besides the issue of j_n[0] being 1, none of the values match anyways. Curiously, jn[2] (scipy) is equivalent to j_n[1] (saf).

    opened by aidanasingh 4
  • install-safmkl.sh script fails to compile the linux libsaf_mkl_custom.so library

    install-safmkl.sh script fails to compile the linux libsaf_mkl_custom.so library



    The install-safmkl.sh script fails to compile the linux libsaf_mkl_custom.so library. Included patch fix the issue on my system.


    1. OS: Ubuntu 20.04
    2. Compiler: GCC
    3. SAF performance library being used: SAF_USE_INTEL_MKL

    Additional information

    I use the intel-mkl-core-rt-2020.4-304 ubuntu package.

    opened by marclava 4
  • Building saf_mkl_custom.dll

    Building saf_mkl_custom.dll

    Hey there!

    Thank you and your team so much for this project. It really is so great to have this framework in place.

    I've been wanting to incorporate this framework into my node environment using N-API wrapping for the SAF functions. I build these wrappers using the node-gyp tool. So far, I'm able to get the project to build, but am running into errors when I try run the project with the saf_mkl_custom.dll that came with the SPARTA plugins - you can find further info on my issue here #1834. As shown in this issue, when I include the saf_mkl_custom.dll in my node extension, I see that there are some functions in the .dll that are missing, or not referenced correctly and the module is unable to run. The dependency walker confirms this.


    I'm still trying to figure out if this is a node-gyp issue or an issue with the saf_mkl_custom.dll.

    I'm using windows 10. I have installed intel's MKL library and am using Visual Studio 2017 nmake for the .dll compilation.

    I've since decided that I should try build the .dll from scratch to see if I can find more information. I've tried to run the command mentioned in the readme. I run this command from the dependencies/win64 directory.

    nmake intel64 interface=lp64 threading=sequential name=saf_mkl_custom export=saf_mkl_list

    However, I get thrown this error from nmake

    Microsoft (R) Program Maintenance Utility Version 14.15.26730.0
    Copyright (C) Microsoft Corporation.  All rights reserved.
    NMAKE : fatal error U1073: don't know how to make 'intel64'

    Might you have any idea why this error would be thrown?

    Any help would be greatly appreciated :)

    opened by tonetechnician 4
  • Add equirectangular view of spherical videos to allow panning of sources on top

    Add equirectangular view of spherical videos to allow panning of sources on top

    Problem to Solve

    Hi Leo, could you add an option in ambiENC to load an equirectangular view of spherically encoded videos to allow panning of sources on top of them. This would allow us to create an automation that would move the source as the objects in the video are moving.

    Current Workaround

    Use a different plugin or blindly place sources for 360 spherical content.

    Additional Information

    This is an example of how it works in the FB360 plugin but it only supports up to 3rd order. image

    opened by abhayap 2
  • Build instructions do not work

    Build instructions do not work

    I use plain Ubuntu.

    $ cmake -S . -B build CMake Error: The source directory "/home/df/Spatial_Audio_Framework-master/build" does not exist. $ cmake --version cmake version 3.10.2

    opened by d01010101 2


    MKL ships with Anaconda by default and is the default performance lib for many python packages there.

    On UNIX, setting

    -DSAF_PERFORMANCE_LIB=SAF_USE_INTEL_MKL -DINTEL_MKL_HEADER_PATH="/opt/anaconda3/include" -DINTEL_MKL_LIB="/opt/anaconda3/lib/libmkl_rt.dylib"


    opened by chris-hld 2
  • Buffer overflow in saf_utility_dvf.c

    Buffer overflow in saf_utility_dvf.c

    Please replace every line in curly brackets { like this } with appropriate answers, and remove this line.


    Trying to track down some mysterious crashes in my app, I tried running the SAF tests with ASAN enabled and it is showing me a buffer overflow in this file, see screenshot


    1. MacOSX 12
    2. Clang
    4. Xcode with ASAN

    Reproducible Steps

    Steps to create the smallest reproducible scenario:

    1. Build SAF test via Xcode
    2. Enable ASAN (see screenshot)
    Screenshot 2022-04-22 at 00 05 09 Screenshot 2022-04-22 at 00 08 17 bug 
    opened by olilarkin 1
  • Fix sofa_filepath memory issues and another memory leak in vbap

    Fix sofa_filepath memory issues and another memory leak in vbap

    From @leomccormack's comment on my last PR, I added the missing calls to free for sofa_filepath in the other examples, as well as changing the malloc to a realloc.

    Also fixed a memory leak in vbap.

    opened by magnus-nomono 1
  • Fix some memory leaks and a missing initialization

    Fix some memory leaks and a missing initialization

    Some small fixes discovered while doing some memory investigation.

    • Initialize pData->fs so it won't cause issues in the future (it does strictly speaking not cause issues today, but in ambi_bin_init it is used in a comparison while uninitialized, which might cause hard to debug issues when other code changes)

    • Add some missing calls to free, fixing memory leaks

    opened by magnus-nomono 1
  • Few questions about the implementation of VBAP

    Few questions about the implementation of VBAP

    Hello! I am reading this repos recently and confused by some details:

    1. There is an eye3 matrix in method invertLsMtx3D of saf_vbap.c. If I understood correctly, it's an identity matrix. I wonder why eye3 is neccessary to multiply with tempGroup. https://github.com/leomccormack/Spatial_Audio_Framework/blob/12381d6631f415839a46e05fc24ff2e70201d32b/framework/modules/saf_vbap/saf_vbap.c#L689

    2. There is a logic that omit Trianges that have an aperture larger than APERTURE_LIMIT_DEG(180) in findLsTriplets. The condition is comparing the return of acosf and aperture_lim (which is pi), However, the return of acosf is always [0,pi]. https://github.com/leomccormack/Spatial_Audio_Framework/blob/12381d6631f415839a46e05fc24ff2e70201d32b/framework/modules/saf_vbap/saf_vbap.c#L638

    Hope you can help me with these confusions, Thanks!

    opened by jinnsjj 1
  • Error building

    Error building

    When trying to execute the script install-safmkl.bat on Windows 11 (Visual Studio 2022) it fails with the following error:

    NMAKE : fatal error U1073: don't know how to make 'intel64'

    I built SAF without any problems by doing the alternate option of using the stock MKL libraries from the OneAPI, but I was wondering what could be causing this issue?

    opened by hectorC 1
  • Function name in ambi_dec example is confusing

    Function name in ambi_dec example is confusing


    Since there is another NormType

    opened by olilarkin 1
  • v1.3.0(Apr 3, 2022)


    • Added saf_hades module (thank you @jananifernandez)
    • Added binauraliser_nf and tvconv examples (thank you @mtmccrea, @rapolasd, @nmkahlen, and Thomas McKenzie)
    • Added saf_utility_dvf.h/.c to saf_utilities module
    • All Bessel and Hankel functions now have two variants, with one having a "_ALL" suffix that returns all orders from 0 to the specified order, and another returning only the specified order
    • Added the ability to select which SOFA reader to use (libmysofa or the built-in netcdf one)
    • Removed the "loadSofaFile()" function (marked as deprecated since October 2020).

    Breaking changes:

    • All Bessel and Hankel functions to have a "_ALL" suffix, since they return all orders up to the specified maximum order. Therefore, if you were using these functions prior to this version, then you will also need to add this suffix to retain previous behaviour.
    Source code(tar.gz)
    Source code(zip)
  • v1.2.4(Nov 19, 2021)


    • Added libmysofa to the saf_sofa_reader module. The saf_sofa_open() function now uses libmysofa by default, unless "SAF_ENABLE_NETCDF" is defined. The libmysofa interface may also be used directly
    • Added zlib to framework/resources, therefore by default the saf_sofa_reader module may be enabled without the need to link external dependencies
    • The default interpolation mode for the binauraliser example is now "Triangular".
    • The ambi_dec example no longer places +/-90degrees virtual loudspeakers for the 2D case, unless the selected decoding mode is "AllRAD".
    • Some optimisations for saf_tracker3d

    Breaking changes:

    • Since saf_sofa_open() now uses libmysofa by default, netcdf is no longer a required dependency. However, if you would like to revert to the previous behaviour (using netcd rather than using libmysofa), then you can use the following pre-processing definition: SAF_ENABLE_NETCDF
    Source code(tar.gz)
    Source code(zip)
  • v1.2.3(Aug 20, 2021)


    • Bug fix in invertLsMtx2D() and invertLsMtx3D()
    • Added install-safipp.bat script for building a custom Intel IPP dll for SAF for Windows
    Source code(tar.gz)
    Source code(zip)
  • v1.2.2(Aug 19, 2021)


    • General documentation improvements, and also switched to a more modern doxygen theme
    • More Intel IPP functions are favoured and called if SAF_USE_INTEL_IPP is defined
    • Added a solo/mute feature for the ambi_enc and binauraliser examples
    • Some more minor optimisations
    Source code(tar.gz)
    Source code(zip)
  • v1.1.7(Jun 5, 2021)


    • saf_utility_fft now uses vDSP's DFT implementation, rather than the scrict 2^x FFT implementation, when the performance library is set to SAF_USE_APPLE_ACCELERATE
    • Added the ability to select either the LP64 or ILP64 version of Intel MKL as the performance library (the install script has been updated accordingly)
    • Added support for building N-dimensional convexhulls and Delaunay meshes to saf_utility_geometry
    • Added support for dynamically allocating 4d, 5d, and 6d arrays to md_malloc
    • The examples that previously required the saf_sofa_reader module to be enabled in order to build them, now no longer require it (instead they use only the default HRIR data)
    • tracker_3d can now optionally return the tracked target variances
    • Added saf_print_warning, saf_print_error, and saf_assert macros to saf_utilities.h

    Breaking changes:

    • Due to the newly added ability to select between the LP64 and ILP64 variants of Intel MKL, the old flag "SAF_USE_INTEL_MKL" (which was always LP64), should be replaced by "SAF_USE_INTEL_MKL_LP64" or "SAF_USE_INTEL_MKL_ILP64". If you were linking your project with the "saf_mkl_custom" library, thenyou will also need to create a new saf_mkl_custom_lp64, or saf_mkl_custom_ilp64 library using the updated scripts/install-safmkl.sh/.bat script.
    • To avoid conflicts between non-define guarded "MIN" and "MAX" macros, they have now been changed to"SAF_MIN" and "SAF_MAX", respectively, throughout the framework.
    • Removed saf_utility_error.h/.c files. Its functionality has been replaced by the cleaner/simplersaf_print_warning, saf_print_error, and saf_assert macros.
    Source code(tar.gz)
    Source code(zip)
  • v1.2.1(Jul 2, 2021)


    • Added (optional) AVX and AVX-512 support, when using: SAF_ENABLE_SIMD
    • Added (optional) FFTW support for saf_utility_fft, via the new flag: SAF_USE_FFTW
    • If Intel IPP is enabled (SAF_USE_INTEL_IPP), then the IPP resampler is employed, instead of the included SPEEX resampler, when calling resampleHRIRs()

    Breaking changes:

    • The install-safipp.sh script now defaults to the new oneAPI install paths. However, an arbitrary install path (e.g. the old one) may also now be specified as an input argument.
    Source code(tar.gz)
    Source code(zip)
  • v1.2.0(Jun 26, 2021)


    • All lapack-related saf_utility_veclib functions now include an option to pre-allocate the run-time memory
    • All saf_utility_veclib vector-vector operations, when using Apple Accelerate as the chosen performance library, now call the appropriate optimised routines. The Intel MKL vector-vector operations have been switched to the "mode overriding" variants, which allows some accuracy to be traded for faster computations
    • Added some SIMD (SSE) optimised function alternatives, which may be enabled with "SAF_ENABLE_SIMD"
    • A number of other minor and some significant optimisations throughout the framework
    • Improved doxygen documentation for the examples
    • Added resampleHRIRs() function to saf_hrir module, which employs the SPEEX resampler.

    Breaking changes:

    • Since the lapack-related saf_utility_veclib now allow a pre-allocated object to be passed to them, the first input argument should either be set to "NULL", (in which case they revert to how they were previously), or you can pass the pre-allocated object, (in which case no run--time malloc calls are made).
    • The SAF_PRINT_VERSION_LICENSE_STRING macro has been removed; use the SAF_LICENSE_STRING instead.
    Source code(tar.gz)
    Source code(zip)
  • v1.1.6(Apr 21, 2021)


    • added a "spreader" example which demonstrates coherent and incoherent source spreading (default is binaural)
    • added truncationEQ to saf_hoa module
    • added Quaternion support to saf_utility_geometry.h/.c
    • improvements to the image-source simulator in saf_reverb module, and the ambi_room_sim example
    • improvements to the lattice decorrelator in saf_utility_decor.h/.c
    • a number of bug fixes and improvements all round.
    Source code(tar.gz)
    Source code(zip)
  • v1.1.5(Oct 22, 2020)

  • v1.1.4(Oct 9, 2020)


    • Doxygen-Documentation is now generated via a github-action and hosted here: https://leomccormack.github.io/Spatial_Audio_Framework/
    • Added an improved SOFA reader, saf_sofa_open(), which fully conforms to the SOFA 1.0 FIR standard
    • Added extras/matlab, which includes scripts to generate the default HRIR database, and the saf_sofa_open matlab equivalent.
    • Added Intel IPP support to the saf_utility_fft.h/c wrapper. Enable with: "SAF_USE_INTEL_IPP".
    • Further optimised the multi-channel and matrix convolvers in saf_utility_matrixConv.h/.c
    • A number of bug fixes and improvements all round.
    Source code(tar.gz)
    Source code(zip)
  • v1.1.3beta(Aug 26, 2020)


    • Added an optional saf_tracker module (GPLv2) for tracking 3-D data points (e.g., direction-of-arrival estimates as unit vectors, Cartesian coordinates [x,y,z] etc.).
    • A number of improvements to the image-source simulator in the saf_reverb module.
    • Added CMake support for the safmex wrappers.
    Source code(tar.gz)
    Source code(zip)
  • v1.1.2(Aug 7, 2020)


    • Decoupled SAF from its external dependencies
    • Added a extras/safmex folder which contains Matlab MEX wrappers; currently for the: afSTFT, QMF, IIR filterbank, VBAP gain tables, and getSHreal/complex SAF functions
    • General bug fixes and improvements all round

    Breaking changes:

    • Due to the decoupling of SAF from its external dependencies, no longer will you be able to use SAF's dependencies within your own project by default; i.e. when including SAF via #include "saf.h", you will no longer also inherit the cblas/lapack functions etc. Instead, these external dependencies are included only internally within SAF by default. However, if you would like to retain access to these external dependencies within your own project, then you may now optionally include them by adding: #include "saf_externals.h" along with #include "saf.h".
    Source code(tar.gz)
    Source code(zip)
  • v1.1.1(Jul 21, 2020)


    • Reworked the afSTFT interface, and optimised its internals
    • Added several more utility functions to saf_utilities, and added a resampler (based on libsamplerate) to resources
    • Added more unit tests
    • General bug fixes and improvements all round

    Breaking changes:

    • Due to the afSTFT interface rework, existing code that uses afSTFT will need to be modified. The main difference is that complexVector has been replaced with the native "float_complex" data type. It also no longer requires the input audio to be subdivided into chunks of "hopsize", as this is now done internally. Users must now also specify if they want the 3-D frequency-domain data permuted as: bands x channels x time, or time x channels x bands. The required changes should be quite self-explanatory, however, one may also refer to the examples (e.g. ambi_bin), which have been updated to use this new interface.
    Source code(tar.gz)
    Source code(zip)
  • v1.1.0(Jul 4, 2020)


    • Added comprehensive CMake support
    • Documentation improvements
    • Added more unit tests
    • Added saf_utility_geometry.h/c (convexhull, spherical Delaunay + Voronoi functions etc.)
    • General bug fixes and improvements all round
    Source code(tar.gz)
    Source code(zip)
  • v1.0.0(May 26, 2020)

Leo McCormack
A doctoral candidate at Aalto University with a keen interest in spatial audio technologies
Leo McCormack
Appupdater is a C++ cross-platform framework to update desktop software (gitlab mirror)

appupdater is a C++ cross-platform framework to update desktop software. How it works Framework checks the URL you specified for info about versions a

Ronzhin Mikhail 1 Jan 8, 2022
An example spatial lookup service. In-memory reverse geocode backed by GEOS.

Spatial Lookup Web Service This GEOS example program demonstrates the use of the STRtree index and PreparedGeometry to create a high-performance in-me

Paul Ramsey 27 May 6, 2022
Fast glsl deNoise spatial filter, with circular gaussian kernel, full configurable

glslSmartDeNoise Fast glsl spatial deNoise filter, with circular gaussian kernel and smart/flexible/adaptable -> full configurable: Standard Deviation

Michele Morrone 190 Jun 26, 2022
SDR++ is a cross-platform and open source SDR software with the aim of being bloat free and simple to use.

SDR++ is a cross-platform and open source SDR software with the aim of being bloat free and simple to use.

AlexandreRouma 1.7k Jun 23, 2022
The Leap Motion cross-format, cross-platform declarative serialization library

Introduction to LeapSerial LeapSerial is a cross-format, declarative, serialization and deserialization library written and maintained by Leap Motion.

Leap Motion (Ultraleap) 15 Jan 17, 2022
A modern port of Turbo Vision 2.0, the classical framework for text-based user interfaces. Now cross-platform and with Unicode support.

Turbo Vision A modern port of Turbo Vision 2.0, the classical framework for text-based user interfaces. Now cross-platform and with Unicode support. I

null 1.3k Jun 24, 2022
A cross-platform,lightweight,scalable game server framework written in C++, and support Lua Script

Current building status Moon Moon is a lightweight online game server framework implement with multithread and multi-luaVM. One thread may have 1-N lu

Bruce 413 Jun 11, 2022
A cross-platform,lightweight,scalable game server framework written in C++, and support Lua Script

hive Distributed game server framework based on CPP 17 && LUA 5.4 框架(hive)+逻辑(server) 支持跨平台开发(windows,linux,mac) oop模式的lua开发,支持lua热更新 protobuf协议 pbc修改

toney 49 Jun 22, 2022
Orca - Advanced Malware with multifeatures written in ASM/C/C++ , work on all windows versions ! (some features still under developing and not stable)

About Orca Orca is an Advanced Malware with multifeatures written in ASM/C/C++ features Run in Background (Hidden Mode) Records keystrokes and saves t

anas 156 Jun 17, 2022
First Rendition of Static Factory Design Method for developing studies and more using C++ ACSIL in Sierra Chart

Thanks for stopping by. This is my first GitHub repo. SierraChart ACSIL C++ STUDY DEV TEMPLATE This is meant to be a template for developing study gro

[Tim] 2 Jan 18, 2022
A cross platform shader language with multi-threaded offline compilation or platform shader source code generation

A cross platform shader language with multi-threaded offline compilation or platform shader source code generation. Output json reflection info and c++ header with your shaders structs, fx-like techniques and compile time branch evaluation via (uber-shader) "permutations".

Alex Dixon 273 Jun 10, 2022
A framework for building Mobile cross-platform UI

Weex A framework for building Mobile cross-platform UI. Distribution Support Android 4.1 (API 16), iOS 9.0+ and WebKit 534.30+. platform status Androi

Alibaba 17.9k Jun 26, 2022
Cross-platform GPU-oriented C++ application/game framework

Introduction neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for perfor

i42 Software 444 Jun 27, 2022
Bond is a cross-platform framework for working with schematized data

Bond is a cross-platform framework for working with schematized data. It supports cross-language de/serialization and powerful generic mechanisms for efficiently manipulating data. Bond is broadly used at Microsoft in high scale services.

Microsoft 2.4k Jun 22, 2022
Developing a Drone from scratch in ROS Gazebo

Project Building a drone and developing its control system. Table of Contents Project Table of Contents About The Project Tech Stack File Structure Ge

null 15 Mar 22, 2022
Half-Life : Extended main branch for developing purposes

Half Life : Extended SDK Source Code of Half Life : Extended as a open source modbase for everyone publicly, make your own mod with alot of features e

Bacontsu 12 May 10, 2022
The Vulkan Profiles Tools are a collection of tools delivered with the Vulkan SDK for Vulkan application developers to leverage Vulkan Profiles while developing a Vulkan application

Copyright © 2021-2022 LunarG, Inc. Vulkan Profiles Tools (BETA) The Vulkan Profiles Tools are a collection of tools delivered with the Vulkan SDK for

The Khronos Group 52 Jun 9, 2022
OpenAL Soft is a software implementation of the OpenAL 3D audio API.

OpenAL soft master branch CI status : OpenAL Soft is an LGPL-licensed, cross-platform, software implementation of the OpenAL 3D audio API. It's forked

null 1.6k Jun 23, 2022
This is a tool for software engineers to view,record and analyse data(sensor data and module data) In the process of software development.

![Contributors][Huang Jianyu] Statement 由于工具源码在网上公开,除使用部分开源项目代码外,其余代码均来自我个人,工具本身不包含公司的知识产权,所有与公司有关的内容均从软件包中移除,软件发布遵循Apache协议,任何人均可下载进行修改使用,如使用过程中出现任何问

HuangJianyu 34 May 5, 2022