Snap for 7550844 from 3aa1b5c299d6cefb61340faf3eccc538744d5b4c to mainline-os-statsd-release

Change-Id: I3a53740efd61b210e7e8b624e8504e63b194d9d3

114 files changed, 6518 insertions, 2295 deletions

diff --git a/.appveyor.yml b/.appveyor.yml
new file mode 100644
index 00000000..a0f4a776
--- /dev/null
+++ b/.appveyor.yml
@@ -0,0 +1,37 @@
+image: Visual Studio 2015
+configuration:
+- Debug
+- DebugDLL
+- DebugDLL_fixed
+- Release
+- ReleaseDLL
+- ReleaseDLL_fixed
+
+platform:
+- Win32
+- x64
+
+environment:
+  api_key:
+    secure: kR3Ac0NjGwFnTmXdFrR8d6VXjdk5F7L4F/BilC4nvaM=
+
+build:
+  project: win32\VS2015\opus.sln
+  parallel: true
+  verbosity: minimal
+
+after_build:
+- cd %APPVEYOR_BUILD_FOLDER%
+- 7z a opus.zip win32\VS2015\%PLATFORM%\%CONFIGURATION%\opus.??? include\*.h
+
+test_script:
+- cd %APPVEYOR_BUILD_FOLDER%\win32\VS2015\%PLATFORM%\%CONFIGURATION%
+- test_opus_api.exe
+- test_opus_decode.exe
+- test_opus_encode.exe
+
+artifacts:
+- path: opus.zip
+
+on_success:
+- ps: if ($env:api_key -and "$env:configuration/$env:platform" -eq "ReleaseDLL_fixed/x64") { Start-AppveyorBuild -ApiKey $env:api_key -ProjectSlug 'opus-tools' }
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..649c8100
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,10 @@
+.gitignore		export-ignore
+.gitattributes		export-ignore
+
+update_version		export-ignore
+
+*.bat eol=crlf
+*.sln eol=crlf
+*.vcxproj eol=crlf
+*.vcxproj.filters eol=crlf
+common.props eol=crlf
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..837619f9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,90 @@
+Doxyfile
+Makefile
+Makefile.in
+TAGS
+aclocal.m4
+autom4te.cache
+*.kdevelop.pcs
+*.kdevses
+compile
+config.guess
+config.h
+config.h.in
+config.log
+config.status
+config.sub
+configure
+depcomp
+INSTALL
+install-sh
+.deps
+.libs
+.dirstamp
+*.a
+*.exe
+*.la
+*-gnu.S
+testcelt
+libtool
+ltmain.sh
+missing
+m4/libtool.m4
+m4/ltoptions.m4
+m4/ltsugar.m4
+m4/ltversion.m4
+m4/lt~obsolete.m4
+opus_compare
+opus_demo
+repacketizer_demo
+stamp-h1
+test-driver
+trivial_example
+*.sw*
+*.o
+*.lo
+*.pc
+*.tar.gz
+*~
+tests/*test
+tests/test_opus_api
+tests/test_opus_decode
+tests/test_opus_encode
+tests/test_opus_padding
+tests/test_opus_projection
+celt/arm/armopts.s
+celt/dump_modes/dump_modes
+celt/tests/test_unit_cwrs32
+celt/tests/test_unit_dft
+celt/tests/test_unit_entropy
+celt/tests/test_unit_laplace
+celt/tests/test_unit_mathops
+celt/tests/test_unit_mdct
+celt/tests/test_unit_rotation
+celt/tests/test_unit_types
+doc/doxygen_sqlite3.db
+doc/doxygen-build.stamp
+doc/html
+doc/latex
+doc/man
+package_version
+version.h
+celt/Debug
+celt/Release
+celt/x64
+silk/Debug
+silk/Release
+silk/x64
+silk/fixed/Debug
+silk/fixed/Release
+silk/fixed/x64
+silk/float/Debug
+silk/float/Release
+silk/float/x64
+silk/tests/test_unit_LPC_inv_pred_gain
+src/Debug
+src/Release
+src/x64
+/*[Bb]uild*/
+.vs/
+.vscode/
+CMakeSettings.json
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
new file mode 100644
index 00000000..01b033fd
--- /dev/null
+++ b/.gitlab-ci.yml
@@ -0,0 +1,61 @@
+include:
+  - template: 'Workflows/Branch-Pipelines.gitlab-ci.yml'
+
+default:
+  tags:
+    - docker
+  # Image from https://hub.docker.com/_/gcc/ based on Debian
+  image: gcc:9
+
+whitespace:
+  stage: test
+  script:
+    - git diff-tree --check origin/master HEAD
+
+autoconf:
+  stage: build
+  before_script:
+    - apt-get update &&
+      apt-get install -y zip doxygen
+  script:
+    - ./autogen.sh
+    - ./configure
+    - make -j4
+    - make distcheck
+  cache:
+    paths:
+      - "src/*.o"
+      - "src/.libs/*.o"
+      - "silk/*.o"
+      - "silk/.libs/*.o"
+      - "celt/*.o"
+      - "celt/.libs/*.o"
+
+cmake:
+  stage: build
+  before_script:
+    - apt-get update &&
+      apt-get install -y cmake ninja-build
+  script:
+    - mkdir build
+    - cmake -S . -B build -G "Ninja" -DCMAKE_BUILD_TYPE=Release -DOPUS_BUILD_TESTING=ON -DOPUS_BUILD_PROGRAMS=ON
+    - cmake --build build
+    - cd build && ctest --output-on-failure
+
+meson:
+  stage: build
+  before_script:
+    - apt-get update &&
+      apt-get install -y python3-pip ninja-build doxygen
+    - export XDG_CACHE_HOME=$PWD/pip-cache
+    - pip3 install --user meson
+  script:
+    - export PATH=$PATH:$HOME/.local/bin
+    - mkdir builddir
+    - meson setup --werror -Dtests=enabled -Ddocs=enabled -Dbuildtype=release builddir
+    - meson compile -C builddir
+    - meson test -C builddir
+    #- meson dist --no-tests -C builddir
+  cache:
+    paths:
+      - 'pip-cache/*'
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..821c813e
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,21 @@
+language: c
+
+compiler:
+  - gcc
+  - clang
+
+os:
+  - linux
+  - osx
+
+env:
+  - CONFIG=""
+  - CONFIG="--enable-assertions"
+  - CONFIG="--enable-fixed-point"
+  - CONFIG="--enable-fixed-point --disable-float-api"
+  - CONFIG="--enable-fixed-point --enable-assertions"
+
+script:
+  - ./autogen.sh
+  - ./configure $CONFIG
+  - make distcheck
diff --git a/Android.bp b/Android.bp
index 7dfcd86c..702ddcc4 100644
--- a/Android.bp
+++ b/Android.bp
@@ -1,4 +1,40 @@
-cc_library_shared {
+package {
+    default_applicable_licenses: ["external_libopus_license"],
+}
+
+// Added automatically by a large-scale-change that took the approach of
+// 'apply every license found to every target'. While this makes sure we respect
+// every license restriction, it may not be entirely correct.
+//
+// e.g. GPL in an MIT project might only apply to the contrib/ directory.
+//
+// Please consider splitting the single license below into multiple licenses,
+// taking care not to lose any license_kind information, and overriding the
+// default license using the 'licenses: [...]' property on targets as needed.
+//
+// For unused files, consider creating a 'filegroup' with "//visibility:private"
+// to attach the license to, and including a comment whether the files may be
+// used in the current project.
+//
+// large-scale-change included anything that looked like it might be a license
+// text as a license_text. e.g. LICENSE, NOTICE, COPYING etc.
+//
+// Please consider removing redundant or irrelevant files from 'license_text:'.
+// http://go/android-license-faq
+license {
+    name: "external_libopus_license",
+    visibility: [":__subpackages__"],
+    license_kinds: [
+        "SPDX-license-identifier-Apache-2.0",
+        "SPDX-license-identifier-BSD",
+    ],
+    license_text: [
+        "COPYING",
+        "NOTICE",
+    ],
+}
+
+cc_library {
     name: "libopus",
     vendor_available: true,
     host_supported: true,
@@ -15,7 +51,7 @@ cc_library_shared {
     sanitize: {
         integer_overflow: true,
         misc_undefined: ["bounds"],
-        blacklist: "libopus_blacklist.txt",
+        blocklist: "libopus_blocklist.txt",
     },
 
     srcs: [
@@ -338,6 +374,11 @@ cc_library_shared {
         },
     },
 
+    target: {
+        darwin: {
+            enabled: false,
+        },
+    },
     apex_available: [
         "//apex_available:platform", // used by libstagefright_soft_opusdec
         "com.android.media.swcodec",
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 00000000..a28f441c
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,618 @@
+cmake_minimum_required(VERSION 3.1)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+include(OpusPackageVersion)
+get_package_version(PACKAGE_VERSION PROJECT_VERSION)
+
+project(Opus LANGUAGES C VERSION ${PROJECT_VERSION})
+
+include(OpusFunctions)
+include(OpusBuildtype)
+include(OpusConfig)
+include(OpusSources)
+include(GNUInstallDirs)
+include(CMakeDependentOption)
+include(FeatureSummary)
+
+set(OPUS_BUILD_SHARED_LIBRARY_HELP_STR "build shared library.")
+option(OPUS_BUILD_SHARED_LIBRARY ${OPUS_BUILD_SHARED_LIBRARY_HELP_STR} OFF)
+if(OPUS_BUILD_SHARED_LIBRARY OR BUILD_SHARED_LIBS OR OPUS_BUILD_FRAMEWORK)
+  # Global flag to cause add_library() to create shared libraries if on.
+  set(BUILD_SHARED_LIBS ON)
+  set(OPUS_BUILD_SHARED_LIBRARY ON)
+endif()
+add_feature_info(OPUS_BUILD_SHARED_LIBRARY OPUS_BUILD_SHARED_LIBRARY ${OPUS_BUILD_SHARED_LIBRARY_HELP_STR})
+
+set(OPUS_BUILD_TESTING_HELP_STR "build tests.")
+option(OPUS_BUILD_TESTING ${OPUS_BUILD_TESTING_HELP_STR} OFF)
+if(OPUS_BUILD_TESTING OR BUILD_TESTING)
+  set(OPUS_BUILD_TESTING ON)
+  set(BUILD_TESTING ON)
+endif()
+add_feature_info(OPUS_BUILD_TESTING OPUS_BUILD_TESTING ${OPUS_BUILD_TESTING_HELP_STR})
+
+set(OPUS_CUSTOM_MODES_HELP_STR "enable non-Opus modes, e.g. 44.1 kHz & 2^n frames.")
+option(OPUS_CUSTOM_MODES ${OPUS_CUSTOM_MODES_HELP_STR} OFF)
+add_feature_info(OPUS_CUSTOM_MODES OPUS_CUSTOM_MODES ${OPUS_CUSTOM_MODES_HELP_STR})
+
+set(OPUS_BUILD_PROGRAMS_HELP_STR "build programs.")
+option(OPUS_BUILD_PROGRAMS ${OPUS_BUILD_PROGRAMS_HELP_STR} OFF)
+add_feature_info(OPUS_BUILD_PROGRAMS OPUS_BUILD_PROGRAMS ${OPUS_BUILD_PROGRAMS_HELP_STR})
+
+set(OPUS_DISABLE_INTRINSICS_HELP_STR "disable all intrinsics optimizations.")
+option(OPUS_DISABLE_INTRINSICS ${OPUS_DISABLE_INTRINSICS_HELP_STR} OFF)
+add_feature_info(OPUS_DISABLE_INTRINSICS OPUS_DISABLE_INTRINSICS ${OPUS_DISABLE_INTRINSICS_HELP_STR})
+
+set(OPUS_FIXED_POINT_HELP_STR "compile as fixed-point (for machines without a fast enough FPU).")
+option(OPUS_FIXED_POINT ${OPUS_FIXED_POINT_HELP_STR} OFF)
+add_feature_info(OPUS_FIXED_POINT OPUS_FIXED_POINT ${OPUS_FIXED_POINT_HELP_STR})
+
+set(OPUS_ENABLE_FLOAT_API_HELP_STR "compile with the floating point API (for machines with float library).")
+option(OPUS_ENABLE_FLOAT_API ${OPUS_ENABLE_FLOAT_API_HELP_STR} ON)
+add_feature_info(OPUS_ENABLE_FLOAT_API OPUS_ENABLE_FLOAT_API ${OPUS_ENABLE_FLOAT_API_HELP_STR})
+
+set(OPUS_FLOAT_APPROX_HELP_STR "enable floating point approximations (Ensure your platform supports IEEE 754 before enabling).")
+option(OPUS_FLOAT_APPROX ${OPUS_FLOAT_APPROX_HELP_STR} OFF)
+add_feature_info(OPUS_FLOAT_APPROX OPUS_FLOAT_APPROX ${OPUS_FLOAT_APPROX_HELP_STR})
+
+set(OPUS_ASSERTIONS_HELP_STR "additional software error checking.")
+option(OPUS_ASSERTIONS ${OPUS_ASSERTIONS_HELP_STR} OFF)
+add_feature_info(OPUS_ASSERTIONS OPUS_ASSERTIONS ${OPUS_ASSERTIONS_HELP_STR})
+
+set(OPUS_HARDENING_HELP_STR "run-time checks that are cheap and safe for use in production.")
+option(OPUS_HARDENING ${OPUS_HARDENING_HELP_STR} ON)
+add_feature_info(OPUS_HARDENING OPUS_HARDENING ${OPUS_HARDENING_HELP_STR})
+
+set(OPUS_FUZZING_HELP_STR "causes the encoder to make random decisions (do not use in production).")
+option(OPUS_FUZZING ${OPUS_FUZZING_HELP_STR} OFF)
+add_feature_info(OPUS_FUZZING OPUS_FUZZING ${OPUS_FUZZING_HELP_STR})
+
+set(OPUS_CHECK_ASM_HELP_STR "enable bit-exactness checks between optimized and c implementations.")
+option(OPUS_CHECK_ASM ${OPUS_CHECK_ASM_HELP_STR} OFF)
+add_feature_info(OPUS_CHECK_ASM OPUS_CHECK_ASM ${OPUS_CHECK_ASM_HELP_STR})
+
+set(OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR "install pkg-config module.")
+option(OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR} ON)
+add_feature_info(OPUS_INSTALL_PKG_CONFIG_MODULE OPUS_INSTALL_PKG_CONFIG_MODULE ${OPUS_INSTALL_PKG_CONFIG_MODULE_HELP_STR})
+
+set(OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR "install CMake package config module.")
+option(OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR} ON)
+add_feature_info(OPUS_INSTALL_CMAKE_CONFIG_MODULE OPUS_INSTALL_CMAKE_CONFIG_MODULE ${OPUS_INSTALL_CMAKE_CONFIG_MODULE_HELP_STR})
+
+if(APPLE)
+  set(OPUS_BUILD_FRAMEWORK_HELP_STR "build Framework bundle for Apple systems.")
+  option(OPUS_BUILD_FRAMEWORK ${OPUS_BUILD_FRAMEWORK_HELP_STR} OFF)
+  add_feature_info(OPUS_BUILD_FRAMEWORK OPUS_BUILD_FRAMEWORK ${OPUS_BUILD_FRAMEWORK_HELP_STR})
+endif()
+
+set(OPUS_FIXED_POINT_DEBUG_HELP_STR "debug fixed-point implementation.")
+cmake_dependent_option(OPUS_FIXED_POINT_DEBUG
+                      ${OPUS_FIXED_POINT_DEBUG_HELP_STR}
+                      ON
+                      "OPUS_FIXED_POINT; OPUS_FIXED_POINT_DEBUG"
+                      OFF)
+add_feature_info(OPUS_FIXED_POINT_DEBUG OPUS_FIXED_POINT_DEBUG ${OPUS_FIXED_POINT_DEBUG_HELP_STR})
+
+set(OPUS_VAR_ARRAYS_HELP_STR "use variable length arrays for stack arrays.")
+cmake_dependent_option(OPUS_VAR_ARRAYS
+                      ${OPUS_VAR_ARRAYS_HELP_STR}
+                      ON
+                      "VLA_SUPPORTED; NOT OPUS_USE_ALLOCA; NOT OPUS_NONTHREADSAFE_PSEUDOSTACK"
+                      OFF)
+add_feature_info(OPUS_VAR_ARRAYS OPUS_VAR_ARRAYS ${OPUS_VAR_ARRAYS_HELP_STR})
+
+set(OPUS_USE_ALLOCA_HELP_STR "use alloca for stack arrays (on non-C99 compilers).")
+cmake_dependent_option(OPUS_USE_ALLOCA
+                       ${OPUS_USE_ALLOCA_HELP_STR}
+                       ON
+                       "USE_ALLOCA_SUPPORTED; NOT OPUS_VAR_ARRAYS; NOT OPUS_NONTHREADSAFE_PSEUDOSTACK"
+                       OFF)
+add_feature_info(OPUS_USE_ALLOCA OPUS_USE_ALLOCA ${OPUS_USE_ALLOCA_HELP_STR})
+
+set(OPUS_NONTHREADSAFE_PSEUDOSTACK_HELP_STR "use a non threadsafe pseudostack when neither variable length arrays or alloca is supported.")
+cmake_dependent_option(OPUS_NONTHREADSAFE_PSEUDOSTACK
+                       ${OPUS_NONTHREADSAFE_PSEUDOSTACK_HELP_STR}
+                       ON
+                       "NOT OPUS_VAR_ARRAYS; NOT OPUS_USE_ALLOCA"
+                       OFF)
+add_feature_info(OPUS_NONTHREADSAFE_PSEUDOSTACK OPUS_NONTHREADSAFE_PSEUDOSTACK ${OPUS_NONTHREADSAFE_PSEUDOSTACK_HELP_STR})
+
+set(OPUS_FAST_MATH_HELP_STR "enable fast math (unsupported and discouraged use, as code is not well tested with this build option).")
+cmake_dependent_option(OPUS_FAST_MATH
+                       ${OPUS_FAST_MATH_HELP_STR}
+                       ON
+                       "OPUS_FLOAT_APPROX; OPUS_FAST_MATH; FAST_MATH_SUPPORTED"
+                       OFF)
+add_feature_info(OPUS_FAST_MATH OPUS_FAST_MATH ${OPUS_FAST_MATH_HELP_STR})
+
+set(OPUS_STACK_PROTECTOR_HELP_STR "use stack protection.")
+cmake_dependent_option(OPUS_STACK_PROTECTOR
+                       ${OPUS_STACK_PROTECTOR_HELP_STR}
+                       ON
+                       "STACK_PROTECTOR_SUPPORTED"
+                       OFF)
+add_feature_info(OPUS_STACK_PROTECTOR OPUS_STACK_PROTECTOR ${OPUS_STACK_PROTECTOR_HELP_STR})
+
+if(NOT MSVC)
+  set(OPUS_FORTIFY_SOURCE_HELP_STR "add protection against buffer overflows.")
+  cmake_dependent_option(OPUS_FORTIFY_SOURCE
+                         ${OPUS_FORTIFY_SOURCE_HELP_STR}
+                         ON
+                         "FORTIFY_SOURCE_SUPPORTED"
+                         OFF)
+  add_feature_info(OPUS_FORTIFY_SOURCE OPUS_FORTIFY_SOURCE ${OPUS_FORTIFY_SOURCE_HELP_STR})
+endif()
+
+if(MINGW AND (OPUS_FORTIFY_SOURCE OR OPUS_STACK_PROTECTOR))
+  # ssp lib is needed for security features for MINGW
+  list(APPEND OPUS_REQUIRED_LIBRARIES ssp)
+endif()
+
+if(OPUS_CPU_X86 OR OPUS_CPU_X64)
+  set(OPUS_X86_MAY_HAVE_SSE_HELP_STR "does runtime check for SSE1 support.")
+  cmake_dependent_option(OPUS_X86_MAY_HAVE_SSE
+                         ${OPUS_X86_MAY_HAVE_SSE_HELP_STR}
+                         ON
+                         "SSE1_SUPPORTED; NOT OPUS_DISABLE_INTRINSICS"
+                         OFF)
+  add_feature_info(OPUS_X86_MAY_HAVE_SSE OPUS_X86_MAY_HAVE_SSE ${OPUS_X86_MAY_HAVE_SSE_HELP_STR})
+
+  set(OPUS_X86_MAY_HAVE_SSE2_HELP_STR "does runtime check for SSE2 support.")
+  cmake_dependent_option(OPUS_X86_MAY_HAVE_SSE2
+                         ${OPUS_X86_MAY_HAVE_SSE2_HELP_STR}
+                         ON
+                         "SSE2_SUPPORTED; NOT OPUS_DISABLE_INTRINSICS"
+                         OFF)
+  add_feature_info(OPUS_X86_MAY_HAVE_SSE2 OPUS_X86_MAY_HAVE_SSE2 ${OPUS_X86_MAY_HAVE_SSE2_HELP_STR})
+
+  set(OPUS_X86_MAY_HAVE_SSE4_1_HELP_STR "does runtime check for SSE4.1 support.")
+  cmake_dependent_option(OPUS_X86_MAY_HAVE_SSE4_1
+                         ${OPUS_X86_MAY_HAVE_SSE4_1_HELP_STR}
+                         ON
+                         "SSE4_1_SUPPORTED; NOT OPUS_DISABLE_INTRINSICS"
+                         OFF)
+  add_feature_info(OPUS_X86_MAY_HAVE_SSE4_1 OPUS_X86_MAY_HAVE_SSE4_1 ${OPUS_X86_MAY_HAVE_SSE4_1_HELP_STR})
+
+  set(OPUS_X86_MAY_HAVE_AVX_HELP_STR "does runtime check for AVX support.")
+  cmake_dependent_option(OPUS_X86_MAY_HAVE_AVX
+                         ${OPUS_X86_MAY_HAVE_AVX_HELP_STR}
+                         ON
+                         "AVX_SUPPORTED; NOT OPUS_DISABLE_INTRINSICS"
+                         OFF)
+  add_feature_info(OPUS_X86_MAY_HAVE_AVX OPUS_X86_MAY_HAVE_AVX ${OPUS_X86_MAY_HAVE_AVX_HELP_STR})
+
+  # PRESUME depends on MAY HAVE, but PRESUME will override runtime detection
+  set(OPUS_X86_PRESUME_SSE_HELP_STR "assume target CPU has SSE1 support (override runtime check).")
+  set(OPUS_X86_PRESUME_SSE2_HELP_STR "assume target CPU has SSE2 support (override runtime check).")
+  if(OPUS_CPU_X64) # Assume x86_64 has up to SSE2 support
+    cmake_dependent_option(OPUS_X86_PRESUME_SSE
+                           ${OPUS_X86_PRESUME_SSE_HELP_STR}
+                           ON
+                           "OPUS_X86_MAY_HAVE_SSE; NOT OPUS_DISABLE_INTRINSICS"
+                           OFF)
+
+    cmake_dependent_option(OPUS_X86_PRESUME_SSE2
+                           ${OPUS_X86_PRESUME_SSE2_HELP_STR}
+                           ON
+                           "OPUS_X86_MAY_HAVE_SSE2; NOT OPUS_DISABLE_INTRINSICS"
+                           OFF)
+  else()
+    cmake_dependent_option(OPUS_X86_PRESUME_SSE
+                           ${OPUS_X86_PRESUME_SSE_HELP_STR}
+                           OFF
+                           "OPUS_X86_MAY_HAVE_SSE; NOT OPUS_DISABLE_INTRINSICS"
+                           OFF)
+
+    cmake_dependent_option(OPUS_X86_PRESUME_SSE2
+                           ${OPUS_X86_PRESUME_SSE2_HELP_STR}
+                           OFF
+                           "OPUS_X86_MAY_HAVE_SSE2; NOT OPUS_DISABLE_INTRINSICS"
+                           OFF)
+  endif()
+  add_feature_info(OPUS_X86_PRESUME_SSE OPUS_X86_PRESUME_SSE ${OPUS_X86_PRESUME_SSE_HELP_STR})
+  add_feature_info(OPUS_X86_PRESUME_SSE2 OPUS_X86_PRESUME_SSE2 ${OPUS_X86_PRESUME_SSE2_HELP_STR})
+
+  set(OPUS_X86_PRESUME_SSE4_1_HELP_STR "assume target CPU has SSE4.1 support (override runtime check).")
+  cmake_dependent_option(OPUS_X86_PRESUME_SSE4_1
+                         ${OPUS_X86_PRESUME_SSE4_1_HELP_STR}
+                         OFF
+                         "OPUS_X86_MAY_HAVE_SSE4_1; NOT OPUS_DISABLE_INTRINSICS"
+                         OFF)
+  add_feature_info(OPUS_X86_PRESUME_SSE4_1 OPUS_X86_PRESUME_SSE4_1 ${OPUS_X86_PRESUME_SSE4_1_HELP_STR})
+
+  set(OPUS_X86_PRESUME_AVX_HELP_STR "assume target CPU has AVX support (override runtime check).")
+  cmake_dependent_option(OPUS_X86_PRESUME_AVX
+                         ${OPUS_X86_PRESUME_AVX_HELP_STR}
+                         OFF
+                         "OPUS_X86_MAY_HAVE_AVX; NOT OPUS_DISABLE_INTRINSICS"
+                         OFF)
+  add_feature_info(OPUS_X86_PRESUME_AVX OPUS_X86_PRESUME_AVX ${OPUS_X86_PRESUME_AVX_HELP_STR})
+endif()
+
+feature_summary(WHAT ALL)
+
+set_package_properties(Git
+                       PROPERTIES
+                       TYPE
+                       REQUIRED
+                       DESCRIPTION
+                       "fast, scalable, distributed revision control system"
+                       URL
+                       "https://git-scm.com/"
+                       PURPOSE
+                       "required to set up package version")
+
+set(Opus_PUBLIC_HEADER
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/opus.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/opus_defines.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/opus_multistream.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/opus_projection.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/opus_types.h)
+
+if(OPUS_CUSTOM_MODES)
+  list(APPEND Opus_PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/include/opus_custom.h)
+endif()
+
+add_library(opus ${opus_headers} ${opus_sources} ${opus_sources_float} ${Opus_PUBLIC_HEADER})
+add_library(Opus::opus ALIAS opus)
+
+get_library_version(OPUS_LIBRARY_VERSION OPUS_LIBRARY_VERSION_MAJOR)
+message(DEBUG "Opus library version: ${OPUS_LIBRARY_VERSION}")
+
+set_target_properties(opus
+                      PROPERTIES SOVERSION
+                                 ${OPUS_LIBRARY_VERSION_MAJOR}
+                                 VERSION
+                                 ${OPUS_LIBRARY_VERSION}
+                                 PUBLIC_HEADER
+                                 "${Opus_PUBLIC_HEADER}")
+
+target_include_directories(
+  opus
+  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/opus>
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
+          ${CMAKE_CURRENT_SOURCE_DIR}
+          celt
+          silk)
+
+target_link_libraries(opus PRIVATE ${OPUS_REQUIRED_LIBRARIES})
+target_compile_definitions(opus PRIVATE OPUS_BUILD)
+
+if(OPUS_FIXED_POINT_DEBUG)
+  target_compile_definitions(opus PRIVATE FIXED_DEBUG)
+endif()
+
+if(OPUS_FORTIFY_SOURCE AND NOT MSVC)
+  target_compile_definitions(opus PRIVATE
+                             $<$<NOT:$<CONFIG:debug>>:_FORTIFY_SOURCE=2>)
+endif()
+
+if(OPUS_FLOAT_APPROX)
+  target_compile_definitions(opus PRIVATE FLOAT_APPROX)
+endif()
+
+if(OPUS_ASSERTIONS)
+  target_compile_definitions(opus PRIVATE ENABLE_ASSERTIONS)
+endif()
+
+if(OPUS_HARDENING)
+  target_compile_definitions(opus PRIVATE ENABLE_HARDENING)
+endif()
+
+if(OPUS_FUZZING)
+  target_compile_definitions(opus PRIVATE FUZZING)
+endif()
+
+if(OPUS_CHECK_ASM)
+  target_compile_definitions(opus PRIVATE OPUS_CHECK_ASM)
+endif()
+
+if(OPUS_VAR_ARRAYS)
+  target_compile_definitions(opus PRIVATE VAR_ARRAYS)
+elseif(OPUS_USE_ALLOCA)
+  target_compile_definitions(opus PRIVATE USE_ALLOCA)
+elseif(OPUS_NONTHREADSAFE_PSEUDOSTACK)
+  target_compile_definitions(opus PRIVATE NONTHREADSAFE_PSEUDOSTACK)
+else()
+  message(ERROR "Need to set a define for stack allocation")
+endif()
+
+if(OPUS_CUSTOM_MODES)
+  target_compile_definitions(opus PRIVATE CUSTOM_MODES)
+endif()
+
+if(OPUS_FAST_MATH)
+  if(MSVC)
+    target_compile_options(opus PRIVATE /fp:fast)
+  else()
+    target_compile_options(opus PRIVATE -ffast-math)
+  endif()
+endif()
+
+if(OPUS_STACK_PROTECTOR)
+  if(MSVC)
+    target_compile_options(opus PRIVATE /GS)
+  else()
+    target_compile_options(opus PRIVATE -fstack-protector-strong)
+  endif()
+elseif(STACK_PROTECTOR_DISABLED_SUPPORTED)
+  target_compile_options(opus PRIVATE /GS-)
+endif()
+
+if(BUILD_SHARED_LIBS)
+  if(WIN32)
+    target_compile_definitions(opus PRIVATE DLL_EXPORT)
+  elseif(HIDDEN_VISIBILITY_SUPPORTED)
+    set_target_properties(opus PROPERTIES C_VISIBILITY_PRESET hidden)
+  endif()
+endif()
+
+add_sources_group(opus silk ${silk_headers} ${silk_sources})
+add_sources_group(opus celt ${celt_headers} ${celt_sources})
+
+if(OPUS_FIXED_POINT)
+  add_sources_group(opus silk ${silk_sources_fixed})
+  target_include_directories(opus PRIVATE silk/fixed)
+  target_compile_definitions(opus PRIVATE FIXED_POINT=1)
+else()
+  add_sources_group(opus silk ${silk_sources_float})
+  target_include_directories(opus PRIVATE silk/float)
+endif()
+
+if(NOT OPUS_ENABLE_FLOAT_API)
+  target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
+endif()
+
+if(NOT OPUS_DISABLE_INTRINSICS)
+  if((OPUS_X86_MAY_HAVE_SSE AND NOT OPUS_X86_PRESUME_SSE) OR
+     (OPUS_X86_MAY_HAVE_SSE2 AND NOT OPUS_X86_PRESUME_SSE2) OR
+     (OPUS_X86_MAY_HAVE_SSE4_1 AND NOT OPUS_X86_PRESUME_SSE4_1) OR
+     (OPUS_X86_MAY_HAVE_AVX AND NOT OPUS_X86_PRESUME_AVX))
+    target_compile_definitions(opus PRIVATE OPUS_HAVE_RTCD)
+  endif()
+
+  if(SSE1_SUPPORTED)
+    if(OPUS_X86_MAY_HAVE_SSE)
+      add_sources_group(opus celt ${celt_sources_sse})
+      target_compile_definitions(opus PRIVATE OPUS_X86_MAY_HAVE_SSE)
+      if(NOT MSVC)
+        set_source_files_properties(${celt_sources_sse} PROPERTIES COMPILE_FLAGS -msse)
+      endif()
+    endif()
+    if(OPUS_X86_PRESUME_SSE)
+      target_compile_definitions(opus PRIVATE OPUS_X86_PRESUME_SSE)
+      if(NOT MSVC)
+        target_compile_options(opus PRIVATE -msse)
+      endif()
+    endif()
+  endif()
+
+  if(SSE2_SUPPORTED)
+    if(OPUS_X86_MAY_HAVE_SSE2)
+      add_sources_group(opus celt ${celt_sources_sse2})
+      target_compile_definitions(opus PRIVATE OPUS_X86_MAY_HAVE_SSE2)
+      if(NOT MSVC)
+        set_source_files_properties(${celt_sources_sse2} PROPERTIES COMPILE_FLAGS -msse2)
+      endif()
+    endif()
+    if(OPUS_X86_PRESUME_SSE2)
+      target_compile_definitions(opus PRIVATE OPUS_X86_PRESUME_SSE2)
+      if(NOT MSVC)
+        target_compile_options(opus PRIVATE -msse2)
+      endif()
+    endif()
+  endif()
+
+  if(SSE4_1_SUPPORTED)
+    if(OPUS_X86_MAY_HAVE_SSE4_1)
+      add_sources_group(opus celt ${celt_sources_sse4_1})
+      add_sources_group(opus silk ${silk_sources_sse4_1})
+      target_compile_definitions(opus PRIVATE OPUS_X86_MAY_HAVE_SSE4_1)
+      if(NOT MSVC)
+        set_source_files_properties(${celt_sources_sse4_1} ${silk_sources_sse4_1} PROPERTIES COMPILE_FLAGS -msse4.1)
+      endif()
+
+      if(OPUS_FIXED_POINT)
+        add_sources_group(opus silk ${silk_sources_fixed_sse4_1})
+        if(NOT MSVC)
+          set_source_files_properties(${silk_sources_fixed_sse4_1} PROPERTIES COMPILE_FLAGS -msse4.1)
+        endif()
+      endif()
+    endif()
+    if(OPUS_X86_PRESUME_SSE4_1)
+      target_compile_definitions(opus PRIVATE OPUS_X86_PRESUME_SSE4_1)
+      if(NOT MSVC)
+        target_compile_options(opus PRIVATE -msse4.1)
+      endif()
+    endif()
+  endif()
+
+  if(AVX_SUPPORTED)
+    # mostly placeholder in case of avx intrinsics is added
+    if(OPUS_X86_MAY_HAVE_AVX)
+      target_compile_definitions(opus PRIVATE OPUS_X86_MAY_HAVE_AVX)
+    endif()
+    if(OPUS_X86_PRESUME_AVX)
+      target_compile_definitions(opus PRIVATE OPUS_X86_PRESUME_AVX)
+      if(NOT MSVC)
+        target_compile_options(opus PRIVATE -mavx)
+      endif()
+    endif()
+  endif()
+
+  if(MSVC)
+    if(AVX_SUPPORTED AND OPUS_X86_PRESUME_AVX) # on 64 bit and 32 bits
+      add_definitions(/arch:AVX)
+    elseif(OPUS_CPU_X86) # if AVX not supported then set SSE flag
+      if((SSE4_1_SUPPORTED AND OPUS_X86_PRESUME_SSE4_1)
+         OR (SSE2_SUPPORTED AND OPUS_X86_PRESUME_SSE2))
+        target_compile_definitions(opus PRIVATE /arch:SSE2)
+      elseif(SSE1_SUPPORTED AND OPUS_X86_PRESUME_SSE)
+        target_compile_definitions(opus PRIVATE /arch:SSE)
+      endif()
+    endif()
+  endif()
+
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "(arm|aarch64)")
+    add_sources_group(opus celt ${celt_sources_arm})
+  endif()
+
+  if(COMPILER_SUPPORT_NEON)
+    if(OPUS_MAY_HAVE_NEON)
+      if(RUNTIME_CPU_CAPABILITY_DETECTION)
+        message(STATUS "OPUS_MAY_HAVE_NEON enabling runtime detection")
+        target_compile_definitions(opus PRIVATE OPUS_HAVE_RTCD)
+      else()
+        message(ERROR "Runtime cpu capability detection needed for MAY_HAVE_NEON")
+      endif()
+      # Do runtime check for NEON
+      target_compile_definitions(opus
+                                 PRIVATE
+                                 OPUS_ARM_MAY_HAVE_NEON
+                                 OPUS_ARM_MAY_HAVE_NEON_INTR)
+    endif()
+
+    add_sources_group(opus celt ${celt_sources_arm_neon_intr})
+    add_sources_group(opus silk ${silk_sources_arm_neon_intr})
+
+    # silk arm neon depends on main_Fix.h
+    target_include_directories(opus PRIVATE silk/fixed)
+
+    if(OPUS_FIXED_POINT)
+      add_sources_group(opus silk ${silk_sources_fixed_arm_neon_intr})
+    endif()
+
+    if(OPUS_PRESUME_NEON)
+      target_compile_definitions(opus
+                                 PRIVATE
+                                 OPUS_ARM_PRESUME_NEON
+                                 OPUS_ARM_PRESUME_NEON_INTR)
+    endif()
+  endif()
+endif()
+
+target_compile_definitions(opus
+                           PRIVATE
+                           $<$<BOOL:${HAVE_LRINT}>:HAVE_LRINT>
+                           $<$<BOOL:${HAVE_LRINTF}>:HAVE_LRINTF>)
+
+if(OPUS_BUILD_FRAMEWORK)
+  set_target_properties(opus PROPERTIES
+                        FRAMEWORK TRUE
+                        FRAMEWORK_VERSION ${PROJECT_VERSION}
+                        MACOSX_FRAMEWORK_IDENTIFIER org.xiph.opus
+                        MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${PROJECT_VERSION}
+                        MACOSX_FRAMEWORK_BUNDLE_VERSION ${PROJECT_VERSION}
+                        XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
+                        OUTPUT_NAME Opus)
+endif()
+
+install(TARGETS opus
+        EXPORT OpusTargets
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
+        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
+
+if(OPUS_INSTALL_PKG_CONFIG_MODULE)
+  set(prefix ${CMAKE_INSTALL_PREFIX})
+  set(exec_prefix ${CMAKE_INSTALL_PREFIX})
+  set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
+  set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
+  set(VERSION ${PACKAGE_VERSION})
+  if(HAVE_LIBM)
+    set(LIBM "-lm")
+  endif()
+  configure_file(opus.pc.in opus.pc)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
+          DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+endif()
+
+if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
+  set(CPACK_GENERATOR TGZ)
+  include(CPack)
+  set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
+  install(EXPORT OpusTargets
+          NAMESPACE Opus::
+          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
+
+  include(CMakePackageConfigHelpers)
+
+  set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
+  configure_package_config_file(${PROJECT_SOURCE_DIR}/cmake/OpusConfig.cmake.in
+                                OpusConfig.cmake
+                                INSTALL_DESTINATION
+                                ${CMAKE_INSTALL_PACKAGEDIR}
+                                PATH_VARS
+                                INCLUDE_INSTALL_DIR
+                                INSTALL_PREFIX
+                                ${CMAKE_INSTALL_PREFIX})
+  write_basic_package_version_file(OpusConfigVersion.cmake
+                                   VERSION ${PROJECT_VERSION}
+                                   COMPATIBILITY SameMajorVersion)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
+                ${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
+          DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
+endif()
+
+if(OPUS_BUILD_PROGRAMS)
+  # demo
+  if(OPUS_CUSTOM_MODES)
+    add_executable(opus_custom_demo ${opus_custom_demo_sources})
+    target_include_directories(opus_custom_demo
+                               PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+    target_link_libraries(opus_custom_demo PRIVATE opus)
+  endif()
+
+  add_executable(opus_demo ${opus_demo_sources})
+  target_include_directories(opus_demo PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+  target_include_directories(opus_demo PRIVATE silk) # debug.h
+  target_include_directories(opus_demo PRIVATE celt) # arch.h
+  target_link_libraries(opus_demo PRIVATE opus ${OPUS_REQUIRED_LIBRARIES})
+
+  # compare
+  add_executable(opus_compare ${opus_compare_sources})
+  target_include_directories(opus_compare PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+  target_link_libraries(opus_compare PRIVATE opus ${OPUS_REQUIRED_LIBRARIES})
+endif()
+
+if(BUILD_TESTING)
+  enable_testing()
+
+  # tests
+  add_executable(test_opus_decode ${test_opus_decode_sources})
+  target_include_directories(test_opus_decode
+                             PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+  target_link_libraries(test_opus_decode PRIVATE opus)
+  if(OPUS_FIXED_POINT)
+    target_compile_definitions(test_opus_decode PRIVATE DISABLE_FLOAT_API)
+  endif()
+  add_test(NAME test_opus_decode COMMAND $<TARGET_FILE:test_opus_decode> WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+
+  add_executable(test_opus_padding ${test_opus_padding_sources})
+  target_include_directories(test_opus_padding
+                             PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+  target_link_libraries(test_opus_padding PRIVATE opus)
+  add_test(NAME test_opus_padding COMMAND $<TARGET_FILE:test_opus_padding> WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+
+  if(NOT BUILD_SHARED_LIBS)
+    # disable tests that depends on private API when building shared lib
+    add_executable(test_opus_api ${test_opus_api_sources})
+    target_include_directories(test_opus_api
+                               PRIVATE ${CMAKE_CURRENT_BINARY_DIR} celt)
+    target_link_libraries(test_opus_api PRIVATE opus)
+    if(OPUS_FIXED_POINT)
+      target_compile_definitions(test_opus_api PRIVATE DISABLE_FLOAT_API)
+    endif()
+    add_test(NAME test_opus_api COMMAND $<TARGET_FILE:test_opus_api> WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+
+    add_executable(test_opus_encode ${test_opus_encode_sources})
+    target_include_directories(test_opus_encode
+                               PRIVATE ${CMAKE_CURRENT_BINARY_DIR} celt)
+    target_link_libraries(test_opus_encode PRIVATE opus)
+    add_test(NAME test_opus_encode COMMAND $<TARGET_FILE:test_opus_encode> WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+  endif()
+endif()
diff --git a/METADATA b/METADATA
new file mode 100644
index 00000000..4d26f677
--- /dev/null
+++ b/METADATA
@@ -0,0 +1,15 @@
+name: "libopus"
+description: "Android fork of the opus library."
+third_party {
+  url {
+    type: GIT
+    value: "https://gitlab.xiph.org/xiph/opus.git"
+  }
+  version: "d633f523e36e3b6d01cc6d57386458d770d618be"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2021
+    month: 2
+    day: 5
+  }
+}
diff --git a/Makefile.am b/Makefile.am
index 9c09decd..83beaa3f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -103,7 +103,8 @@ noinst_PROGRAMS = celt/tests/test_unit_cwrs32 \
                   tests/test_opus_decode \
                   tests/test_opus_encode \
                   tests/test_opus_padding \
-                  tests/test_opus_projection
+                  tests/test_opus_projection \
+                  trivial_example
 
 TESTS = celt/tests/test_unit_cwrs32 \
         celt/tests/test_unit_dft \
@@ -131,6 +132,9 @@ repacketizer_demo_LDADD = libopus.la $(NE10_LIBS) $(LIBM)
 opus_compare_SOURCES = src/opus_compare.c
 opus_compare_LDADD = $(LIBM)
 
+trivial_example_SOURCES = doc/trivial_example.c
+trivial_example_LDADD = libopus.la $(LIBM)
+
 tests_test_opus_api_SOURCES = tests/test_opus_api.c tests/test_opus_common.h
 tests_test_opus_api_LDADD = libopus.la $(NE10_LIBS) $(LIBM)
 
@@ -210,6 +214,28 @@ EXTRA_DIST = opus.pc.in \
              opus.m4 \
              Makefile.mips \
              Makefile.unix \
+             CMakeLists.txt \
+             cmake/CFeatureCheck.cmake \
+             cmake/OpusBuildtype.cmake \
+             cmake/OpusConfig.cmake \
+             cmake/OpusConfig.cmake.in \
+             cmake/OpusFunctions.cmake \
+             cmake/OpusPackageVersion.cmake \
+             cmake/OpusSources.cmake \
+             cmake/config.h.cmake.in \
+             cmake/vla.c \
+             meson/get-version.py \
+             meson/read-sources-list.py \
+             meson.build \
+             meson_options.txt \
+             include/meson.build \
+             celt/meson.build \
+             celt/tests/meson.build \
+             silk/meson.build \
+             silk/tests/meson.build \
+             src/meson.build \
+             tests/meson.build \
+             doc/meson.build \
              tests/run_vectors.sh \
              celt/arm/arm2gnu.pl \
              celt/arm/celt_pitch_xcorr_arm.s \
diff --git a/Makefile.mips b/Makefile.mips
index d25af8cb..e9bfc22e 100644
--- a/Makefile.mips
+++ b/Makefile.mips
@@ -12,7 +12,7 @@ CFLAGS := -DUSE_ALLOCA $(CFLAGS)
 
 # These options affect performance
 # HAVE_LRINTF: Use C99 intrinsics to speed up float-to-int conversion
-#CFLAGS := -DHAVE_LRINTF $(CFLAGS)
+CFLAGS := -DHAVE_LRINTF $(CFLAGS)
 
 ###################### END OF OPTIONS ######################
 
diff --git a/OWNERS b/OWNERS
index 229a6413..c836410a 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1,4 +1,4 @@
-# Default code reviewers picked from top 3 or more developers.
-# Please update this list if you find better candidates.
+# owners for external/sonivox
+include platform/frameworks/av:/media/janitors/codec_OWNERS
 flim@google.com
 essick@google.com
diff --git a/README b/README
index 27fddf96..4b13076f 100644
--- a/README
+++ b/README
@@ -35,7 +35,7 @@ An opus-tools package is available which provides encoding and decoding of
 Ogg encapsulated Opus files and includes a number of useful features.
 
 Opus-tools can be found at:
- https://git.xiph.org/?p=opus-tools.git
+ https://gitlab.xiph.org/xiph/opus-tools.git
 or on the main Opus website:
  https://opus-codec.org/
 
@@ -68,7 +68,7 @@ On Apple macOS, install Xcode and brew.sh, then in the Terminal enter:
 
 1) Clone the repository:
 
-    % git clone https://git.xiph.org/opus.git
+    % git clone https://gitlab.xiph.org/xiph/opus.git
     % cd opus
 
 2) Compiling the source
diff --git a/README.draft b/README.draft
index 8d8e24df..9c31bd02 100644
--- a/README.draft
+++ b/README.draft
@@ -7,7 +7,7 @@ If this does not work, or if you want to change the default configuration
 in the Makefile.
 
 An up-to-date implementation conforming to this standard is available in a
-Git repository at https://git.xiph.org/opus.git or on a website at:
+Git repository at https://gitlab.xiph.org/xiph/opus.git or on a website at:
 https://opus-codec.org/
 However, although that implementation is expected to remain conformant
 with the standard, it is the code in this RFC that shall remain normative.
@@ -17,7 +17,7 @@ steps:
 1) Clone the repository (latest implementation of this standard at the time
 of publication)
 
-% git clone https://git.xiph.org/opus.git
+% git clone https://gitlab.xiph.org/xiph/opus.git
 % cd opus
 
 2) Compile
diff --git a/README.version b/README.version
index 77ed7aa4..515fea88 100644
--- a/README.version
+++ b/README.version
@@ -1,3 +1,7 @@
-URL: https://git.xiph.org/?p=opus.git;a=snapshot;h=83d5155f151ca47c9d6274ded1a7481f746b9a43;sf=tgz
-Version: 1.3
-BugComponent: 25690
+This commit is upto-date with following the commit in upstream-master
+Branch: upstream-master
+commit: b83dd52868326a401c8578041e3dbea439d53f11
+
+upstream-master is in sync with upstream project at
+URL: https://gitlab.xiph.org/xiph/opus.git
+
diff --git a/celt/arch.h b/celt/arch.h
index c627a744..3845c3a0 100644
--- a/celt/arch.h
+++ b/celt/arch.h
@@ -73,6 +73,9 @@ __attribute__((noreturn))
 void celt_fatal(const char *str, const char *file, int line)
 {
    fprintf (stderr, "Fatal (internal) error in %s, line %d: %s\n", file, line, str);
+#if defined(_MSC_VER)
+   _set_abort_behavior( 0, _WRITE_ABORT_MSG);
+#endif
    abort();
 }
 #endif
@@ -160,7 +163,7 @@ static OPUS_INLINE opus_int16 SAT16(opus_int32 x) {
 
 #ifdef OPUS_ARM_PRESUME_AARCH64_NEON_INTR
 #include "arm/fixed_arm64.h"
-#elif OPUS_ARM_INLINE_EDSP
+#elif defined (OPUS_ARM_INLINE_EDSP)
 #include "arm/fixed_armv5e.h"
 #elif defined (OPUS_ARM_INLINE_ASM)
 #include "arm/fixed_armv4.h"
diff --git a/celt/arm/armcpu.c b/celt/arm/armcpu.c
index 694a63b7..cce3ae3a 100644
--- a/celt/arm/armcpu.c
+++ b/celt/arm/armcpu.c
@@ -93,6 +93,8 @@ static OPUS_INLINE opus_uint32 opus_cpu_capabilities(void){
 
 #elif defined(__linux__)
 /* Linux based */
+#include <stdio.h>
+
 opus_uint32 opus_cpu_capabilities(void)
 {
   opus_uint32 flags = 0;
diff --git a/celt/arm/celt_pitch_xcorr_arm.s b/celt/arm/celt_pitch_xcorr_arm.s
new file mode 100644
index 00000000..6e873afc
--- /dev/null
+++ b/celt/arm/celt_pitch_xcorr_arm.s
@@ -0,0 +1,551 @@
+; Copyright (c) 2007-2008 CSIRO
+; Copyright (c) 2007-2009 Xiph.Org Foundation
+; Copyright (c) 2013      Parrot
+; Written by Aurélien Zanelli
+;
+; 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.
+;
+; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+; OR 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.
+
+  AREA  |.text|, CODE, READONLY
+
+  GET    celt/arm/armopts.s
+
+IF OPUS_ARM_MAY_HAVE_EDSP
+  EXPORT celt_pitch_xcorr_edsp
+ENDIF
+
+IF OPUS_ARM_MAY_HAVE_NEON
+  EXPORT celt_pitch_xcorr_neon
+ENDIF
+
+IF OPUS_ARM_MAY_HAVE_NEON
+
+; Compute sum[k]=sum(x[j]*y[j+k],j=0...len-1), k=0...3
+xcorr_kernel_neon PROC
+xcorr_kernel_neon_start
+  ; input:
+  ;   r3     = int         len
+  ;   r4     = opus_val16 *x
+  ;   r5     = opus_val16 *y
+  ;   q0     = opus_val32  sum[4]
+  ; output:
+  ;   q0     = opus_val32  sum[4]
+  ; preserved: r0-r3, r6-r11, d2, q4-q7, q9-q15
+  ; internal usage:
+  ;   r12 = int j
+  ;   d3  = y_3|y_2|y_1|y_0
+  ;   q2  = y_B|y_A|y_9|y_8|y_7|y_6|y_5|y_4
+  ;   q3  = x_7|x_6|x_5|x_4|x_3|x_2|x_1|x_0
+  ;   q8  = scratch
+  ;
+  ; Load y[0...3]
+  ; This requires len>0 to always be valid (which we assert in the C code).
+  VLD1.16      {d5}, [r5]!
+  SUBS         r12, r3, #8
+  BLE xcorr_kernel_neon_process4
+; Process 8 samples at a time.
+; This loop loads one y value more than we actually need. Therefore we have to
+; stop as soon as there are 8 or fewer samples left (instead of 7), to avoid
+; reading past the end of the array.
+xcorr_kernel_neon_process8
+  ; This loop has 19 total instructions (10 cycles to issue, minimum), with
+  ; - 2 cycles of ARM insrtuctions,
+  ; - 10 cycles of load/store/byte permute instructions, and
+  ; - 9 cycles of data processing instructions.
+  ; On a Cortex A8, we dual-issue the maximum amount (9 cycles) between the
+  ; latter two categories, meaning the whole loop should run in 10 cycles per
+  ; iteration, barring cache misses.
+  ;
+  ; Load x[0...7]
+  VLD1.16      {d6, d7}, [r4]!
+  ; Unlike VMOV, VAND is a data processsing instruction (and doesn't get
+  ; assembled to VMOV, like VORR would), so it dual-issues with the prior VLD1.
+  VAND         d3, d5, d5
+  SUBS         r12, r12, #8
+  ; Load y[4...11]
+  VLD1.16      {d4, d5}, [r5]!
+  VMLAL.S16    q0, d3, d6[0]
+  VEXT.16      d16, d3, d4, #1
+  VMLAL.S16    q0, d4, d7[0]
+  VEXT.16      d17, d4, d5, #1
+  VMLAL.S16    q0, d16, d6[1]
+  VEXT.16      d16, d3, d4, #2
+  VMLAL.S16    q0, d17, d7[1]
+  VEXT.16      d17, d4, d5, #2
+  VMLAL.S16    q0, d16, d6[2]
+  VEXT.16      d16, d3, d4, #3
+  VMLAL.S16    q0, d17, d7[2]
+  VEXT.16      d17, d4, d5, #3
+  VMLAL.S16    q0, d16, d6[3]
+  VMLAL.S16    q0, d17, d7[3]
+  BGT xcorr_kernel_neon_process8
+; Process 4 samples here if we have > 4 left (still reading one extra y value).
+xcorr_kernel_neon_process4
+  ADDS         r12, r12, #4
+  BLE xcorr_kernel_neon_process2
+  ; Load x[0...3]
+  VLD1.16      d6, [r4]!
+  ; Use VAND since it's a data processing instruction again.
+  VAND         d4, d5, d5
+  SUB          r12, r12, #4
+  ; Load y[4...7]
+  VLD1.16      d5, [r5]!
+  VMLAL.S16    q0, d4, d6[0]
+  VEXT.16      d16, d4, d5, #1
+  VMLAL.S16    q0, d16, d6[1]
+  VEXT.16      d16, d4, d5, #2
+  VMLAL.S16    q0, d16, d6[2]
+  VEXT.16      d16, d4, d5, #3
+  VMLAL.S16    q0, d16, d6[3]
+; Process 2 samples here if we have > 2 left (still reading one extra y value).
+xcorr_kernel_neon_process2
+  ADDS         r12, r12, #2
+  BLE xcorr_kernel_neon_process1
+  ; Load x[0...1]
+  VLD2.16      {d6[],d7[]}, [r4]!
+  ; Use VAND since it's a data processing instruction again.
+  VAND         d4, d5, d5
+  SUB          r12, r12, #2
+  ; Load y[4...5]
+  VLD1.32      {d5[]}, [r5]!
+  VMLAL.S16    q0, d4, d6
+  VEXT.16      d16, d4, d5, #1
+  ; Replace bottom copy of {y5,y4} in d5 with {y3,y2} from d4, using VSRI
+  ; instead of VEXT, since it's a data-processing instruction.
+  VSRI.64      d5, d4, #32
+  VMLAL.S16    q0, d16, d7
+; Process 1 sample using the extra y value we loaded above.
+xcorr_kernel_neon_process1
+  ; Load next *x
+  VLD1.16      {d6[]}, [r4]!
+  ADDS         r12, r12, #1
+  ; y[0...3] are left in d5 from prior iteration(s) (if any)
+  VMLAL.S16    q0, d5, d6
+  MOVLE        pc, lr
+; Now process 1 last sample, not reading ahead.
+  ; Load last *y
+  VLD1.16      {d4[]}, [r5]!
+  VSRI.64      d4, d5, #16
+  ; Load last *x
+  VLD1.16      {d6[]}, [r4]!
+  VMLAL.S16    q0, d4, d6
+  MOV          pc, lr
+  ENDP
+
+; opus_val32 celt_pitch_xcorr_neon(opus_val16 *_x, opus_val16 *_y,
+;  opus_val32 *xcorr, int len, int max_pitch, int arch)
+celt_pitch_xcorr_neon PROC
+  ; input:
+  ;   r0  = opus_val16 *_x
+  ;   r1  = opus_val16 *_y
+  ;   r2  = opus_val32 *xcorr
+  ;   r3  = int         len
+  ; output:
+  ;   r0  = int         maxcorr
+  ; internal usage:
+  ;   r4  = opus_val16 *x (for xcorr_kernel_neon())
+  ;   r5  = opus_val16 *y (for xcorr_kernel_neon())
+  ;   r6  = int         max_pitch
+  ;   r12 = int         j
+  ;   q15 = int         maxcorr[4] (q15 is not used by xcorr_kernel_neon())
+  ; ignored:
+  ;         int         arch
+  STMFD        sp!, {r4-r6, lr}
+  LDR          r6, [sp, #16]
+  VMOV.S32     q15, #1
+  ; if (max_pitch < 4) goto celt_pitch_xcorr_neon_process4_done
+  SUBS         r6, r6, #4
+  BLT celt_pitch_xcorr_neon_process4_done
+celt_pitch_xcorr_neon_process4
+  ; xcorr_kernel_neon parameters:
+  ; r3 = len, r4 = _x, r5 = _y, q0 = {0, 0, 0, 0}
+  MOV          r4, r0
+  MOV          r5, r1
+  VEOR         q0, q0, q0
+  ; xcorr_kernel_neon only modifies r4, r5, r12, and q0...q3.
+  ; So we don't save/restore any other registers.
+  BL xcorr_kernel_neon_start
+  SUBS         r6, r6, #4
+  VST1.32      {q0}, [r2]!
+  ; _y += 4
+  ADD          r1, r1, #8
+  VMAX.S32     q15, q15, q0
+  ; if (max_pitch < 4) goto celt_pitch_xcorr_neon_process4_done
+  BGE celt_pitch_xcorr_neon_process4
+; We have less than 4 sums left to compute.
+celt_pitch_xcorr_neon_process4_done
+  ADDS         r6, r6, #4
+  ; Reduce maxcorr to a single value
+  VMAX.S32     d30, d30, d31
+  VPMAX.S32    d30, d30, d30
+  ; if (max_pitch <= 0) goto celt_pitch_xcorr_neon_done
+  BLE celt_pitch_xcorr_neon_done
+; Now compute each remaining sum one at a time.
+celt_pitch_xcorr_neon_process_remaining
+  MOV          r4, r0
+  MOV          r5, r1
+  VMOV.I32     q0, #0
+  SUBS         r12, r3, #8
+  BLT celt_pitch_xcorr_neon_process_remaining4
+; Sum terms 8 at a time.
+celt_pitch_xcorr_neon_process_remaining_loop8
+  ; Load x[0...7]
+  VLD1.16      {q1}, [r4]!
+  ; Load y[0...7]
+  VLD1.16      {q2}, [r5]!
+  SUBS         r12, r12, #8
+  VMLAL.S16    q0, d4, d2
+  VMLAL.S16    q0, d5, d3
+  BGE celt_pitch_xcorr_neon_process_remaining_loop8
+; Sum terms 4 at a time.
+celt_pitch_xcorr_neon_process_remaining4
+  ADDS         r12, r12, #4
+  BLT celt_pitch_xcorr_neon_process_remaining4_done
+  ; Load x[0...3]
+  VLD1.16      {d2}, [r4]!
+  ; Load y[0...3]
+  VLD1.16      {d3}, [r5]!
+  SUB          r12, r12, #4
+  VMLAL.S16    q0, d3, d2
+celt_pitch_xcorr_neon_process_remaining4_done
+  ; Reduce the sum to a single value.
+  VADD.S32     d0, d0, d1
+  VPADDL.S32   d0, d0
+  ADDS         r12, r12, #4
+  BLE celt_pitch_xcorr_neon_process_remaining_loop_done
+; Sum terms 1 at a time.
+celt_pitch_xcorr_neon_process_remaining_loop1
+  VLD1.16      {d2[]}, [r4]!
+  VLD1.16      {d3[]}, [r5]!
+  SUBS         r12, r12, #1
+  VMLAL.S16    q0, d2, d3
+  BGT celt_pitch_xcorr_neon_process_remaining_loop1
+celt_pitch_xcorr_neon_process_remaining_loop_done
+  VST1.32      {d0[0]}, [r2]!
+  VMAX.S32     d30, d30, d0
+  SUBS         r6, r6, #1
+  ; _y++
+  ADD          r1, r1, #2
+  ; if (--max_pitch > 0) goto celt_pitch_xcorr_neon_process_remaining
+  BGT celt_pitch_xcorr_neon_process_remaining
+celt_pitch_xcorr_neon_done
+  VMOV.32      r0, d30[0]
+  LDMFD        sp!, {r4-r6, pc}
+  ENDP
+
+ENDIF
+
+IF OPUS_ARM_MAY_HAVE_EDSP
+
+; This will get used on ARMv7 devices without NEON, so it has been optimized
+; to take advantage of dual-issuing where possible.
+xcorr_kernel_edsp PROC
+xcorr_kernel_edsp_start
+  ; input:
+  ;   r3      = int         len
+  ;   r4      = opus_val16 *_x (must be 32-bit aligned)
+  ;   r5      = opus_val16 *_y (must be 32-bit aligned)
+  ;   r6...r9 = opus_val32  sum[4]
+  ; output:
+  ;   r6...r9 = opus_val32  sum[4]
+  ; preserved: r0-r5
+  ; internal usage
+  ;   r2      = int         j
+  ;   r12,r14 = opus_val16  x[4]
+  ;   r10,r11 = opus_val16  y[4]
+  STMFD        sp!, {r2,r4,r5,lr}
+  LDR          r10, [r5], #4      ; Load y[0...1]
+  SUBS         r2, r3, #4         ; j = len-4
+  LDR          r11, [r5], #4      ; Load y[2...3]
+  BLE xcorr_kernel_edsp_process4_done
+  LDR          r12, [r4], #4      ; Load x[0...1]
+  ; Stall
+xcorr_kernel_edsp_process4
+  ; The multiplies must issue from pipeline 0, and can't dual-issue with each
+  ; other. Every other instruction here dual-issues with a multiply, and is
+  ; thus "free". There should be no stalls in the body of the loop.
+  SMLABB       r6, r12, r10, r6   ; sum[0] = MAC16_16(sum[0],x_0,y_0)
+  LDR          r14, [r4], #4      ; Load x[2...3]
+  SMLABT       r7, r12, r10, r7   ; sum[1] = MAC16_16(sum[1],x_0,y_1)
+  SUBS         r2, r2, #4         ; j-=4
+  SMLABB       r8, r12, r11, r8   ; sum[2] = MAC16_16(sum[2],x_0,y_2)
+  SMLABT       r9, r12, r11, r9   ; sum[3] = MAC16_16(sum[3],x_0,y_3)
+  SMLATT       r6, r12, r10, r6   ; sum[0] = MAC16_16(sum[0],x_1,y_1)
+  LDR          r10, [r5], #4      ; Load y[4...5]
+  SMLATB       r7, r12, r11, r7   ; sum[1] = MAC16_16(sum[1],x_1,y_2)
+  SMLATT       r8, r12, r11, r8   ; sum[2] = MAC16_16(sum[2],x_1,y_3)
+  SMLATB       r9, r12, r10, r9   ; sum[3] = MAC16_16(sum[3],x_1,y_4)
+  LDRGT        r12, [r4], #4      ; Load x[0...1]
+  SMLABB       r6, r14, r11, r6   ; sum[0] = MAC16_16(sum[0],x_2,y_2)
+  SMLABT       r7, r14, r11, r7   ; sum[1] = MAC16_16(sum[1],x_2,y_3)
+  SMLABB       r8, r14, r10, r8   ; sum[2] = MAC16_16(sum[2],x_2,y_4)
+  SMLABT       r9, r14, r10, r9   ; sum[3] = MAC16_16(sum[3],x_2,y_5)
+  SMLATT       r6, r14, r11, r6   ; sum[0] = MAC16_16(sum[0],x_3,y_3)
+  LDR          r11, [r5], #4      ; Load y[6...7]
+  SMLATB       r7, r14, r10, r7   ; sum[1] = MAC16_16(sum[1],x_3,y_4)
+  SMLATT       r8, r14, r10, r8   ; sum[2] = MAC16_16(sum[2],x_3,y_5)
+  SMLATB       r9, r14, r11, r9   ; sum[3] = MAC16_16(sum[3],x_3,y_6)
+  BGT xcorr_kernel_edsp_process4
+xcorr_kernel_edsp_process4_done
+  ADDS         r2, r2, #4
+  BLE xcorr_kernel_edsp_done
+  LDRH         r12, [r4], #2      ; r12 = *x++
+  SUBS         r2, r2, #1         ; j--
+  ; Stall
+  SMLABB       r6, r12, r10, r6   ; sum[0] = MAC16_16(sum[0],x,y_0)
+  LDRHGT       r14, [r4], #2      ; r14 = *x++
+  SMLABT       r7, r12, r10, r7   ; sum[1] = MAC16_16(sum[1],x,y_1)
+  SMLABB       r8, r12, r11, r8   ; sum[2] = MAC16_16(sum[2],x,y_2)
+  SMLABT       r9, r12, r11, r9   ; sum[3] = MAC16_16(sum[3],x,y_3)
+  BLE xcorr_kernel_edsp_done
+  SMLABT       r6, r14, r10, r6   ; sum[0] = MAC16_16(sum[0],x,y_1)
+  SUBS         r2, r2, #1         ; j--
+  SMLABB       r7, r14, r11, r7   ; sum[1] = MAC16_16(sum[1],x,y_2)
+  LDRH         r10, [r5], #2      ; r10 = y_4 = *y++
+  SMLABT       r8, r14, r11, r8   ; sum[2] = MAC16_16(sum[2],x,y_3)
+  LDRHGT       r12, [r4], #2      ; r12 = *x++
+  SMLABB       r9, r14, r10, r9   ; sum[3] = MAC16_16(sum[3],x,y_4)
+  BLE xcorr_kernel_edsp_done
+  SMLABB       r6, r12, r11, r6   ; sum[0] = MAC16_16(sum[0],tmp,y_2)
+  CMP          r2, #1             ; j--
+  SMLABT       r7, r12, r11, r7   ; sum[1] = MAC16_16(sum[1],tmp,y_3)
+  LDRH         r2, [r5], #2       ; r2 = y_5 = *y++
+  SMLABB       r8, r12, r10, r8   ; sum[2] = MAC16_16(sum[2],tmp,y_4)
+  LDRHGT       r14, [r4]          ; r14 = *x
+  SMLABB       r9, r12, r2, r9    ; sum[3] = MAC16_16(sum[3],tmp,y_5)
+  BLE xcorr_kernel_edsp_done
+  SMLABT       r6, r14, r11, r6   ; sum[0] = MAC16_16(sum[0],tmp,y_3)
+  LDRH         r11, [r5]          ; r11 = y_6 = *y
+  SMLABB       r7, r14, r10, r7   ; sum[1] = MAC16_16(sum[1],tmp,y_4)
+  SMLABB       r8, r14, r2, r8    ; sum[2] = MAC16_16(sum[2],tmp,y_5)
+  SMLABB       r9, r14, r11, r9   ; sum[3] = MAC16_16(sum[3],tmp,y_6)
+xcorr_kernel_edsp_done
+  LDMFD        sp!, {r2,r4,r5,pc}
+  ENDP
+
+celt_pitch_xcorr_edsp PROC
+  ; input:
+  ;   r0  = opus_val16 *_x (must be 32-bit aligned)
+  ;   r1  = opus_val16 *_y (only needs to be 16-bit aligned)
+  ;   r2  = opus_val32 *xcorr
+  ;   r3  = int         len
+  ; output:
+  ;   r0  = maxcorr
+  ; internal usage
+  ;   r4  = opus_val16 *x
+  ;   r5  = opus_val16 *y
+  ;   r6  = opus_val32  sum0
+  ;   r7  = opus_val32  sum1
+  ;   r8  = opus_val32  sum2
+  ;   r9  = opus_val32  sum3
+  ;   r1  = int         max_pitch
+  ;   r12 = int         j
+  ; ignored:
+  ;         int         arch
+  STMFD        sp!, {r4-r11, lr}
+  MOV          r5, r1
+  LDR          r1, [sp, #36]
+  MOV          r4, r0
+  TST          r5, #3
+  ; maxcorr = 1
+  MOV          r0, #1
+  BEQ          celt_pitch_xcorr_edsp_process1u_done
+; Compute one sum at the start to make y 32-bit aligned.
+  SUBS         r12, r3, #4
+  ; r14 = sum = 0
+  MOV          r14, #0
+  LDRH         r8, [r5], #2
+  BLE celt_pitch_xcorr_edsp_process1u_loop4_done
+  LDR          r6, [r4], #4
+  MOV          r8, r8, LSL #16
+celt_pitch_xcorr_edsp_process1u_loop4
+  LDR          r9, [r5], #4
+  SMLABT       r14, r6, r8, r14     ; sum = MAC16_16(sum, x_0, y_0)
+  LDR          r7, [r4], #4
+  SMLATB       r14, r6, r9, r14     ; sum = MAC16_16(sum, x_1, y_1)
+  LDR          r8, [r5], #4
+  SMLABT       r14, r7, r9, r14     ; sum = MAC16_16(sum, x_2, y_2)
+  SUBS         r12, r12, #4         ; j-=4
+  SMLATB       r14, r7, r8, r14     ; sum = MAC16_16(sum, x_3, y_3)
+  LDRGT        r6, [r4], #4
+  BGT celt_pitch_xcorr_edsp_process1u_loop4
+  MOV          r8, r8, LSR #16
+celt_pitch_xcorr_edsp_process1u_loop4_done
+  ADDS         r12, r12, #4
+celt_pitch_xcorr_edsp_process1u_loop1
+  LDRHGE       r6, [r4], #2
+  ; Stall
+  SMLABBGE     r14, r6, r8, r14    ; sum = MAC16_16(sum, *x, *y)
+  SUBSGE       r12, r12, #1
+  LDRHGT       r8, [r5], #2
+  BGT celt_pitch_xcorr_edsp_process1u_loop1
+  ; Restore _x
+  SUB          r4, r4, r3, LSL #1
+  ; Restore and advance _y
+  SUB          r5, r5, r3, LSL #1
+  ; maxcorr = max(maxcorr, sum)
+  CMP          r0, r14
+  ADD          r5, r5, #2
+  MOVLT        r0, r14
+  SUBS         r1, r1, #1
+  ; xcorr[i] = sum
+  STR          r14, [r2], #4
+  BLE celt_pitch_xcorr_edsp_done
+celt_pitch_xcorr_edsp_process1u_done
+  ; if (max_pitch < 4) goto celt_pitch_xcorr_edsp_process2
+  SUBS         r1, r1, #4
+  BLT celt_pitch_xcorr_edsp_process2
+celt_pitch_xcorr_edsp_process4
+  ; xcorr_kernel_edsp parameters:
+  ; r3 = len, r4 = _x, r5 = _y, r6...r9 = sum[4] = {0, 0, 0, 0}
+  MOV          r6, #0
+  MOV          r7, #0
+  MOV          r8, #0
+  MOV          r9, #0
+  BL xcorr_kernel_edsp_start  ; xcorr_kernel_edsp(_x, _y+i, xcorr+i, len)
+  ; maxcorr = max(maxcorr, sum0, sum1, sum2, sum3)
+  CMP          r0, r6
+  ; _y+=4
+  ADD          r5, r5, #8
+  MOVLT        r0, r6
+  CMP          r0, r7
+  MOVLT        r0, r7
+  CMP          r0, r8
+  MOVLT        r0, r8
+  CMP          r0, r9
+  MOVLT        r0, r9
+  STMIA        r2!, {r6-r9}
+  SUBS         r1, r1, #4
+  BGE celt_pitch_xcorr_edsp_process4
+celt_pitch_xcorr_edsp_process2
+  ADDS         r1, r1, #2
+  BLT celt_pitch_xcorr_edsp_process1a
+  SUBS         r12, r3, #4
+  ; {r10, r11} = {sum0, sum1} = {0, 0}
+  MOV          r10, #0
+  MOV          r11, #0
+  LDR          r8, [r5], #4
+  BLE celt_pitch_xcorr_edsp_process2_loop_done
+  LDR          r6, [r4], #4
+  LDR          r9, [r5], #4
+celt_pitch_xcorr_edsp_process2_loop4
+  SMLABB       r10, r6, r8, r10     ; sum0 = MAC16_16(sum0, x_0, y_0)
+  LDR          r7, [r4], #4
+  SMLABT       r11, r6, r8, r11     ; sum1 = MAC16_16(sum1, x_0, y_1)
+  SUBS         r12, r12, #4         ; j-=4
+  SMLATT       r10, r6, r8, r10     ; sum0 = MAC16_16(sum0, x_1, y_1)
+  LDR          r8, [r5], #4
+  SMLATB       r11, r6, r9, r11     ; sum1 = MAC16_16(sum1, x_1, y_2)
+  LDRGT        r6, [r4], #4
+  SMLABB       r10, r7, r9, r10     ; sum0 = MAC16_16(sum0, x_2, y_2)
+  SMLABT       r11, r7, r9, r11     ; sum1 = MAC16_16(sum1, x_2, y_3)
+  SMLATT       r10, r7, r9, r10     ; sum0 = MAC16_16(sum0, x_3, y_3)
+  LDRGT        r9, [r5], #4
+  SMLATB       r11, r7, r8, r11     ; sum1 = MAC16_16(sum1, x_3, y_4)
+  BGT celt_pitch_xcorr_edsp_process2_loop4
+celt_pitch_xcorr_edsp_process2_loop_done
+  ADDS         r12, r12, #2
+  BLE  celt_pitch_xcorr_edsp_process2_1
+  LDR          r6, [r4], #4
+  ; Stall
+  SMLABB       r10, r6, r8, r10     ; sum0 = MAC16_16(sum0, x_0, y_0)
+  LDR          r9, [r5], #4
+  SMLABT       r11, r6, r8, r11     ; sum1 = MAC16_16(sum1, x_0, y_1)
+  SUB          r12, r12, #2
+  SMLATT       r10, r6, r8, r10     ; sum0 = MAC16_16(sum0, x_1, y_1)
+  MOV          r8, r9
+  SMLATB       r11, r6, r9, r11     ; sum1 = MAC16_16(sum1, x_1, y_2)
+celt_pitch_xcorr_edsp_process2_1
+  LDRH         r6, [r4], #2
+  ADDS         r12, r12, #1
+  ; Stall
+  SMLABB       r10, r6, r8, r10     ; sum0 = MAC16_16(sum0, x_0, y_0)
+  LDRHGT       r7, [r4], #2
+  SMLABT       r11, r6, r8, r11     ; sum1 = MAC16_16(sum1, x_0, y_1)
+  BLE celt_pitch_xcorr_edsp_process2_done
+  LDRH         r9, [r5], #2
+  SMLABT       r10, r7, r8, r10     ; sum0 = MAC16_16(sum0, x_0, y_1)
+  SMLABB       r11, r7, r9, r11     ; sum1 = MAC16_16(sum1, x_0, y_2)
+celt_pitch_xcorr_edsp_process2_done
+  ; Restore _x
+  SUB          r4, r4, r3, LSL #1
+  ; Restore and advance _y
+  SUB          r5, r5, r3, LSL #1
+  ; maxcorr = max(maxcorr, sum0)
+  CMP          r0, r10
+  ADD          r5, r5, #2
+  MOVLT        r0, r10
+  SUB          r1, r1, #2
+  ; maxcorr = max(maxcorr, sum1)
+  CMP          r0, r11
+  ; xcorr[i] = sum
+  STR          r10, [r2], #4
+  MOVLT        r0, r11
+  STR          r11, [r2], #4
+celt_pitch_xcorr_edsp_process1a
+  ADDS         r1, r1, #1
+  BLT celt_pitch_xcorr_edsp_done
+  SUBS         r12, r3, #4
+  ; r14 = sum = 0
+  MOV          r14, #0
+  BLT celt_pitch_xcorr_edsp_process1a_loop_done
+  LDR          r6, [r4], #4
+  LDR          r8, [r5], #4
+  LDR          r7, [r4], #4
+  LDR          r9, [r5], #4
+celt_pitch_xcorr_edsp_process1a_loop4
+  SMLABB       r14, r6, r8, r14     ; sum = MAC16_16(sum, x_0, y_0)
+  SUBS         r12, r12, #4         ; j-=4
+  SMLATT       r14, r6, r8, r14     ; sum = MAC16_16(sum, x_1, y_1)
+  LDRGE        r6, [r4], #4
+  SMLABB       r14, r7, r9, r14     ; sum = MAC16_16(sum, x_2, y_2)
+  LDRGE        r8, [r5], #4
+  SMLATT       r14, r7, r9, r14     ; sum = MAC16_16(sum, x_3, y_3)
+  LDRGE        r7, [r4], #4
+  LDRGE        r9, [r5], #4
+  BGE celt_pitch_xcorr_edsp_process1a_loop4
+celt_pitch_xcorr_edsp_process1a_loop_done
+  ADDS         r12, r12, #2
+  LDRGE        r6, [r4], #4
+  LDRGE        r8, [r5], #4
+  ; Stall
+  SMLABBGE     r14, r6, r8, r14     ; sum = MAC16_16(sum, x_0, y_0)
+  SUBGE        r12, r12, #2
+  SMLATTGE     r14, r6, r8, r14     ; sum = MAC16_16(sum, x_1, y_1)
+  ADDS         r12, r12, #1
+  LDRHGE       r6, [r4], #2
+  LDRHGE       r8, [r5], #2
+  ; Stall
+  SMLABBGE     r14, r6, r8, r14     ; sum = MAC16_16(sum, *x, *y)
+  ; maxcorr = max(maxcorr, sum)
+  CMP          r0, r14
+  ; xcorr[i] = sum
+  STR          r14, [r2], #4
+  MOVLT        r0, r14
+celt_pitch_xcorr_edsp_done
+  LDMFD        sp!, {r4-r11, pc}
+  ENDP
+
+ENDIF
+
+END
diff --git a/celt/bands.c b/celt/bands.c
index f7bb66a9..2702963c 100644
--- a/celt/bands.c
+++ b/celt/bands.c
@@ -371,14 +371,14 @@ void anti_collapse(const CELTMode *m, celt_norm *X_, unsigned char *collapse_mas
 static void compute_channel_weights(celt_ener Ex, celt_ener Ey, opus_val16 w[2])
 {
    celt_ener minE;
-#if FIXED_POINT
+#ifdef FIXED_POINT
    int shift;
 #endif
    minE = MIN32(Ex, Ey);
    /* Adjustment to make the weights a bit more conservative. */
    Ex = ADD32(Ex, minE/3);
    Ey = ADD32(Ey, minE/3);
-#if FIXED_POINT
+#ifdef FIXED_POINT
    shift = celt_ilog2(EPSILON+MAX32(Ex, Ey))-14;
 #endif
    w[0] = VSHR32(Ex, shift);
diff --git a/celt/celt_decoder.c b/celt/celt_decoder.c
index e6efce93..74ca3b74 100644
--- a/celt/celt_decoder.c
+++ b/celt/celt_decoder.c
@@ -117,13 +117,19 @@ void validate_celt_decoder(CELTDecoder *st)
 #ifndef CUSTOM_MODES
    celt_assert(st->mode == opus_custom_mode_create(48000, 960, NULL));
    celt_assert(st->overlap == 120);
+   celt_assert(st->end <= 21);
+#else
+/* From Section 4.3 in the spec: "The normal CELT layer uses 21 of those bands,
+   though Opus Custom (see Section 6.2) may use a different number of bands"
+
+   Check if it's within the maximum number of Bark frequency bands instead */
+   celt_assert(st->end <= 25);
 #endif
    celt_assert(st->channels == 1 || st->channels == 2);
    celt_assert(st->stream_channels == 1 || st->stream_channels == 2);
    celt_assert(st->downsample > 0);
    celt_assert(st->start == 0 || st->start == 17);
    celt_assert(st->start < st->end);
-   celt_assert(st->end <= 21);
 #ifdef OPUS_ARCHMASK
    celt_assert(st->arch >= 0);
    celt_assert(st->arch <= OPUS_ARCHMASK);
diff --git a/celt/celt_encoder.c b/celt/celt_encoder.c
index 44cb0850..d6f8afc2 100644
--- a/celt/celt_encoder.c
+++ b/celt/celt_encoder.c
@@ -1571,7 +1571,7 @@ int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm,
                (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling));
       effectiveBytes = nbCompressedBytes - nbFilledBytes;
    }
-   equiv_rate = ((opus_int32)nbCompressedBytes*8*50 >> (3-LM)) - (40*C+20)*((400>>LM) - 50);
+   equiv_rate = ((opus_int32)nbCompressedBytes*8*50 << (3-LM)) - (40*C+20)*((400>>LM) - 50);
    if (st->bitrate != OPUS_BITRATE_MAX)
       equiv_rate = IMIN(equiv_rate, st->bitrate - (40*C+20)*((400>>LM) - 50));
 
diff --git a/celt/ecintrin.h b/celt/ecintrin.h
index 2263cff6..66a4c36e 100644
--- a/celt/ecintrin.h
+++ b/celt/ecintrin.h
@@ -49,7 +49,11 @@
   This macro should only be used for implementing ec_ilog(), if it is defined.
   All other code should use EC_ILOG() instead.*/
 #if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#if defined(_MSC_VER) && (_MSC_VER >= 1910)
+# include <intrin0.h> /* Improve compiler throughput. */
+#else
 # include <intrin.h>
+#endif
 /*In _DEBUG mode this is not an intrinsic by default.*/
 # pragma intrinsic(_BitScanReverse)
 
diff --git a/celt/fixed_generic.h b/celt/fixed_generic.h
index 5f4abda7..0ecbb899 100644
--- a/celt/fixed_generic.h
+++ b/celt/fixed_generic.h
@@ -102,9 +102,9 @@
 
 #define SATURATE16(x) (EXTRACT16((x)>32767 ? 32767 : (x)<-32768 ? -32768 : (x)))
 
-/** Shift by a and round-to-neareast 32-bit value. Result is a 16-bit value */
+/** Shift by a and round-to-nearest 32-bit value. Result is a 16-bit value */
 #define ROUND16(x,a) (EXTRACT16(PSHR32((x),(a))))
-/** Shift by a and round-to-neareast 32-bit value. Result is a saturated 16-bit value */
+/** Shift by a and round-to-nearest 32-bit value. Result is a saturated 16-bit value */
 #define SROUND16(x,a) EXTRACT16(SATURATE(PSHR32(x,a), 32767));
 
 /** Divide by two */
diff --git a/celt/float_cast.h b/celt/float_cast.h
index f218e864..9d34976e 100644
--- a/celt/float_cast.h
+++ b/celt/float_cast.h
@@ -67,6 +67,38 @@
 #include <xmmintrin.h>
 static OPUS_INLINE opus_int32 float2int(float x) {return _mm_cvt_ss2si(_mm_set_ss(x));}
 
+#elif (defined(_MSC_VER) && _MSC_VER >= 1400) && (defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1))
+
+        #include <xmmintrin.h>
+        static OPUS_INLINE opus_int32 float2int(float value)
+        {
+                /* _mm_load_ss will generate same code as _mm_set_ss
+                ** in _MSC_VER >= 1914 /02 so keep __mm_load__ss
+                ** for backward compatibility.
+                */
+                return _mm_cvtss_si32(_mm_load_ss(&value));
+        }
+
+#elif (defined(_MSC_VER) && _MSC_VER >= 1400) && defined (_M_IX86)
+
+        #include <math.h>
+
+        /*      Win32 doesn't seem to have these functions.
+        **      Therefore implement OPUS_INLINE versions of these functions here.
+        */
+
+        static OPUS_INLINE opus_int32
+        float2int (float flt)
+        {       int intgr;
+
+                _asm
+                {       fld flt
+                        fistp intgr
+                } ;
+
+                return intgr ;
+        }
+
 #elif defined(HAVE_LRINTF)
 
 /*      These defines enable functionality introduced with the 1999 ISO C
@@ -96,32 +128,6 @@ static OPUS_INLINE opus_int32 float2int(float x) {return _mm_cvt_ss2si(_mm_set_s
 #include <math.h>
 #define float2int(x) lrint(x)
 
-#elif (defined(_MSC_VER) && _MSC_VER >= 1400) && (defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1))
-        #include <xmmintrin.h>
-
-        __inline long int float2int(float value)
-        {
-                return _mm_cvtss_si32(_mm_load_ss(&value));
-        }
-#elif (defined(_MSC_VER) && _MSC_VER >= 1400) && defined (_M_IX86)
-        #include <math.h>
-
-        /*      Win32 doesn't seem to have these functions.
-        **      Therefore implement OPUS_INLINE versions of these functions here.
-        */
-
-        __inline long int
-        float2int (float flt)
-        {       int intgr;
-
-                _asm
-                {       fld flt
-                        fistp intgr
-                } ;
-
-                return intgr ;
-        }
-
 #else
 
 #if (defined(__GNUC__) && defined(__STDC__) && __STDC__ && __STDC_VERSION__ >= 199901L)
diff --git a/celt/mathops.h b/celt/mathops.h
index 5e86ff0d..fe29dac1 100644
--- a/celt/mathops.h
+++ b/celt/mathops.h
@@ -137,7 +137,7 @@ static OPUS_INLINE float celt_log2(float x)
    } in;
    in.f = x;
    integer = (in.i>>23)-127;
-   in.i -= integer<<23;
+   in.i -= (opus_uint32)integer<<23;
    frac = in.f - 1.5f;
    frac = -0.41445418f + frac*(0.95909232f
           + frac*(-0.33951290f + frac*0.16541097f));
@@ -160,7 +160,7 @@ static OPUS_INLINE float celt_exp2(float x)
    /* K0 = 1, K1 = log(2), K2 = 3-4*log(2), K3 = 3*log(2) - 2 */
    res.f = 0.99992522f + frac * (0.69583354f
            + frac * (0.22606716f + 0.078024523f*frac));
-   res.i = (res.i + (integer<<23)) & 0x7fffffff;
+   res.i = (res.i + ((opus_uint32)integer<<23)) & 0x7fffffff;
    return res.f;
 }
 
diff --git a/celt/meson.build b/celt/meson.build
new file mode 100644
index 00000000..370ea1fe
--- /dev/null
+++ b/celt/meson.build
@@ -0,0 +1,63 @@
+celt_sources = sources['CELT_SOURCES']
+
+celt_sse_sources = sources['CELT_SOURCES_SSE']
+
+celt_sse2_sources = sources['CELT_SOURCES_SSE2']
+
+celt_sse4_1_sources = sources['CELT_SOURCES_SSE4_1']
+
+celt_neon_intr_sources = sources['CELT_SOURCES_ARM_NEON_INTR']
+
+celt_static_libs = []
+
+foreach intr_name : ['sse', 'sse2', 'sse4_1', 'neon_intr']
+  have_intr = get_variable('have_' + intr_name)
+  if not have_intr
+    continue
+  endif
+
+  intr_sources = get_variable('celt_@0@_sources'.format(intr_name))
+  intr_args = get_variable('opus_@0@_args'.format(intr_name), [])
+  celt_static_libs += static_library('celt_' + intr_name, intr_sources,
+      c_args: intr_args,
+      include_directories: opus_includes,
+      install: false)
+endforeach
+
+have_arm_intrinsics_or_asm = have_arm_ne10
+if (intrinsics_support.length() + asm_optimization.length() + inline_optimization.length()) > 0
+  have_arm_intrinsics_or_asm = true
+endif
+
+if host_cpu_family in ['arm', 'aarch64'] and have_arm_intrinsics_or_asm
+  celt_sources +=  sources['CELT_SOURCES_ARM']
+  if have_arm_ne10
+    celt_sources += sources['CELT_SOURCES_ARM_NE10']
+  endif
+  if opus_arm_external_asm
+    arm2gnu = [find_program('arm/arm2gnu.pl')] + arm2gnu_args
+    celt_sources_arm_asm = configure_file(input: 'arm/celt_pitch_xcorr_arm.s',
+      output: '@BASENAME@-gnu.S',
+      command: arm2gnu + ['@INPUT@'],
+      capture: true)
+    celt_arm_armopts_s = configure_file(input: 'arm/armopts.s.in',
+      output: 'arm/armopts.s',
+      configuration: opus_conf)
+    celt_static_libs += static_library('celt-armasm',
+      celt_arm_armopts_s, celt_sources_arm_asm,
+      install: false)
+  endif
+endif
+
+celt_c_args = []
+if host_system == 'windows'
+  celt_c_args += ['-DDLL_EXPORT']
+endif
+
+celt_lib = static_library('opus-celt',
+  celt_sources,
+  c_args: celt_c_args,
+  include_directories: opus_includes,
+  link_whole: celt_static_libs,
+  dependencies: libm,
+  install: false)
diff --git a/celt/mips/celt_mipsr1.h b/celt/mips/celt_mipsr1.h
index e85661a6..c332fe04 100644
--- a/celt/mips/celt_mipsr1.h
+++ b/celt/mips/celt_mipsr1.h
@@ -53,6 +53,7 @@
 #include "celt_lpc.h"
 #include "vq.h"
 
+#define OVERRIDE_COMB_FILTER_CONST
 #define OVERRIDE_comb_filter
 void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N,
       opus_val16 g0, opus_val16 g1, int tapset0, int tapset1,
diff --git a/celt/mips/vq_mipsr1.h b/celt/mips/vq_mipsr1.h
index fd18eab7..f26a33e7 100644
--- a/celt/mips/vq_mipsr1.h
+++ b/celt/mips/vq_mipsr1.h
@@ -36,8 +36,6 @@
 #include "mathops.h"
 #include "arch.h"
 
-static void renormalise_vector_mips(celt_norm *X, int N, opus_val16 gain, int arch);
-
 #define OVERRIDE_vq_exp_rotation1
 static void exp_rotation1(celt_norm *X, int len, int stride, opus_val16 c, opus_val16 s)
 {
@@ -66,11 +64,7 @@ static void exp_rotation1(celt_norm *X, int len, int stride, opus_val16 c, opus_
 }
 
 #define OVERRIDE_renormalise_vector
-
-#define renormalise_vector(X, N, gain, arch) \
- (renormalise_vector_mips(X, N, gain, arch))
-
-void renormalise_vector_mips(celt_norm *X, int N, opus_val16 gain, int arch)
+void renormalise_vector(celt_norm *X, int N, opus_val16 gain, int arch)
 {
    int i;
 #ifdef FIXED_POINT
diff --git a/celt/os_support.h b/celt/os_support.h
index a2171971..009bf861 100644
--- a/celt/os_support.h
+++ b/celt/os_support.h
@@ -39,7 +39,6 @@
 #include "opus_defines.h"
 
 #include <string.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 /** Opus wrapper for malloc(). To do your own dynamic allocation, all you need to do is replace this function and opus_free */
diff --git a/celt/rate.h b/celt/rate.h
index 852b9d6f..fad5e412 100644
--- a/celt/rate.h
+++ b/celt/rate.h
@@ -95,7 +95,7 @@ static OPUS_INLINE int pulses2bits(const CELTMode *m, int band, int LM, int puls
  @param pulses Number of pulses per band (returned)
  @return Total number of bits allocated
 */
-int clt_compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stero,
+int clt_compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo,
       opus_int32 total, opus_int32 *balance, int *pulses, int *ebits, int *fine_priority, int C, int LM, ec_ctx *ec, int encode, int prev, int signalBandwidth);
 
 #endif
diff --git a/celt/stack_alloc.h b/celt/stack_alloc.h
index 2b51c8d8..ae40e2a1 100644
--- a/celt/stack_alloc.h
+++ b/celt/stack_alloc.h
@@ -40,7 +40,7 @@
 #endif
 
 #ifdef USE_ALLOCA
-# ifdef WIN32
+# ifdef _WIN32
 #  include <malloc.h>
 # else
 #  ifdef HAVE_ALLOCA_H
@@ -102,7 +102,7 @@
 
 #define VARDECL(type, var) type *var
 
-# ifdef WIN32
+# ifdef _WIN32
 #  define ALLOC(var, size, type) var = ((type*)_alloca(sizeof(type)*(size)))
 # else
 #  define ALLOC(var, size, type) var = ((type*)alloca(sizeof(type)*(size)))
diff --git a/celt/tests/meson.build b/celt/tests/meson.build
new file mode 100644
index 00000000..0e6d2e62
--- /dev/null
+++ b/celt/tests/meson.build
@@ -0,0 +1,19 @@
+tests = [
+  'test_unit_types',
+  'test_unit_mathops',
+  'test_unit_entropy',
+  'test_unit_laplace',
+  'test_unit_dft',
+  'test_unit_mdct',
+  'test_unit_rotation',
+  'test_unit_cwrs32',
+]
+
+foreach test_name : tests
+  exe = executable(test_name, '@0@.c'.format(test_name),
+                   include_directories : opus_includes,
+                   link_with : [celt_lib, celt_static_libs],
+                   dependencies : libm,
+                   install : false)
+  test(test_name, exe)
+endforeach
diff --git a/celt/tests/test_unit_mathops.c b/celt/tests/test_unit_mathops.c
index 874e9adf..0615448d 100644
--- a/celt/tests/test_unit_mathops.c
+++ b/celt/tests/test_unit_mathops.c
@@ -143,7 +143,7 @@ void testbitexactlog2tan(void)
 void testlog2(void)
 {
    float x;
-   for (x=0.001;x<1677700.0;x+=(x/8.0))
+   for (x=0.001f;x<1677700.0;x+=(x/8.0))
    {
       float error = fabs((1.442695040888963387*log(x))-celt_log2(x));
       if (error>0.0009)
@@ -157,7 +157,7 @@ void testlog2(void)
 void testexp2(void)
 {
    float x;
-   for (x=-11.0;x<24.0;x+=0.0007)
+   for (x=-11.0;x<24.0;x+=0.0007f)
    {
       float error = fabs(x-(1.442695040888963387*log(celt_exp2(x))));
       if (error>0.0002)
@@ -171,7 +171,7 @@ void testexp2(void)
 void testexp2log2(void)
 {
    float x;
-   for (x=-11.0;x<24.0;x+=0.0007)
+   for (x=-11.0;x<24.0;x+=0.0007f)
    {
       float error = fabs(x-(celt_log2(celt_exp2(x))));
       if (error>0.001)
diff --git a/celt/vq.c b/celt/vq.c
index a6b5552d..8011e225 100644
--- a/celt/vq.c
+++ b/celt/vq.c
@@ -39,6 +39,10 @@
 #include "rate.h"
 #include "pitch.h"
 
+#if defined(MIPSr1_ASM)
+#include "mips/vq_mipsr1.h"
+#endif
+
 #ifndef OVERRIDE_vq_exp_rotation1
 static void exp_rotation1(celt_norm *X, int len, int stride, opus_val16 c, opus_val16 s)
 {
diff --git a/celt/vq.h b/celt/vq.h
index 0dfe6af0..45ec5591 100644
--- a/celt/vq.h
+++ b/celt/vq.h
@@ -41,10 +41,6 @@
 #include "x86/vq_sse.h"
 #endif
 
-#if defined(MIPSr1_ASM)
-#include "mips/vq_mipsr1.h"
-#endif
-
 void exp_rotation(celt_norm *X, int len, int dir, int stride, int K, int spread);
 
 opus_val16 op_pvq_search_c(celt_norm *X, int *iy, int K, int N, int arch);
diff --git a/celt/x86/pitch_sse.h b/celt/x86/pitch_sse.h
index e5f87ab5..f7a014b6 100644
--- a/celt/x86/pitch_sse.h
+++ b/celt/x86/pitch_sse.h
@@ -91,7 +91,7 @@ opus_val32 celt_inner_prod_sse2(
     int               N);
 #endif
 
-#if defined(OPUS_X86_MAY_HAVE_SSE2) && !defined(FIXED_POINT)
+#if defined(OPUS_X86_MAY_HAVE_SSE) && !defined(FIXED_POINT)
 opus_val32 celt_inner_prod_sse(
     const opus_val16 *x,
     const opus_val16 *y,
diff --git a/celt_sources.mk b/celt_sources.mk
index b619dae3..c9dab06e 100644
--- a/celt_sources.mk
+++ b/celt_sources.mk
@@ -1,4 +1,5 @@
-CELT_SOURCES = celt/bands.c \
+CELT_SOURCES = \
+celt/bands.c \
 celt/celt.c \
 celt/celt_encoder.c \
 celt/celt_decoder.c \
diff --git a/cmake/CFeatureCheck.cmake b/cmake/CFeatureCheck.cmake
new file mode 100644
index 00000000..08828f58
--- /dev/null
+++ b/cmake/CFeatureCheck.cmake
@@ -0,0 +1,39 @@
+# - Compile and run code to check for C features
+#
+# This functions compiles a source file under the `cmake` folder
+# and adds the corresponding `HAVE_[FILENAME]` flag to the CMake
+# environment
+#
+#  c_feature_check(<FLAG> [<VARIANT>])
+#
+# - Example
+#
+# include(CFeatureCheck)
+# c_feature_check(VLA)
+
+if(__c_feature_check)
+  return()
+endif()
+set(__c_feature_check INCLUDED)
+
+function(c_feature_check FILE)
+  string(TOLOWER ${FILE} FILE)
+  string(TOUPPER ${FILE} VAR)
+  string(TOUPPER "${VAR}_SUPPORTED" FEATURE)
+  if (DEFINED ${VAR}_SUPPORTED)
+    set(${VAR}_SUPPORTED 1 PARENT_SCOPE)
+    return()
+  endif()
+
+  if (NOT DEFINED COMPILE_${FEATURE})
+      message(STATUS "Performing Test ${FEATURE}")
+      try_compile(COMPILE_${FEATURE} ${PROJECT_BINARY_DIR} ${PROJECT_SOURCE_DIR}/cmake/${FILE}.c)
+  endif()
+
+  if(COMPILE_${FEATURE})
+    message(STATUS "Performing Test ${FEATURE} -- success")
+    set(${VAR}_SUPPORTED 1 PARENT_SCOPE)
+  else()
+    message(STATUS "Performing Test ${FEATURE} -- failed to compile")
+  endif()
+endfunction()
diff --git a/cmake/OpusBuildtype.cmake b/cmake/OpusBuildtype.cmake
new file mode 100644
index 00000000..557cc89b
--- /dev/null
+++ b/cmake/OpusBuildtype.cmake
@@ -0,0 +1,27 @@
+# Set a default build type if none was specified
+if(__opus_buildtype)
+  return()
+endif()
+set(__opus_buildtype INCLUDED)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  if(CMAKE_C_FLAGS)
+    message(STATUS "CMAKE_C_FLAGS: " ${CMAKE_C_FLAGS})
+  else()
+    set(default_build_type "Release")
+    message(
+      STATUS
+        "Setting build type to '${default_build_type}' as none was specified and no CFLAGS was exported."
+      )
+    set(CMAKE_BUILD_TYPE "${default_build_type}"
+        CACHE STRING "Choose the type of build."
+        FORCE)
+    # Set the possible values of build type for cmake-gui
+    set_property(CACHE CMAKE_BUILD_TYPE
+                 PROPERTY STRINGS
+                          "Debug"
+                          "Release"
+                          "MinSizeRel"
+                          "RelWithDebInfo")
+  endif()
+endif()
diff --git a/cmake/OpusConfig.cmake b/cmake/OpusConfig.cmake
new file mode 100644
index 00000000..8d19a535
--- /dev/null
+++ b/cmake/OpusConfig.cmake
@@ -0,0 +1,104 @@
+if(__opus_config)
+  return()
+endif()
+set(__opus_config INCLUDED)
+
+include(OpusFunctions)
+
+configure_file(cmake/config.h.cmake.in config.h @ONLY)
+add_definitions(-DHAVE_CONFIG_H)
+
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+set_property(GLOBAL PROPERTY C_STANDARD 99)
+
+if(MSVC)
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+include(CheckLibraryExists)
+check_library_exists(m floor "" HAVE_LIBM)
+if(HAVE_LIBM)
+  list(APPEND OPUS_REQUIRED_LIBRARIES m)
+endif()
+
+include(CFeatureCheck)
+c_feature_check(VLA)
+
+include(CheckIncludeFile)
+check_include_file(alloca.h HAVE_ALLOCA_H)
+
+include(CheckSymbolExists)
+if(HAVE_ALLOCA_H)
+  add_definitions(-DHAVE_ALLOCA_H)
+  check_symbol_exists(alloca "alloca.h" USE_ALLOCA_SUPPORTED)
+else()
+  check_symbol_exists(alloca "stdlib.h;malloc.h" USE_ALLOCA_SUPPORTED)
+endif()
+
+include(CheckFunctionExists)
+check_function_exists(lrintf HAVE_LRINTF)
+check_function_exists(lrint HAVE_LRINT)
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "(i[0-9]86|x86|X86|amd64|AMD64|x86_64)")
+  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(OPUS_CPU_X64 1)
+  else()
+    set(OPUS_CPU_X86 1)
+  endif()
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(arm|aarch64)")
+  set(OPUS_CPU_ARM 1)
+endif()
+
+if(NOT OPUS_DISABLE_INTRINSICS)
+  opus_supports_cpu_detection(RUNTIME_CPU_CAPABILITY_DETECTION)
+endif()
+
+if(OPUS_CPU_X86 OR OPUS_CPU_X64 AND NOT OPUS_DISABLE_INTRINSICS)
+  opus_detect_sse(COMPILER_SUPPORT_SIMD)
+elseif(OPUS_CPU_ARM AND NOT OPUS_DISABLE_INTRINSICS)
+  opus_detect_neon(COMPILER_SUPPORT_NEON)
+  if(COMPILER_SUPPORT_NEON)
+    option(OPUS_USE_NEON "Option to enable NEON" ON)
+    option(OPUS_MAY_HAVE_NEON "Does runtime check for neon support" ON)
+    option(OPUS_PRESUME_NEON "Assume target CPU has NEON support" OFF)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+      set(OPUS_PRESUME_NEON ON)
+    elseif(CMAKE_SYSTEM_NAME MATCHES "iOS")
+      set(OPUS_PRESUME_NEON ON)
+    endif()
+  endif()
+endif()
+
+if(MSVC)
+  check_flag(FAST_MATH /fp:fast)
+  check_flag(STACK_PROTECTOR /GS)
+  check_flag(STACK_PROTECTOR_DISABLED /GS-)
+else()
+  check_flag(FAST_MATH -ffast-math)
+  check_flag(STACK_PROTECTOR -fstack-protector-strong)
+  check_flag(HIDDEN_VISIBILITY -fvisibility=hidden)
+  set(FORTIFY_SOURCE_SUPPORTED 1)
+endif()
+
+if(MINGW)
+  # For MINGW we need to link ssp lib for security features such as
+  # stack protector and fortify_sources
+  check_library_exists(ssp __stack_chk_fail "" HAVE_LIBSSP)
+  if(NOT HAVE_LIBSSP)
+    message(WARNING "Could not find libssp in MinGW, disabling STACK_PROTECTOR and FORTIFY_SOURCE")
+    set(STACK_PROTECTOR_SUPPORTED 0)
+    set(FORTIFY_SOURCE_SUPPORTED 0)
+  endif()
+endif()
+
+if(NOT MSVC)
+  set(WARNING_LIST -Wall -W -Wstrict-prototypes -Wextra -Wcast-align -Wnested-externs -Wshadow)
+  include(CheckCCompilerFlag)
+  foreach(WARNING_FLAG ${WARNING_LIST})
+    string(REPLACE - "" WARNING_VAR ${WARNING_FLAG})
+    check_c_compiler_flag(${WARNING_FLAG} ${WARNING_VAR}_SUPPORTED)
+    if(${WARNING_VAR}_SUPPORTED)
+      add_compile_options(${WARNING_FLAG})
+    endif()
+  endforeach()
+endif()
diff --git a/cmake/OpusConfig.cmake.in b/cmake/OpusConfig.cmake.in
new file mode 100644
index 00000000..0b21231d
--- /dev/null
+++ b/cmake/OpusConfig.cmake.in
@@ -0,0 +1,20 @@
+set(OPUS_VERSION @PROJECT_VERSION@)
+set(OPUS_VERSION_STRING @PROJECT_VERSION@)
+set(OPUS_VERSION_MAJOR @PROJECT_VERSION_MAJOR@)
+set(OPUS_VERSION_MINOR @PROJECT_VERSION_MINOR@)
+set(OPUS_VERSION_PATCH @PROJECT_VERSION_PATCH@)
+
+@PACKAGE_INIT@
+
+set_and_check(OPUS_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
+set(OPUS_INCLUDE_DIR ${OPUS_INCLUDE_DIR};${OPUS_INCLUDE_DIR}/opus)
+set(OPUS_INCLUDE_DIRS "@PACKAGE_INCLUDE_INSTALL_DIR@;@PACKAGE_INCLUDE_INSTALL_DIR@/opus")
+
+include(${CMAKE_CURRENT_LIST_DIR}/OpusTargets.cmake)
+
+set(OPUS_LIBRARY Opus::opus)
+set(OPUS_LIBRARIES Opus::opus)
+
+check_required_components(Opus)
+
+set(OPUS_FOUND 1)
diff --git a/cmake/OpusFunctions.cmake b/cmake/OpusFunctions.cmake
new file mode 100644
index 00000000..fcf3351f
--- /dev/null
+++ b/cmake/OpusFunctions.cmake
@@ -0,0 +1,215 @@
+if(__opus_functions)
+  return()
+endif()
+set(__opus_functions INCLUDED)
+
+function(get_library_version OPUS_LIBRARY_VERSION OPUS_LIBRARY_VERSION_MAJOR)
+  file(STRINGS configure.ac opus_lt_current_string
+       LIMIT_COUNT 1
+       REGEX "OPUS_LT_CURRENT=")
+  string(REGEX MATCH
+               "OPUS_LT_CURRENT=([0-9]*)"
+               _
+               ${opus_lt_current_string})
+  set(OPUS_LT_CURRENT ${CMAKE_MATCH_1})
+
+  file(STRINGS configure.ac opus_lt_revision_string
+       LIMIT_COUNT 1
+       REGEX "OPUS_LT_REVISION=")
+  string(REGEX MATCH
+               "OPUS_LT_REVISION=([0-9]*)"
+               _
+               ${opus_lt_revision_string})
+  set(OPUS_LT_REVISION ${CMAKE_MATCH_1})
+
+  file(STRINGS configure.ac opus_lt_age_string
+       LIMIT_COUNT 1
+       REGEX "OPUS_LT_AGE=")
+  string(REGEX MATCH
+               "OPUS_LT_AGE=([0-9]*)"
+               _
+               ${opus_lt_age_string})
+  set(OPUS_LT_AGE ${CMAKE_MATCH_1})
+
+  math(EXPR OPUS_LIBRARY_VERSION_MAJOR "${OPUS_LT_CURRENT} - ${OPUS_LT_AGE}")
+  set(OPUS_LIBRARY_VERSION_MINOR ${OPUS_LT_AGE})
+  set(OPUS_LIBRARY_VERSION_PATCH ${OPUS_LT_REVISION})
+  set(
+    OPUS_LIBRARY_VERSION
+    "${OPUS_LIBRARY_VERSION_MAJOR}.${OPUS_LIBRARY_VERSION_MINOR}.${OPUS_LIBRARY_VERSION_PATCH}"
+    PARENT_SCOPE)
+  set(OPUS_LIBRARY_VERSION_MAJOR ${OPUS_LIBRARY_VERSION_MAJOR} PARENT_SCOPE)
+endfunction()
+
+function(check_flag NAME FLAG)
+  include(CheckCCompilerFlag)
+  check_c_compiler_flag(${FLAG} ${NAME}_SUPPORTED)
+endfunction()
+
+include(CheckIncludeFile)
+# function to check if compiler supports SSE, SSE2, SSE4.1 and AVX if target
+# systems may not have SSE support then use OPUS_MAY_HAVE_SSE option if target
+# system is guaranteed to have SSE support then OPUS_PRESUME_SSE can be used to
+# skip SSE runtime check
+function(opus_detect_sse COMPILER_SUPPORT_SIMD)
+  message(STATUS "Check SIMD support by compiler")
+  check_include_file(xmmintrin.h HAVE_XMMINTRIN_H) # SSE1
+  if(HAVE_XMMINTRIN_H)
+    if(MSVC)
+      # different arch options for 32 and 64 bit target for MSVC
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        check_flag(SSE1 /arch:SSE)
+      else()
+        set(SSE1_SUPPORTED
+            1
+            PARENT_SCOPE)
+      endif()
+    else()
+      check_flag(SSE1 -msse)
+    endif()
+  else()
+    set(SSE1_SUPPORTED
+        0
+        PARENT_SCOPE)
+  endif()
+
+  check_include_file(emmintrin.h HAVE_EMMINTRIN_H) # SSE2
+  if(HAVE_EMMINTRIN_H)
+    if(MSVC)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        check_flag(SSE2 /arch:SSE2)
+      else()
+        set(SSE2_SUPPORTED
+            1
+            PARENT_SCOPE)
+      endif()
+    else()
+      check_flag(SSE2 -msse2)
+    endif()
+  else()
+    set(SSE2_SUPPORTED
+        0
+        PARENT_SCOPE)
+  endif()
+
+  check_include_file(smmintrin.h HAVE_SMMINTRIN_H) # SSE4.1
+  if(HAVE_SMMINTRIN_H)
+    if(MSVC)
+      if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        check_flag(SSE4_1 /arch:SSE2) # SSE2 and above
+      else()
+        set(SSE4_1_SUPPORTED
+            1
+            PARENT_SCOPE)
+      endif()
+    else()
+      check_flag(SSE4_1 -msse4.1)
+    endif()
+  else()
+    set(SSE4_1_SUPPORTED
+        0
+        PARENT_SCOPE)
+  endif()
+
+  check_include_file(immintrin.h HAVE_IMMINTRIN_H) # AVX
+  if(HAVE_IMMINTRIN_H)
+    if(MSVC)
+      check_flag(AVX /arch:AVX)
+    else()
+      check_flag(AVX -mavx)
+    endif()
+  else()
+    set(AVX_SUPPORTED
+        0
+        PARENT_SCOPE)
+  endif()
+
+  if(SSE1_SUPPORTED OR SSE2_SUPPORTED OR SSE4_1_SUPPORTED OR AVX_SUPPORTED)
+    set(COMPILER_SUPPORT_SIMD 1 PARENT_SCOPE)
+  else()
+    message(STATUS "No SIMD support in compiler")
+  endif()
+endfunction()
+
+function(opus_detect_neon COMPILER_SUPPORT_NEON)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "(arm|aarch64)")
+    message(STATUS "Check NEON support by compiler")
+    check_include_file(arm_neon.h HAVE_ARM_NEON_H)
+    if(HAVE_ARM_NEON_H)
+      set(COMPILER_SUPPORT_NEON ${HAVE_ARM_NEON_H} PARENT_SCOPE)
+    endif()
+  endif()
+endfunction()
+
+function(opus_supports_cpu_detection RUNTIME_CPU_CAPABILITY_DETECTION)
+  if(MSVC)
+    check_include_file(intrin.h HAVE_INTRIN_H)
+  else()
+    check_include_file(cpuid.h HAVE_CPUID_H)
+  endif()
+  if(HAVE_INTRIN_H OR HAVE_CPUID_H)
+    set(RUNTIME_CPU_CAPABILITY_DETECTION 1 PARENT_SCOPE)
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(arm|aarch64)")
+    # ARM cpu detection is implemented for Windows and anything
+    # using a Linux kernel (such as Android).
+    if (CMAKE_SYSTEM_NAME MATCHES "(Windows|Linux|Android)")
+      set(RUNTIME_CPU_CAPABILITY_DETECTION 1 PARENT_SCOPE)
+    endif ()
+  else()
+    set(RUNTIME_CPU_CAPABILITY_DETECTION 0 PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(add_sources_group target group)
+  target_sources(${target} PRIVATE ${ARGN})
+  source_group(${group} FILES ${ARGN})
+endfunction()
+
+function(get_opus_sources SOURCE_GROUP MAKE_FILE SOURCES)
+  # read file, each item in list is one group
+  file(STRINGS ${MAKE_FILE} opus_sources)
+
+  # add wildcard for regex match
+  string(CONCAT SOURCE_GROUP ${SOURCE_GROUP} ".*$")
+
+  # find group
+  foreach(val IN LISTS opus_sources)
+    if(val MATCHES ${SOURCE_GROUP})
+      list(LENGTH val list_length)
+      if(${list_length} EQUAL 1)
+        # for tests split by '=' and clean up the rest into a list
+        string(FIND ${val} "=" index)
+        math(EXPR index "${index} + 1")
+        string(SUBSTRING ${val}
+                         ${index}
+                         -1
+                         sources)
+        string(REPLACE " "
+                       ";"
+                       sources
+                       ${sources})
+      else()
+        # discard the group
+        list(REMOVE_AT val 0)
+        set(sources ${val})
+      endif()
+      break()
+    endif()
+  endforeach()
+
+  list(LENGTH sources list_length)
+  if(${list_length} LESS 1)
+    message(
+      FATAL_ERROR
+        "No files parsed succesfully from ${SOURCE_GROUP} in ${MAKE_FILE}")
+  endif()
+
+  # remove trailing whitespaces
+  set(list_var "")
+  foreach(source ${sources})
+    string(STRIP "${source}" source)
+    list(APPEND list_var "${source}")
+  endforeach()
+
+  set(${SOURCES} ${list_var} PARENT_SCOPE)
+endfunction()
diff --git a/cmake/OpusPackageVersion.cmake b/cmake/OpusPackageVersion.cmake
new file mode 100644
index 00000000..447ce3b1
--- /dev/null
+++ b/cmake/OpusPackageVersion.cmake
@@ -0,0 +1,70 @@
+if(__opus_version)
+  return()
+endif()
+set(__opus_version INCLUDED)
+
+function(get_package_version PACKAGE_VERSION PROJECT_VERSION)
+
+  find_package(Git)
+  if(GIT_FOUND AND EXISTS "${CMAKE_CURRENT_LIST_DIR}/.git")
+    execute_process(COMMAND ${GIT_EXECUTABLE}
+                    --git-dir=${CMAKE_CURRENT_LIST_DIR}/.git describe
+                    --tags --match "v*" OUTPUT_VARIABLE OPUS_PACKAGE_VERSION)
+    if(OPUS_PACKAGE_VERSION)
+      string(STRIP ${OPUS_PACKAGE_VERSION}, OPUS_PACKAGE_VERSION)
+      string(REPLACE \n
+                     ""
+                     OPUS_PACKAGE_VERSION
+                     ${OPUS_PACKAGE_VERSION})
+      string(REPLACE ,
+                     ""
+                     OPUS_PACKAGE_VERSION
+                     ${OPUS_PACKAGE_VERSION})
+
+      string(SUBSTRING ${OPUS_PACKAGE_VERSION}
+                       1
+                       -1
+                       OPUS_PACKAGE_VERSION)
+      message(STATUS "Opus package version from git repo: ${OPUS_PACKAGE_VERSION}")
+    endif()
+
+  elseif(EXISTS "${CMAKE_CURRENT_LIST_DIR}/package_version"
+         AND NOT OPUS_PACKAGE_VERSION)
+    # Not a git repo, lets' try to parse it from package_version file if exists
+    file(STRINGS package_version OPUS_PACKAGE_VERSION
+         LIMIT_COUNT 1
+         REGEX "PACKAGE_VERSION=")
+    string(REPLACE "PACKAGE_VERSION="
+                   ""
+                   OPUS_PACKAGE_VERSION
+                   ${OPUS_PACKAGE_VERSION})
+    string(REPLACE "\""
+                   ""
+                   OPUS_PACKAGE_VERSION
+                   ${OPUS_PACKAGE_VERSION})
+    # In case we have a unknown dist here we just replace it with 0
+    string(REPLACE "unknown"
+                   "0"
+                   OPUS_PACKAGE_VERSION
+                   ${OPUS_PACKAGE_VERSION})
+      message(STATUS "Opus package version from package_version file: ${OPUS_PACKAGE_VERSION}")
+  endif()
+
+  if(OPUS_PACKAGE_VERSION)
+    string(REGEX
+      REPLACE "^([0-9]+.[0-9]+\\.?([0-9]+)?).*"
+               "\\1"
+               OPUS_PROJECT_VERSION
+               ${OPUS_PACKAGE_VERSION})
+  else()
+    # fail to parse version from git and package version
+    message(WARNING "Could not get package version.")
+    set(OPUS_PACKAGE_VERSION 0)
+    set(OPUS_PROJECT_VERSION 0)
+  endif()
+
+  message(STATUS "Opus project version: ${OPUS_PROJECT_VERSION}")
+
+  set(PACKAGE_VERSION ${OPUS_PACKAGE_VERSION} PARENT_SCOPE)
+  set(PROJECT_VERSION ${OPUS_PROJECT_VERSION} PARENT_SCOPE)
+endfunction()
diff --git a/cmake/OpusSources.cmake b/cmake/OpusSources.cmake
new file mode 100644
index 00000000..01e75d1a
--- /dev/null
+++ b/cmake/OpusSources.cmake
@@ -0,0 +1,46 @@
+if(__opus_sources)
+  return()
+endif()
+set(__opus_sources INCLUDED)
+
+include(OpusFunctions)
+
+get_opus_sources(SILK_HEAD silk_headers.mk silk_headers)
+get_opus_sources(SILK_SOURCES silk_sources.mk silk_sources)
+get_opus_sources(SILK_SOURCES_FLOAT silk_sources.mk silk_sources_float)
+get_opus_sources(SILK_SOURCES_FIXED silk_sources.mk silk_sources_fixed)
+get_opus_sources(SILK_SOURCES_SSE4_1 silk_sources.mk silk_sources_sse4_1)
+get_opus_sources(SILK_SOURCES_FIXED_SSE4_1 silk_sources.mk
+                 silk_sources_fixed_sse4_1)
+get_opus_sources(SILK_SOURCES_ARM_NEON_INTR silk_sources.mk
+                 silk_sources_arm_neon_intr)
+get_opus_sources(SILK_SOURCES_FIXED_ARM_NEON_INTR silk_sources.mk
+                 silk_sources_fixed_arm_neon_intr)
+
+get_opus_sources(OPUS_HEAD opus_headers.mk opus_headers)
+get_opus_sources(OPUS_SOURCES opus_sources.mk opus_sources)
+get_opus_sources(OPUS_SOURCES_FLOAT opus_sources.mk opus_sources_float)
+
+get_opus_sources(CELT_HEAD celt_headers.mk celt_headers)
+get_opus_sources(CELT_SOURCES celt_sources.mk celt_sources)
+get_opus_sources(CELT_SOURCES_SSE celt_sources.mk celt_sources_sse)
+get_opus_sources(CELT_SOURCES_SSE2 celt_sources.mk celt_sources_sse2)
+get_opus_sources(CELT_SOURCES_SSE4_1 celt_sources.mk celt_sources_sse4_1)
+get_opus_sources(CELT_SOURCES_ARM celt_sources.mk celt_sources_arm)
+get_opus_sources(CELT_SOURCES_ARM_ASM celt_sources.mk celt_sources_arm_asm)
+get_opus_sources(CELT_AM_SOURCES_ARM_ASM celt_sources.mk
+                 celt_am_sources_arm_asm)
+get_opus_sources(CELT_SOURCES_ARM_NEON_INTR celt_sources.mk
+                 celt_sources_arm_neon_intr)
+get_opus_sources(CELT_SOURCES_ARM_NE10 celt_sources.mk celt_sources_arm_ne10)
+
+get_opus_sources(opus_demo_SOURCES Makefile.am opus_demo_sources)
+get_opus_sources(opus_custom_demo_SOURCES Makefile.am opus_custom_demo_sources)
+get_opus_sources(opus_compare_SOURCES Makefile.am opus_compare_sources)
+get_opus_sources(tests_test_opus_api_SOURCES Makefile.am test_opus_api_sources)
+get_opus_sources(tests_test_opus_encode_SOURCES Makefile.am
+                 test_opus_encode_sources)
+get_opus_sources(tests_test_opus_decode_SOURCES Makefile.am
+                 test_opus_decode_sources)
+get_opus_sources(tests_test_opus_padding_SOURCES Makefile.am
+                 test_opus_padding_sources)
diff --git a/cmake/config.h.cmake.in b/cmake/config.h.cmake.in
new file mode 100644
index 00000000..5550842c
--- /dev/null
+++ b/cmake/config.h.cmake.in
@@ -0,0 +1 @@
+#cmakedefine PACKAGE_VERSION "@PACKAGE_VERSION@"
\ No newline at end of file
diff --git a/cmake/vla.c b/cmake/vla.c
new file mode 100644
index 00000000..05b21197
--- /dev/null
+++ b/cmake/vla.c
@@ -0,0 +1,7 @@
+int main() {
+    static int x;
+    char a[++x];
+    a[sizeof a - 1] = 0;
+    int N;
+    return a[0];
+}
\ No newline at end of file
diff --git a/configure.ac b/configure.ac
index e2921fa2..f12f0aa9 100644
--- a/configure.ac
+++ b/configure.ac
@@ -22,9 +22,9 @@ m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 
 # For libtool.
 dnl Please update these for releases.
-OPUS_LT_CURRENT=7
+OPUS_LT_CURRENT=8
 OPUS_LT_REVISION=0
-OPUS_LT_AGE=7
+OPUS_LT_AGE=8
 
 AC_SUBST(OPUS_LT_CURRENT)
 AC_SUBST(OPUS_LT_REVISION)
@@ -691,6 +691,18 @@ AS_IF([test x"$enable_intrinsics" = x"yes"],[
                  unsigned int CPUInfo2;
                  unsigned int CPUInfo3;
                  unsigned int InfoType;
+                #if defined(__i386__) && defined(__PIC__)
+                 __asm__ __volatile__ (
+                 "xchg %%ebx, %1\n"
+                 "cpuid\n"
+                 "xchg %%ebx, %1\n":
+                 "=a" (CPUInfo0),
+                 "=r" (CPUInfo1),
+                 "=c" (CPUInfo2),
+                 "=d" (CPUInfo3) :
+                 "a" (InfoType), "c" (0)
+                );
+               #else
                  __asm__ __volatile__ (
                  "cpuid":
                  "=a" (CPUInfo0),
@@ -699,6 +711,7 @@ AS_IF([test x"$enable_intrinsics" = x"yes"],[
                  "=d" (CPUInfo3) :
                  "a" (InfoType), "c" (0)
                 );
+               #endif
             ]])],
             [get_cpuid_by_asm="yes"
              AC_MSG_RESULT([Inline Assembly])
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
index 36eee0b5..6eef650b 100644
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -1,4 +1,4 @@
-# Doxyfile 1.8.10
+# Doxyfile 1.8.18
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -101,7 +101,7 @@ EXTRACT_PRIVATE        = NO
 # names in lower-case letters. If set to YES, upper-case letters are also
 # allowed. This is useful if you have classes or files whose names only differ
 # in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
+# (including Cygwin) ands Mac users are advised to set this option to NO.
 # The default value is: system dependent.
 
 CASE_SENSE_NAMES       = YES
@@ -248,8 +248,8 @@ HTML_TIMESTAMP         = YES
 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# MathJax from https://www.mathjax.org before deployment.
+# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_RELPATH        = https://www.mathjax.org/mathjax
@@ -326,10 +326,15 @@ PREDEFINED             = OPUS_EXPORT= \
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz (see:
 # http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs.
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: NO.
 
 # Debian defaults to YES here, while Fedora and Homebrew default to NO.
 # So we set this based on whether the graphviz package is available at
 # configure time.
 #
-HAVE_DOT = @HAVE_DOT@
+HAVE_DOT               = @HAVE_DOT@
+
+# move docs to the correct place
+OUTPUT_DIRECTORY       = @top_builddir@/doc
diff --git a/doc/build_draft.sh b/doc/build_draft.sh
index d15b22a7..14ae51dd 100755
--- a/doc/build_draft.sh
+++ b/doc/build_draft.sh
@@ -48,7 +48,16 @@ mkdir "${destdir}/src"
 mkdir "${destdir}/silk"
 mkdir "${destdir}/silk/float"
 mkdir "${destdir}/silk/fixed"
+mkdir "${destdir}/silk/fixed/x86"
+mkdir "${destdir}/silk/fixed/arm"
+mkdir "${destdir}/silk/fixed/mips"
+mkdir "${destdir}/silk/x86"
+mkdir "${destdir}/silk/arm"
+mkdir "${destdir}/silk/mips"
 mkdir "${destdir}/celt"
+mkdir "${destdir}/celt/x86"
+mkdir "${destdir}/celt/arm"
+mkdir "${destdir}/celt/mips"
 mkdir "${destdir}/include"
 for f in `cat "${toplevel}"/opus_sources.mk "${toplevel}"/celt_sources.mk \
  "${toplevel}"/silk_sources.mk "${toplevel}"/opus_headers.mk \
@@ -82,7 +91,7 @@ cat opus_source.tar.gz| base64 | tr -d '\n' | fold -w 64 | \
 #echo '</artwork>' >> opus_compare_escaped.c
 #echo '</figure>' >> opus_compare_escaped.c
 
-if [[ ! -d ../opus_testvectors ]] ; then
+if [ ! -d ../opus_testvectors ] ; then
   echo "Downloading test vectors..."
   wget 'http://opus-codec.org/testvectors/opus_testvectors.tar.gz'
   tar -C .. -xvzf opus_testvectors.tar.gz
diff --git a/doc/footer.html b/doc/footer.html
index ad4a9259..346c40ab 100644
--- a/doc/footer.html
+++ b/doc/footer.html
@@ -1,6 +1,10 @@
+<!-- HTML footer for doxygen 1.8.18-->
+<!-- start footer part -->
 <!--BEGIN GENERATE_TREEVIEW-->
+<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
+  <ul>
     <li class="footer">Generated by
-    <a href="https://www.stack.nl/~dimitri/doxygen/">
+    <a href="http://www.doxygen.org/index.html">
     <img class="footer" src="doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
    </ul>
  </div>
@@ -16,7 +20,7 @@ For more information visit the <a href="https://opus-codec.org">Opus Website</a>
       <td>
         <address class="footer"><small>
           Generated by
-          <a href="https://www.stack.nl/~dimitri/doxygen/">doxygen</a>
+          <a href="http://www.doxygen.org/index.html">doxygen</a>
           $doxygenversion
         </small></address>
       </td>
diff --git a/doc/header.html b/doc/header.html
index b2c906be..babdcf6d 100644
--- a/doc/header.html
+++ b/doc/header.html
@@ -1,18 +1,24 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<!-- HTML header for doxygen 1.8.18-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
 <meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen $doxygenversion"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
 <!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
 <!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
-<link href="$relpath$tabs.css" rel="stylesheet" type="text/css"/>
-<link href="$relpath$customdoxygen.css" rel="stylesheet" type="text/css" />
+<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="$relpath^jquery.js"></script>
+<script type="text/javascript" src="$relpath^dynsections.js"></script>
 $treeview
 $search
 $mathjax
+<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
+$extrastylesheet
 </head>
 <body>
-<div id="top"><!-- do not remove this div! -->
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
 
 <!--BEGIN TITLEAREA-->
 <div id="titlearea">
@@ -20,7 +26,7 @@ $mathjax
  <tbody>
  <tr style="height: 64px;">
   <!--BEGIN PROJECT_LOGO-->
-  <td id="projectlogo"><img alt="Logo" src="$relpath$$projectlogo"/></td>
+  <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
   <!--END PROJECT_LOGO-->
   <!--BEGIN PROJECT_NAME-->
   <td style="padding-left: 0.5em;">
@@ -52,3 +58,4 @@ $mathjax
 </table>
 </div>
 <!--END TITLEAREA-->
+<!-- end header part -->
diff --git a/doc/meson.build b/doc/meson.build
new file mode 100644
index 00000000..ee42a2b0
--- /dev/null
+++ b/doc/meson.build
@@ -0,0 +1,33 @@
+have_dot = find_program('dot', required: false).found()
+
+doxyfile_conf = configuration_data()
+doxyfile_conf.set('VERSION', opus_version)
+doxyfile_conf.set('HAVE_DOT', have_dot)
+doxyfile_conf.set('top_srcdir', top_srcdir)
+doxyfile_conf.set('top_builddir', top_builddir)
+
+doxyfile = configure_file(input: 'Doxyfile.in',
+  output: 'Doxyfile',
+  configuration: doxyfile_conf,
+  install: false)
+
+docdir = join_paths(get_option('datadir'), get_option('docdir'))
+
+doc_inputs = [
+  'customdoxygen.css',
+  'footer.html',
+  'header.html',
+  'opus_logo.svg',
+  top_srcdir + '/include/opus.h',
+  top_srcdir + '/include/opus_multistream.h',
+  top_srcdir + '/include/opus_defines.h',
+  top_srcdir + '/include/opus_types.h',
+  top_srcdir + '/include/opus_custom.h',
+]
+
+custom_target('doc',
+  input: [ doxyfile ] + doc_inputs,
+  output: [ 'html' ],
+  command: [ doxygen, doxyfile ],
+  install_dir: docdir,
+  install: true)
diff --git a/doc/release.txt b/doc/release.txt
index 6d3ffa23..411ab7f4 100644
--- a/doc/release.txt
+++ b/doc/release.txt
@@ -15,7 +15,7 @@
  - svn commit
  - Copy to archive.mozilla.org/pub/opus/
  - Update checksum files there as well.
-- Add release notes to https://git.xiph.org/opus-website.git
+- Add release notes to https://gitlab.xiph.org/xiph/opus-website.git
 - Update links and checksums on the downloads page.
 - Add a copy of the documentation to <https://www.opus-codec.org/docs/>
   and update the links.
@@ -25,7 +25,7 @@ Releases are commited to https://svn.xiph.org/releases/opus/
 which propagates to downloads.xiph.org, and copied manually
 to https://archive.mozilla.org/pub/opus/
 
-Website updates are committed to https://git.xiph.org/opus-website.git
+Website updates are committed to https://gitlab.xiph.org/xiph/opus-website.git
 which propagates to https://opus-codec.org/
 
 == Binary release ==
diff --git a/doc/trivial_example.c b/doc/trivial_example.c
index 047ca0a2..9cf435b4 100644
--- a/doc/trivial_example.c
+++ b/doc/trivial_example.c
@@ -85,7 +85,7 @@ int main(int argc, char **argv)
       return EXIT_FAILURE;
    }
    inFile = argv[1];
-   fin = fopen(inFile, "r");
+   fin = fopen(inFile, "rb");
    if (fin==NULL)
    {
       fprintf(stderr, "failed to open input file: %s\n", strerror(errno));
@@ -101,7 +101,7 @@ int main(int argc, char **argv)
       return EXIT_FAILURE;
    }
    outFile = argv[2];
-   fout = fopen(outFile, "w");
+   fout = fopen(outFile, "wb");
    if (fout==NULL)
    {
       fprintf(stderr, "failed to open output file: %s\n", strerror(errno));
@@ -113,14 +113,25 @@ int main(int argc, char **argv)
       int i;
       unsigned char pcm_bytes[MAX_FRAME_SIZE*CHANNELS*2];
       int frame_size;
+      size_t samples;
 
       /* Read a 16 bits/sample audio frame. */
-      fread(pcm_bytes, sizeof(short)*CHANNELS, FRAME_SIZE, fin);
-      if (feof(fin))
+      samples = fread(pcm_bytes, sizeof(short)*CHANNELS, FRAME_SIZE, fin);
+
+      /* For simplicity, only read whole frames. In a real application,
+       * we'd pad the final partial frame with zeroes, record the exact
+       * duration, and trim the decoded audio to match.
+       */
+      if (samples != FRAME_SIZE)
+      {
          break;
+      }
+
       /* Convert from little-endian ordering. */
       for (i=0;i<CHANNELS*FRAME_SIZE;i++)
+      {
          in[i]=pcm_bytes[2*i+1]<<8|pcm_bytes[2*i];
+      }
 
       /* Encode the frame. */
       nbBytes = opus_encode(encoder, in, FRAME_SIZE, cbits, MAX_PACKET_SIZE);
diff --git a/fuzzer/Android.bp b/fuzzer/Android.bp
new file mode 100644
index 00000000..45ce6ab4
--- /dev/null
+++ b/fuzzer/Android.bp
@@ -0,0 +1,99 @@
+/******************************************************************************
+ *
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *****************************************************************************
+ * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
+ */
+
+package {
+    // http://go/android-license-faq
+    // A large-scale-change added 'default_applicable_licenses' to import
+    // the below license kinds from "external_libopus_license":
+    //   SPDX-license-identifier-Apache-2.0
+    default_applicable_licenses: ["external_libopus_license"],
+}
+
+cc_defaults {
+    name: "opus_fuzz_defaults",
+    host_supported: true,
+
+    static_libs: [
+        "libopus",
+    ],
+
+    fuzz_config: {
+        cc: [
+            "android-media-fuzzing-reports@google.com",
+        ],
+        componentid: 155276,
+    },
+}
+
+cc_fuzz {
+    name: "opus_dec_fuzzer",
+
+    srcs: [
+        "opus_dec_fuzzer.cpp",
+    ],
+
+    defaults: [
+        "opus_fuzz_defaults",
+    ],
+}
+
+cc_fuzz {
+    name: "opus_multistream_dec_fuzzer",
+
+    srcs: [
+        "opus_dec_fuzzer.cpp",
+    ],
+
+    cflags: [
+        "-DMULTISTREAM",
+    ],
+
+    defaults: [
+        "opus_fuzz_defaults",
+    ],
+}
+
+cc_fuzz {
+    name: "opus_enc_fuzzer",
+
+    srcs: [
+        "opus_enc_fuzzer.cpp",
+    ],
+
+    defaults: [
+        "opus_fuzz_defaults"
+    ],
+}
+
+cc_fuzz {
+    name: "opus_multistream_enc_fuzzer",
+
+    srcs: [
+        "opus_enc_fuzzer.cpp",
+    ],
+
+    defaults: [
+        "opus_fuzz_defaults"
+    ],
+
+    cflags: [
+        "-DMULTISTREAM",
+    ],
+}
diff --git a/fuzzer/README.md b/fuzzer/README.md
new file mode 100644
index 00000000..42b9057c
--- /dev/null
+++ b/fuzzer/README.md
@@ -0,0 +1,152 @@
+# Fuzzer for libopus decoder
+
+## Plugin Design Considerations
+The fuzzer plugin for opus decoder is designed based on the understanding of the
+codec and tries to achieve the following:
+
+##### Maximize code coverage
+
+This fuzzer provides support for both single stream and multi stream inputs,
+thus enabling fuzzing for API's provided for single stream as well as multi
+stream.
+
+Following arguments are passed to OPUS_DEC_CREATE_API:
+
+1. Sampling frequency (parameter name: `Fs`)
+2. Number of channels (parameter name: `channels`)
+
+| Parameter| Valid Values| Configured Value|
+|------------- |-------------| ----- |
+| `Fs` | `8000 ` `12000 ` `16000 ` `24000 ` `48000 ` | Derived from Byte-9 of input stream|
+| `channels`   | `1 ` `2 ` | Derived from Byte-9 of input stream |
+
+##### Maximize utilization of input data
+The plugin feeds the entire input data to the codec. Frame sizes are determined only
+after the call to extractor, so in absence of call to extractor,
+we feed the entire data to the decoder.
+This ensures that the plugin tolerates any kind of input (empty, huge,
+malformed, etc) and doesnt `exit()` on any input and thereby increasing the
+chance of identifying vulnerabilities.
+
+## Build
+
+This describes steps to build opus_dec_fuzzer and opus_multistream_dec_fuzzer binary.
+
+## Android
+
+### Steps to build
+Build the fuzzer
+```
+  $ mm -j$(nproc) opus_dec_fuzzer
+  $ mm -j$(nproc) opus_multistream_dec_fuzzer
+```
+
+### Steps to run
+Create a directory CORPUS_DIR and copy some opus files to that folder.
+Push this directory to device.
+
+To run on device
+```
+  $ adb sync data
+  $ adb shell /data/fuzz/arm64/opus_dec_fuzzer/opus_dec_fuzzer CORPUS_DIR
+  $ adb shell /data/fuzz/arm64/opus_multistream_dec_fuzzer/opus_multistream_dec_fuzzer CORPUS_DIR
+```
+To run on host
+```
+  $ $ANDROID_HOST_OUT/fuzz/x86_64/opus_dec_fuzzer/opus_dec_fuzzer CORPUS_DIR
+  $ $ANDROID_HOST_OUT/fuzz/x86_64/opus_multistream_dec_fuzzer/opus_multistream_dec_fuzzer CORPUS_DIR
+```
+
+# Fuzzer for libopus encoder
+
+## Plugin Design Considerations
+The fuzzer plugin for opus encoder is designed based on the understanding of the
+codec and tries to achieve the following:
+
+##### Maximize code coverage
+
+This fuzzer provides support for both single stream and multi stream inputs,
+thus enabling fuzzing for API's provided for single stream as well as multi
+stream.
+Following arguments are passed to OPUS_ENC_CREATE_API:
+
+1. Sampling rate (parameter name: `sampleRate`)
+2. Number of channels (parameter name: `channels`)
+
+| Parameter| Valid Values| Configured Value|
+|------------- |-------------| ----- |
+| `sampleRate` | `8000 ` `12000 ` `16000 ` `24000 ` `48000 ` | An index ranging from 0-4 is calculated using first byte of data which is used to assign value to `sampleRate` from array `kSampleRates`|
+| `channels` (single stream)   | `1 ` `2 ` | Calculated using second byte of data |
+| `channels` (multi stream)   | In range `1 `- `255 ` | Calculated using second byte of data |
+
+Following arguments are passed to OPUS_ENC_CTL_API:
+
+1. OPUS_SET_BITRATE (parameter name: `bitRate`)
+2. OPUS_SET_COMPLEXITY (parameter name: `complexity`)
+3. OPUS_SET_APPLICATION (parameter name: `application`)
+4. OPUS_SET_DTX (parameter name: `setDTX`)
+5. OPUS_SET_SIGNAL (parameter name: `signal`)
+6. OPUS_SET_VBR (parameter name: `setVBR`)
+7. OPUS_SET_VBR_CONSTRAINT (parameter name: `setVBRConstraint`)
+8. OPUS_SET_FORCE_CHANNELS (parameter name: `forceChannel`)
+9. OPUS_SET_MAX_BANDWIDTH (parameter name: `maxBandwidth`)
+10. OPUS_SET_INBAND_FEC (parameter name: `setInbandFec`)
+11. OPUS_SET_PACKET_LOSS_PERC (parameter name: `pktLoss`)
+12. OPUS_SET_LSB_DEPTH (parameter name: `lsbDepth`)
+13. OPUS_SET_PREDICTION_DISABLED (parameter name: `setPredDisable`)
+14. OPUS_SET_EXPERT_FRAME_DURATION (parameter name: `frameSizeEnum`)
+
+| Parameter| Valid Values| Configured Value|
+|------------- |-------------| ----- |
+| `bitRate`   | In range `500 ` to `512000 ` | Calculated using all bits of 3rd, 4th and 5th byte of data |
+| `complexity`   |0.`0 ` 1.`1 ` 2.`2 ` 3.`3 ` 4.`4 ` 5.`5 ` 6.`6 ` 7.`7 ` 8.`8 ` 9.`9 ` 10.`10 ` | Calculated using all bits of 6th byte of data |
+| `application`   | 0.`OPUS_APPLICATION_VOIP ` 1.`OPUS_APPLICATION_AUDIO ` 2.`OPUS_APPLICATION_RESTRICTED_LOWDELAY ` | Calculated using all bits of 7th byte of data |
+| `setDTX`   | 0.`0 ` 1.`1 ` | Calculated using bit 0 of 8th byte of data |
+| `signal`   | 0.`OPUS_AUTO ` 1.`OPUS_SIGNAL_VOICE ` 2.`OPUS_SIGNAL_MUSIC ` | Calculated using bit 0 and bit 1 of 9th byte of data |
+| `setVBR`   | 0.`0 ` 1.`1 `  | Calculated using bit 0 of 10th byte of data |
+| `setVBRConstraint`   | 0.`0 ` 1.`1 ` | Calculated using bit 0 of 11th byte of data |
+| `forceChannel`   | 0.`OPUS_AUTO ` 1.`1 ` 2.`2 ` | Calculated using all bits of 12th byte of data |
+| `maxBandwidth`   | 0.`OPUS_BANDWIDTH_NARROWBAND ` 1.`OPUS_BANDWIDTH_MEDIUMBAND ` 2.`OPUS_BANDWIDTH_WIDEBAND ` 3.`OPUS_BANDWIDTH_SUPERWIDEBAND ` 4.`OPUS_BANDWIDTH_FULLBAND ` | Calculated using all bits of 13th byte of data |
+| `setInbandFec`   | 0.`0 ` 1.`1 ` | Calculated using bit 0 of 14th byte of data |
+| `pktLoss`   | 0.`0 ` 1.`1 ` 2.`2 ` 3.`5 `| Calculated using all bits of 15th byte of data |
+| `lsbDepth`   | 0.`8 ` 1.`24 ` | Calculated using bit 0 of 16th byte of data |
+| `setPredDisable`   | 0.`0 ` 1.`1 ` | Calculated using bit 0 of 17th byte of data |
+| `frameSizeEnum`   | 0.`OPUS_FRAMESIZE_2_5_MS ` 1.`OPUS_FRAMESIZE_5_MS ` 2.`OPUS_FRAMESIZE_10_MS ` 3.`OPUS_FRAMESIZE_20_MS ` 4.`OPUS_FRAMESIZE_40_MS ` 5.`OPUS_FRAMESIZE_60_MS ` 6.`OPUS_FRAMESIZE_80_MS ` 7.`OPUS_FRAMESIZE_100_MS ` 8.`OPUS_FRAMESIZE_120_MS ` | Calculated using all bits of 18th byte of data |
+
+
+##### Maximize utilization of input data
+The plugin feeds the entire input data to the codec. For buffer size which is not a multiple of mNumPcmBytesPerInputFrame, we will accumulate the input and keep it. Once the input is filled with expected number of bytes, we will send it to encoder. This ensures that the plugin tolerates any kind of input (empty, huge,
+malformed, etc) and doesnt `exit()` on any input and thereby increasing the chance of identifying vulnerabilities.
+
+## Build
+
+This describes steps to build opus_enc_fuzzer and opus_multistream_enc_fuzzer.
+
+## Android
+
+### Steps to build
+Build the fuzzer
+```
+  $ mm -j$(nproc) opus_enc_fuzzer
+  $ mm -j$(nproc) opus_multistream_enc_fuzzer
+```
+
+### Steps to run
+Create a directory CORPUS_DIR and copy some raw media files to that folder.
+Push this directory to device.
+
+To run on device
+```
+  $ adb sync data
+  $ adb shell /data/fuzz/arm64/opus_enc_fuzzer/opus_enc_fuzzer CORPUS_DIR
+  $ adb shell /data/fuzz/arm64/opus_multistream_enc_fuzzer/opus_multistream_enc_fuzzer CORPUS_DIR
+```
+To run on host
+```
+  $ $ANDROID_HOST_OUT/fuzz/x86_64/opus_enc_fuzzer/opus_enc_fuzzer CORPUS_DIR
+  $ $ANDROID_HOST_OUT/fuzz/x86_64/opus_multistream_enc_fuzzer/opus_multistream_enc_fuzzer CORPUS_DIR
+```
+
+## References:
+ * http://llvm.org/docs/LibFuzzer.html
+ * https://github.com/google/oss-fuzz
diff --git a/fuzzer/opus_dec_fuzzer.cpp b/fuzzer/opus_dec_fuzzer.cpp
new file mode 100644
index 00000000..23bf69e4
--- /dev/null
+++ b/fuzzer/opus_dec_fuzzer.cpp
@@ -0,0 +1,124 @@
+/******************************************************************************
+ *
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *****************************************************************************
+ * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <opus.h>
+
+/* 4 bytes: packet length, 4 bytes: encoder final range */
+constexpr int kSetupByteOffset = 8;
+constexpr int kMaxFrameSample = 5760;
+const int kSamplingRates[] = {8000, 12000, 16000, 24000, 48000};
+constexpr int kNumberSamplingRates = sizeof(kSamplingRates) / sizeof(kSamplingRates[0]);
+
+#ifdef MULTISTREAM
+#include "opus_multistream.h"
+#define OPUS_DEC_DATA_TYPE OpusMSDecoder
+#define OPUS_DEC_DECODE_API opus_multistream_decode
+#define OPUS_DEC_CREATE_API ms_opus_decoder_create
+#define OPUS_DEC_DESTROY_API opus_multistream_decoder_destroy
+static OpusMSDecoder *ms_opus_decoder_create(opus_int32 Fs, int channels, int *error) {
+  int streams = 1;
+  int coupledStreams = channels == 2;
+  unsigned char mapping[256] = {0, 1};
+  return opus_multistream_decoder_create(Fs, channels, streams, coupledStreams, mapping, error);
+}
+#else
+#define OPUS_DEC_DATA_TYPE OpusDecoder
+#define OPUS_DEC_DECODE_API opus_decode
+#define OPUS_DEC_CREATE_API opus_decoder_create
+#define OPUS_DEC_DESTROY_API opus_decoder_destroy
+#endif
+
+class Codec {
+ public:
+  Codec() = default;
+  ~Codec() { deInitDecoder(); }
+  bool initDecoder(const uint8_t *data);
+  void decodeFrames(const uint8_t *data, size_t size);
+  void deInitDecoder();
+
+ private:
+  int mSamplingRate;
+  int mNoOfChannels;
+  OPUS_DEC_DATA_TYPE *mDec = nullptr;
+  opus_int16 *mPcm = nullptr;
+};
+
+bool Codec::initDecoder(const uint8_t *data) {
+  const uint8_t *tocPtr = &data[kSetupByteOffset];
+  const int bandwidth = opus_packet_get_bandwidth(tocPtr);
+  int samplingRateIndex = bandwidth - OPUS_BANDWIDTH_NARROWBAND;
+
+  /*bounds check on samplingRateIndex*/
+  if ((samplingRateIndex >= 0) && (samplingRateIndex < kNumberSamplingRates)) {
+    mSamplingRate = kSamplingRates[samplingRateIndex];
+  } else {
+    mSamplingRate = 8000;  // set to a default value
+  }
+
+  mNoOfChannels = opus_packet_get_nb_channels(tocPtr);
+  if ((mNoOfChannels != 1) && (mNoOfChannels != 2)) {
+    mNoOfChannels = 1;
+  }
+
+  int err;
+  mDec = OPUS_DEC_CREATE_API(mSamplingRate, mNoOfChannels, &err);
+  if (!mDec || err != OPUS_OK) {
+    return false;
+  }
+  size_t sizePcm = sizeof(*mPcm) * kMaxFrameSample * mNoOfChannels;
+  mPcm = static_cast<opus_int16 *>(malloc(sizePcm));
+  if (!mPcm) {
+    return false;
+  }
+  memset(mPcm, 0x0, sizePcm);
+  return true;
+}
+
+void Codec::deInitDecoder() {
+  OPUS_DEC_DESTROY_API(mDec);
+  mDec = nullptr;
+  if (mPcm) {
+    free(mPcm);
+  }
+  mPcm = nullptr;
+}
+
+void Codec::decodeFrames(const uint8_t *data, size_t size) {
+  (void)OPUS_DEC_DECODE_API(mDec, data, size, mPcm, kMaxFrameSample, 0 /*fec*/);
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  if (size < kSetupByteOffset + 1) {
+    return 0;
+  }
+  Codec *codec = new Codec();
+  if (!codec) {
+    return 0;
+  }
+  if (codec->initDecoder(data)) {
+    codec->decodeFrames(data, size);
+  }
+  delete codec;
+  return 0;
+}
diff --git a/fuzzer/opus_enc_fuzzer.cpp b/fuzzer/opus_enc_fuzzer.cpp
new file mode 100644
index 00000000..c2258fde
--- /dev/null
+++ b/fuzzer/opus_enc_fuzzer.cpp
@@ -0,0 +1,314 @@
+/******************************************************************************
+ *
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *****************************************************************************
+ * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
+ */
+
+#include <algorithm>
+
+#include "opus.h"
+
+using namespace std;
+
+constexpr int kFrameDuration = 50;
+constexpr int kMaxPacket = 1500;
+constexpr int kMinBitRate = 500;
+constexpr int kMaxBitRate = 512000;
+
+constexpr opus_int32 kSampleRates[] = {8000, 12000, 16000, 24000, 48000};
+constexpr size_t kSampleRatesSize = size(kSampleRates);
+
+#ifndef MULTISTREAM
+constexpr int kChannels[] = {1, 2};
+constexpr size_t kChannelsSize = size(kChannels);
+#endif
+
+constexpr int kApplications[] = {OPUS_APPLICATION_VOIP, OPUS_APPLICATION_AUDIO,
+                                 OPUS_APPLICATION_RESTRICTED_LOWDELAY};
+constexpr size_t kApplicationsSize = size(kApplications);
+
+constexpr int kSignals[] = {OPUS_AUTO, OPUS_SIGNAL_VOICE, OPUS_SIGNAL_MUSIC};
+constexpr size_t kSignalsSize = size(kSignals);
+
+constexpr int kSetDTX[] = {0, 1};
+constexpr size_t kSetDTXSize = size(kSetDTX);
+
+constexpr int kSetVBR[] = {0, 1};
+constexpr size_t kSetVBRSize = size(kSetVBR);
+
+constexpr int kSetInbandFec[] = {0, 1};
+constexpr size_t kSetInbandFecSize = size(kSetInbandFec);
+
+constexpr int kSetVBRConstraint[] = {0, 1};
+constexpr size_t kSetVBRConstraintSize = size(kSetVBRConstraint);
+
+constexpr int kSetPredDisable[] = {0, 1};
+constexpr size_t kSetPredDisableSize = size(kSetPredDisable);
+
+constexpr int kComplexities[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+constexpr size_t kComplexitiesSize = size(kComplexities);
+
+constexpr int kForceChannels[] = {OPUS_AUTO, 1, 2};
+constexpr size_t kForceChannelsSize = size(kForceChannels);
+
+constexpr int kMaxBandwidths[] = {OPUS_BANDWIDTH_NARROWBAND, OPUS_BANDWIDTH_MEDIUMBAND,
+                                  OPUS_BANDWIDTH_WIDEBAND, OPUS_BANDWIDTH_SUPERWIDEBAND,
+                                  OPUS_BANDWIDTH_FULLBAND};
+constexpr size_t kMaxBandwidthsSize = size(kMaxBandwidths);
+
+constexpr int kPacketLossPerc[] = {0, 1, 2, 5};
+constexpr size_t kPacketLossPercSize = size(kPacketLossPerc);
+
+constexpr int kLsbDepths[] = {8, 24};
+constexpr size_t kLsbDepthsSize = size(kLsbDepths);
+
+constexpr int kFrameDurations[] = {
+    OPUS_FRAMESIZE_2_5_MS, OPUS_FRAMESIZE_5_MS,   OPUS_FRAMESIZE_10_MS,
+    OPUS_FRAMESIZE_20_MS,  OPUS_FRAMESIZE_40_MS,  OPUS_FRAMESIZE_60_MS,
+    OPUS_FRAMESIZE_80_MS,  OPUS_FRAMESIZE_100_MS, OPUS_FRAMESIZE_120_MS};
+constexpr size_t kFrameDurationsSize = size(kFrameDurations);
+
+#ifdef MULTISTREAM
+#include "opus_multistream.h"
+#define OPUS_ENC_DATA_TYPE OpusMSEncoder
+#define OPUS_ENC_ENCODE_API opus_multistream_encode
+#define OPUS_ENC_CTL_API opus_multistream_encoder_ctl
+#define OPUS_ENC_CREATE_API ms_opus_encoder_create
+#define OPUS_ENC_DESTROY_API opus_multistream_encoder_destroy
+static OpusMSEncoder* ms_opus_encoder_create(opus_int32 sampleRate, int channels, int application,
+                                             int* error) {
+    unsigned char* mapping = (unsigned char*)malloc(sizeof(unsigned char) * channels);
+    if (!mapping) {
+        *error = 1;
+        return nullptr;
+    }
+    for (unsigned char x = 0; x < channels; ++x) {
+        mapping[x] = x;
+    }
+    OpusMSEncoder* enc = opus_multistream_encoder_create(sampleRate, channels, 1, channels - 1,
+                                                         mapping, application, error);
+    free(mapping);
+    return enc;
+}
+#else
+#define OPUS_ENC_DATA_TYPE OpusEncoder
+#define OPUS_ENC_ENCODE_API opus_encode
+#define OPUS_ENC_CTL_API opus_encoder_ctl
+#define OPUS_ENC_CREATE_API opus_encoder_create
+#define OPUS_ENC_DESTROY_API opus_encoder_destroy
+#endif
+
+enum {
+    IDX_SAMPLE_RATE_INDEX = 0,
+    IDX_CHANNEL,
+    IDX_BIT_RATE_1,
+    IDX_BIT_RATE_2,
+    IDX_BIT_RATE_3,
+    IDX_COMPLEXITY,
+    IDX_APPLICATION,
+    IDX_SET_DTX,
+    IDX_SET_SIGNAL,
+    IDX_SET_VBR,
+    IDX_SET_VBR_CONSTRAINT,
+    IDX_FORCE_CHANNEL_INDEX,
+    IDX_SET_MAX_BANDWIDTH,
+    IDX_SET_INBAND_FEC,
+    IDX_SET_PACKET_LOSS_PERC,
+    IDX_SET_LSB_DEPTH,
+    IDX_SET_PREDICTION_DISABLED,
+    IDX_FRAME_ENUM,
+    IDX_LAST
+};
+
+template <typename type1, typename type2, typename type3>
+auto generateNumberInRangeFromData(type1 data, type2 min, type3 max) -> decltype(max) {
+    return (data % (1 + max - min)) + min;
+}
+
+class Codec {
+   public:
+    ~Codec() { deInitEncoder(); }
+    bool initEncoder(uint8_t** dataPtr, size_t* sizePtr);
+    void encodeFrames(const uint8_t* data, size_t size);
+    void deInitEncoder();
+
+   private:
+    OPUS_ENC_DATA_TYPE* mEncoder = nullptr;
+    int mChannels = 0;
+    int mNumSamplesPerFrame = 0;
+    size_t mFrameSize = 0;
+    size_t mNumPcmBytesPerInputFrame = 0;
+};
+
+int get_frame_size(int frameSizeEnum, int samplingRate) {
+    int frameSize = 0;
+    switch (frameSizeEnum) {
+        case OPUS_FRAMESIZE_2_5_MS:
+            frameSize = samplingRate / 400;
+            break;
+        case OPUS_FRAMESIZE_5_MS:
+            frameSize = samplingRate / 200;
+            break;
+        case OPUS_FRAMESIZE_10_MS:
+            frameSize = samplingRate / 100;
+            break;
+        case OPUS_FRAMESIZE_20_MS:
+            frameSize = samplingRate / 50;
+            break;
+        case OPUS_FRAMESIZE_40_MS:
+            frameSize = samplingRate / 25;
+            break;
+        case OPUS_FRAMESIZE_60_MS:
+            frameSize = 3 * samplingRate / 50;
+            break;
+        case OPUS_FRAMESIZE_80_MS:
+            frameSize = 4 * samplingRate / 50;
+            break;
+        case OPUS_FRAMESIZE_100_MS:
+            frameSize = 5 * samplingRate / 50;
+            break;
+        case OPUS_FRAMESIZE_120_MS:
+            frameSize = 6 * samplingRate / 50;
+            break;
+        default:
+            break;
+    }
+    return frameSize;
+}
+
+bool Codec::initEncoder(uint8_t** dataPtr, size_t* sizePtr) {
+    uint8_t* data = *dataPtr;
+
+    int sampleRateIndex = data[IDX_SAMPLE_RATE_INDEX] % kSampleRatesSize;
+    opus_int32 sampleRate = kSampleRates[sampleRateIndex];
+
+#ifdef MULTISTREAM
+    mChannels = generateNumberInRangeFromData(data[IDX_CHANNEL], 1, 255);
+#else
+    int channelIndex = data[IDX_CHANNEL] % kChannelsSize;
+    mChannels = kChannels[channelIndex];
+#endif
+
+    mNumSamplesPerFrame = sampleRate / kFrameDuration;
+    mNumPcmBytesPerInputFrame = mChannels * mNumSamplesPerFrame * sizeof(int16_t);
+
+    int application = kApplications[data[IDX_APPLICATION] % kApplicationsSize];
+    int err = 0;
+    mEncoder = OPUS_ENC_CREATE_API(sampleRate, mChannels, application, &err);
+    if (err) {
+        return false;
+    }
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_APPLICATION(application));
+
+    int complexityIndex = data[IDX_COMPLEXITY] % kComplexitiesSize;
+    int complexity = kComplexities[complexityIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_COMPLEXITY(complexity));
+
+    int setDTXIndex = data[IDX_SET_DTX] % kSetDTXSize;
+    int setDTX = kSetDTX[setDTXIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_DTX(setDTX));
+
+    int signalIndex = data[IDX_SET_SIGNAL] % kSignalsSize;
+    int signal = kSignals[signalIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_SIGNAL(signal));
+
+    int setVBRIndex = data[IDX_SET_VBR] % kSetVBRSize;
+    int setVBR = kSetVBR[setVBRIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_VBR(setVBR));
+
+    int setVBRConstraintIndex = data[IDX_SET_VBR_CONSTRAINT] % kSetVBRConstraintSize;
+    int setVBRConstraint = kSetVBRConstraint[setVBRConstraintIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_VBR_CONSTRAINT(setVBRConstraint));
+
+    // Clubbing 3 bytes of data to ensure bit rate in the range [kMinBitRate, kMaxBitRate]
+    uint32_t tempValue =
+        (data[IDX_BIT_RATE_1] << 16) | (data[IDX_BIT_RATE_2] << 8) | data[IDX_BIT_RATE_3];
+    uint32_t bitRate = generateNumberInRangeFromData(tempValue, kMinBitRate, kMaxBitRate);
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_BITRATE(bitRate));
+
+    int forceChanneIndex = data[IDX_FORCE_CHANNEL_INDEX] % kForceChannelsSize;
+    int forceChannel = kForceChannels[forceChanneIndex];
+    forceChannel = min(forceChannel, mChannels);
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_FORCE_CHANNELS(forceChannel));
+
+    int maxBandwidthIndex = data[IDX_SET_MAX_BANDWIDTH] % kMaxBandwidthsSize;
+    opus_int32 maxBandwidth = kMaxBandwidths[maxBandwidthIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_MAX_BANDWIDTH(maxBandwidth));
+
+    int setInbandFecIndex = data[IDX_SET_INBAND_FEC] % kSetInbandFecSize;
+    int setInbandFec = kSetInbandFec[setInbandFecIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_INBAND_FEC(setInbandFec));
+
+    int pktLossIndex = data[IDX_SET_PACKET_LOSS_PERC] % kPacketLossPercSize;
+    int pktLoss = kPacketLossPerc[pktLossIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_PACKET_LOSS_PERC(pktLoss));
+
+    int lsbDepthIndex = data[IDX_SET_LSB_DEPTH] % kLsbDepthsSize;
+    int lsbDepth = kLsbDepths[lsbDepthIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_LSB_DEPTH(lsbDepth));
+
+    int setPredDisableIndex = data[IDX_SET_PREDICTION_DISABLED] % kSetPredDisableSize;
+    int setPredDisable = kSetPredDisable[setPredDisableIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_PREDICTION_DISABLED(setPredDisable));
+
+    int frameSizesEnumIndex = data[IDX_FRAME_ENUM] % kFrameDurationsSize;
+    int frameSizeEnum = kFrameDurations[frameSizesEnumIndex];
+    OPUS_ENC_CTL_API(mEncoder, OPUS_SET_EXPERT_FRAME_DURATION(frameSizeEnum));
+
+    mFrameSize = get_frame_size(frameSizeEnum, sampleRate);
+    if (mFrameSize == 0) {
+        return false;
+    }
+
+    // Not re-using the data which was used for configuration for encoding
+    *dataPtr += IDX_LAST;
+    *sizePtr -= IDX_LAST;
+    return true;
+}
+
+void Codec::encodeFrames(const uint8_t* data, size_t size) {
+    opus_int16* inputBuffer = (opus_int16*)data;
+    size = size / sizeof(opus_int16);
+    size_t offset = 0;
+    do {
+        size_t frameSize = mFrameSize / mChannels;
+        if (frameSize > (size - offset)) {
+            frameSize = size - offset;
+        }
+        unsigned char packet[kMaxPacket];
+        (void)OPUS_ENC_ENCODE_API(mEncoder, &inputBuffer[offset], frameSize, packet, kMaxPacket);
+        offset += mFrameSize * mChannels;
+    } while (offset < size);
+}
+
+void Codec::deInitEncoder() {
+    if (mEncoder) {
+        OPUS_ENC_DESTROY_API(mEncoder);
+        mEncoder = nullptr;
+    }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+    if (size < IDX_LAST) {
+        return 0;
+    }
+    Codec encoder;
+    if (encoder.initEncoder(const_cast<uint8_t**>(&data), &size)) {
+        encoder.encodeFrames(data, size);
+    }
+    return 0;
+}
diff --git a/include/meson.build b/include/meson.build
new file mode 100644
index 00000000..c1fb0b76
--- /dev/null
+++ b/include/meson.build
@@ -0,0 +1,13 @@
+opus_headers = [
+  'opus.h',
+  'opus_multistream.h',
+  'opus_projection.h',
+  'opus_types.h',
+  'opus_defines.h',
+]
+
+if opt_custom_modes
+  opus_headers += ['opus_custom.h']
+endif
+
+install_headers(opus_headers, subdir: 'opus')
diff --git a/include/opus_custom.h b/include/opus_custom.h
index 41f36bf2..2227be01 100644
--- a/include/opus_custom.h
+++ b/include/opus_custom.h
@@ -178,7 +178,7 @@ OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomEncoder *opus_custom_encode
 ) OPUS_ARG_NONNULL(1);
 
 
-/** Destroys a an encoder state.
+/** Destroys an encoder state.
   * @param[in] st <tt>OpusCustomEncoder*</tt>: State to be freed.
   */
 OPUS_CUSTOM_EXPORT void opus_custom_encoder_destroy(OpusCustomEncoder *st);
@@ -286,7 +286,7 @@ OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomDecoder *opus_custom_decode
     int *error
 ) OPUS_ARG_NONNULL(1);
 
-/** Destroys a an decoder state.
+/** Destroys a decoder state.
   * @param[in] st <tt>OpusCustomDecoder*</tt>: State to be freed.
   */
 OPUS_CUSTOM_EXPORT void opus_custom_decoder_destroy(OpusCustomDecoder *st);
diff --git a/include/opus_defines.h b/include/opus_defines.h
index fbf5d0eb..ceee5b84 100644
--- a/include/opus_defines.h
+++ b/include/opus_defines.h
@@ -64,7 +64,7 @@ extern "C" {
 /**Export control for opus functions */
 
 #ifndef OPUS_EXPORT
-# if defined(WIN32)
+# if defined(_WIN32)
 #  if defined(OPUS_BUILD) && defined(DLL_EXPORT)
 #   define OPUS_EXPORT __declspec(dllexport)
 #  else
@@ -168,6 +168,7 @@ extern "C" {
 /* Don't use 4045, it's already taken by OPUS_GET_GAIN_REQUEST */
 #define OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST 4046
 #define OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST 4047
+#define OPUS_GET_IN_DTX_REQUEST              4049
 
 /** Defines for the presence of extended APIs. */
 #define OPUS_HAVE_OPUS_PROJECTION_H
@@ -715,6 +716,16 @@ extern "C" {
   * </dl>
   * @hideinitializer */
 #define OPUS_GET_PHASE_INVERSION_DISABLED(x) OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST, __opus_check_int_ptr(x)
+/** Gets the DTX state of the encoder.
+  * Returns whether the last encoded frame was either a comfort noise update
+  * during DTX or not encoded because of DTX.
+  * @param[out] x <tt>opus_int32 *</tt>: Returns one of the following values:
+  * <dl>
+  * <dt>0</dt><dd>The encoder is not in DTX.</dd>
+  * <dt>1</dt><dd>The encoder is in DTX.</dd>
+  * </dl>
+  * @hideinitializer */
+#define OPUS_GET_IN_DTX(x) OPUS_GET_IN_DTX_REQUEST, __opus_check_int_ptr(x)
 
 /**@}*/
 
diff --git a/libopus_blacklist.txt b/libopus_blocklist.txt
index 51db6112..51db6112 100644
--- a/libopus_blacklist.txt
+++ b/libopus_blocklist.txt
diff --git a/meson.build b/meson.build
new file mode 100644
index 00000000..41f69353
--- /dev/null
+++ b/meson.build
@@ -0,0 +1,675 @@
+project('opus', 'c',
+  version: run_command('meson/get-version.py', '--package-version', check: true).stdout().strip(),
+  meson_version: '>=0.54.0',
+  default_options: ['warning_level=2',
+                    'c_std=gnu99',
+                    'buildtype=debugoptimized'])
+
+libversion = run_command('meson/get-version.py', '--libtool-version', check: true).stdout().strip()
+macosversion = run_command('meson/get-version.py', '--darwin-version', check: true).stdout().strip()
+
+cc = meson.get_compiler('c')
+host_system = host_machine.system()
+host_cpu_family = host_machine.cpu_family()
+top_srcdir = meson.current_source_dir()
+top_builddir = meson.current_build_dir()
+
+opus_includes = include_directories('.', 'include', 'celt', 'silk')
+opus_public_includes = include_directories('include')
+
+add_project_arguments('-DOPUS_BUILD', language: 'c')
+add_project_arguments('-DHAVE_CONFIG_H', language: 'c')
+
+if host_system == 'windows'
+  if cc.get_argument_syntax() == 'msvc'
+    add_project_arguments('-D_CRT_SECURE_NO_WARNINGS', language: 'c')
+  endif
+endif
+
+if cc.get_argument_syntax() == 'gnu'
+  add_project_arguments('-D_FORTIFY_SOURCE=2', language: 'c')
+endif
+
+# Check for extra compiler args
+additional_c_args = []
+if cc.get_argument_syntax() != 'msvc'
+  additional_c_args += [
+    '-fvisibility=hidden',
+    '-Wcast-align',
+    '-Wnested-externs',
+    '-Wshadow',
+    '-Wstrict-prototypes',
+  ]
+
+  # On Windows, -fstack-protector-strong adds a libssp-0.dll dependency and
+  # prevents static linking
+  if host_system != 'windows'
+    additional_c_args += ['-fstack-protector-strong']
+  endif
+endif
+
+foreach arg : additional_c_args
+  if cc.has_argument(arg)
+    add_project_arguments(arg, language: 'c')
+  endif
+endforeach
+
+# Windows MSVC warnings
+if cc.get_id() == 'msvc'
+  # Ignore several spurious warnings.
+  # If a warning is completely useless and spammy, use '/wdXXXX' to suppress it
+  # If a warning is harmless but hard to fix, use '/woXXXX' so it's shown once
+  # NOTE: Only add warnings here if you are sure they're spurious
+  add_project_arguments('/wd4035', '/wd4715', '/wd4116', '/wd4046', '/wd4068',
+    '/wd4820', '/wd4244', '/wd4255', '/wd4668',
+    language : 'c')
+endif
+
+opus_version = meson.project_version()
+
+opus_conf = configuration_data()
+opus_conf.set('PACKAGE_BUGREPORT', '"opus@xiph.org"')
+opus_conf.set('PACKAGE_NAME', '"opus"')
+opus_conf.set('PACKAGE_STRING', '"opus @0@"'.format(opus_version))
+opus_conf.set('PACKAGE_TARNAME', '"opus"')
+opus_conf.set('PACKAGE_URL', '""')
+opus_conf.set('PACKAGE_VERSION', '"@0@"'.format(opus_version))
+
+# FIXME: optional Ne10 dependency
+have_arm_ne10 = false
+
+libm = cc.find_library('m', required : false)
+
+opus_conf.set('HAVE_LRINTF', cc.has_function('lrintf', prefix: '#include <math.h>', dependencies: libm))
+opus_conf.set('HAVE_LRINT', cc.has_function('lrint', prefix: '#include <math.h>', dependencies: libm))
+opus_conf.set('HAVE___MALLOC_HOOK', cc.has_function('__malloc_hook', prefix: '#include <malloc.h>'))
+opus_conf.set('HAVE_STDINT_H', cc.check_header('stdint.h'))
+
+# Check for restrict keyword
+restrict_tmpl = '''
+typedef int * int_ptr;
+int foo (int_ptr @0@ ip, int * @0@ baz[]) {
+  return ip[0];
+}
+int main (int argc, char ** argv) {
+  int s[1];
+  int * @0@ t = s;
+  t[0] = 0;
+  return foo(t, (void *)0);
+}'''
+# Define restrict to the equivalent of the C99 restrict keyword, or to
+# nothing if this is not supported.  Do not define if restrict is
+# supported directly.
+if not cc.compiles(restrict_tmpl.format('restrict'), name : 'restrict keyword')
+  if cc.compiles(restrict_tmpl.format('__restrict'), name : '__restrict')
+    opus_conf.set('restrict', '__restrict')
+  elif cc.compiles(restrict_tmpl.format('__restrict__'), name : '__restrict__')
+    opus_conf.set('restrict', '__restrict')
+  elif cc.compiles(restrict_tmpl.format('_Restrict'), name : '_Restrict')
+    opus_conf.set('restrict', '_Restrict')
+  else
+    opus_conf.set('restrict', '/**/')
+  endif
+endif
+
+# Check for C99 variable-size arrays, or alloca() as fallback
+msg_use_alloca = false
+if cc.compiles('''static int x;
+                  char some_func (void) {
+                    char a[++x];
+                    a[sizeof a - 1] = 0;
+                    int N;
+                    return a[0];
+                  }''', name : 'C99 variable-size arrays')
+  opus_conf.set('VAR_ARRAYS', 1)
+  msg_use_alloca = 'NO (using C99 variable-size arrays instead)'
+elif cc.compiles('''#include <alloca.h>
+                    void some_func (void) {
+                      int foo=10;
+                      int * array = alloca(foo);
+                    }''', name : 'alloca (alloca.h)')
+  opus_conf.set('USE_ALLOCA', true)
+  opus_conf.set('HAVE_ALLOCA_H', true)
+  msg_use_alloca = true
+elif cc.compiles('''#include <malloc.h>
+                    #include <stdlib.h>
+                    void some_func (void) {
+                      int foo=10;
+                      int * array = alloca(foo);
+                    }''', name : 'alloca (std)')
+  opus_conf.set('USE_ALLOCA', true)
+  msg_use_alloca = true
+endif
+
+opts = [
+  [ 'fixed-point', 'FIXED_POINT' ],
+  [ 'fixed-point-debug', 'FIXED_DEBUG' ],
+  [ 'custom-modes', 'CUSTOM_MODES' ],
+  [ 'float-approx', 'FLOAT_APPROX' ],
+  [ 'assertions', 'ENABLE_ASSERTIONS' ],
+  [ 'hardening', 'ENABLE_HARDENING' ],
+  [ 'fuzzing', 'FUZZING' ],
+  [ 'check-asm', 'OPUS_CHECK_ASM' ],
+]
+
+foreach opt : opts
+  # we assume these are all boolean options
+  opt_foo = get_option(opt[0])
+  if opt_foo
+    opus_conf.set(opt[1], 1)
+  endif
+  set_variable('opt_' + opt[0].underscorify(), opt_foo)
+endforeach
+
+opt_asm = get_option('asm')
+opt_rtcd = get_option('rtcd')
+opt_intrinsics = get_option('intrinsics')
+extra_programs = get_option('extra-programs')
+opt_tests = get_option('tests')
+
+disable_float_api = not get_option('float-api')
+if disable_float_api
+  opus_conf.set('DISABLE_FLOAT_API', 1)
+endif
+
+# This is for the description in the pkg-config .pc file
+if opt_fixed_point
+  pc_build = 'fixed-point'
+else
+  pc_build = 'floating-point'
+endif
+if opt_custom_modes
+  pc_build = pc_build + ', custom modes'
+endif
+
+rtcd_support = []
+# With GCC, Clang, ICC, etc, we differentiate between 'may support this SIMD'
+# and 'presume we have this SIMD' by checking whether the SIMD / intrinsics can
+# be compiled by the compiler as-is (presume) or with SIMD cflags (may have).
+# With MSVC, the compiler will always build SIMD/intrinsics targeting all
+# specific instruction sets supported by that version of the compiler. No
+# special arguments are ever needed. If runtime CPU detection is not disabled,
+# we must always assume that we only 'may have' it.
+opus_can_presume_simd = true
+if cc.get_argument_syntax() == 'msvc'
+  if opt_rtcd.disabled()
+    warning('Building with an MSVC-like compiler and runtime CPU detection is disabled. Outputs may not run on all @0@ CPUs.'.format(host_cpu_family))
+  else
+    opus_can_presume_simd = false
+  endif
+endif
+
+opus_arm_external_asm = false
+
+asm_tmpl = '''
+int main (int argc, char ** argv) {
+  __asm__("@0@");
+  return 0;
+}'''
+
+asm_optimization = []
+inline_optimization = []
+if not opt_asm.disabled()
+  # Currently we only have inline asm for fixed-point
+  if host_cpu_family == 'arm' and opt_fixed_point
+    opus_conf.set('OPUS_ARM_ASM', true)
+
+    # Check if compiler supports gcc-style inline assembly
+    if cc.compiles('''#ifdef __GNUC_MINOR__
+                      #if (__GNUC__ * 1000 + __GNUC_MINOR__) < 3004
+                      #error GCC before 3.4 has critical bugs compiling inline assembly
+                      #endif
+                      #endif
+                      __asm__ (""::)''',
+                   name : 'compiler supports gcc-style inline assembly')
+
+      opus_conf.set('OPUS_ARM_INLINE_ASM', 1)
+
+      # AS_ASM_ARM_EDSP
+      if cc.compiles(asm_tmpl.format('qadd r3,r3,r3'),
+                     name : 'assembler supports EDSP instructions on ARM')
+        opus_conf.set('OPUS_ARM_INLINE_EDSP', 1)
+        inline_optimization += ['ESDP']
+      endif
+
+      # AS_ASM_ARM_MEDIA
+      if cc.compiles(asm_tmpl.format('shadd8 r3,r3,r3'),
+                     name : 'assembler supports ARMv6 media instructions on ARM')
+        opus_conf.set('OPUS_ARM_INLINE_MEDIA', 1)
+        inline_optimization += ['Media']
+      endif
+
+      # AS_ASM_ARM_NEON
+      if cc.compiles(asm_tmpl.format('vorr d0,d0,d0'),
+                     name : 'assembler supports NEON instructions on ARM')
+        opus_conf.set('OPUS_ARM_INLINE_NEON', 1)
+        inline_optimization += ['NEON']
+      endif
+    endif
+
+    # We need Perl to translate RVCT-syntax asm to gas syntax
+    perl = find_program('perl', required: get_option('asm'))
+    if perl.found()
+      opus_arm_external_asm = true
+      # opus_arm_presume_* mean we can and will use those instructions
+      # directly without doing runtime CPU detection.
+      # opus_arm_may_have_* mean we can emit those instructions, but we can
+      # only use them after runtime detection.
+      # The same rules apply for x86 assembly and intrinsics.
+
+      opus_arm_may_have_edsp = opus_conf.has('OPUS_ARM_INLINE_EDSP')
+      opus_arm_presume_edsp = opus_arm_may_have_edsp and opus_can_presume_simd
+
+      opus_arm_may_have_media = opus_conf.has('OPUS_ARM_INLINE_MEDIA')
+      opus_arm_presume_media = opus_arm_may_have_media and opus_can_presume_simd
+
+      opus_arm_may_have_neon = opus_conf.has('OPUS_ARM_INLINE_NEON')
+      opus_arm_presume_neon = opus_arm_may_have_neon and opus_can_presume_simd
+
+      if not opt_rtcd.disabled()
+        if not opus_arm_may_have_edsp
+          message('Trying to force-enable armv5e EDSP instructions...')
+          # AS_ASM_ARM_EDSP_FORCE
+          opus_arm_may_have_edsp = cc.compiles(asm_tmpl.format('.arch armv5te\n.object_arch armv4t\nqadd r3,r3,r3'),
+                                               name : 'Assembler supports EDSP instructions on ARM (forced)')
+        endif
+        if not opus_arm_may_have_media
+          message('Trying to force-enable ARMv6 media instructions...')
+          opus_arm_may_have_media = cc.compiles(asm_tmpl.format('.arch armv6\n.object_arch armv4t\nshadd8 r3,r3,r3'),
+                                                name : 'Assembler supports ARMv6 media instructions on ARM (forced)')
+        endif
+        if not opus_arm_may_have_neon
+          message('Trying to force-enable NEON instructions...')
+          opus_arm_may_have_neon = cc.compiles(asm_tmpl.format('.arch armv7-a\n.fpu neon\n.object_arch armv4t\nvorr d0,d0,d0'),
+                                               name : 'Assembler supports NEON instructions on ARM (forced)')
+        endif
+      endif
+
+      if opus_arm_may_have_edsp
+        opus_conf.set('OPUS_ARM_MAY_HAVE_EDSP', 1)
+        if opus_arm_presume_edsp
+          opus_conf.set('OPUS_ARM_PRESUME_EDSP', 1)
+          asm_optimization += ['EDSP']
+        else
+          rtcd_support += ['EDSP']
+        endif
+      endif
+      if opus_arm_may_have_media
+        opus_conf.set('OPUS_ARM_MAY_HAVE_MEDIA', 1)
+        if opus_arm_presume_media
+          opus_conf.set('OPUS_ARM_PRESUME_MEDIA', 1)
+          asm_optimization += ['Media']
+        else
+          rtcd_support += ['Media']
+        endif
+      endif
+      if opus_arm_may_have_neon
+        opus_conf.set('OPUS_ARM_MAY_HAVE_NEON', 1)
+        if opus_arm_presume_neon
+          opus_conf.set('OPUS_ARM_PRESUME_NEON', 1)
+          asm_optimization += ['NEON']
+        else
+          rtcd_support += ['NEON']
+        endif
+      endif
+
+      if cc.get_define('__APPLE__')
+        arm2gnu_args = ['--apple']
+      else
+        arm2gnu_args = []
+      endif
+    endif # found perl
+  else # arm + enable fixed point
+    if opt_asm.enabled()
+      error('asm option is enabled, but no assembly support for ' + host_cpu_family)
+    endif
+  endif
+endif # enable asm
+
+# Check whether we require assembly and we support assembly on this arch,
+# but none were detected. Can happen because of incorrect compiler flags, such
+# as missing -mfloat-abi=softfp on ARM32 softfp architectures.
+if opt_asm.enabled() and (asm_optimization.length() + inline_optimization.length()) == 0
+  error('asm option was enabled, but no assembly support was detected')
+endif
+
+# XXX: NEON has hardfp vs softfp compiler configuration issues
+# When targeting ARM32 softfp, we sometimes need to explicitly pass
+# -mfloat-abi=softfp to enable NEON. F.ex., on Android. It should
+# be set in the cross file.
+arm_neon_intr_link_args = ['-mfpu=neon']
+
+have_sse = false
+have_sse2 = false
+have_sse4_1 = false
+have_avx = false # no avx opus code yet
+have_neon_intr = false
+
+intrinsics_support = []
+if not opt_intrinsics.disabled()
+  if host_cpu_family in ['arm', 'aarch64']
+    # Check for ARMv7/AArch64 neon intrinsics
+    intrin_check = '''
+    #include <arm_neon.h>
+      int main (void) {
+        static float32x4_t A0, A1, SUMM;
+        SUMM = vmlaq_f32(SUMM, A0, A1);
+        return (int)vgetq_lane_f32(SUMM, 0);
+      }'''
+    intrin_name = 'ARMv7/AArch64 NEON'
+    if cc.links(intrin_check,
+                name: 'compiler supports @0@ intrinsics'.format(intrin_name))
+      opus_arm_presume_neon_intr = opus_can_presume_simd
+      opus_arm_may_have_neon_intr = true
+    else
+      opus_arm_presume_neon_intr = false
+      if cc.links(intrin_check,
+                  args: arm_neon_intr_link_args,
+                  name: 'compiler supports @0@ intrinsics with @1@'.format(intrin_name, ' '.join(arm_neon_intr_link_args)))
+        opus_arm_may_have_neon_intr = true
+      else
+        opus_arm_may_have_neon_intr = false
+      endif
+    endif
+
+    if opus_arm_may_have_neon_intr
+      have_neon_intr = true
+      intrinsics_support += [intrin_name]
+      opus_conf.set('OPUS_ARM_MAY_HAVE_NEON_INTR', 1)
+      if opus_arm_presume_neon_intr
+        opus_conf.set('OPUS_ARM_PRESUME_NEON_INTR', 1)
+      else
+        rtcd_support += [intrin_name]
+        opus_neon_intr_args = arm_neon_intr_link_args
+      endif
+    else
+      message('Compiler does not support @0@ intrinsics'.format(intrin_name))
+    endif
+
+    # Check for aarch64 neon intrinsics
+    intrin_check = '''
+    #include <arm_neon.h>
+      int main (void) {
+        static int32_t IN;
+        static int16_t OUT;
+        OUT = vqmovns_s32(IN);
+      }'''
+    intrin_name = 'AArch64 NEON'
+    if cc.links(intrin_check,
+                name: 'compiler supports @0@ intrinsics'.format(intrin_name))
+      opus_arm_presume_aarch64_neon_intr = opus_can_presume_simd
+      opus_arm_may_have_aarch64_neon_intr = true
+    else
+      opus_arm_presume_aarch64_neon_intr = false
+      if cc.links(intrin_check,
+                  args: arm_neon_intr_link_args,
+                  name: 'compiler supports @0@ intrinsics with @1@'.format(intrin_name, ' '.join(arm_neon_intr_link_args)))
+        opus_arm_may_have_aarch64_neon_intr = true
+      else
+        opus_arm_may_have_aarch64_neon_intr = false
+      endif
+    endif
+
+    if opus_arm_may_have_aarch64_neon_intr
+      intrinsics_support += [intrin_name]
+      opus_conf.set('OPUS_X86_MAY_HAVE_AARCH64_NEON_INTR', 1)
+      if opus_arm_presume_aarch64_neon_intr
+        opus_conf.set('OPUS_X86_PRESUME_AARCH64_NEON_INTR', 1)
+      endif
+    else
+      message('Compiler does not support @0@ intrinsics'.format(intrin_name))
+    endif
+  elif host_cpu_family in ['x86', 'x86_64']
+    # XXX: allow external override/specification of the flags
+    x86_intrinsics = [
+      [ 'SSE', 'xmmintrin.h', '__m128', '_mm_setzero_ps()', ['-msse'] ],
+      [ 'SSE2', 'emmintrin.h', '__m128i', '_mm_setzero_si128()', ['-msse2'] ],
+      [ 'SSE4.1', 'smmintrin.h', '__m128i', '_mm_setzero_si128(); mtest = _mm_cmpeq_epi64(mtest, mtest)', ['-msse4.1'] ],
+      [ 'AVX', 'immintrin.h', '__m256', '_mm256_setzero_ps()', ['-mavx'] ],
+    ]
+
+    foreach intrin : x86_intrinsics
+      intrin_check = '''#include <@0@>
+                        int main (int argc, char ** argv) {
+                          static @1@ mtest;
+                          mtest = @2@;
+                          return *((unsigned char *) &mtest) != 0;
+                        }'''.format(intrin[1],intrin[2],intrin[3])
+      intrin_name = intrin[0]
+      # Intrinsics arguments are not available with MSVC-like compilers
+      intrin_args = cc.get_argument_syntax() == 'msvc' ? [] : intrin[4]
+      if cc.links(intrin_check, name : 'compiler supports @0@ intrinsics'.format(intrin_name))
+        may_have_intrin = true
+        presume_intrin = opus_can_presume_simd
+      elif intrin_args.length() > 0
+        presume_intrin = false
+        if cc.links(intrin_check,
+                    args : intrin_args,
+                    name : 'compiler supports @0@ intrinsics with @1@'.format(intrin_name, ' '.join(intrin_args)))
+          may_have_intrin = true
+        else
+          may_have_intrin = false
+        endif
+      endif
+      if may_have_intrin
+        intrinsics_support += [intrin_name]
+        intrin_lower_name = intrin_name.to_lower().underscorify()
+        set_variable('have_' + intrin_lower_name, true)
+        opus_conf.set('OPUS_X86_MAY_HAVE_' + intrin_name.underscorify(), 1)
+        if presume_intrin
+          opus_conf.set('OPUS_X86_PRESUME_' + intrin_name.underscorify(), 1)
+        else
+          rtcd_support += [intrin_name]
+          set_variable('opus_@0@_args'.format(intrin_lower_name), intrin_args)
+        endif
+      else
+        message('Compiler does not support @0@ intrinsics'.format(intrin_name))
+      endif
+    endforeach
+
+    if not opt_rtcd.disabled()
+      get_cpuid_by_asm = false
+      cpuid_asm_code = '''
+        #include <stdio.h>
+        int main (int argc, char ** argv) {
+                 unsigned int CPUInfo0;
+                 unsigned int CPUInfo1;
+                 unsigned int CPUInfo2;
+                 unsigned int CPUInfo3;
+                 unsigned int InfoType;
+                #if defined(__i386__) && defined(__PIC__)
+                 __asm__ __volatile__ (
+                 "xchg %%ebx, %1\n"
+                 "cpuid\n"
+                 "xchg %%ebx, %1\n":
+                 "=a" (CPUInfo0),
+                 "=r" (CPUInfo1),
+                 "=c" (CPUInfo2),
+                 "=d" (CPUInfo3) :
+                 "a" (InfoType), "c" (0)
+                );
+               #else
+                 __asm__ __volatile__ (
+                 "cpuid":
+                 "=a" (CPUInfo0),
+                 "=b" (CPUInfo1),
+                 "=c" (CPUInfo2),
+                 "=d" (CPUInfo3) :
+                 "a" (InfoType), "c" (0)
+                );
+               #endif
+          return 0;
+        }'''
+      cpuid_c_code = '''
+        #include <cpuid.h>
+        int main (int argc, char ** argv) {
+          unsigned int CPUInfo0;
+          unsigned int CPUInfo1;
+          unsigned int CPUInfo2;
+          unsigned int CPUInfo3;
+          unsigned int InfoType;
+          __get_cpuid(InfoType, &CPUInfo0, &CPUInfo1, &CPUInfo2, &CPUInfo3);
+          return 0;
+        }'''
+      cpuid_msvc_code = '''
+        #include <intrin.h>
+        int main (void) {
+          int CPUInfo, InfoType;
+          __cpuid(&CPUInfo, InfoType);
+        }'''
+      if cc.links(cpuid_asm_code, name : 'Get X86 CPU info via inline assembly')
+        opus_conf.set('CPU_INFO_BY_ASM', 1)
+      elif cc.links(cpuid_c_code, name : 'Get X86 CPU info via C method')
+        opus_conf.set('CPU_INFO_BY_C', 1)
+      elif cc.get_define('_MSC_VER') != '' and cc.links(cpuid_msvc_code)
+        message('Getting X86 CPU info via __cpuid')
+      else
+        if opt_intrinsics.enabled() and opt_rtcd.enabled()
+          error('intrinsics and rtcd options are enabled, but no Get CPU Info method detected')
+        endif
+        warning('Get CPU Info method not detected, no rtcd for intrinsics')
+      endif
+    endif # opt_rtcd
+  else
+    if opt_intrinsics.enabled()
+      error('intrinsics option enabled, but no intrinsics support for ' + host_machine.get_cpu())
+    endif
+    warning('No intrinsics support for ' + host_machine.get_cpu())
+  endif
+endif
+
+# Check whether we require intrinsics and we support intrinsics on this arch,
+# but none were detected. Can happen because of incorrect compiler flags, such
+# as missing -mfloat-abi=softfp on ARM32 softfp architectures.
+if opt_intrinsics.enabled() and intrinsics_support.length() == 0
+  error('intrinsics option was enabled, but none were detected')
+endif
+
+if opt_rtcd.disabled()
+  rtcd_support = 'disabled'
+else
+  if rtcd_support.length() > 0
+    opus_conf.set('OPUS_HAVE_RTCD', 1)
+  else
+    if intrinsics_support.length() == 0
+      rtcd_support = 'none'
+      if opt_rtcd.enabled()
+        error('rtcd option is enabled, but no support for intrinsics or assembly is available')
+      endif
+    else
+      rtcd_support = 'not needed'
+    endif
+  endif
+endif
+
+# extract source file lists from .mk files
+mk_files = ['silk_sources.mk', 'opus_headers.mk', 'opus_sources.mk', 'silk_headers.mk', 'celt_sources.mk', 'celt_headers.mk']
+lines = run_command('meson/read-sources-list.py', mk_files, check: true).stdout().strip().split('\n')
+sources = {}
+foreach l : lines
+  a = l.split(' = ')
+  var_name = a[0]
+  file_list = a[1].split()
+  sources += {var_name: files(file_list)}
+endforeach
+
+subdir('include')
+subdir('silk')
+subdir('celt')
+subdir('src')
+
+configure_file(output: 'config.h', configuration: opus_conf)
+
+if not opt_tests.disabled()
+  subdir('celt/tests')
+  subdir('silk/tests')
+  subdir('tests')
+endif
+
+# pkg-config files (not using pkg module so we can use the existing .pc.in file)
+pkgconf = configuration_data()
+
+pkgconf.set('prefix', join_paths(get_option('prefix')))
+pkgconf.set('exec_prefix', '${prefix}')
+pkgconf.set('libdir', '${prefix}/@0@'.format(get_option('libdir')))
+pkgconf.set('includedir', '${prefix}/@0@'.format(get_option('includedir')))
+pkgconf.set('VERSION', opus_version)
+pkgconf.set('PC_BUILD', pc_build)
+pkgconf.set('LIBM', libm.found() ? '-lm' : '')
+
+pkg_install_dir = '@0@/pkgconfig'.format(get_option('libdir'))
+
+configure_file(input : 'opus.pc.in',
+  output : 'opus.pc',
+  configuration : pkgconf,
+  install_dir : pkg_install_dir)
+
+# The uninstalled one has hardcoded libtool + static lib stuff, skip it for now
+#configure_file(input : 'opus-uninstalled.pc.in',
+#  output : 'opus-uninstalled.pc',
+#  configuration : pkgconf,
+#  install : false)
+
+doxygen = find_program('doxygen', required: get_option('docs'))
+if doxygen.found()
+  subdir('doc')
+endif
+
+summary(
+  {
+    'C99 var arrays': opus_conf.has('VAR_ARRAYS'),
+    'C99 lrintf': opus_conf.has('HAVE_LRINTF'),
+    'Use alloca': msg_use_alloca,
+  },
+  section: 'Compiler support',
+  bool_yn: true,
+  list_sep: ', ',
+)
+
+# Parse optimization status
+foreach status : [['inline_optimization', opt_asm],
+                  ['asm_optimization', opt_asm],
+                  ['intrinsics_support', opt_intrinsics]]
+  res = status[0]
+  opt = status[1]
+  resval = get_variable(res)
+  if opt.disabled()
+    set_variable(res, 'disabled')
+  elif resval.length() == 0
+    if host_cpu_family not in ['arm', 'aarch64', 'x86', 'x86_64']
+      set_variable(res, 'No optimizations for your platform, please send patches')
+    else
+      set_variable(res, 'none')
+    endif
+  endif
+endforeach
+
+summary(
+  {
+    'Floating point support': not opt_fixed_point,
+    'Fast float approximations': opt_float_approx,
+    'Fixed point debugging': opt_fixed_point_debug,
+    'Inline assembly optimizations': inline_optimization,
+    'External assembly optimizations': asm_optimization,
+    'Intrinsics optimizations': intrinsics_support,
+    'Run-time CPU detection': rtcd_support,
+  },
+  section: 'Optimizations',
+  bool_yn: true,
+  list_sep: ', ',
+)
+summary(
+  {
+    'Custom modes': opt_custom_modes,
+    'Assertions': opt_assertions,
+    'Hardening': opt_hardening,
+    'Fuzzing': opt_fuzzing,
+    'Check ASM': opt_check_asm,
+    'API documentation': doxygen.found(),
+    'Extra programs': not extra_programs.disabled(),
+    'Tests': not opt_tests.disabled(),
+  },
+  section: 'General configuration',
+  bool_yn: true,
+  list_sep: ', ',
+)
diff --git a/meson/get-version.py b/meson/get-version.py
new file mode 100755
index 00000000..0e8b8623
--- /dev/null
+++ b/meson/get-version.py
@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+#
+# Opus get-version.py
+#
+# Extracts versions for build:
+#  - Opus package version based on 'git describe' or $srcroot/package_version
+#  - libtool version based on configure.ac
+#  - macos lib version based on configure.ac
+#
+# Usage:
+# get-version.py [--package-version | --libtool-version | --darwin-version]
+import argparse
+import subprocess
+import os
+import sys
+import shutil
+
+if __name__ == '__main__':
+    arg_parser = argparse.ArgumentParser(description='Extract Opus package version or libtool version')
+    group = arg_parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('--libtool-version', action='store_true')
+    group.add_argument('--package-version', action='store_true')
+    group.add_argument('--darwin-version', action='store_true')
+    args = arg_parser.parse_args()
+
+    srcroot = os.path.normpath(os.path.join(os.path.dirname(__file__), '..'))
+
+    # package version
+    if args.package_version:
+        package_version = None
+
+        # check if git checkout
+        git_dir = os.path.join(srcroot, '.git')
+        is_git = os.path.isdir(git_dir)
+        have_git = shutil.which('git') is not None
+
+        if is_git and have_git:
+            git_cmd = subprocess.run(['git', '--git-dir=' + git_dir, 'describe', 'HEAD'], stdout=subprocess.PIPE)
+            if git_cmd.returncode:
+                print('ERROR: Could not extract package version via `git describe` in', srcroot, file=sys.stderr)
+                sys.exit(-1)
+            package_version = git_cmd.stdout.decode('ascii').strip().lstrip('v')
+        else:
+            with open(os.path.join(srcroot, 'package_version'), 'r') as f:
+                for line in f:
+                    if line.startswith('PACKAGE_VERSION="'):
+                        package_version = line[17:].strip().lstrip('v').rstrip('"')
+                    if package_version:
+                        break
+
+        if not package_version:
+            print('ERROR: Could not extract package version from package_version file in', srcroot, file=sys.stderr)
+            sys.exit(-1)
+
+        print(package_version)
+        sys.exit(0)
+
+    # libtool version + darwin version
+    elif args.libtool_version or args.darwin_version:
+        opus_lt_cur = None
+        opus_lt_rev = None
+        opus_lt_age = None
+
+        with open(os.path.join(srcroot, 'configure.ac'), 'r') as f:
+            for line in f:
+                if line.strip().startswith('OPUS_LT_CURRENT='):
+                    opus_lt_cur = line[16:].strip()
+                elif line.strip().startswith('OPUS_LT_REVISION='):
+                    opus_lt_rev = line[17:].strip()
+                elif line.strip().startswith('OPUS_LT_AGE='):
+                    opus_lt_age = line[12:].strip()
+
+        if opus_lt_cur and opus_lt_rev and opus_lt_age:
+            opus_lt_cur = int(opus_lt_cur)
+            opus_lt_rev = int(opus_lt_rev)
+            opus_lt_age = int(opus_lt_age)
+            if args.libtool_version:
+              print('{}.{}.{}'.format(opus_lt_cur - opus_lt_age, opus_lt_age, opus_lt_rev))
+            elif args.darwin_version:
+              print('{}.{}.{}'.format(opus_lt_cur + 1, 0, 0))
+            sys.exit(0)
+        else:
+            print('ERROR: Could not extract libtool version from configure.ac file in', srcroot, file=sys.stderr)
+            sys.exit(-1)
+    else:
+        sys.exit(-1)
diff --git a/meson/read-sources-list.py b/meson/read-sources-list.py
new file mode 100755
index 00000000..fcbec501
--- /dev/null
+++ b/meson/read-sources-list.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+#
+# opus/read-sources-list.py
+#
+# Parses .mk files and extracts list of source files.
+# Prints one line per source file list, with filenames space-separated.
+
+import sys
+
+if len(sys.argv) < 2:
+  sys.exit('Usage: {} sources_foo.mk [sources_bar.mk...]'.format(sys.argv[0]))
+
+for input_fn in sys.argv[1:]:
+  with open(input_fn, 'r', encoding='utf8') as f:
+    text = f.read()
+    text = text.replace('\\\n', '')
+
+    # Remove empty lines
+    lines = [line for line in text.split('\n') if line.strip()]
+
+    # Print SOURCES_XYZ = file1.c file2.c
+    for line in lines:
+      values = line.strip().split('=', maxsplit=2)
+      if len(values) != 2:
+        raise RuntimeError('Unable to parse line "{}" from file "{}"'.format(line, input_fn))
+      var, files = values
+      sources_list = [f for f in files.split(' ') if f]
+      print(var.strip(), '=', ' '.join(sources_list))
diff --git a/meson_options.txt b/meson_options.txt
new file mode 100644
index 00000000..360ff263
--- /dev/null
+++ b/meson_options.txt
@@ -0,0 +1,22 @@
+# Optimizations
+option('fixed-point', type : 'boolean', value : false, description : 'Compile without floating point (for machines without a fast enough FPU')
+option('fixed-point-debug', type : 'boolean', value : false, description : 'Debug fixed-point implementation')
+option('float-api', type : 'boolean', value : true, description : 'Compile with or without the floating point API (for machines with no float library')
+option('float-approx', type : 'boolean', value : false, description : 'Enable fast approximations for floating point (not supported on all platforms)')
+option('rtcd', type : 'feature', value : 'auto', description : 'Run-time CPU capabilities detection')
+option('asm', type : 'feature', value : 'auto', description : 'Assembly optimizations for ARM (fixed-point)')
+option('intrinsics', type : 'feature', value : 'auto', description : 'Intrinsics optimizations for ARM NEON or x86')
+
+option('custom-modes', type : 'boolean', value : false, description : 'Enable non-Opus modes, e.g. 44.1 kHz & 2^n frames')
+option('extra-programs', type : 'feature', value : 'auto', description : 'Extra programs (demo and tests)')
+option('assertions', type : 'boolean', value : false, description : 'Additional software error checking')
+option('hardening', type : 'boolean', value : true, description : 'Run-time checks that are cheap and safe for use in production')
+option('fuzzing', type : 'boolean', value : false, description : 'Causes the encoder to make random decisions')
+option('check-asm', type : 'boolean', value : false, description : 'Run bit-exactness checks between optimized and c implementations')
+
+# common feature options
+option('tests', type : 'feature', value : 'auto', description : 'Build tests')
+option('docs', type: 'feature', value: 'auto', description: 'Build API documentation')
+
+# other options
+option('docdir', type: 'string', value: 'doc/opus', description: 'Directory to install documentation into (default: DATADIR/doc/opus')
diff --git a/opus_sources.mk b/opus_sources.mk
index b0763f99..44153b57 100644
--- a/opus_sources.mk
+++ b/opus_sources.mk
@@ -1,4 +1,5 @@
-OPUS_SOURCES = src/opus.c \
+OPUS_SOURCES = \
+src/opus.c \
 src/opus_decoder.c \
 src/opus_encoder.c \
 src/opus_multistream.c \
diff --git a/releases.sha2 b/releases.sha2
index 76170ac9..334976b1 100644
--- a/releases.sha2
+++ b/releases.sha2
@@ -38,8 +38,12 @@ c0e90507259cf21ce7b2c82fb9ac55367d8543dae91cc3d4d2c59afd37f44023  opus-1.2-alpha
 cfafd339ccd9c5ef8d6ab15d7e1a412c054bf4cb4ecbbbcc78c12ef2def70732  opus-1.2.1.tar.gz
 7f56e058c9549d03ae35511ad9e16ef6d1eb257836830d54abff0f495f17e187  opus-1.3-beta.tar.gz
 96fa28598e8ccd558b297277ad59a045c551ba0e06d65a9675938e084f837669  opus-1.3-rc.tar.gz
+f6bab321fb81db984766f1e4d340a9e71a5ca2c5d4d53f4ee072e84afda271ca  opus-1.3-rc2.tar.gz
+4f3d69aefdf2dbaf9825408e452a8a414ffc60494c70633560700398820dc550  opus-1.3.tar.gz
+65b58e1e25b2a114157014736a3d9dfeaad8d41be1c8179866f144a2fb44ff9d  opus-1.3.1.tar.gz
 94ac78ca4f74c4e43bc9fe4ec1ad0aa36f38ab90f45b0727c40dd1e96096e767  opus_testvectors-draft11.tar.gz
 94ac78ca4f74c4e43bc9fe4ec1ad0aa36f38ab90f45b0727c40dd1e96096e767  opus_testvectors.tar.gz
+6b26a22f9ba87b2b836906a9bb7afec5f8e54d49553b1200382520ee6fedfa55  opus_testvectors-rfc8251.tar.gz
 5d2b99757bcb628bab2611f3ed27af6f35276ce3abc96c0ed4399d6c6463dda5  opus-tools-0.1.2.tar.gz
 008317297d6ce84f84992abf8cc948a048a4fa135e1d1caf429fafde8965a792  opus-tools-0.1.3.tar.gz
 de80485c5afa1fd83c0e16a0dd4860470c872997a7dd0a58e99b2ee8a93e5168  opus-tools-0.1.4.tar.gz
@@ -49,7 +53,11 @@ e0f08d301555dffc417604269b5a85d2bd197f259c7d6c957f370ffd33d6d9cd  opus-tools-0.1
 e4e188579ea1c4e4d5066460d4a7214a7eafe3539e9a4466fdc98af41ba4a2f6  opus-tools-0.1.8.tar.gz
 b1873dd78c7fbc98cf65d6e10cfddb5c2c03b3af93f922139a2104baedb4643a  opus-tools-0.1.9.tar.gz
 a2357532d19471b70666e0e0ec17d514246d8b3cb2eb168f68bb0f6fd372b28c  opus-tools-0.1.10.tar.gz
+b4e56cb00d3e509acfba9a9b627ffd8273b876b4e2408642259f6da28fa0ff86  opus-tools-0.2.tar.gz
 bd6d14e8897a2f80065ef34a516c70e74f8e00060abdbc238e79e5f99bca3e96  libopusenc-0.1.tar.gz
+02e6e0b14cbbe0569d948a46420f9c9a81d93bba32dc576a4007cbf96da68ef3  libopusenc-0.1.1.tar.gz
+c79e95eeee43a0b965e9b2c59a243763a8f8b0a7e71441df2aa9084f6171c73a  libopusenc-0.2.tar.gz
+8298db61a8d3d63e41c1a80705baa8ce9ff3f50452ea7ec1c19a564fe106cbb9  libopusenc-0.2.1.tar.gz
 8071b968475c1a17f54b6840d6de9d9ee20f930e827b0401abe3c4cf4f3bf30a  opusfile-0.1.tar.gz
 b4a678b3b6c4adfb6aff1f67ef658becfe146ea7c7ff228e99543762171557f9  opusfile-0.2.tar.gz
 4248927f2c4e316ea5b84fb02bd100bfec8fa4624a6910d77f0af7f0c6cb8baa  opusfile-0.3.tar.gz
@@ -63,3 +71,9 @@ b940d62beb15b5974764574b9f265481fe5b6ee16902fb705727546caf956261  opusfile-0.5.z
 346967d7989bb83b05949483b76bd0f69a12c59bd8b4457e864902b52bb0ac34  opusfile-0.7.zip
 2c231ed3cfaa1b3173f52d740e5bbd77d51b9dfecb87014b404917fba4b855a4  opusfile-0.8.tar.gz
 89dff4342c3b789574cbea5c57f11b96d4ebe4d28ab90248c1783ea569b1e9e3  opusfile-0.8.zip
+f75fb500e40b122775ac1a71ad80c4477698842a8fe9da4a1b4a1a9f16e4e979  opusfile-0.9.tar.gz
+e9591da4d4c9e857436c2d46a28a9e470fa5355ea5a76d4d582f137d18755d36  opusfile-0.9.zip
+48e03526ba87ef9cf5f1c47b5ebe3aa195bd89b912a57060c36184a6cd19412f  opusfile-0.10.tar.gz
+9d9e95d01817ecf48bf6daaea8f071f9b45bd1751ca1fc8ce50e5075eb2bc3c8  opusfile-0.10.zip
+74ce9b6cf4da103133e7b5c95df810ceb7195471e1162ed57af415fabf5603bf  opusfile-0.11.tar.gz
+23c5168026c4f1fc34843650135b409d0fc8cf452508163b4ece8077256ac6ff  opusfile-0.11.zip
diff --git a/silk/CNG.c b/silk/CNG.c
index ef8e38df..2a910099 100644
--- a/silk/CNG.c
+++ b/silk/CNG.c
@@ -118,6 +118,10 @@ void silk_CNG(
         /* Smooth gains */
         for( i = 0; i < psDec->nb_subfr; i++ ) {
             psCNG->CNG_smth_Gain_Q16 += silk_SMULWB( psDecCtrl->Gains_Q16[ i ] - psCNG->CNG_smth_Gain_Q16, CNG_GAIN_SMTH_Q16 );
+            /* If the smoothed gain is 3 dB greater than this subframe's gain, use this subframe's gain to adapt faster. */
+            if( silk_SMULWW( psCNG->CNG_smth_Gain_Q16, CNG_GAIN_SMTH_THRESHOLD_Q16 ) > psDecCtrl->Gains_Q16[ i ] ) {
+                psCNG->CNG_smth_Gain_Q16 = psDecCtrl->Gains_Q16[ i ];
+            }
         }
     }
 
diff --git a/silk/MacroCount.h b/silk/MacroCount.h
index 78100ffe..dab2f57a 100644
--- a/silk/MacroCount.h
+++ b/silk/MacroCount.h
@@ -27,9 +27,9 @@ POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef SIGPROCFIX_API_MACROCOUNT_H
 #define SIGPROCFIX_API_MACROCOUNT_H
-#include <stdio.h>
 
 #ifdef    silk_MACRO_COUNT
+#include <stdio.h>
 #define varDefine opus_int64 ops_count = 0;
 
 extern opus_int64 ops_count;
diff --git a/silk/NSQ_del_dec.c b/silk/NSQ_del_dec.c
index 3fd9fa0d..00e749c3 100644
--- a/silk/NSQ_del_dec.c
+++ b/silk/NSQ_del_dec.c
@@ -394,8 +394,8 @@ static OPUS_INLINE void silk_noise_shape_quantizer_del_dec(
         /* Long-term shaping */
         if( lag > 0 ) {
             /* Symmetric, packed FIR coefficients */
-            n_LTP_Q14 = silk_SMULWB( silk_ADD32( shp_lag_ptr[ 0 ], shp_lag_ptr[ -2 ] ), HarmShapeFIRPacked_Q14 );
-            n_LTP_Q14 = silk_SMLAWT( n_LTP_Q14, shp_lag_ptr[ -1 ],                      HarmShapeFIRPacked_Q14 );
+            n_LTP_Q14 = silk_SMULWB( silk_ADD_SAT32( shp_lag_ptr[ 0 ], shp_lag_ptr[ -2 ] ), HarmShapeFIRPacked_Q14 );
+            n_LTP_Q14 = silk_SMLAWT( n_LTP_Q14, shp_lag_ptr[ -1 ], HarmShapeFIRPacked_Q14 );
             n_LTP_Q14 = silk_SUB_LSHIFT32( LTP_pred_Q14, n_LTP_Q14, 2 );            /* Q12 -> Q14 */
             shp_lag_ptr++;
         } else {
@@ -451,9 +451,9 @@ static OPUS_INLINE void silk_noise_shape_quantizer_del_dec(
 
             /* Input minus prediction plus noise feedback                       */
             /* r = x[ i ] - LTP_pred - LPC_pred + n_AR + n_Tilt + n_LF + n_LTP  */
-            tmp1 = silk_ADD32( n_AR_Q14, n_LF_Q14 );                                    /* Q14 */
+            tmp1 = silk_ADD_SAT32( n_AR_Q14, n_LF_Q14 );                                /* Q14 */
             tmp2 = silk_ADD32( n_LTP_Q14, LPC_pred_Q14 );                               /* Q13 */
-            tmp1 = silk_SUB32( tmp2, tmp1 );                                            /* Q13 */
+            tmp1 = silk_SUB_SAT32( tmp2, tmp1 );                                        /* Q13 */
             tmp1 = silk_RSHIFT_ROUND( tmp1, 4 );                                        /* Q10 */
 
             r_Q10 = silk_SUB32( x_Q10[ i ], tmp1 );                                     /* residual error Q10 */
@@ -535,7 +535,7 @@ static OPUS_INLINE void silk_noise_shape_quantizer_del_dec(
             /* Update states */
             psSS[ 0 ].Diff_Q14     = silk_SUB_LSHIFT32( xq_Q14, x_Q10[ i ], 4 );
             sLF_AR_shp_Q14         = silk_SUB32( psSS[ 0 ].Diff_Q14, n_AR_Q14 );
-            psSS[ 0 ].sLTP_shp_Q14 = silk_SUB32( sLF_AR_shp_Q14, n_LF_Q14 );
+            psSS[ 0 ].sLTP_shp_Q14 = silk_SUB_SAT32( sLF_AR_shp_Q14, n_LF_Q14 );
             psSS[ 0 ].LF_AR_Q14    = sLF_AR_shp_Q14;
             psSS[ 0 ].LPC_exc_Q14  = LPC_exc_Q14;
             psSS[ 0 ].xq_Q14       = xq_Q14;
@@ -555,7 +555,7 @@ static OPUS_INLINE void silk_noise_shape_quantizer_del_dec(
             /* Update states */
             psSS[ 1 ].Diff_Q14     = silk_SUB_LSHIFT32( xq_Q14, x_Q10[ i ], 4 );
             sLF_AR_shp_Q14         = silk_SUB32( psSS[ 1 ].Diff_Q14, n_AR_Q14 );
-            psSS[ 1 ].sLTP_shp_Q14 = silk_SUB32( sLF_AR_shp_Q14, n_LF_Q14 );
+            psSS[ 1 ].sLTP_shp_Q14 = silk_SUB_SAT32( sLF_AR_shp_Q14, n_LF_Q14 );
             psSS[ 1 ].LF_AR_Q14    = sLF_AR_shp_Q14;
             psSS[ 1 ].LPC_exc_Q14  = LPC_exc_Q14;
             psSS[ 1 ].xq_Q14       = xq_Q14;
diff --git a/silk/PLC.c b/silk/PLC.c
index f8939165..4667440d 100644
--- a/silk/PLC.c
+++ b/silk/PLC.c
@@ -328,10 +328,8 @@ static OPUS_INLINE void silk_PLC_conceal(
         for( j = 0; j < LTP_ORDER; j++ ) {
             B_Q14[ j ] = silk_RSHIFT( silk_SMULBB( harm_Gain_Q15, B_Q14[ j ] ), 15 );
         }
-        if ( psDec->indices.signalType != TYPE_NO_VOICE_ACTIVITY ) {
-            /* Gradually reduce excitation gain */
-            rand_scale_Q14 = silk_RSHIFT( silk_SMULBB( rand_scale_Q14, rand_Gain_Q15 ), 15 );
-        }
+        /* Gradually reduce excitation gain */
+        rand_scale_Q14 = silk_RSHIFT( silk_SMULBB( rand_scale_Q14, rand_Gain_Q15 ), 15 );
 
         /* Slowly increase pitch lag */
         psPLC->pitchL_Q8 = silk_SMLAWB( psPLC->pitchL_Q8, psPLC->pitchL_Q8, PITCH_DRIFT_FAC_Q16 );
diff --git a/silk/debug.c b/silk/debug.c
index 9253faf7..eb0c36ef 100644
--- a/silk/debug.c
+++ b/silk/debug.c
@@ -30,18 +30,20 @@ POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #include "debug.h"
+
+#if SILK_DEBUG || SILK_TIC_TOC
 #include "SigProc_FIX.h"
+#endif
 
 #if SILK_TIC_TOC
 
-#ifdef _WIN32
-
 #if (defined(_WIN32) || defined(_WINCE))
 #include <windows.h>    /* timer */
 #else   /* Linux or Mac*/
 #include <sys/time.h>
 #endif
 
+#ifdef _WIN32
 unsigned long silk_GetHighResolutionTime(void) /* O  time in usec*/
 {
     /* Returns a time counter in microsec   */
@@ -65,7 +67,7 @@ unsigned long GetHighResolutionTime(void) /* O  time in usec*/
 int           silk_Timer_nTimers = 0;
 int           silk_Timer_depth_ctr = 0;
 char          silk_Timer_tags[silk_NUM_TIMERS_MAX][silk_NUM_TIMERS_MAX_TAG_LEN];
-#ifdef WIN32
+#ifdef _WIN32
 LARGE_INTEGER silk_Timer_start[silk_NUM_TIMERS_MAX];
 #else
 unsigned long silk_Timer_start[silk_NUM_TIMERS_MAX];
@@ -76,7 +78,7 @@ opus_int64     silk_Timer_sum[silk_NUM_TIMERS_MAX];
 opus_int64     silk_Timer_max[silk_NUM_TIMERS_MAX];
 opus_int64     silk_Timer_depth[silk_NUM_TIMERS_MAX];
 
-#ifdef WIN32
+#ifdef _WIN32
 void silk_TimerSave(char *file_name)
 {
     if( silk_Timer_nTimers > 0 )
diff --git a/silk/debug.h b/silk/debug.h
index 6f68c1ca..36163e47 100644
--- a/silk/debug.h
+++ b/silk/debug.h
@@ -28,28 +28,29 @@ POSSIBILITY OF SUCH DAMAGE.
 #ifndef SILK_DEBUG_H
 #define SILK_DEBUG_H
 
-#include "typedef.h"
-#include <stdio.h>      /* file writing */
-#include <string.h>     /* strcpy, strcmp */
-
-#ifdef  __cplusplus
-extern "C"
-{
-#endif
-
-unsigned long GetHighResolutionTime(void); /* O  time in usec*/
-
 /* Set to 1 to enable DEBUG_STORE_DATA() macros for dumping
  * intermediate signals from the codec.
  */
 #define SILK_DEBUG 0
 
 /* Flag for using timers */
-#define SILK_TIC_TOC    0
+#define SILK_TIC_TOC 0
 
+#if SILK_DEBUG || SILK_TIC_TOC
+#include "typedef.h"
+#include <string.h>     /* strcpy, strcmp */
+#include <stdio.h>      /* file writing */
+#endif
+
+#ifdef  __cplusplus
+extern "C"
+{
+#endif
 
 #if SILK_TIC_TOC
 
+unsigned long GetHighResolutionTime(void); /* O  time in usec*/
+
 #if (defined(_WIN32) || defined(_WINCE))
 #include <windows.h>    /* timer */
 #else   /* Linux or Mac*/
diff --git a/silk/decode_frame.c b/silk/decode_frame.c
index e73825b2..4f36f854 100644
--- a/silk/decode_frame.c
+++ b/silk/decode_frame.c
@@ -97,7 +97,6 @@ opus_int silk_decode_frame(
         psDec->first_frame_after_reset = 0;
     } else {
         /* Handle packet loss by extrapolation */
-        psDec->indices.signalType = psDec->prevSignalType;
         silk_PLC( psDec, psDecCtrl, pOut, 1, arch );
     }
 
diff --git a/silk/define.h b/silk/define.h
index 247cb0bf..491c86f3 100644
--- a/silk/define.h
+++ b/silk/define.h
@@ -225,6 +225,7 @@ extern "C"
 /* Defines for CN generation */
 #define CNG_BUF_MASK_MAX                        255     /* 2^floor(log2(MAX_FRAME_LENGTH))-1    */
 #define CNG_GAIN_SMTH_Q16                       4634    /* 0.25^(1/4)                           */
+#define CNG_GAIN_SMTH_THRESHOLD_Q16             46396   /* -3 dB                                */
 #define CNG_NLSF_SMTH_Q16                       16348   /* 0.25                                 */
 
 #ifdef __cplusplus
diff --git a/silk/fixed/mips/warped_autocorrelation_FIX_mipsr1.h b/silk/fixed/mips/warped_autocorrelation_FIX_mipsr1.h
index fcbd96c8..66eb2ed2 100644
--- a/silk/fixed/mips/warped_autocorrelation_FIX_mipsr1.h
+++ b/silk/fixed/mips/warped_autocorrelation_FIX_mipsr1.h
@@ -41,15 +41,14 @@ POSSIBILITY OF SUCH DAMAGE.
 #define QS  14
 
 /* Autocorrelations for a warped frequency axis */
-#define OVERRIDE_silk_warped_autocorrelation_FIX
-void silk_warped_autocorrelation_FIX(
+#define OVERRIDE_silk_warped_autocorrelation_FIX_c
+void silk_warped_autocorrelation_FIX_c(
           opus_int32                *corr,                                  /* O    Result [order + 1]                                                          */
           opus_int                  *scale,                                 /* O    Scaling of the correlation vector                                           */
     const opus_int16                *input,                                 /* I    Input data to correlate                                                     */
     const opus_int                  warping_Q16,                            /* I    Warping coefficient                                                         */
     const opus_int                  length,                                 /* I    Length of input                                                             */
-    const opus_int                  order,                                  /* I    Correlation order (even)                                                    */
-    int                             arch                                    /* I    Run-time architecture                                                       */
+    const opus_int                  order                                   /* I    Correlation order (even)                                                    */
 )
 {
     opus_int   n, i, lsh;
diff --git a/silk/fixed/warped_autocorrelation_FIX.c b/silk/fixed/warped_autocorrelation_FIX.c
index 52002a11..5c79553b 100644
--- a/silk/fixed/warped_autocorrelation_FIX.c
+++ b/silk/fixed/warped_autocorrelation_FIX.c
@@ -37,6 +37,7 @@ POSSIBILITY OF SUCH DAMAGE.
 
 
 /* Autocorrelations for a warped frequency axis */
+#ifndef OVERRIDE_silk_warped_autocorrelation_FIX_c
 void silk_warped_autocorrelation_FIX_c(
           opus_int32                *corr,                                  /* O    Result [order + 1]                                                          */
           opus_int                  *scale,                                 /* O    Scaling of the correlation vector                                           */
@@ -88,3 +89,4 @@ void silk_warped_autocorrelation_FIX_c(
     }
     silk_assert( corr_QC[ 0 ] >= 0 ); /* If breaking, decrease QC*/
 }
+#endif /* OVERRIDE_silk_warped_autocorrelation_FIX_c */
diff --git a/silk/float/warped_autocorrelation_FLP.c b/silk/float/warped_autocorrelation_FLP.c
index 96662767..09186e73 100644
--- a/silk/float/warped_autocorrelation_FLP.c
+++ b/silk/float/warped_autocorrelation_FLP.c
@@ -42,8 +42,8 @@ void silk_warped_autocorrelation_FLP(
 {
     opus_int    n, i;
     double      tmp1, tmp2;
-    double      state[ MAX_SHAPE_LPC_ORDER + 1 ] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
-    double      C[     MAX_SHAPE_LPC_ORDER + 1 ] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+    double      state[ MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };
+    double      C[     MAX_SHAPE_LPC_ORDER + 1 ] = { 0 };
 
     /* Order must be even */
     celt_assert( ( order & 1 ) == 0 );
diff --git a/silk/meson.build b/silk/meson.build
new file mode 100644
index 00000000..70692372
--- /dev/null
+++ b/silk/meson.build
@@ -0,0 +1,53 @@
+silk_sources = sources['SILK_SOURCES']
+
+silk_sources_sse4_1 = sources['SILK_SOURCES_SSE4_1']
+
+silk_sources_neon_intr = sources['SILK_SOURCES_ARM_NEON_INTR']
+
+silk_sources_fixed_neon_intr = sources['SILK_SOURCES_FIXED_ARM_NEON_INTR']
+
+silk_sources_fixed = sources['SILK_SOURCES_FIXED']
+
+silk_sources_fixed_sse4_1 = sources['SILK_SOURCES_FIXED_SSE4_1']
+
+silk_sources_float = sources['SILK_SOURCES_FLOAT']
+
+if opt_fixed_point
+  silk_sources += silk_sources_fixed
+else
+  silk_sources += silk_sources_float
+endif
+
+silk_includes = [opus_includes, include_directories('float', 'fixed')]
+silk_static_libs = []
+
+foreach intr_name : ['sse4_1', 'neon_intr']
+  have_intr = get_variable('have_' + intr_name)
+  if not have_intr
+    continue
+  endif
+
+  intr_sources = get_variable('silk_sources_' + intr_name)
+  if opt_fixed_point
+    intr_sources += get_variable('silk_sources_fixed_' + intr_name)
+  endif
+
+  intr_args = get_variable('opus_@0@_args'.format(intr_name), [])
+  silk_static_libs += static_library('silk_' + intr_name, intr_sources,
+      c_args: intr_args,
+      include_directories: silk_includes,
+      install: false)
+endforeach
+
+silk_c_args = []
+if host_machine.system() == 'windows'
+  silk_c_args += ['-DDLL_EXPORT']
+endif
+
+silk_lib = static_library('opus-silk',
+  silk_sources,
+  c_args: silk_c_args,
+  include_directories: silk_includes,
+  link_whole: silk_static_libs,
+  dependencies: libm,
+  install: false)
diff --git a/silk/tests/meson.build b/silk/tests/meson.build
new file mode 100644
index 00000000..b7c70f75
--- /dev/null
+++ b/silk/tests/meson.build
@@ -0,0 +1,8 @@
+exe = executable('test_unit_LPC_inv_pred_gain',
+  'test_unit_LPC_inv_pred_gain.c', '../LPC_inv_pred_gain.c',
+  include_directories: opus_includes,
+  link_with: [celt_lib, celt_static_libs, silk_lib, silk_static_libs],
+  dependencies: libm,
+  install: false)
+
+test(test_name, exe)
diff --git a/silk/typedef.h b/silk/typedef.h
index 97b7e709..793d2c0c 100644
--- a/silk/typedef.h
+++ b/silk/typedef.h
@@ -67,6 +67,9 @@ __attribute__((noreturn))
 static OPUS_INLINE void _silk_fatal(const char *str, const char *file, int line)
 {
    fprintf (stderr, "Fatal (internal) error in %s, line %d: %s\n", file, line, str);
+#if defined(_MSC_VER)
+   _set_abort_behavior( 0, _WRITE_ABORT_MSG);
+#endif
    abort();
 }
 #  define silk_assert(COND) {if (!(COND)) {silk_fatal("assertion failed: " #COND);}}
diff --git a/silk_sources.mk b/silk_sources.mk
index 67c8a4fd..d2666e66 100644
--- a/silk_sources.mk
+++ b/silk_sources.mk
@@ -77,7 +77,8 @@ silk/stereo_find_predictor.c \
 silk/stereo_quant_pred.c \
 silk/LPC_fit.c
 
-SILK_SOURCES_SSE4_1 = silk/x86/NSQ_sse4_1.c \
+SILK_SOURCES_SSE4_1 =  \
+silk/x86/NSQ_sse4_1.c \
 silk/x86/NSQ_del_dec_sse4_1.c \
 silk/x86/x86_silk_map.c \
 silk/x86/VAD_sse4_1.c \
@@ -115,7 +116,8 @@ silk/fixed/vector_ops_FIX.c \
 silk/fixed/schur64_FIX.c \
 silk/fixed/schur_FIX.c
 
-SILK_SOURCES_FIXED_SSE4_1 = silk/fixed/x86/vector_ops_FIX_sse4_1.c \
+SILK_SOURCES_FIXED_SSE4_1 = \
+silk/fixed/x86/vector_ops_FIX_sse4_1.c \
 silk/fixed/x86/burg_modified_FIX_sse4_1.c
 
 SILK_SOURCES_FIXED_ARM_NEON_INTR = \
diff --git a/src/analysis.c b/src/analysis.c
index b192ae4e..058328f0 100644
--- a/src/analysis.c
+++ b/src/analysis.c
@@ -31,7 +31,9 @@
 
 #define ANALYSIS_C
 
+#ifdef MLP_TRAINING
 #include <stdio.h>
+#endif
 
 #include "mathops.h"
 #include "kiss_fft.h"
@@ -249,6 +251,15 @@ void tonality_get_info(TonalityAnalysisState *tonal, AnalysisInfo *info_out, int
    if (curr_lookahead<0)
       curr_lookahead += DETECT_SIZE;
 
+   tonal->read_subframe += len/(tonal->Fs/400);
+   while (tonal->read_subframe>=8)
+   {
+      tonal->read_subframe -= 8;
+      tonal->read_pos++;
+   }
+   if (tonal->read_pos>=DETECT_SIZE)
+      tonal->read_pos-=DETECT_SIZE;
+
    /* On long frames, look at the second analysis window rather than the first. */
    if (len > tonal->Fs/50 && pos != tonal->write_pos)
    {
@@ -262,6 +273,8 @@ void tonality_get_info(TonalityAnalysisState *tonal, AnalysisInfo *info_out, int
       pos = DETECT_SIZE-1;
    pos0 = pos;
    OPUS_COPY(info_out, &tonal->info[pos], 1);
+   if (!info_out->valid)
+      return;
    tonality_max = tonality_avg = info_out->tonality;
    tonality_count = 1;
    /* Look at the neighbouring frames and pick largest bandwidth found (to be safe). */
@@ -393,14 +406,6 @@ void tonality_get_info(TonalityAnalysisState *tonal, AnalysisInfo *info_out, int
    info_out->music_prob_max = prob_max;
 
    /* printf("%f %f %f %f %f\n", prob_min, prob_max, prob_avg/prob_count, vad_prob, info_out->music_prob); */
-   tonal->read_subframe += len/(tonal->Fs/400);
-   while (tonal->read_subframe>=8)
-   {
-      tonal->read_subframe -= 8;
-      tonal->read_pos++;
-   }
-   if (tonal->read_pos>=DETECT_SIZE)
-      tonal->read_pos-=DETECT_SIZE;
 }
 
 static const float std_feature_bias[9] = {
@@ -420,6 +425,24 @@ static const float std_feature_bias[9] = {
 #define SCALE_ENER(e) (e)
 #endif
 
+#ifdef FIXED_POINT
+static int is_digital_silence32(const opus_val32* pcm, int frame_size, int channels, int lsb_depth)
+{
+   int silence = 0;
+   opus_val32 sample_max = 0;
+#ifdef MLP_TRAINING
+   return 0;
+#endif
+   sample_max = celt_maxabs32(pcm, frame_size*channels);
+
+   silence = (sample_max == 0);
+   (void)lsb_depth;
+   return silence;
+}
+#else
+#define is_digital_silence32(pcm, frame_size, channels, lsb_depth) is_digital_silence(pcm, frame_size, channels, lsb_depth)
+#endif
+
 static void tonality_analysis(TonalityAnalysisState *tonal, const CELTMode *celt_mode, const void *x, int len, int offset, int c1, int c2, int C, int lsb_depth, downmix_func downmix)
 {
     int i, b;
@@ -464,8 +487,14 @@ static void tonality_analysis(TonalityAnalysisState *tonal, const CELTMode *celt
     float layer_out[MAX_NEURONS];
     float below_max_pitch;
     float above_max_pitch;
+    int is_silence;
     SAVE_STACK;
 
+    if (!tonal->initialized)
+    {
+       tonal->mem_fill = 240;
+       tonal->initialized = 1;
+    }
     alpha = 1.f/IMIN(10, 1+tonal->count);
     alphaE = 1.f/IMIN(25, 1+tonal->count);
     /* Noise floor related decay for bandwidth detection: -2.2 dB/second */
@@ -483,8 +512,6 @@ static void tonality_analysis(TonalityAnalysisState *tonal, const CELTMode *celt
     }
 
     kfft = celt_mode->mdct.kfft[0];
-    if (tonal->count==0)
-       tonal->mem_fill = 240;
     tonal->hp_ener_accum += (float)downmix_and_resample(downmix, x,
           &tonal->inmem[tonal->mem_fill], tonal->downmix_state,
           IMIN(len, ANALYSIS_BUF_SIZE-tonal->mem_fill), offset, c1, c2, C, tonal->Fs);
@@ -500,6 +527,8 @@ static void tonality_analysis(TonalityAnalysisState *tonal, const CELTMode *celt
     if (tonal->write_pos>=DETECT_SIZE)
        tonal->write_pos-=DETECT_SIZE;
 
+    is_silence = is_digital_silence32(tonal->inmem, ANALYSIS_BUF_SIZE, 1, lsb_depth);
+
     ALLOC(in, 480, kiss_fft_cpx);
     ALLOC(out, 480, kiss_fft_cpx);
     ALLOC(tonality, 240, float);
@@ -518,6 +547,16 @@ static void tonality_analysis(TonalityAnalysisState *tonal, const CELTMode *celt
           &tonal->inmem[240], tonal->downmix_state, remaining,
           offset+ANALYSIS_BUF_SIZE-tonal->mem_fill, c1, c2, C, tonal->Fs);
     tonal->mem_fill = 240 + remaining;
+    if (is_silence)
+    {
+       /* On silence, copy the previous analysis. */
+       int prev_pos = tonal->write_pos-2;
+       if (prev_pos < 0)
+          prev_pos += DETECT_SIZE;
+       OPUS_COPY(info, &tonal->info[prev_pos], 1);
+       RESTORE_STACK;
+       return;
+    }
     opus_fft(kfft, in, out, tonal->arch);
 #ifndef FIXED_POINT
     /* If there's any NaN on the input, the entire output will be NaN, so we only need to check one value. */
@@ -654,7 +693,7 @@ static void tonality_analysis(TonalityAnalysisState *tonal, const CELTMode *celt
           tonal->lowE[b] = logE[b];
           tonal->highE[b] = MIN32(tonal->lowE[b]+15, tonal->highE[b]);
        }
-       relativeE += (logE[b]-tonal->lowE[b])/(1e-15f + (tonal->highE[b]-tonal->lowE[b]));
+       relativeE += (logE[b]-tonal->lowE[b])/(1e-5f + (tonal->highE[b]-tonal->lowE[b]));
 
        L1=L2=0;
        for (i=0;i<NB_FRAMES;i++)
@@ -938,7 +977,6 @@ void run_analysis(TonalityAnalysisState *analysis, const CELTMode *celt_mode, co
       analysis->analysis_offset -= frame_size;
    }
 
-   analysis_info->valid = 0;
    tonality_get_info(analysis, analysis_info, frame_size);
 }
 
diff --git a/src/analysis.h b/src/analysis.h
index 289c845e..0b66555f 100644
--- a/src/analysis.h
+++ b/src/analysis.h
@@ -74,6 +74,7 @@ typedef struct {
    int read_pos;
    int read_subframe;
    float hp_ener_accum;
+   int initialized;
    float rnn_state[MAX_NEURONS];
    opus_val32 downmix_state[3];
    AnalysisInfo info[DETECT_SIZE];
diff --git a/src/mapping_matrix.h b/src/mapping_matrix.h
index 9c20483e..98bc82df 100644
--- a/src/mapping_matrix.h
+++ b/src/mapping_matrix.h
@@ -53,7 +53,7 @@ opus_int32 mapping_matrix_get_size(int rows, int cols);
 opus_int16 *mapping_matrix_get_data(const MappingMatrix *matrix);
 
 void mapping_matrix_init(
-    MappingMatrix * const st,
+    MappingMatrix * const matrix,
     int rows,
     int cols,
     int gain,
diff --git a/src/meson.build b/src/meson.build
new file mode 100644
index 00000000..cc07ff06
--- /dev/null
+++ b/src/meson.build
@@ -0,0 +1,45 @@
+opus_sources = sources['OPUS_SOURCES']
+
+opus_sources_float = sources['OPUS_SOURCES_FLOAT']
+
+if not disable_float_api
+  opus_sources += opus_sources_float
+endif
+
+opus_lib_c_args = []
+if host_machine.system() == 'windows'
+  opus_lib_c_args += ['-DDLL_EXPORT']
+endif
+
+opus_lib = library('opus',
+  opus_sources,
+  version: libversion,
+  darwin_versions: macosversion,
+  c_args: opus_lib_c_args,
+  include_directories: opus_includes,
+  link_with: [celt_lib, silk_lib],
+  dependencies: libm,
+  install: true)
+
+opus_dep = declare_dependency(link_with: opus_lib,
+  include_directories: opus_public_includes)
+
+# Extra uninstalled Opus programs
+if not extra_programs.disabled()
+  foreach prog : ['opus_compare', 'opus_demo', 'repacketizer_demo']
+    executable(prog, '@0@.c'.format(prog),
+               include_directories: opus_includes,
+               link_with: opus_lib,
+               dependencies: libm,
+               install: false)
+  endforeach
+
+  if opt_custom_modes
+    executable('opus_custom_demo', '../celt/opus_custom_demo.c',
+               include_directories: opus_includes,
+               link_with: opus_lib,
+               dependencies: libm,
+               install: false)
+  endif
+
+endif
diff --git a/src/mlp.c b/src/mlp.c
index f43a704e..964c6a98 100644
--- a/src/mlp.c
+++ b/src/mlp.c
@@ -69,22 +69,29 @@ static OPUS_INLINE float sigmoid_approx(float x)
    return .5f + .5f*tansig_approx(.5f*x);
 }
 
-void compute_dense(const DenseLayer *layer, float *output, const float *input)
+static void gemm_accum(float *out, const opus_int8 *weights, int rows, int cols, int col_stride, const float *x)
 {
    int i, j;
+   for (i=0;i<rows;i++)
+   {
+      for (j=0;j<cols;j++)
+         out[i] += weights[j*col_stride + i]*x[j];
+   }
+}
+
+void compute_dense(const DenseLayer *layer, float *output, const float *input)
+{
+   int i;
    int N, M;
    int stride;
    M = layer->nb_inputs;
    N = layer->nb_neurons;
    stride = N;
    for (i=0;i<N;i++)
-   {
-      /* Compute update gate. */
-      float sum = layer->bias[i];
-      for (j=0;j<M;j++)
-         sum += layer->input_weights[j*stride + i]*input[j];
-      output[i] = WEIGHTS_SCALE*sum;
-   }
+      output[i] = layer->bias[i];
+   gemm_accum(output, layer->input_weights, N, M, stride, input);
+   for (i=0;i<N;i++)
+      output[i] *= WEIGHTS_SCALE;
    if (layer->sigmoid) {
       for (i=0;i<N;i++)
          output[i] = sigmoid_approx(output[i]);
@@ -96,45 +103,41 @@ void compute_dense(const DenseLayer *layer, float *output, const float *input)
 
 void compute_gru(const GRULayer *gru, float *state, const float *input)
 {
-   int i, j;
+   int i;
    int N, M;
    int stride;
+   float tmp[MAX_NEURONS];
    float z[MAX_NEURONS];
    float r[MAX_NEURONS];
    float h[MAX_NEURONS];
    M = gru->nb_inputs;
    N = gru->nb_neurons;
    stride = 3*N;
+   /* Compute update gate. */
    for (i=0;i<N;i++)
-   {
-      /* Compute update gate. */
-      float sum = gru->bias[i];
-      for (j=0;j<M;j++)
-         sum += gru->input_weights[j*stride + i]*input[j];
-      for (j=0;j<N;j++)
-         sum += gru->recurrent_weights[j*stride + i]*state[j];
-      z[i] = sigmoid_approx(WEIGHTS_SCALE*sum);
-   }
+      z[i] = gru->bias[i];
+   gemm_accum(z, gru->input_weights, N, M, stride, input);
+   gemm_accum(z, gru->recurrent_weights, N, N, stride, state);
    for (i=0;i<N;i++)
-   {
-      /* Compute reset gate. */
-      float sum = gru->bias[N + i];
-      for (j=0;j<M;j++)
-         sum += gru->input_weights[N + j*stride + i]*input[j];
-      for (j=0;j<N;j++)
-         sum += gru->recurrent_weights[N + j*stride + i]*state[j];
-      r[i] = sigmoid_approx(WEIGHTS_SCALE*sum);
-   }
+      z[i] = sigmoid_approx(WEIGHTS_SCALE*z[i]);
+
+   /* Compute reset gate. */
    for (i=0;i<N;i++)
-   {
-      /* Compute output. */
-      float sum = gru->bias[2*N + i];
-      for (j=0;j<M;j++)
-         sum += gru->input_weights[2*N + j*stride + i]*input[j];
-      for (j=0;j<N;j++)
-         sum += gru->recurrent_weights[2*N + j*stride + i]*state[j]*r[j];
-      h[i] = z[i]*state[i] + (1-z[i])*tansig_approx(WEIGHTS_SCALE*sum);
-   }
+      r[i] = gru->bias[N + i];
+   gemm_accum(r, &gru->input_weights[N], N, M, stride, input);
+   gemm_accum(r, &gru->recurrent_weights[N], N, N, stride, state);
+   for (i=0;i<N;i++)
+      r[i] = sigmoid_approx(WEIGHTS_SCALE*r[i]);
+
+   /* Compute output. */
+   for (i=0;i<N;i++)
+      h[i] = gru->bias[2*N + i];
+   for (i=0;i<N;i++)
+      tmp[i] = state[i] * r[i];
+   gemm_accum(h, &gru->input_weights[2*N], N, M, stride, input);
+   gemm_accum(h, &gru->recurrent_weights[2*N], N, N, stride, tmp);
+   for (i=0;i<N;i++)
+      h[i] = z[i]*state[i] + (1-z[i])*tansig_approx(WEIGHTS_SCALE*h[i]);
    for (i=0;i<N;i++)
       state[i] = h[i];
 }
diff --git a/src/opus_encoder.c b/src/opus_encoder.c
index 1c5a8b33..7b5f0abf 100644
--- a/src/opus_encoder.c
+++ b/src/opus_encoder.c
@@ -837,7 +837,7 @@ static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels,
 
 #ifndef DISABLE_FLOAT_API
 
-static int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth)
+int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth)
 {
    int silence = 0;
    opus_val32 sample_max = 0;
@@ -892,34 +892,15 @@ static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, in
 #endif
 
 /* Decides if DTX should be turned on (=1) or off (=0) */
-static int decide_dtx_mode(float activity_probability,    /* probability that current frame contains speech/music */
-                           int *nb_no_activity_frames,    /* number of consecutive frames with no activity */
-                           opus_val32 peak_signal_energy, /* peak energy of desired signal detected so far */
-                           const opus_val16 *pcm,         /* input pcm signal */
-                           int frame_size,                /* frame size */
-                           int channels,
-                           int is_silence,                 /* only digital silence detected in this frame */
-                           int arch
-                          )
-{
-   opus_val32 noise_energy;
-
-   if (!is_silence)
-   {
-      if (activity_probability < DTX_ACTIVITY_THRESHOLD)  /* is noise */
-      {
-         noise_energy = compute_frame_energy(pcm, frame_size, channels, arch);
+static int decide_dtx_mode(opus_int activity,            /* indicates if this frame contains speech/music */
+                           int *nb_no_activity_frames    /* number of consecutive frames with no activity */
+                           )
 
-         /* but is sufficiently quiet */
-         is_silence = peak_signal_energy >= (PSEUDO_SNR_THRESHOLD * noise_energy);
-      }
-   }
-
-   if (is_silence)
+{
+   if (!activity)
    {
       /* The number of consecutive DTX frames should be within the allowed bounds */
       (*nb_no_activity_frames)++;
-
       if (*nb_no_activity_frames > NB_SPEECH_FRAMES_BEFORE_DTX)
       {
          if (*nb_no_activity_frames <= (NB_SPEECH_FRAMES_BEFORE_DTX + MAX_CONSECUTIVE_DTX))
@@ -1102,6 +1083,8 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
     int analysis_read_subframe_bak=-1;
     int is_silence = 0;
 #endif
+    opus_int activity = VAD_NO_DECISION;
+
     VARDECL(opus_val16, tmp_prefill);
 
     ALLOC_STACK;
@@ -1140,21 +1123,19 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
     if (st->silk_mode.complexity >= 7 && st->Fs>=16000)
 #endif
     {
-       if (is_digital_silence(pcm, frame_size, st->channels, lsb_depth))
-       {
-          is_silence = 1;
-       } else {
-          analysis_read_pos_bak = st->analysis.read_pos;
-          analysis_read_subframe_bak = st->analysis.read_subframe;
-          run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
-                c1, c2, analysis_channels, st->Fs,
-                lsb_depth, downmix, &analysis_info);
-       }
+       is_silence = is_digital_silence(pcm, frame_size, st->channels, lsb_depth);
+       analysis_read_pos_bak = st->analysis.read_pos;
+       analysis_read_subframe_bak = st->analysis.read_subframe;
+       run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
+             c1, c2, analysis_channels, st->Fs,
+             lsb_depth, downmix, &analysis_info);
 
        /* Track the peak signal energy */
        if (!is_silence && analysis_info.activity_probability > DTX_ACTIVITY_THRESHOLD)
           st->peak_signal_energy = MAX32(MULT16_32_Q15(QCONST16(0.999f, 15), st->peak_signal_energy),
                 compute_frame_energy(pcm, frame_size, st->channels, st->arch));
+    } else if (st->analysis.initialized) {
+       tonality_analysis_reset(&st->analysis);
     }
 #else
     (void)analysis_pcm;
@@ -1171,6 +1152,20 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
     if (!is_silence)
       st->voice_ratio = -1;
 
+    if (is_silence)
+    {
+       activity = !is_silence;
+    } else if (analysis_info.valid)
+    {
+       activity = analysis_info.activity_probability >= DTX_ACTIVITY_THRESHOLD;
+       if (!activity)
+       {
+           /* Mark as active if this noise frame is sufficiently loud */
+           opus_val32 noise_energy = compute_frame_energy(pcm, frame_size, st->channels, st->arch);
+           activity = st->peak_signal_energy < (PSEUDO_SNR_THRESHOLD * noise_energy);
+       }
+    }
+
     st->detected_bandwidth = 0;
     if (analysis_info.valid)
     {
@@ -1338,6 +1333,14 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
 
+    /* Allow SILK DTX if DTX is enabled but the generalized DTX cannot be used,
+       e.g. because of the complexity setting or sample rate. */
+#ifndef DISABLE_FLOAT_API
+    st->silk_mode.useDTX = st->use_dtx && !(analysis_info.valid || is_silence);
+#else
+    st->silk_mode.useDTX = st->use_dtx;
+#endif
+
     /* Mode selection depending on application and signal type */
     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
     {
@@ -1386,13 +1389,7 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
           st->mode = MODE_SILK_ONLY;
        /* When encoding voice and DTX is enabled but the generalized DTX cannot be used,
-          because of complexity and sampling frequency settings, switch to SILK DTX and
-          set the encoder to SILK mode */
-#ifndef DISABLE_FLOAT_API
-       st->silk_mode.useDTX = st->use_dtx && !(analysis_info.valid || is_silence);
-#else
-       st->silk_mode.useDTX = st->use_dtx;
-#endif
+          use SILK in order to make use of its DTX. */
        if (st->silk_mode.useDTX && voice_est > 100)
           st->mode = MODE_SILK_ONLY;
 #endif
@@ -1668,7 +1665,6 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
     if (st->mode != MODE_CELT_ONLY)
     {
         opus_int32 total_bitRate, celt_rate;
-        opus_int activity;
 #ifdef FIXED_POINT
        const opus_int16 *pcm_silk;
 #else
@@ -1676,14 +1672,6 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
 #endif
 
-        activity = VAD_NO_DECISION;
-#ifndef DISABLE_FLOAT_API
-        if( analysis_info.valid ) {
-            /* Inform SILK about the Opus VAD decision */
-            activity = ( analysis_info.activity_probability >= DTX_ACTIVITY_THRESHOLD );
-        }
-#endif
-
         /* Distribute bits between SILK and CELT */
         total_bitRate = 8 * bytes_target * frame_rate;
         if( st->mode == MODE_HYBRID ) {
@@ -2144,14 +2132,15 @@ opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_
 #ifndef DISABLE_FLOAT_API
     if (st->use_dtx && (analysis_info.valid || is_silence))
     {
-       if (decide_dtx_mode(analysis_info.activity_probability, &st->nb_no_activity_frames,
-             st->peak_signal_energy, pcm, frame_size, st->channels, is_silence, st->arch))
+       if (decide_dtx_mode(activity, &st->nb_no_activity_frames))
        {
           st->rangeFinal = 0;
           data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
           RESTORE_STACK;
           return 1;
        }
+    } else {
+       st->nb_no_activity_frames = 0;
     }
 #endif
 
@@ -2629,7 +2618,6 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
                goto bad_arg;
             }
             st->variable_duration = value;
-            celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
         }
         break;
         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
@@ -2726,7 +2714,33 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
         }
         break;
-
+        case OPUS_GET_IN_DTX_REQUEST:
+        {
+            opus_int32 *value = va_arg(ap, opus_int32*);
+            if (!value)
+            {
+                goto bad_arg;
+            }
+            if (st->silk_mode.useDTX && (st->prev_mode == MODE_SILK_ONLY || st->prev_mode == MODE_HYBRID)) {
+                /* DTX determined by Silk. */
+                silk_encoder *silk_enc = (silk_encoder*)(void *)((char*)st+st->silk_enc_offset);
+                *value = silk_enc->state_Fxx[0].sCmn.noSpeechCounter >= NB_SPEECH_FRAMES_BEFORE_DTX;
+                /* Stereo: check second channel unless only the middle channel was encoded. */
+                if(*value == 1 && st->silk_mode.nChannelsInternal == 2 && silk_enc->prev_decode_only_middle == 0) {
+                    *value = silk_enc->state_Fxx[1].sCmn.noSpeechCounter >= NB_SPEECH_FRAMES_BEFORE_DTX;
+                }
+            }
+#ifndef DISABLE_FLOAT_API
+            else if (st->use_dtx) {
+                /* DTX determined by Opus. */
+                *value = st->nb_no_activity_frames >= NB_SPEECH_FRAMES_BEFORE_DTX;
+            }
+#endif
+            else {
+                *value = 0;
+            }
+        }
+        break;
         case CELT_GET_MODE_REQUEST:
         {
            const CELTMode ** value = va_arg(ap, const CELTMode**);
diff --git a/src/opus_multistream_decoder.c b/src/opus_multistream_decoder.c
index 562103cd..a2837c35 100644
--- a/src/opus_multistream_decoder.c
+++ b/src/opus_multistream_decoder.c
@@ -251,8 +251,11 @@ int opus_multistream_decode_native(
       }
       packet_offset = 0;
       ret = opus_decode_native(dec, data, len, buf, frame_size, decode_fec, s!=st->layout.nb_streams-1, &packet_offset, soft_clip);
-      data += packet_offset;
-      len -= packet_offset;
+      if (!do_plc)
+      {
+        data += packet_offset;
+        len -= packet_offset;
+      }
       if (ret <= 0)
       {
          RESTORE_STACK;
@@ -487,7 +490,7 @@ int opus_multistream_decoder_ctl_va_list(OpusMSDecoder *st, int request,
           OpusDecoder **value;
           stream_id = va_arg(ap, opus_int32);
           if (stream_id<0 || stream_id >= st->layout.nb_streams)
-             ret = OPUS_BAD_ARG;
+             goto bad_arg;
           value = va_arg(ap, OpusDecoder**);
           if (!value)
           {
diff --git a/src/opus_multistream_encoder.c b/src/opus_multistream_encoder.c
index 9cb9bf34..93204a14 100644
--- a/src/opus_multistream_encoder.c
+++ b/src/opus_multistream_encoder.c
@@ -1249,7 +1249,7 @@ int opus_multistream_encoder_ctl_va_list(OpusMSEncoder *st, int request,
       OpusEncoder **value;
       stream_id = va_arg(ap, opus_int32);
       if (stream_id<0 || stream_id >= st->layout.nb_streams)
-         ret = OPUS_BAD_ARG;
+         goto bad_arg;
       value = va_arg(ap, OpusEncoder**);
       if (!value)
       {
diff --git a/src/opus_private.h b/src/opus_private.h
index 09783cee..5e2463f5 100644
--- a/src/opus_private.h
+++ b/src/opus_private.h
@@ -135,6 +135,7 @@ typedef void (*opus_copy_channel_out_func)(
 typedef void (*downmix_func)(const void *, opus_val32 *, int, int, int, int, int);
 void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C);
 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C);
+int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth);
 
 int encode_size(int size, unsigned char *data);
 
diff --git a/src/repacketizer_demo.c b/src/repacketizer_demo.c
index dc05c1b3..43de7019 100644
--- a/src/repacketizer_demo.c
+++ b/src/repacketizer_demo.c
@@ -119,7 +119,19 @@ int main(int argc, char *argv[])
       for (i=0;i<nb_packets;i++)
       {
          unsigned char ch[4];
-         err = fread(ch, 1, 4, fin);
+         if (fread(ch, 1, 4, fin)!=4)
+         {
+             if (feof(fin))
+             {
+                eof = 1;
+             } else {
+                fprintf(stderr, "Error reading payload length.\n");
+                fclose(fin);
+                fclose(fout);
+                return EXIT_FAILURE;
+             }
+             break;
+         }
          len[i] = char_to_int(ch);
          /*fprintf(stderr, "in len = %d\n", len[i]);*/
          if (len[i]>1500 || len[i]<0)
@@ -135,13 +147,31 @@ int main(int argc, char *argv[])
              }
              break;
          }
-         err = fread(ch, 1, 4, fin);
-         rng[i] = char_to_int(ch);
-         err = fread(packets[i], 1, len[i], fin);
-         if (feof(fin))
+         if (fread(ch, 1, 4, fin)!=4)
          {
-            eof = 1;
-            break;
+             if (feof(fin))
+             {
+                eof = 1;
+             } else {
+                fprintf(stderr, "Error reading.\n");
+                fclose(fin);
+                fclose(fout);
+                return EXIT_FAILURE;
+             }
+             break;
+         }
+         rng[i] = char_to_int(ch);
+         if (fread(packets[i], len[i], 1, fin)!=1) {
+             if (feof(fin))
+             {
+                eof = 1;
+             } else {
+                fprintf(stderr, "Error reading packet of %u bytes.\n", len[i]);
+                fclose(fin);
+                fclose(fout);
+                return EXIT_FAILURE;
+             }
+             break;
          }
          err = opus_repacketizer_cat(rp, packets[i], len[i]);
          if (err!=OPUS_OK)
diff --git a/tests/meson.build b/tests/meson.build
new file mode 100644
index 00000000..5f3ac9df
--- /dev/null
+++ b/tests/meson.build
@@ -0,0 +1,34 @@
+# Tests that link to libopus
+opus_tests = [
+  ['test_opus_api'],
+  ['test_opus_decode', [], 60],
+  ['test_opus_encode', 'opus_encode_regressions.c', 120],
+  ['test_opus_padding'],
+  ['test_opus_projection'],
+]
+
+foreach t : opus_tests
+  test_name = t.get(0)
+  extra_srcs = t.get(1, [])
+
+  test_kwargs = {}
+  if t.length() > 2
+    test_kwargs += {'timeout': t[2]}
+  endif
+
+  exe_kwargs = {}
+  # This test uses private symbols
+  if test_name == 'test_opus_projection'
+    exe_kwargs = {
+      'link_with': [celt_lib, silk_lib],
+      'objects': opus_lib.extract_all_objects(),
+    }
+  endif
+
+  exe = executable(test_name, '@0@.c'.format(test_name), extra_srcs,
+    include_directories: opus_includes,
+    dependencies: [libm, opus_dep],
+    install: false,
+    kwargs: exe_kwargs)
+  test(test_name, exe, kwargs: test_kwargs)
+endforeach
diff --git a/tests/opus_decode_fuzzer.c b/tests/opus_decode_fuzzer.c
index 90026221..ea6ec4fd 100644
--- a/tests/opus_decode_fuzzer.c
+++ b/tests/opus_decode_fuzzer.c
@@ -40,6 +40,8 @@
 /* 4 bytes: packet length, 4 bytes: encoder final range */
 #define SETUP_BYTE_COUNT 8
 
+#define MAX_DECODES 12
+
 typedef struct {
     int fs;
     int channels;
@@ -62,9 +64,11 @@ static void ParseToc(const uint8_t *toc, TocInfo *const info) {
 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
     OpusDecoder *dec;
     opus_int16 *pcm;
-    uint8_t *packet;
+    uint8_t *temp_data;
     TocInfo toc;
-    int i, err;
+    int i = 0;
+    int err = OPUS_OK;
+    int num_decodes = 0;
 
     /* Not enough data to setup the decoder (+1 for the ToC) */
     if (size < SETUP_BYTE_COUNT + 1) {
@@ -75,26 +79,20 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
     ParseToc(&data[SETUP_BYTE_COUNT], &toc);
 
     dec = opus_decoder_create(toc.fs, toc.channels, &err);
-    if (err != OPUS_OK | dec == NULL) {
+    if (err != OPUS_OK || dec == NULL) {
         return 0;
     }
 
     pcm = (opus_int16*) malloc(sizeof(*pcm) * MAX_FRAME_SAMP * toc.channels);
-    packet = (uint8_t*) calloc(MAX_PACKET, sizeof(*packet));
 
-    i = 0;
-    while (1) {
+    while (i + SETUP_BYTE_COUNT < size && num_decodes++ < MAX_DECODES) {
         int len, fec;
 
-        if (i + SETUP_BYTE_COUNT >= size) {
-            break;
-        }
-
         len = (opus_uint32) data[i    ] << 24 |
               (opus_uint32) data[i + 1] << 16 |
               (opus_uint32) data[i + 2] <<  8 |
               (opus_uint32) data[i + 3];
-        if (len > MAX_PACKET || len < 0) {
+        if (len > MAX_PACKET || len < 0 || i + SETUP_BYTE_COUNT + len > size) {
             break;
         }
 
@@ -102,17 +100,18 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
          * Instead, byte 4 is repurposed to determine if FEC is used. */
         fec = data[i + 4] & 1;
 
-        /* Lost packet */
         if (len == 0) {
+            /* Lost packet */
             int frame_size;
             opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&frame_size));
-            (void) opus_decode(dec, NULL, size, pcm, frame_size, fec);
+            (void) opus_decode(dec, NULL, len, pcm, frame_size, fec);
         } else {
-            if (i + SETUP_BYTE_COUNT + len > size) {
-                break;
-            }
-            memcpy(pcm, &data[i + SETUP_BYTE_COUNT], len);
-            (void) opus_decode(dec, data, size, pcm, MAX_FRAME_SAMP, fec);
+            temp_data = (uint8_t*) malloc(len);
+            memcpy(temp_data, &data[i + SETUP_BYTE_COUNT], len);
+
+            (void) opus_decode(dec, temp_data, len, pcm, MAX_FRAME_SAMP, fec);
+
+            free(temp_data);
         }
 
         i += SETUP_BYTE_COUNT + len;
@@ -120,7 +119,6 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 
     opus_decoder_destroy(dec);
     free(pcm);
-    free(packet);
 
     return 0;
 }
diff --git a/tests/test_opus_common.h b/tests/test_opus_common.h
index 235cf1c1..d96c7d84 100644
--- a/tests/test_opus_common.h
+++ b/tests/test_opus_common.h
@@ -75,6 +75,9 @@ static OPUS_INLINE void _test_failed(const char *file, int line)
   fprintf(stderr,"Please report this failure and include\n");
   fprintf(stderr,"'make check SEED=%u fails %s at line %d for %s'\n",iseed,file,line,opus_get_version_string());
   fprintf(stderr,"and any relevant details about your system.\n\n");
+#if defined(_MSC_VER)
+   _set_abort_behavior( 0, _WRITE_ABORT_MSG);
+#endif
   abort();
 }
 #define test_failed() _test_failed(__FILE__, __LINE__);
diff --git a/tests/test_opus_decode.c b/tests/test_opus_decode.c
index 5197fa1d..2d1e2d41 100644
--- a/tests/test_opus_decode.c
+++ b/tests/test_opus_decode.c
@@ -36,7 +36,7 @@
 #include <math.h>
 #include <string.h>
 #include <time.h>
-#if (!defined WIN32 && !defined _WIN32) || defined(__MINGW32__)
+#ifndef _WIN32
 #include <unistd.h>
 #else
 #include <process.h>
diff --git a/tests/test_opus_encode.c b/tests/test_opus_encode.c
index dae49c3d..00795a1e 100644
--- a/tests/test_opus_encode.c
+++ b/tests/test_opus_encode.c
@@ -140,7 +140,7 @@ int get_frame_size_enum(int frame_size, int sampling_rate)
    return frame_size_enum;
 }
 
-void test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *dec, const char* debug_info)
+int test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *dec)
 {
    int samp_count = 0;
    opus_int16 *inbuf;
@@ -148,6 +148,7 @@ void test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *de
    int len;
    opus_int16 *outbuf;
    int out_samples;
+   int ret = 0;
 
    /* Generate input data */
    inbuf = (opus_int16*)malloc(sizeof(*inbuf)*SSAMPLES);
@@ -160,16 +161,16 @@ void test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *de
    do {
       len = opus_encode(enc, &inbuf[samp_count*channels], frame_size, packet, MAX_PACKET);
       if(len<0 || len>MAX_PACKET) {
-         fprintf(stderr,"%s\n",debug_info);
          fprintf(stderr,"opus_encode() returned %d\n",len);
-         test_failed();
+         ret = -1;
+         break;
       }
 
       out_samples = opus_decode(dec, packet, len, outbuf, MAX_FRAME_SAMP, 0);
       if(out_samples!=frame_size) {
-         fprintf(stderr,"%s\n",debug_info);
          fprintf(stderr,"opus_decode() returned %d\n",out_samples);
-         test_failed();
+         ret = -1;
+         break;
       }
 
       samp_count += frame_size;
@@ -178,6 +179,7 @@ void test_encode(OpusEncoder *enc, int channels, int frame_size, OpusDecoder *de
    /* Clean up */
    free(inbuf);
    free(outbuf);
+   return ret;
 }
 
 void fuzz_encoder_settings(const int num_encoders, const int num_setting_changes)
@@ -205,7 +207,6 @@ void fuzz_encoder_settings(const int num_encoders, const int num_setting_changes
    int prediction_disabled[3] = {0, 0, 1};
    int use_dtx[2] = {0, 1};
    int frame_sizes_ms_x2[9] = {5, 10, 20, 40, 80, 120, 160, 200, 240};  /* x2 to avoid 2.5 ms */
-   char debug_info[512];
 
    for (i=0; i<num_encoders; i++) {
       int sampling_rate = RAND_SAMPLE(sampling_rates);
@@ -236,15 +237,6 @@ void fuzz_encoder_settings(const int num_encoders, const int num_setting_changes
          int frame_size_enum = get_frame_size_enum(frame_size, sampling_rate);
          force_channel = IMIN(force_channel, num_channels);
 
-         sprintf(debug_info,
-                 "fuzz_encoder_settings: %d kHz, %d ch, application: %d, "
-                 "%d bps, force ch: %d, vbr: %d, vbr constraint: %d, complexity: %d, "
-                 "max bw: %d, signal: %d, inband fec: %d, pkt loss: %d%%, lsb depth: %d, "
-                 "pred disabled: %d, dtx: %d, (%d/2) ms\n",
-                 sampling_rate/1000, num_channels, application, bitrate,
-                 force_channel, vbr, vbr_constraint, complexity, max_bw, sig, inband_fec,
-                 pkt_loss, lsb_depth, pred_disabled, dtx, frame_size_ms_x2);
-
          if(opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate)) != OPUS_OK) test_failed();
          if(opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(force_channel)) != OPUS_OK) test_failed();
          if(opus_encoder_ctl(enc, OPUS_SET_VBR(vbr)) != OPUS_OK) test_failed();
@@ -259,7 +251,17 @@ void fuzz_encoder_settings(const int num_encoders, const int num_setting_changes
          if(opus_encoder_ctl(enc, OPUS_SET_DTX(dtx)) != OPUS_OK) test_failed();
          if(opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(frame_size_enum)) != OPUS_OK) test_failed();
 
-         test_encode(enc, num_channels, frame_size, dec, debug_info);
+         if(test_encode(enc, num_channels, frame_size, dec)) {
+            fprintf(stderr,
+               "fuzz_encoder_settings: %d kHz, %d ch, application: %d, "
+               "%d bps, force ch: %d, vbr: %d, vbr constraint: %d, complexity: %d, "
+               "max bw: %d, signal: %d, inband fec: %d, pkt loss: %d%%, lsb depth: %d, "
+               "pred disabled: %d, dtx: %d, (%d/2) ms\n",
+               sampling_rate/1000, num_channels, application, bitrate,
+               force_channel, vbr, vbr_constraint, complexity, max_bw, sig, inband_fec,
+               pkt_loss, lsb_depth, pred_disabled, dtx, frame_size_ms_x2);
+            test_failed();
+         }
       }
 
       opus_encoder_destroy(enc);
diff --git a/tests/test_opus_projection.c b/tests/test_opus_projection.c
index 4d622e86..5f0d672c 100644
--- a/tests/test_opus_projection.c
+++ b/tests/test_opus_projection.c
@@ -360,6 +360,8 @@ void test_encode_decode(opus_int32 bitrate, opus_int32 channels,
     goto bad_cleanup;
   }
 
+  opus_projection_decoder_destroy(st_dec);
+  opus_projection_encoder_destroy(st_enc);
   free(buffer_in);
   free(buffer_out);
   return;
diff --git a/training/rnn_dump.py b/training/rnn_dump.py
new file mode 100755
index 00000000..c312088e
--- /dev/null
+++ b/training/rnn_dump.py
@@ -0,0 +1,66 @@
+#!/usr/bin/python
+
+from __future__ import print_function
+
+from keras.models import Sequential
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.layers import GRU
+from keras.models import load_model
+from keras import backend as K
+import sys
+
+import numpy as np
+
+def printVector(f, vector, name):
+    v = np.reshape(vector, (-1));
+    #print('static const float ', name, '[', len(v), '] = \n', file=f)
+    f.write('static const opus_int8 {}[{}] = {{\n   '.format(name, len(v)))
+    for i in range(0, len(v)):
+        f.write('{}'.format(max(-128,min(127,int(round(128*v[i]))))))
+        if (i!=len(v)-1):
+            f.write(',')
+        else:
+            break;
+        if (i%8==7):
+            f.write("\n   ")
+        else:
+            f.write(" ")
+    #print(v, file=f)
+    f.write('\n};\n\n')
+    return;
+
+def binary_crossentrop2(y_true, y_pred):
+        return K.mean(2*K.abs(y_true-0.5) * K.binary_crossentropy(y_pred, y_true), axis=-1)
+
+
+#model = load_model(sys.argv[1], custom_objects={'binary_crossentrop2': binary_crossentrop2})
+main_input = Input(shape=(None, 25), name='main_input')
+x = Dense(32, activation='tanh')(main_input)
+x = GRU(24, activation='tanh', recurrent_activation='sigmoid', return_sequences=True)(x)
+x = Dense(2, activation='sigmoid')(x)
+model = Model(inputs=main_input, outputs=x)
+model.load_weights(sys.argv[1])
+
+weights = model.get_weights()
+
+f = open(sys.argv[2], 'w')
+
+f.write('/*This file is automatically generated from a Keras model*/\n\n')
+f.write('#ifdef HAVE_CONFIG_H\n#include "config.h"\n#endif\n\n#include "mlp.h"\n\n')
+
+printVector(f, weights[0], 'layer0_weights')
+printVector(f, weights[1], 'layer0_bias')
+printVector(f, weights[2], 'layer1_weights')
+printVector(f, weights[3], 'layer1_recur_weights')
+printVector(f, weights[4], 'layer1_bias')
+printVector(f, weights[5], 'layer2_weights')
+printVector(f, weights[6], 'layer2_bias')
+
+f.write('const DenseLayer layer0 = {\n   layer0_bias,\n   layer0_weights,\n   25, 32, 0\n};\n\n')
+f.write('const GRULayer layer1 = {\n   layer1_bias,\n   layer1_weights,\n   layer1_recur_weights,\n   32, 24\n};\n\n')
+f.write('const DenseLayer layer2 = {\n   layer2_bias,\n   layer2_weights,\n   24, 2, 1\n};\n\n')
+
+f.close()
diff --git a/training/rnn_train.py b/training/rnn_train.py
new file mode 100755
index 00000000..29bcb034
--- /dev/null
+++ b/training/rnn_train.py
@@ -0,0 +1,177 @@
+#!/usr/bin/python3
+
+from __future__ import print_function
+
+from keras.models import Sequential
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Dense
+from keras.layers import LSTM
+from keras.layers import GRU
+from keras.layers import CuDNNGRU
+from keras.layers import SimpleRNN
+from keras.layers import Dropout
+from keras import losses
+import h5py
+from keras.optimizers import Adam
+
+from keras.constraints import Constraint
+from keras import backend as K
+import numpy as np
+
+import tensorflow as tf
+from keras.backend.tensorflow_backend import set_session
+config = tf.ConfigProto()
+config.gpu_options.per_process_gpu_memory_fraction = 0.44
+set_session(tf.Session(config=config))
+
+def binary_crossentrop2(y_true, y_pred):
+    return K.mean(2*K.abs(y_true-0.5) * K.binary_crossentropy(y_true, y_pred), axis=-1)
+
+def binary_accuracy2(y_true, y_pred):
+    return K.mean(K.cast(K.equal(y_true, K.round(y_pred)), 'float32') + K.cast(K.equal(y_true, 0.5), 'float32'), axis=-1)
+
+def quant_model(model):
+    weights = model.get_weights()
+    for k in range(len(weights)):
+        weights[k] = np.maximum(-128, np.minimum(127, np.round(128*weights[k])*0.0078125))
+    model.set_weights(weights)
+
+class WeightClip(Constraint):
+    '''Clips the weights incident to each hidden unit to be inside a range
+    '''
+    def __init__(self, c=2):
+        self.c = c
+
+    def __call__(self, p):
+        return K.clip(p, -self.c, self.c)
+
+    def get_config(self):
+        return {'name': self.__class__.__name__,
+            'c': self.c}
+
+reg = 0.000001
+constraint = WeightClip(.998)
+
+print('Build model...')
+
+main_input = Input(shape=(None, 25), name='main_input')
+x = Dense(32, activation='tanh', kernel_constraint=constraint, bias_constraint=constraint)(main_input)
+#x = CuDNNGRU(24, return_sequences=True, kernel_constraint=constraint, recurrent_constraint=constraint, bias_constraint=constraint)(x)
+x = GRU(24, recurrent_activation='sigmoid', activation='tanh', return_sequences=True, kernel_constraint=constraint, recurrent_constraint=constraint, bias_constraint=constraint)(x)
+x = Dense(2, activation='sigmoid', kernel_constraint=constraint, bias_constraint=constraint)(x)
+model = Model(inputs=main_input, outputs=x)
+
+batch_size = 2048
+
+print('Loading data...')
+with h5py.File('features10b.h5', 'r') as hf:
+    all_data = hf['data'][:]
+print('done.')
+
+window_size = 1500
+
+nb_sequences = len(all_data)//window_size
+print(nb_sequences, ' sequences')
+x_train = all_data[:nb_sequences*window_size, :-2]
+x_train = np.reshape(x_train, (nb_sequences, window_size, 25))
+
+y_train = np.copy(all_data[:nb_sequences*window_size, -2:])
+y_train = np.reshape(y_train, (nb_sequences, window_size, 2))
+
+print("Marking ignores")
+for s in y_train:
+    for e in s:
+        if (e[1] >= 1):
+            break
+        e[0] = 0.5
+
+all_data = 0;
+x_train = x_train.astype('float32')
+y_train = y_train.astype('float32')
+
+print(len(x_train), 'train sequences. x shape =', x_train.shape, 'y shape = ', y_train.shape)
+
+model.load_weights('newweights10a1b_ep206.hdf5')
+
+#weights = model.get_weights()
+#for k in range(len(weights)):
+#    weights[k] = np.round(128*weights[k])*0.0078125
+#model.set_weights(weights)
+
+# try using different optimizers and different optimizer configs
+model.compile(loss=binary_crossentrop2,
+              optimizer=Adam(0.0001),
+              metrics=[binary_accuracy2])
+
+print('Train...')
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=10, validation_data=(x_train, y_train))
+model.save("newweights10a1c_ep10.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=50, initial_epoch=10)
+model.save("newweights10a1c_ep50.hdf5")
+
+model.compile(loss=binary_crossentrop2,
+              optimizer=Adam(0.0001),
+              metrics=[binary_accuracy2])
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=100, initial_epoch=50)
+model.save("newweights10a1c_ep100.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=150, initial_epoch=100)
+model.save("newweights10a1c_ep150.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=200, initial_epoch=150)
+model.save("newweights10a1c_ep200.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=201, initial_epoch=200)
+model.save("newweights10a1c_ep201.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=202, initial_epoch=201, validation_data=(x_train, y_train))
+model.save("newweights10a1c_ep202.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=203, initial_epoch=202, validation_data=(x_train, y_train))
+model.save("newweights10a1c_ep203.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=204, initial_epoch=203, validation_data=(x_train, y_train))
+model.save("newweights10a1c_ep204.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=205, initial_epoch=204, validation_data=(x_train, y_train))
+model.save("newweights10a1c_ep205.hdf5")
+
+quant_model(model)
+model.fit(x_train, y_train,
+          batch_size=batch_size,
+          epochs=206, initial_epoch=205, validation_data=(x_train, y_train))
+model.save("newweights10a1c_ep206.hdf5")
+
diff --git a/training/txt2hdf5.py b/training/txt2hdf5.py
new file mode 100755
index 00000000..9c602877
--- /dev/null
+++ b/training/txt2hdf5.py
@@ -0,0 +1,12 @@
+#!/usr/bin/python
+
+from __future__ import print_function
+
+import numpy as np
+import h5py
+import sys
+
+data = np.loadtxt(sys.argv[1], dtype='float32')
+h5f = h5py.File(sys.argv[2], 'w');
+h5f.create_dataset('data', data=data)
+h5f.close()
diff --git a/win32/VS2015/common.props b/win32/VS2015/common.props
index 03cd45b0..f6e920b6 100644
--- a/win32/VS2015/common.props
+++ b/win32/VS2015/common.props
@@ -1,82 +1,82 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ImportGroup Label="PropertySheets" />

-  <PropertyGroup Label="UserMacros" />

-  <PropertyGroup>

-    <OutDir>$(Platform)\$(Configuration)\</OutDir>

-    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>

-    <CharacterSet Condition="'$(ConfigurationType)'=='Application'">Unicode</CharacterSet>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)'=='Debug' or '$(Configuration)'=='DebugDLL' or '$(Configuration)'=='DebugDLL_fixed'">

-    <LinkIncremental>true</LinkIncremental>

-    <UseDebugLibraries>true</UseDebugLibraries>

-    <WholeProgramOptimization>false</WholeProgramOptimization>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)'=='Release' or '$(Configuration)'=='ReleaseDLL' or '$(Configuration)'=='ReleaseDLL_fixed'">

-    <LinkIncremental>false</LinkIncremental>

-    <UseDebugLibraries>false</UseDebugLibraries>

-    <WholeProgramOptimization>true</WholeProgramOptimization>

-  </PropertyGroup>

-  <ItemDefinitionGroup>

-    <ClCompile>

-      <WarningLevel>Level3</WarningLevel>

-      <CompileAsManaged>false</CompileAsManaged>

-      <CompileAsWinRT>false</CompileAsWinRT>

-      <AdditionalIncludeDirectories>..\..;..\..\include;..\..\silk;..\..\celt;..\..\win32;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

-      <PreprocessorDefinitions>HAVE_CONFIG_H;WIN32;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <RuntimeTypeInfo>false</RuntimeTypeInfo>

-      <OpenMPSupport>false</OpenMPSupport>

-    </ClCompile>

-    <Lib>

-      <SubSystem>Console</SubSystem>

-    </Lib>

-    <Link>

-      <LargeAddressAware>true</LargeAddressAware>

-      <SubSystem>Console</SubSystem>

-    </Link>

-  </ItemDefinitionGroup>

-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug' or '$(Configuration)'=='DebugDLL' or '$(Configuration)'=='DebugDLL_fixed'">

-    <ClCompile>

-      <ControlFlowGuard>Guard</ControlFlowGuard>

-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

-      <EnableEnhancedInstructionSet Condition="'$(Platform)'=='Win32'">NoExtensions</EnableEnhancedInstructionSet>

-      <EnableParallelCodeGeneration>false</EnableParallelCodeGeneration>

-      <FloatingPointExceptions>true</FloatingPointExceptions>

-      <FunctionLevelLinking>false</FunctionLevelLinking>

-      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>

-      <MultiProcessorCompilation>false</MultiProcessorCompilation>

-      <OmitFramePointers>false</OmitFramePointers>

-      <Optimization>Disabled</Optimization>

-      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>

-      <RuntimeLibrary Condition="'$(Configuration)'!='Debug'">MultiThreadedDebugDLL</RuntimeLibrary>

-      <SDLCheck>true</SDLCheck>

-      <StringPooling>false</StringPooling>

-    </ClCompile>

-    <Link>

-      <GenerateDebugInformation>true</GenerateDebugInformation>

-    </Link>

-  </ItemDefinitionGroup>

-  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release' or '$(Configuration)'=='ReleaseDLL' or '$(Configuration)'=='ReleaseDLL_fixed'">

-    <ClCompile>

-      <ControlFlowGuard>false</ControlFlowGuard>

-      <DebugInformationFormat>None</DebugInformationFormat>

-      <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>

-      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>

-      <ExceptionHandling>false</ExceptionHandling>

-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

-      <FloatingPointModel Condition="'$(Configuration)'=='Release'">Fast</FloatingPointModel>

-      <FloatingPointModel Condition="'$(Configuration)'!='Release'">Precise</FloatingPointModel>

-      <FunctionLevelLinking>true</FunctionLevelLinking>

-      <IntrinsicFunctions>true</IntrinsicFunctions>

-      <MultiProcessorCompilation>true</MultiProcessorCompilation>

-      <Optimization>MaxSpeed</Optimization>

-      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>

-      <RuntimeLibrary Condition="'$(Configuration)'!='Release'">MultiThreadedDLL</RuntimeLibrary>

-      <StructMemberAlignment>16Bytes</StructMemberAlignment>

-    </ClCompile>

-    <Link>

-      <GenerateDebugInformation>false</GenerateDebugInformation>

-    </Link>

-  </ItemDefinitionGroup>

-  <ItemGroup />

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir>$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
+    <CharacterSet Condition="'$(ConfigurationType)'=='Application'">Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug' or '$(Configuration)'=='DebugDLL' or '$(Configuration)'=='DebugDLL_fixed'">
+    <LinkIncremental>true</LinkIncremental>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release' or '$(Configuration)'=='ReleaseDLL' or '$(Configuration)'=='ReleaseDLL_fixed'">
+    <LinkIncremental>false</LinkIncremental>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <CompileAsManaged>false</CompileAsManaged>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <AdditionalIncludeDirectories>..\..;..\..\include;..\..\silk;..\..\celt;..\..\win32;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>HAVE_CONFIG_H;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <OpenMPSupport>false</OpenMPSupport>
+    </ClCompile>
+    <Lib>
+      <SubSystem>Console</SubSystem>
+    </Lib>
+    <Link>
+      <LargeAddressAware>true</LargeAddressAware>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug' or '$(Configuration)'=='DebugDLL' or '$(Configuration)'=='DebugDLL_fixed'">
+    <ClCompile>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <EnableEnhancedInstructionSet Condition="'$(Platform)'=='Win32'">NoExtensions</EnableEnhancedInstructionSet>
+      <EnableParallelCodeGeneration>false</EnableParallelCodeGeneration>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
+      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
+      <MultiProcessorCompilation>false</MultiProcessorCompilation>
+      <OmitFramePointers>false</OmitFramePointers>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'!='Debug'">MultiThreadedDebugDLL</RuntimeLibrary>
+      <SDLCheck>true</SDLCheck>
+      <StringPooling>false</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release' or '$(Configuration)'=='ReleaseDLL' or '$(Configuration)'=='ReleaseDLL_fixed'">
+    <ClCompile>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
+      <ExceptionHandling>false</ExceptionHandling>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <FloatingPointModel Condition="'$(Configuration)'=='Release'">Fast</FloatingPointModel>
+      <FloatingPointModel Condition="'$(Configuration)'!='Release'">Precise</FloatingPointModel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'!='Release'">MultiThreadedDLL</RuntimeLibrary>
+      <StructMemberAlignment>16Bytes</StructMemberAlignment>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup />
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/opus.sln b/win32/VS2015/opus.sln
index abd7a4dd..7b678e7f 100644
--- a/win32/VS2015/opus.sln
+++ b/win32/VS2015/opus.sln
@@ -1,168 +1,168 @@
-

-Microsoft Visual Studio Solution File, Format Version 12.00

-# Visual Studio 14

-VisualStudioVersion = 14.0.25420.1

-MinimumVisualStudioVersion = 10.0.40219.1

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opus", "opus.vcxproj", "{219EC965-228A-1824-174D-96449D05F88A}"

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opus_demo", "opus_demo.vcxproj", "{016C739D-6389-43BF-8D88-24B2BF6F620F}"

-	ProjectSection(ProjectDependencies) = postProject

-		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}

-	EndProjectSection

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_opus_api", "test_opus_api.vcxproj", "{1D257A17-D254-42E5-82D6-1C87A6EC775A}"

-	ProjectSection(ProjectDependencies) = postProject

-		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}

-	EndProjectSection

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_opus_decode", "test_opus_decode.vcxproj", "{8578322A-1883-486B-B6FA-E0094B65C9F2}"

-	ProjectSection(ProjectDependencies) = postProject

-		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}

-	EndProjectSection

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_opus_encode", "test_opus_encode.vcxproj", "{84DAA768-1A38-4312-BB61-4C78BB59E5B8}"

-	ProjectSection(ProjectDependencies) = postProject

-		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}

-	EndProjectSection

-EndProject

-Global

-	GlobalSection(SolutionConfigurationPlatforms) = preSolution

-		Debug|Win32 = Debug|Win32

-		Debug|x64 = Debug|x64

-		DebugDLL_fixed|Win32 = DebugDLL_fixed|Win32

-		DebugDLL_fixed|x64 = DebugDLL_fixed|x64

-		DebugDLL|Win32 = DebugDLL|Win32

-		DebugDLL|x64 = DebugDLL|x64

-		Release|Win32 = Release|Win32

-		Release|x64 = Release|x64

-		ReleaseDLL_fixed|Win32 = ReleaseDLL_fixed|Win32

-		ReleaseDLL_fixed|x64 = ReleaseDLL_fixed|x64

-		ReleaseDLL|Win32 = ReleaseDLL|Win32

-		ReleaseDLL|x64 = ReleaseDLL|x64

-	EndGlobalSection

-	GlobalSection(ProjectConfigurationPlatforms) = postSolution

-		{219EC965-228A-1824-174D-96449D05F88A}.Debug|Win32.ActiveCfg = Debug|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.Debug|Win32.Build.0 = Debug|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.Debug|x64.ActiveCfg = Debug|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.Debug|x64.Build.0 = Debug|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|Win32.Build.0 = DebugDLL|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|x64.ActiveCfg = DebugDLL|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|x64.Build.0 = DebugDLL|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.Release|Win32.ActiveCfg = Release|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.Release|Win32.Build.0 = Release|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.Release|x64.ActiveCfg = Release|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.Release|x64.Build.0 = Release|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64

-		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|Win32.ActiveCfg = Debug|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|Win32.Build.0 = Debug|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|x64.ActiveCfg = Debug|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|x64.Build.0 = Debug|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|Win32.Build.0 = DebugDLL|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|x64.ActiveCfg = DebugDLL|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|x64.Build.0 = DebugDLL|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|Win32.ActiveCfg = Release|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|Win32.Build.0 = Release|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|x64.ActiveCfg = Release|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|x64.Build.0 = Release|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64

-		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|Win32.ActiveCfg = Debug|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|Win32.Build.0 = Debug|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|x64.ActiveCfg = Debug|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|x64.Build.0 = Debug|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|Win32.Build.0 = DebugDLL|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|x64.ActiveCfg = DebugDLL|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|x64.Build.0 = DebugDLL|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|Win32.ActiveCfg = Release|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|Win32.Build.0 = Release|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|x64.ActiveCfg = Release|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|x64.Build.0 = Release|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64

-		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|Win32.ActiveCfg = Debug|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|Win32.Build.0 = Debug|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|x64.ActiveCfg = Debug|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|x64.Build.0 = Debug|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|Win32.Build.0 = DebugDLL|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|x64.ActiveCfg = DebugDLL|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|x64.Build.0 = DebugDLL|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|Win32.ActiveCfg = Release|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|Win32.Build.0 = Release|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|x64.ActiveCfg = Release|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|x64.Build.0 = Release|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64

-		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|Win32.ActiveCfg = Debug|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|Win32.Build.0 = Debug|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|x64.ActiveCfg = Debug|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|x64.Build.0 = Debug|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|Win32.Build.0 = DebugDLL|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|x64.ActiveCfg = DebugDLL|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|x64.Build.0 = DebugDLL|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|Win32.ActiveCfg = Release|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|Win32.Build.0 = Release|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|x64.ActiveCfg = Release|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|x64.Build.0 = Release|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64

-		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64

-	EndGlobalSection

-	GlobalSection(SolutionProperties) = preSolution

-		HideSolutionNode = FALSE

-	EndGlobalSection

-EndGlobal

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opus", "opus.vcxproj", "{219EC965-228A-1824-174D-96449D05F88A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opus_demo", "opus_demo.vcxproj", "{016C739D-6389-43BF-8D88-24B2BF6F620F}"
+	ProjectSection(ProjectDependencies) = postProject
+		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_opus_api", "test_opus_api.vcxproj", "{1D257A17-D254-42E5-82D6-1C87A6EC775A}"
+	ProjectSection(ProjectDependencies) = postProject
+		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_opus_decode", "test_opus_decode.vcxproj", "{8578322A-1883-486B-B6FA-E0094B65C9F2}"
+	ProjectSection(ProjectDependencies) = postProject
+		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test_opus_encode", "test_opus_encode.vcxproj", "{84DAA768-1A38-4312-BB61-4C78BB59E5B8}"
+	ProjectSection(ProjectDependencies) = postProject
+		{219EC965-228A-1824-174D-96449D05F88A} = {219EC965-228A-1824-174D-96449D05F88A}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		DebugDLL_fixed|Win32 = DebugDLL_fixed|Win32
+		DebugDLL_fixed|x64 = DebugDLL_fixed|x64
+		DebugDLL|Win32 = DebugDLL|Win32
+		DebugDLL|x64 = DebugDLL|x64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+		ReleaseDLL_fixed|Win32 = ReleaseDLL_fixed|Win32
+		ReleaseDLL_fixed|x64 = ReleaseDLL_fixed|x64
+		ReleaseDLL|Win32 = ReleaseDLL|Win32
+		ReleaseDLL|x64 = ReleaseDLL|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{219EC965-228A-1824-174D-96449D05F88A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.Debug|Win32.Build.0 = Debug|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.Debug|x64.ActiveCfg = Debug|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.Debug|x64.Build.0 = Debug|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|Win32.Build.0 = DebugDLL|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.Release|Win32.ActiveCfg = Release|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.Release|Win32.Build.0 = Release|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.Release|x64.ActiveCfg = Release|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.Release|x64.Build.0 = Release|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{219EC965-228A-1824-174D-96449D05F88A}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|Win32.Build.0 = Debug|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|x64.ActiveCfg = Debug|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Debug|x64.Build.0 = Debug|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|Win32.Build.0 = DebugDLL|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|Win32.ActiveCfg = Release|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|Win32.Build.0 = Release|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|x64.ActiveCfg = Release|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.Release|x64.Build.0 = Release|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{016C739D-6389-43BF-8D88-24B2BF6F620F}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|Win32.Build.0 = Debug|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|x64.ActiveCfg = Debug|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Debug|x64.Build.0 = Debug|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|Win32.Build.0 = DebugDLL|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|Win32.ActiveCfg = Release|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|Win32.Build.0 = Release|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|x64.ActiveCfg = Release|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.Release|x64.Build.0 = Release|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{1D257A17-D254-42E5-82D6-1C87A6EC775A}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|Win32.Build.0 = Debug|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|x64.ActiveCfg = Debug|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Debug|x64.Build.0 = Debug|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|Win32.Build.0 = DebugDLL|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|Win32.ActiveCfg = Release|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|Win32.Build.0 = Release|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|x64.ActiveCfg = Release|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.Release|x64.Build.0 = Release|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{8578322A-1883-486B-B6FA-E0094B65C9F2}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|Win32.Build.0 = Debug|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|x64.ActiveCfg = Debug|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Debug|x64.Build.0 = Debug|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|Win32.ActiveCfg = DebugDLL_fixed|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|Win32.Build.0 = DebugDLL_fixed|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|x64.ActiveCfg = DebugDLL_fixed|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL_fixed|x64.Build.0 = DebugDLL_fixed|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|Win32.ActiveCfg = DebugDLL|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|Win32.Build.0 = DebugDLL|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|x64.ActiveCfg = DebugDLL|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.DebugDLL|x64.Build.0 = DebugDLL|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|Win32.ActiveCfg = Release|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|Win32.Build.0 = Release|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|x64.ActiveCfg = Release|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.Release|x64.Build.0 = Release|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|Win32.ActiveCfg = ReleaseDLL_fixed|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|Win32.Build.0 = ReleaseDLL_fixed|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|x64.ActiveCfg = ReleaseDLL_fixed|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL_fixed|x64.Build.0 = ReleaseDLL_fixed|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|Win32.ActiveCfg = ReleaseDLL|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|Win32.Build.0 = ReleaseDLL|Win32
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64
+		{84DAA768-1A38-4312-BB61-4C78BB59E5B8}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/win32/VS2015/opus.vcxproj b/win32/VS2015/opus.vcxproj
index e7a17da5..34b1233c 100644
--- a/win32/VS2015/opus.vcxproj
+++ b/win32/VS2015/opus.vcxproj
@@ -1,399 +1,399 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup Label="ProjectConfigurations">

-    <ProjectConfiguration Include="DebugDLL_fixed|Win32">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL_fixed|x64">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|Win32">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|x64">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|Win32">

-      <Configuration>Debug</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|x64">

-      <Configuration>Debug</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|Win32">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|x64">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|Win32">

-      <Configuration>Release</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|x64">

-      <Configuration>Release</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-  </ItemGroup>

-  <PropertyGroup Label="Globals">

-    <Keyword>Win32Proj</Keyword>

-    <ProjectName>opus</ProjectName>

-    <ProjectGuid>{219EC965-228A-1824-174D-96449D05F88A}</ProjectGuid>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

-    <ConfigurationType>StaticLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

-    <ConfigurationType>StaticLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

-    <ConfigurationType>StaticLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

-    <ConfigurationType>StaticLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>DynamicLibrary</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

-  <ImportGroup Label="ExtensionSettings">

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <PropertyGroup Label="UserMacros" />

-  <ItemDefinitionGroup>

-    <ClCompile>

-      <AdditionalIncludeDirectories>..\..\silk\fixed;..\..\silk\float;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

-      <PreprocessorDefinitions Condition="'$(ConfigurationType)'=='DynamicLibrary'">DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <PreprocessorDefinitions Condition="'$(Configuration)'=='DebugDLL_fixed' or '$(Configuration)'=='ReleaseDLL_fixed'">FIXED_POINT;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <AdditionalOptions Condition="'$(Platform)'=='Win32'">/arch:IA32 %(AdditionalOptions)</AdditionalOptions>

-    </ClCompile>

-    <Lib>

-      <AdditionalOptions>/ignore:4221 %(AdditionalOptions)</AdditionalOptions>

-    </Lib>

-    <PreBuildEvent>

-      <Command>"$(ProjectDir)..\..\win32\genversion.bat" "$(ProjectDir)..\..\win32\version.h" PACKAGE_VERSION</Command>

-      <Message>Generating version.h</Message>

-    </PreBuildEvent>

-  </ItemDefinitionGroup>

-  <ItemGroup>

-    <ClInclude Include="..\..\celt\arch.h" />

-    <ClInclude Include="..\..\celt\bands.h" />

-    <ClInclude Include="..\..\celt\celt.h" />

-    <ClInclude Include="..\..\celt\celt_lpc.h" />

-    <ClInclude Include="..\..\celt\cwrs.h" />

-    <ClInclude Include="..\..\celt\ecintrin.h" />

-    <ClInclude Include="..\..\celt\entcode.h" />

-    <ClInclude Include="..\..\celt\entdec.h" />

-    <ClInclude Include="..\..\celt\entenc.h" />

-    <ClInclude Include="..\..\celt\fixed_c5x.h" />

-    <ClInclude Include="..\..\celt\fixed_c6x.h" />

-    <ClInclude Include="..\..\celt\fixed_debug.h" />

-    <ClInclude Include="..\..\celt\fixed_generic.h" />

-    <ClInclude Include="..\..\celt\float_cast.h" />

-    <ClInclude Include="..\..\celt\kiss_fft.h" />

-    <ClInclude Include="..\..\celt\laplace.h" />

-    <ClInclude Include="..\..\celt\mathops.h" />

-    <ClInclude Include="..\..\celt\mdct.h" />

-    <ClInclude Include="..\..\celt\mfrngcod.h" />

-    <ClInclude Include="..\..\celt\modes.h" />

-    <ClInclude Include="..\..\celt\os_support.h" />

-    <ClInclude Include="..\..\celt\pitch.h" />

-    <ClInclude Include="..\..\celt\quant_bands.h" />

-    <ClInclude Include="..\..\celt\rate.h" />

-    <ClInclude Include="..\..\celt\stack_alloc.h" />

-    <ClInclude Include="..\..\celt\static_modes_fixed.h" />

-    <ClInclude Include="..\..\celt\static_modes_float.h" />

-    <ClInclude Include="..\..\celt\vq.h" />

-    <ClInclude Include="..\..\celt\x86\celt_lpc_sse.h" />

-    <ClInclude Include="..\..\celt\x86\pitch_sse.h" />

-    <ClInclude Include="..\..\celt\x86\vq_sse.h" />

-    <ClInclude Include="..\..\celt\x86\x86cpu.h" />

-    <ClInclude Include="..\..\celt\_kiss_fft_guts.h" />

-    <ClInclude Include="..\..\include\opus.h" />

-    <ClInclude Include="..\..\include\opus_defines.h" />

-    <ClInclude Include="..\..\include\opus_types.h" />

-    <ClInclude Include="..\..\include\opus_multistream.h" />

-    <ClInclude Include="..\..\include\opus_projection.h" />

-    <ClInclude Include="..\..\silk\API.h" />

-    <ClInclude Include="..\..\silk\control.h" />

-    <ClInclude Include="..\..\silk\debug.h" />

-    <ClInclude Include="..\..\silk\define.h" />

-    <ClInclude Include="..\..\silk\errors.h" />

-    <ClInclude Include="..\..\silk\float\main_FLP.h" />

-    <ClInclude Include="..\..\silk\float\SigProc_FLP.h" />

-    <ClInclude Include="..\..\silk\float\structs_FLP.h" />

-    <ClInclude Include="..\..\silk\Inlines.h" />

-    <ClInclude Include="..\..\silk\MacroCount.h" />

-    <ClInclude Include="..\..\silk\MacroDebug.h" />

-    <ClInclude Include="..\..\silk\macros.h" />

-    <ClInclude Include="..\..\silk\main.h" />

-    <ClInclude Include="..\..\silk\pitch_est_defines.h" />

-    <ClInclude Include="..\..\silk\PLC.h" />

-    <ClInclude Include="..\..\silk\resampler_private.h" />

-    <ClInclude Include="..\..\silk\resampler_rom.h" />

-    <ClInclude Include="..\..\silk\resampler_structs.h" />

-    <ClInclude Include="..\..\silk\structs.h" />

-    <ClInclude Include="..\..\silk\tables.h" />

-    <ClInclude Include="..\..\silk\tuning_parameters.h" />

-    <ClInclude Include="..\..\silk\typedef.h" />

-    <ClInclude Include="..\..\silk\x86\main_sse.h" />

-    <ClInclude Include="..\..\win32\config.h" />

-    <ClInclude Include="..\..\src\analysis.h" />

-    <ClInclude Include="..\..\src\mapping_matrix.h" />

-    <ClInclude Include="..\..\src\mlp.h" />

-    <ClInclude Include="..\..\src\opus_private.h" />

-    <ClInclude Include="..\..\src\tansig_table.h" />

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\celt\bands.c" />

-    <ClCompile Include="..\..\celt\celt.c" />

-    <ClCompile Include="..\..\celt\celt_decoder.c" />

-    <ClCompile Include="..\..\celt\celt_encoder.c" />

-    <ClCompile Include="..\..\celt\celt_lpc.c" />

-    <ClCompile Include="..\..\celt\cwrs.c" />

-    <ClCompile Include="..\..\celt\entcode.c" />

-    <ClCompile Include="..\..\celt\entdec.c" />

-    <ClCompile Include="..\..\celt\entenc.c" />

-    <ClCompile Include="..\..\celt\kiss_fft.c" />

-    <ClCompile Include="..\..\celt\laplace.c" />

-    <ClCompile Include="..\..\celt\mathops.c" />

-    <ClCompile Include="..\..\celt\mdct.c" />

-    <ClCompile Include="..\..\celt\modes.c" />

-    <ClCompile Include="..\..\celt\pitch.c" />

-    <ClCompile Include="..\..\celt\quant_bands.c" />

-    <ClCompile Include="..\..\celt\rate.c" />

-    <ClCompile Include="..\..\celt\vq.c" />

-    <ClCompile Include="..\..\celt\x86\celt_lpc_sse4_1.c" />

-    <ClCompile Include="..\..\celt\x86\pitch_sse.c" />

-    <ClCompile Include="..\..\celt\x86\pitch_sse2.c" />

-    <ClCompile Include="..\..\celt\x86\pitch_sse4_1.c" />

-    <ClCompile Include="..\..\celt\x86\vq_sse2.c" />

-    <ClCompile Include="..\..\celt\x86\x86cpu.c" />

-    <ClCompile Include="..\..\celt\x86\x86_celt_map.c" />

-    <ClCompile Include="..\..\silk\A2NLSF.c" />

-    <ClCompile Include="..\..\silk\ana_filt_bank_1.c" />

-    <ClCompile Include="..\..\silk\biquad_alt.c" />

-    <ClCompile Include="..\..\silk\bwexpander.c" />

-    <ClCompile Include="..\..\silk\bwexpander_32.c" />

-    <ClCompile Include="..\..\silk\check_control_input.c" />

-    <ClCompile Include="..\..\silk\CNG.c" />

-    <ClCompile Include="..\..\silk\code_signs.c" />

-    <ClCompile Include="..\..\silk\control_audio_bandwidth.c" />

-    <ClCompile Include="..\..\silk\control_codec.c" />

-    <ClCompile Include="..\..\silk\control_SNR.c" />

-    <ClCompile Include="..\..\silk\debug.c" />

-    <ClCompile Include="..\..\silk\decoder_set_fs.c" />

-    <ClCompile Include="..\..\silk\decode_core.c" />

-    <ClCompile Include="..\..\silk\decode_frame.c" />

-    <ClCompile Include="..\..\silk\decode_indices.c" />

-    <ClCompile Include="..\..\silk\decode_parameters.c" />

-    <ClCompile Include="..\..\silk\decode_pitch.c" />

-    <ClCompile Include="..\..\silk\decode_pulses.c" />

-    <ClCompile Include="..\..\silk\dec_API.c" />

-    <ClCompile Include="..\..\silk\encode_indices.c" />

-    <ClCompile Include="..\..\silk\encode_pulses.c" />

-    <ClCompile Include="..\..\silk\enc_API.c" />

-    <ClCompile Include="..\..\silk\gain_quant.c" />

-    <ClCompile Include="..\..\silk\HP_variable_cutoff.c" />

-    <ClCompile Include="..\..\silk\init_decoder.c" />

-    <ClCompile Include="..\..\silk\init_encoder.c" />

-    <ClCompile Include="..\..\silk\inner_prod_aligned.c" />

-    <ClCompile Include="..\..\silk\interpolate.c" />

-    <ClCompile Include="..\..\silk\lin2log.c" />

-    <ClCompile Include="..\..\silk\log2lin.c" />

-    <ClCompile Include="..\..\silk\LPC_analysis_filter.c" />

-    <ClCompile Include="..\..\silk\LPC_fit.c" />

-    <ClCompile Include="..\..\silk\LPC_inv_pred_gain.c" />

-    <ClCompile Include="..\..\silk\LP_variable_cutoff.c" />

-    <ClCompile Include="..\..\silk\NLSF2A.c" />

-    <ClCompile Include="..\..\silk\NLSF_decode.c" />

-    <ClCompile Include="..\..\silk\NLSF_del_dec_quant.c" />

-    <ClCompile Include="..\..\silk\NLSF_encode.c" />

-    <ClCompile Include="..\..\silk\NLSF_stabilize.c" />

-    <ClCompile Include="..\..\silk\NLSF_unpack.c" />

-    <ClCompile Include="..\..\silk\NLSF_VQ.c" />

-    <ClCompile Include="..\..\silk\NLSF_VQ_weights_laroia.c" />

-    <ClCompile Include="..\..\silk\NSQ.c" />

-    <ClCompile Include="..\..\silk\NSQ_del_dec.c" />

-    <ClCompile Include="..\..\silk\pitch_est_tables.c" />

-    <ClCompile Include="..\..\silk\PLC.c" />

-    <ClCompile Include="..\..\silk\process_NLSFs.c" />

-    <ClCompile Include="..\..\silk\quant_LTP_gains.c" />

-    <ClCompile Include="..\..\silk\resampler.c" />

-    <ClCompile Include="..\..\silk\resampler_down2.c" />

-    <ClCompile Include="..\..\silk\resampler_down2_3.c" />

-    <ClCompile Include="..\..\silk\resampler_private_AR2.c" />

-    <ClCompile Include="..\..\silk\resampler_private_down_FIR.c" />

-    <ClCompile Include="..\..\silk\resampler_private_IIR_FIR.c" />

-    <ClCompile Include="..\..\silk\resampler_private_up2_HQ.c" />

-    <ClCompile Include="..\..\silk\resampler_rom.c" />

-    <ClCompile Include="..\..\silk\shell_coder.c" />

-    <ClCompile Include="..\..\silk\sigm_Q15.c" />

-    <ClCompile Include="..\..\silk\sort.c" />

-    <ClCompile Include="..\..\silk\stereo_decode_pred.c" />

-    <ClCompile Include="..\..\silk\stereo_encode_pred.c" />

-    <ClCompile Include="..\..\silk\stereo_find_predictor.c" />

-    <ClCompile Include="..\..\silk\stereo_LR_to_MS.c" />

-    <ClCompile Include="..\..\silk\stereo_MS_to_LR.c" />

-    <ClCompile Include="..\..\silk\stereo_quant_pred.c" />

-    <ClCompile Include="..\..\silk\sum_sqr_shift.c" />

-    <ClCompile Include="..\..\silk\tables_gain.c" />

-    <ClCompile Include="..\..\silk\tables_LTP.c" />

-    <ClCompile Include="..\..\silk\tables_NLSF_CB_NB_MB.c" />

-    <ClCompile Include="..\..\silk\tables_NLSF_CB_WB.c" />

-    <ClCompile Include="..\..\silk\tables_other.c" />

-    <ClCompile Include="..\..\silk\tables_pitch_lag.c" />

-    <ClCompile Include="..\..\silk\tables_pulses_per_block.c" />

-    <ClCompile Include="..\..\silk\table_LSF_cos.c" />

-    <ClCompile Include="..\..\silk\VAD.c" />

-    <ClCompile Include="..\..\silk\VQ_WMat_EC.c" />

-    <ClCompile Include="..\..\silk\x86\NSQ_del_dec_sse4_1.c" />

-    <ClCompile Include="..\..\silk\x86\NSQ_sse4_1.c" />

-    <ClCompile Include="..\..\silk\x86\VAD_sse4_1.c" />

-    <ClCompile Include="..\..\silk\x86\VQ_WMat_EC_sse4_1.c" />

-    <ClCompile Include="..\..\silk\x86\x86_silk_map.c" />

-    <ClCompile Include="..\..\src\analysis.c" />

-    <ClCompile Include="..\..\src\mapping_matrix.c" />

-    <ClCompile Include="..\..\src\mlp.c" />

-    <ClCompile Include="..\..\src\mlp_data.c" />

-    <ClCompile Include="..\..\src\opus.c" />

-    <ClCompile Include="..\..\src\opus_compare.c">

-      <DisableSpecificWarnings>4244;%(DisableSpecificWarnings)</DisableSpecificWarnings>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_decoder.c" />

-    <ClCompile Include="..\..\src\opus_encoder.c" />

-    <ClCompile Include="..\..\src\opus_multistream.c" />

-    <ClCompile Include="..\..\src\opus_multistream_decoder.c" />

-    <ClCompile Include="..\..\src\opus_multistream_encoder.c" />

-    <ClCompile Include="..\..\src\opus_projection_decoder.c" />

-    <ClCompile Include="..\..\src\opus_projection_encoder.c" />

-    <ClCompile Include="..\..\src\repacketizer.c" />

-  </ItemGroup>

-  <Choose>

-    <When Condition="'$(Configuration)'=='DebugDLL_fixed' or '$(Configuration)'=='ReleaseDLL_fixed' or $(PreprocessorDefinitions.Contains('FIXED_POINT'))">

-      <ItemGroup>

-        <ClCompile Include="..\..\silk\fixed\*.c">

-          <ExcludedFromBuild>false</ExcludedFromBuild>

-        </ClCompile>

-        <ClCompile Include="..\..\silk\fixed\x86\*.c">

-          <ExcludedFromBuild>false</ExcludedFromBuild>

-        </ClCompile>

-        <ClCompile Include="..\..\silk\float\*.c">

-          <ExcludedFromBuild>true</ExcludedFromBuild>

-        </ClCompile>

-      </ItemGroup>

-    </When>

-    <Otherwise>

-      <ItemGroup>

-        <ClCompile Include="..\..\silk\fixed\*.c">

-          <ExcludedFromBuild>true</ExcludedFromBuild>

-        </ClCompile>

-        <ClCompile Include="..\..\silk\fixed\x86\*.c">

-          <ExcludedFromBuild>true</ExcludedFromBuild>

-        </ClCompile>

-        <ClCompile Include="..\..\silk\float\*.c">

-          <ExcludedFromBuild>false</ExcludedFromBuild>

-        </ClCompile>

-      </ItemGroup>

-    </Otherwise>

-  </Choose>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

-  <ImportGroup Label="ExtensionTargets">

-  </ImportGroup>

-</Project>

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="DebugDLL_fixed|Win32">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL_fixed|x64">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|Win32">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|x64">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|Win32">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|x64">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <Keyword>Win32Proj</Keyword>
+    <ProjectName>opus</ProjectName>
+    <ProjectGuid>{219EC965-228A-1824-174D-96449D05F88A}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\silk\fixed;..\..\silk\float;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions Condition="'$(ConfigurationType)'=='DynamicLibrary'">DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions Condition="'$(Configuration)'=='DebugDLL_fixed' or '$(Configuration)'=='ReleaseDLL_fixed'">FIXED_POINT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions Condition="'$(Platform)'=='Win32'">/arch:IA32 %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Lib>
+      <AdditionalOptions>/ignore:4221 %(AdditionalOptions)</AdditionalOptions>
+    </Lib>
+    <PreBuildEvent>
+      <Command>"$(ProjectDir)..\..\win32\genversion.bat" "$(ProjectDir)..\..\win32\version.h" PACKAGE_VERSION</Command>
+      <Message>Generating version.h</Message>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\celt\arch.h" />
+    <ClInclude Include="..\..\celt\bands.h" />
+    <ClInclude Include="..\..\celt\celt.h" />
+    <ClInclude Include="..\..\celt\celt_lpc.h" />
+    <ClInclude Include="..\..\celt\cwrs.h" />
+    <ClInclude Include="..\..\celt\ecintrin.h" />
+    <ClInclude Include="..\..\celt\entcode.h" />
+    <ClInclude Include="..\..\celt\entdec.h" />
+    <ClInclude Include="..\..\celt\entenc.h" />
+    <ClInclude Include="..\..\celt\fixed_c5x.h" />
+    <ClInclude Include="..\..\celt\fixed_c6x.h" />
+    <ClInclude Include="..\..\celt\fixed_debug.h" />
+    <ClInclude Include="..\..\celt\fixed_generic.h" />
+    <ClInclude Include="..\..\celt\float_cast.h" />
+    <ClInclude Include="..\..\celt\kiss_fft.h" />
+    <ClInclude Include="..\..\celt\laplace.h" />
+    <ClInclude Include="..\..\celt\mathops.h" />
+    <ClInclude Include="..\..\celt\mdct.h" />
+    <ClInclude Include="..\..\celt\mfrngcod.h" />
+    <ClInclude Include="..\..\celt\modes.h" />
+    <ClInclude Include="..\..\celt\os_support.h" />
+    <ClInclude Include="..\..\celt\pitch.h" />
+    <ClInclude Include="..\..\celt\quant_bands.h" />
+    <ClInclude Include="..\..\celt\rate.h" />
+    <ClInclude Include="..\..\celt\stack_alloc.h" />
+    <ClInclude Include="..\..\celt\static_modes_fixed.h" />
+    <ClInclude Include="..\..\celt\static_modes_float.h" />
+    <ClInclude Include="..\..\celt\vq.h" />
+    <ClInclude Include="..\..\celt\x86\celt_lpc_sse.h" />
+    <ClInclude Include="..\..\celt\x86\pitch_sse.h" />
+    <ClInclude Include="..\..\celt\x86\vq_sse.h" />
+    <ClInclude Include="..\..\celt\x86\x86cpu.h" />
+    <ClInclude Include="..\..\celt\_kiss_fft_guts.h" />
+    <ClInclude Include="..\..\include\opus.h" />
+    <ClInclude Include="..\..\include\opus_defines.h" />
+    <ClInclude Include="..\..\include\opus_types.h" />
+    <ClInclude Include="..\..\include\opus_multistream.h" />
+    <ClInclude Include="..\..\include\opus_projection.h" />
+    <ClInclude Include="..\..\silk\API.h" />
+    <ClInclude Include="..\..\silk\control.h" />
+    <ClInclude Include="..\..\silk\debug.h" />
+    <ClInclude Include="..\..\silk\define.h" />
+    <ClInclude Include="..\..\silk\errors.h" />
+    <ClInclude Include="..\..\silk\float\main_FLP.h" />
+    <ClInclude Include="..\..\silk\float\SigProc_FLP.h" />
+    <ClInclude Include="..\..\silk\float\structs_FLP.h" />
+    <ClInclude Include="..\..\silk\Inlines.h" />
+    <ClInclude Include="..\..\silk\MacroCount.h" />
+    <ClInclude Include="..\..\silk\MacroDebug.h" />
+    <ClInclude Include="..\..\silk\macros.h" />
+    <ClInclude Include="..\..\silk\main.h" />
+    <ClInclude Include="..\..\silk\pitch_est_defines.h" />
+    <ClInclude Include="..\..\silk\PLC.h" />
+    <ClInclude Include="..\..\silk\resampler_private.h" />
+    <ClInclude Include="..\..\silk\resampler_rom.h" />
+    <ClInclude Include="..\..\silk\resampler_structs.h" />
+    <ClInclude Include="..\..\silk\structs.h" />
+    <ClInclude Include="..\..\silk\tables.h" />
+    <ClInclude Include="..\..\silk\tuning_parameters.h" />
+    <ClInclude Include="..\..\silk\typedef.h" />
+    <ClInclude Include="..\..\silk\x86\main_sse.h" />
+    <ClInclude Include="..\..\win32\config.h" />
+    <ClInclude Include="..\..\src\analysis.h" />
+    <ClInclude Include="..\..\src\mapping_matrix.h" />
+    <ClInclude Include="..\..\src\mlp.h" />
+    <ClInclude Include="..\..\src\opus_private.h" />
+    <ClInclude Include="..\..\src\tansig_table.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\celt\bands.c" />
+    <ClCompile Include="..\..\celt\celt.c" />
+    <ClCompile Include="..\..\celt\celt_decoder.c" />
+    <ClCompile Include="..\..\celt\celt_encoder.c" />
+    <ClCompile Include="..\..\celt\celt_lpc.c" />
+    <ClCompile Include="..\..\celt\cwrs.c" />
+    <ClCompile Include="..\..\celt\entcode.c" />
+    <ClCompile Include="..\..\celt\entdec.c" />
+    <ClCompile Include="..\..\celt\entenc.c" />
+    <ClCompile Include="..\..\celt\kiss_fft.c" />
+    <ClCompile Include="..\..\celt\laplace.c" />
+    <ClCompile Include="..\..\celt\mathops.c" />
+    <ClCompile Include="..\..\celt\mdct.c" />
+    <ClCompile Include="..\..\celt\modes.c" />
+    <ClCompile Include="..\..\celt\pitch.c" />
+    <ClCompile Include="..\..\celt\quant_bands.c" />
+    <ClCompile Include="..\..\celt\rate.c" />
+    <ClCompile Include="..\..\celt\vq.c" />
+    <ClCompile Include="..\..\celt\x86\celt_lpc_sse4_1.c" />
+    <ClCompile Include="..\..\celt\x86\pitch_sse.c" />
+    <ClCompile Include="..\..\celt\x86\pitch_sse2.c" />
+    <ClCompile Include="..\..\celt\x86\pitch_sse4_1.c" />
+    <ClCompile Include="..\..\celt\x86\vq_sse2.c" />
+    <ClCompile Include="..\..\celt\x86\x86cpu.c" />
+    <ClCompile Include="..\..\celt\x86\x86_celt_map.c" />
+    <ClCompile Include="..\..\silk\A2NLSF.c" />
+    <ClCompile Include="..\..\silk\ana_filt_bank_1.c" />
+    <ClCompile Include="..\..\silk\biquad_alt.c" />
+    <ClCompile Include="..\..\silk\bwexpander.c" />
+    <ClCompile Include="..\..\silk\bwexpander_32.c" />
+    <ClCompile Include="..\..\silk\check_control_input.c" />
+    <ClCompile Include="..\..\silk\CNG.c" />
+    <ClCompile Include="..\..\silk\code_signs.c" />
+    <ClCompile Include="..\..\silk\control_audio_bandwidth.c" />
+    <ClCompile Include="..\..\silk\control_codec.c" />
+    <ClCompile Include="..\..\silk\control_SNR.c" />
+    <ClCompile Include="..\..\silk\debug.c" />
+    <ClCompile Include="..\..\silk\decoder_set_fs.c" />
+    <ClCompile Include="..\..\silk\decode_core.c" />
+    <ClCompile Include="..\..\silk\decode_frame.c" />
+    <ClCompile Include="..\..\silk\decode_indices.c" />
+    <ClCompile Include="..\..\silk\decode_parameters.c" />
+    <ClCompile Include="..\..\silk\decode_pitch.c" />
+    <ClCompile Include="..\..\silk\decode_pulses.c" />
+    <ClCompile Include="..\..\silk\dec_API.c" />
+    <ClCompile Include="..\..\silk\encode_indices.c" />
+    <ClCompile Include="..\..\silk\encode_pulses.c" />
+    <ClCompile Include="..\..\silk\enc_API.c" />
+    <ClCompile Include="..\..\silk\gain_quant.c" />
+    <ClCompile Include="..\..\silk\HP_variable_cutoff.c" />
+    <ClCompile Include="..\..\silk\init_decoder.c" />
+    <ClCompile Include="..\..\silk\init_encoder.c" />
+    <ClCompile Include="..\..\silk\inner_prod_aligned.c" />
+    <ClCompile Include="..\..\silk\interpolate.c" />
+    <ClCompile Include="..\..\silk\lin2log.c" />
+    <ClCompile Include="..\..\silk\log2lin.c" />
+    <ClCompile Include="..\..\silk\LPC_analysis_filter.c" />
+    <ClCompile Include="..\..\silk\LPC_fit.c" />
+    <ClCompile Include="..\..\silk\LPC_inv_pred_gain.c" />
+    <ClCompile Include="..\..\silk\LP_variable_cutoff.c" />
+    <ClCompile Include="..\..\silk\NLSF2A.c" />
+    <ClCompile Include="..\..\silk\NLSF_decode.c" />
+    <ClCompile Include="..\..\silk\NLSF_del_dec_quant.c" />
+    <ClCompile Include="..\..\silk\NLSF_encode.c" />
+    <ClCompile Include="..\..\silk\NLSF_stabilize.c" />
+    <ClCompile Include="..\..\silk\NLSF_unpack.c" />
+    <ClCompile Include="..\..\silk\NLSF_VQ.c" />
+    <ClCompile Include="..\..\silk\NLSF_VQ_weights_laroia.c" />
+    <ClCompile Include="..\..\silk\NSQ.c" />
+    <ClCompile Include="..\..\silk\NSQ_del_dec.c" />
+    <ClCompile Include="..\..\silk\pitch_est_tables.c" />
+    <ClCompile Include="..\..\silk\PLC.c" />
+    <ClCompile Include="..\..\silk\process_NLSFs.c" />
+    <ClCompile Include="..\..\silk\quant_LTP_gains.c" />
+    <ClCompile Include="..\..\silk\resampler.c" />
+    <ClCompile Include="..\..\silk\resampler_down2.c" />
+    <ClCompile Include="..\..\silk\resampler_down2_3.c" />
+    <ClCompile Include="..\..\silk\resampler_private_AR2.c" />
+    <ClCompile Include="..\..\silk\resampler_private_down_FIR.c" />
+    <ClCompile Include="..\..\silk\resampler_private_IIR_FIR.c" />
+    <ClCompile Include="..\..\silk\resampler_private_up2_HQ.c" />
+    <ClCompile Include="..\..\silk\resampler_rom.c" />
+    <ClCompile Include="..\..\silk\shell_coder.c" />
+    <ClCompile Include="..\..\silk\sigm_Q15.c" />
+    <ClCompile Include="..\..\silk\sort.c" />
+    <ClCompile Include="..\..\silk\stereo_decode_pred.c" />
+    <ClCompile Include="..\..\silk\stereo_encode_pred.c" />
+    <ClCompile Include="..\..\silk\stereo_find_predictor.c" />
+    <ClCompile Include="..\..\silk\stereo_LR_to_MS.c" />
+    <ClCompile Include="..\..\silk\stereo_MS_to_LR.c" />
+    <ClCompile Include="..\..\silk\stereo_quant_pred.c" />
+    <ClCompile Include="..\..\silk\sum_sqr_shift.c" />
+    <ClCompile Include="..\..\silk\tables_gain.c" />
+    <ClCompile Include="..\..\silk\tables_LTP.c" />
+    <ClCompile Include="..\..\silk\tables_NLSF_CB_NB_MB.c" />
+    <ClCompile Include="..\..\silk\tables_NLSF_CB_WB.c" />
+    <ClCompile Include="..\..\silk\tables_other.c" />
+    <ClCompile Include="..\..\silk\tables_pitch_lag.c" />
+    <ClCompile Include="..\..\silk\tables_pulses_per_block.c" />
+    <ClCompile Include="..\..\silk\table_LSF_cos.c" />
+    <ClCompile Include="..\..\silk\VAD.c" />
+    <ClCompile Include="..\..\silk\VQ_WMat_EC.c" />
+    <ClCompile Include="..\..\silk\x86\NSQ_del_dec_sse4_1.c" />
+    <ClCompile Include="..\..\silk\x86\NSQ_sse4_1.c" />
+    <ClCompile Include="..\..\silk\x86\VAD_sse4_1.c" />
+    <ClCompile Include="..\..\silk\x86\VQ_WMat_EC_sse4_1.c" />
+    <ClCompile Include="..\..\silk\x86\x86_silk_map.c" />
+    <ClCompile Include="..\..\src\analysis.c" />
+    <ClCompile Include="..\..\src\mapping_matrix.c" />
+    <ClCompile Include="..\..\src\mlp.c" />
+    <ClCompile Include="..\..\src\mlp_data.c" />
+    <ClCompile Include="..\..\src\opus.c" />
+    <ClCompile Include="..\..\src\opus_compare.c">
+      <DisableSpecificWarnings>4244;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_decoder.c" />
+    <ClCompile Include="..\..\src\opus_encoder.c" />
+    <ClCompile Include="..\..\src\opus_multistream.c" />
+    <ClCompile Include="..\..\src\opus_multistream_decoder.c" />
+    <ClCompile Include="..\..\src\opus_multistream_encoder.c" />
+    <ClCompile Include="..\..\src\opus_projection_decoder.c" />
+    <ClCompile Include="..\..\src\opus_projection_encoder.c" />
+    <ClCompile Include="..\..\src\repacketizer.c" />
+  </ItemGroup>
+  <Choose>
+    <When Condition="'$(Configuration)'=='DebugDLL_fixed' or '$(Configuration)'=='ReleaseDLL_fixed' or $(PreprocessorDefinitions.Contains('FIXED_POINT'))">
+      <ItemGroup>
+        <ClCompile Include="..\..\silk\fixed\*.c">
+          <ExcludedFromBuild>false</ExcludedFromBuild>
+        </ClCompile>
+        <ClCompile Include="..\..\silk\fixed\x86\*.c">
+          <ExcludedFromBuild>false</ExcludedFromBuild>
+        </ClCompile>
+        <ClCompile Include="..\..\silk\float\*.c">
+          <ExcludedFromBuild>true</ExcludedFromBuild>
+        </ClCompile>
+      </ItemGroup>
+    </When>
+    <Otherwise>
+      <ItemGroup>
+        <ClCompile Include="..\..\silk\fixed\*.c">
+          <ExcludedFromBuild>true</ExcludedFromBuild>
+        </ClCompile>
+        <ClCompile Include="..\..\silk\fixed\x86\*.c">
+          <ExcludedFromBuild>true</ExcludedFromBuild>
+        </ClCompile>
+        <ClCompile Include="..\..\silk\float\*.c">
+          <ExcludedFromBuild>false</ExcludedFromBuild>
+        </ClCompile>
+      </ItemGroup>
+    </Otherwise>
+  </Choose>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/win32/VS2015/opus.vcxproj.filters b/win32/VS2015/opus.vcxproj.filters
index d59c7563..8c61d6a0 100644
--- a/win32/VS2015/opus.vcxproj.filters
+++ b/win32/VS2015/opus.vcxproj.filters
@@ -1,585 +1,585 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup>

-    <Filter Include="Source Files">

-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>

-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

-    </Filter>

-    <Filter Include="Header Files">

-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>

-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>

-    </Filter>

-    <Filter Include="Resource Files">

-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>

-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>

-    </Filter>

-  </ItemGroup>

-  <ItemGroup>

-    <ClInclude Include="..\..\celt\arch.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\celt.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\entdec.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\entenc.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\float_cast.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\os_support.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\stack_alloc.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\include\opus.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\include\opus_defines.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\include\opus_types.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\include\opus_multistream.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\include\opus_projection.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\win32\config.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\src\analysis.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\src\mapping_matrix.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\src\mlp.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\src\opus_private.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\src\tansig_table.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\x86\x86cpu.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\_kiss_fft_guts.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\bands.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\celt_lpc.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\x86\celt_lpc_sse.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\cwrs.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\ecintrin.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\entcode.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\fixed_c5x.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\fixed_c6x.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\fixed_debug.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\fixed_generic.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\kiss_fft.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\laplace.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\mathops.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\mdct.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\mfrngcod.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\modes.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\pitch.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\x86\pitch_sse.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\quant_bands.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\rate.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\static_modes_fixed.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\static_modes_float.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\vq.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\typedef.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\API.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\control.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\debug.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\define.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\errors.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\Inlines.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\MacroCount.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\MacroDebug.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\macros.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\main.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\x86\main_sse.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\pitch_est_defines.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\PLC.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\resampler_private.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\resampler_rom.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\resampler_structs.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\structs.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\tables.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\tuning_parameters.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\float\main_FLP.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\float\SigProc_FLP.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\silk\float\structs_FLP.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-    <ClInclude Include="..\..\celt\x86\vq_sse.h">

-      <Filter>Header Files</Filter>

-    </ClInclude>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\src\analysis.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\bands.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\celt.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\celt_decoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\celt_encoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\celt_lpc.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\x86\celt_lpc_sse4_1.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\cwrs.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\entcode.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\entdec.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\entenc.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\kiss_fft.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\laplace.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\mapping_matrix.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\mathops.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\mdct.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\mlp.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\mlp_data.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\modes.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_compare.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_decoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_encoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_multistream.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_multistream_decoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_multistream_encoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_projection_decoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\opus_projection_encoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\pitch.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\x86\pitch_sse.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\x86\pitch_sse2.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\x86\pitch_sse4_1.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\quant_bands.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\rate.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\src\repacketizer.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\vq.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\x86\x86_celt_map.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\x86\x86cpu.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\A2NLSF.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\ana_filt_bank_1.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\biquad_alt.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\bwexpander.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\bwexpander_32.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\check_control_input.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\CNG.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\code_signs.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\control_audio_bandwidth.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\control_codec.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\control_SNR.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\debug.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\dec_API.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\decode_core.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\decode_frame.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\decode_indices.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\decode_parameters.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\decode_pitch.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\decode_pulses.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\decoder_set_fs.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\enc_API.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\encode_indices.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\encode_pulses.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\gain_quant.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\HP_variable_cutoff.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\init_decoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\init_encoder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\inner_prod_aligned.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\interpolate.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\lin2log.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\log2lin.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\LP_variable_cutoff.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\LPC_analysis_filter.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\LPC_inv_pred_gain.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF_decode.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF_del_dec_quant.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF_encode.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF_stabilize.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF_unpack.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF_VQ.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF_VQ_weights_laroia.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NLSF2A.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NSQ.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\NSQ_del_dec.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\x86\NSQ_del_dec_sse4_1.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\x86\NSQ_sse4_1.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\pitch_est_tables.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\PLC.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\process_NLSFs.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\quant_LTP_gains.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler_down2.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler_down2_3.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler_private_AR2.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler_private_down_FIR.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler_private_IIR_FIR.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler_private_up2_HQ.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\resampler_rom.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\shell_coder.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\sigm_Q15.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\sort.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\stereo_decode_pred.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\stereo_encode_pred.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\stereo_find_predictor.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\stereo_LR_to_MS.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\stereo_MS_to_LR.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\stereo_quant_pred.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\sum_sqr_shift.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\table_LSF_cos.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\tables_gain.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\tables_LTP.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\tables_NLSF_CB_NB_MB.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\tables_NLSF_CB_WB.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\tables_other.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\tables_pitch_lag.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\tables_pulses_per_block.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\VAD.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\x86\VAD_sse4_1.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\VQ_WMat_EC.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\x86\VQ_WMat_EC_sse4_1.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\x86\x86_silk_map.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\silk\LPC_fit.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\celt\x86\vq_sse2.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-  </ItemGroup>

-</Project>

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\celt\arch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\celt.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\entdec.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\entenc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\float_cast.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\os_support.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\stack_alloc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\opus.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\opus_defines.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\opus_types.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\opus_multistream.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\opus_projection.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\win32\config.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\analysis.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mapping_matrix.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mlp.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\opus_private.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\tansig_table.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\x86\x86cpu.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\_kiss_fft_guts.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\bands.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\celt_lpc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\x86\celt_lpc_sse.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\cwrs.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\ecintrin.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\entcode.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\fixed_c5x.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\fixed_c6x.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\fixed_debug.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\fixed_generic.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\kiss_fft.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\laplace.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\mathops.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\mdct.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\mfrngcod.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\modes.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\pitch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\x86\pitch_sse.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\quant_bands.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\rate.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\static_modes_fixed.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\static_modes_float.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\vq.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\typedef.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\API.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\control.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\debug.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\define.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\errors.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\Inlines.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\MacroCount.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\MacroDebug.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\macros.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\main.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\x86\main_sse.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\pitch_est_defines.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\PLC.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\resampler_private.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\resampler_rom.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\resampler_structs.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\structs.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\tables.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\tuning_parameters.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\float\main_FLP.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\float\SigProc_FLP.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\silk\float\structs_FLP.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\celt\x86\vq_sse.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\analysis.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\bands.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\celt.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\celt_decoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\celt_encoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\celt_lpc.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\x86\celt_lpc_sse4_1.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\cwrs.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\entcode.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\entdec.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\entenc.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\kiss_fft.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\laplace.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\mapping_matrix.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\mathops.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\mdct.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\mlp.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\mlp_data.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\modes.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_compare.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_decoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_encoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_multistream.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_multistream_decoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_multistream_encoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_projection_decoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\opus_projection_encoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\pitch.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\x86\pitch_sse.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\x86\pitch_sse2.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\x86\pitch_sse4_1.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\quant_bands.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\rate.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\repacketizer.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\vq.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\x86\x86_celt_map.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\x86\x86cpu.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\A2NLSF.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\ana_filt_bank_1.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\biquad_alt.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\bwexpander.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\bwexpander_32.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\check_control_input.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\CNG.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\code_signs.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\control_audio_bandwidth.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\control_codec.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\control_SNR.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\debug.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\dec_API.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\decode_core.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\decode_frame.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\decode_indices.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\decode_parameters.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\decode_pitch.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\decode_pulses.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\decoder_set_fs.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\enc_API.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\encode_indices.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\encode_pulses.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\gain_quant.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\HP_variable_cutoff.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\init_decoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\init_encoder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\inner_prod_aligned.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\interpolate.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\lin2log.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\log2lin.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\LP_variable_cutoff.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\LPC_analysis_filter.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\LPC_inv_pred_gain.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF_decode.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF_del_dec_quant.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF_encode.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF_stabilize.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF_unpack.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF_VQ.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF_VQ_weights_laroia.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NLSF2A.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NSQ.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\NSQ_del_dec.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\x86\NSQ_del_dec_sse4_1.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\x86\NSQ_sse4_1.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\pitch_est_tables.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\PLC.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\process_NLSFs.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\quant_LTP_gains.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler_down2.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler_down2_3.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler_private_AR2.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler_private_down_FIR.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler_private_IIR_FIR.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler_private_up2_HQ.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\resampler_rom.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\shell_coder.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\sigm_Q15.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\sort.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\stereo_decode_pred.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\stereo_encode_pred.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\stereo_find_predictor.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\stereo_LR_to_MS.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\stereo_MS_to_LR.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\stereo_quant_pred.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\sum_sqr_shift.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\table_LSF_cos.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\tables_gain.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\tables_LTP.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\tables_NLSF_CB_NB_MB.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\tables_NLSF_CB_WB.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\tables_other.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\tables_pitch_lag.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\tables_pulses_per_block.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\VAD.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\x86\VAD_sse4_1.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\VQ_WMat_EC.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\x86\VQ_WMat_EC_sse4_1.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\x86\x86_silk_map.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\silk\LPC_fit.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\celt\x86\vq_sse2.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
diff --git a/win32/VS2015/opus_demo.vcxproj b/win32/VS2015/opus_demo.vcxproj
index 9860bf93..f4344e53 100644
--- a/win32/VS2015/opus_demo.vcxproj
+++ b/win32/VS2015/opus_demo.vcxproj
@@ -1,171 +1,171 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup Label="ProjectConfigurations">

-    <ProjectConfiguration Include="DebugDLL_fixed|Win32">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL_fixed|x64">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|Win32">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|x64">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|Win32">

-      <Configuration>Debug</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|x64">

-      <Configuration>Debug</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|Win32">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|x64">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|Win32">

-      <Configuration>Release</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|x64">

-      <Configuration>Release</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-  </ItemGroup>

-  <ItemGroup>

-    <ProjectReference Include="opus.vcxproj">

-      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>

-    </ProjectReference>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\src\opus_demo.c" />

-  </ItemGroup>

-  <PropertyGroup Label="Globals">

-    <ProjectGuid>{016C739D-6389-43BF-8D88-24B2BF6F620F}</ProjectGuid>

-    <Keyword>Win32Proj</Keyword>

-    <RootNamespace>opus_demo</RootNamespace>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

-  <ImportGroup Label="ExtensionSettings">

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <PropertyGroup Label="UserMacros" />

-  <ItemDefinitionGroup />

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

-  <ImportGroup Label="ExtensionTargets">

-  </ImportGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="DebugDLL_fixed|Win32">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL_fixed|x64">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|Win32">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|x64">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|Win32">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|x64">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="opus.vcxproj">
+      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\opus_demo.c" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{016C739D-6389-43BF-8D88-24B2BF6F620F}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>opus_demo</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/opus_demo.vcxproj.filters b/win32/VS2015/opus_demo.vcxproj.filters
index dbcc8ae9..2eb113ac 100644
--- a/win32/VS2015/opus_demo.vcxproj.filters
+++ b/win32/VS2015/opus_demo.vcxproj.filters
@@ -1,22 +1,22 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup>

-    <Filter Include="Source Files">

-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>

-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

-    </Filter>

-    <Filter Include="Header Files">

-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>

-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>

-    </Filter>

-    <Filter Include="Resource Files">

-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>

-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>

-    </Filter>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\src\opus_demo.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-  </ItemGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\opus_demo.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/test_opus_api.vcxproj b/win32/VS2015/test_opus_api.vcxproj
index c6abf88e..7cae131b 100644
--- a/win32/VS2015/test_opus_api.vcxproj
+++ b/win32/VS2015/test_opus_api.vcxproj
@@ -1,171 +1,171 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup Label="ProjectConfigurations">

-    <ProjectConfiguration Include="DebugDLL_fixed|Win32">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL_fixed|x64">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|Win32">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|x64">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|Win32">

-      <Configuration>Debug</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|x64">

-      <Configuration>Debug</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|Win32">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|x64">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|Win32">

-      <Configuration>Release</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|x64">

-      <Configuration>Release</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\tests\test_opus_api.c" />

-  </ItemGroup>

-  <ItemGroup>

-    <ProjectReference Include="opus.vcxproj">

-      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>

-    </ProjectReference>

-  </ItemGroup>

-  <PropertyGroup Label="Globals">

-    <ProjectGuid>{1D257A17-D254-42E5-82D6-1C87A6EC775A}</ProjectGuid>

-    <Keyword>Win32Proj</Keyword>

-    <RootNamespace>test_opus_api</RootNamespace>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

-  <ImportGroup Label="ExtensionSettings">

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <PropertyGroup Label="UserMacros" />

-  <ItemDefinitionGroup />

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

-  <ImportGroup Label="ExtensionTargets">

-  </ImportGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="DebugDLL_fixed|Win32">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL_fixed|x64">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|Win32">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|x64">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|Win32">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|x64">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\tests\test_opus_api.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="opus.vcxproj">
+      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{1D257A17-D254-42E5-82D6-1C87A6EC775A}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>test_opus_api</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/test_opus_api.vcxproj.filters b/win32/VS2015/test_opus_api.vcxproj.filters
index 070c8ab0..383d19f7 100644
--- a/win32/VS2015/test_opus_api.vcxproj.filters
+++ b/win32/VS2015/test_opus_api.vcxproj.filters
@@ -1,14 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup>

-    <Filter Include="Source Files">

-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>

-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

-    </Filter>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\tests\test_opus_api.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-  </ItemGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\tests\test_opus_api.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/test_opus_decode.vcxproj b/win32/VS2015/test_opus_decode.vcxproj
index 9db09b8d..df01dca1 100644
--- a/win32/VS2015/test_opus_decode.vcxproj
+++ b/win32/VS2015/test_opus_decode.vcxproj
@@ -1,171 +1,171 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup Label="ProjectConfigurations">

-    <ProjectConfiguration Include="DebugDLL_fixed|Win32">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL_fixed|x64">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|Win32">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|x64">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|Win32">

-      <Configuration>Debug</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|x64">

-      <Configuration>Debug</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|Win32">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|x64">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|Win32">

-      <Configuration>Release</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|x64">

-      <Configuration>Release</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\tests\test_opus_decode.c" />

-  </ItemGroup>

-  <ItemGroup>

-    <ProjectReference Include="opus.vcxproj">

-      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>

-    </ProjectReference>

-  </ItemGroup>

-  <PropertyGroup Label="Globals">

-    <ProjectGuid>{8578322A-1883-486B-B6FA-E0094B65C9F2}</ProjectGuid>

-    <Keyword>Win32Proj</Keyword>

-    <RootNamespace>test_opus_api</RootNamespace>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

-  <ImportGroup Label="ExtensionSettings">

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <PropertyGroup Label="UserMacros" />

-  <ItemDefinitionGroup />

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

-  <ImportGroup Label="ExtensionTargets">

-  </ImportGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="DebugDLL_fixed|Win32">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL_fixed|x64">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|Win32">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|x64">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|Win32">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|x64">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\tests\test_opus_decode.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="opus.vcxproj">
+      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8578322A-1883-486B-B6FA-E0094B65C9F2}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>test_opus_api</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/test_opus_decode.vcxproj.filters b/win32/VS2015/test_opus_decode.vcxproj.filters
index 588637e8..3036a4e7 100644
--- a/win32/VS2015/test_opus_decode.vcxproj.filters
+++ b/win32/VS2015/test_opus_decode.vcxproj.filters
@@ -1,14 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup>

-    <Filter Include="Source Files">

-      <UniqueIdentifier>{4a0dd677-931f-4728-afe5-b761149fc7eb}</UniqueIdentifier>

-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

-    </Filter>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\tests\test_opus_decode.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-  </ItemGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4a0dd677-931f-4728-afe5-b761149fc7eb}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\tests\test_opus_decode.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/test_opus_encode.vcxproj b/win32/VS2015/test_opus_encode.vcxproj
index b10eaf21..405efee9 100644
--- a/win32/VS2015/test_opus_encode.vcxproj
+++ b/win32/VS2015/test_opus_encode.vcxproj
@@ -1,172 +1,172 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup Label="ProjectConfigurations">

-    <ProjectConfiguration Include="DebugDLL_fixed|Win32">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL_fixed|x64">

-      <Configuration>DebugDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|Win32">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="DebugDLL|x64">

-      <Configuration>DebugDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|Win32">

-      <Configuration>Debug</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Debug|x64">

-      <Configuration>Debug</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">

-      <Configuration>ReleaseDLL_fixed</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|Win32">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="ReleaseDLL|x64">

-      <Configuration>ReleaseDLL</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|Win32">

-      <Configuration>Release</Configuration>

-      <Platform>Win32</Platform>

-    </ProjectConfiguration>

-    <ProjectConfiguration Include="Release|x64">

-      <Configuration>Release</Configuration>

-      <Platform>x64</Platform>

-    </ProjectConfiguration>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\tests\opus_encode_regressions.c" />

-    <ClCompile Include="..\..\tests\test_opus_encode.c" />

-  </ItemGroup>

-  <ItemGroup>

-    <ProjectReference Include="opus.vcxproj">

-      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>

-    </ProjectReference>

-  </ItemGroup>

-  <PropertyGroup Label="Globals">

-    <ProjectGuid>{84DAA768-1A38-4312-BB61-4C78BB59E5B8}</ProjectGuid>

-    <Keyword>Win32Proj</Keyword>

-    <RootNamespace>test_opus_api</RootNamespace>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">

-    <ConfigurationType>Application</ConfigurationType>

-    <PlatformToolset>v140</PlatformToolset>

-  </PropertyGroup>

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

-  <ImportGroup Label="ExtensionSettings">

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">

-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

-    <Import Project="common.props" />

-  </ImportGroup>

-  <PropertyGroup Label="UserMacros" />

-  <ItemDefinitionGroup />

-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

-  <ImportGroup Label="ExtensionTargets">

-  </ImportGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="DebugDLL_fixed|Win32">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL_fixed|x64">
+      <Configuration>DebugDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|Win32">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="DebugDLL|x64">
+      <Configuration>DebugDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|Win32">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL_fixed|x64">
+      <Configuration>ReleaseDLL_fixed</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|Win32">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="ReleaseDLL|x64">
+      <Configuration>ReleaseDLL</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\tests\opus_encode_regressions.c" />
+    <ClCompile Include="..\..\tests\test_opus_encode.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="opus.vcxproj">
+      <Project>{219ec965-228a-1824-174d-96449d05f88a}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{84DAA768-1A38-4312-BB61-4C78BB59E5B8}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>test_opus_api</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='DebugDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseDLL_fixed|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup />
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/VS2015/test_opus_encode.vcxproj.filters b/win32/VS2015/test_opus_encode.vcxproj.filters
index f0477638..4ed3bb9e 100644
--- a/win32/VS2015/test_opus_encode.vcxproj.filters
+++ b/win32/VS2015/test_opus_encode.vcxproj.filters
@@ -1,17 +1,17 @@
-<?xml version="1.0" encoding="utf-8"?>

-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

-  <ItemGroup>

-    <Filter Include="Source Files">

-      <UniqueIdentifier>{546c8d9a-103e-4f78-972b-b44e8d3c8aba}</UniqueIdentifier>

-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

-    </Filter>

-  </ItemGroup>

-  <ItemGroup>

-    <ClCompile Include="..\..\tests\test_opus_encode.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-    <ClCompile Include="..\..\tests\opus_encode_regressions.c">

-      <Filter>Source Files</Filter>

-    </ClCompile>

-  </ItemGroup>

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{546c8d9a-103e-4f78-972b-b44e8d3c8aba}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\tests\test_opus_encode.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\tests\opus_encode_regressions.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/win32/genversion.bat b/win32/genversion.bat
index aea55739..1def7460 100644
--- a/win32/genversion.bat
+++ b/win32/genversion.bat
@@ -1,37 +1,37 @@
-@echo off

-

-setlocal enableextensions enabledelayedexpansion

-

-for /f %%v in ('cd "%~dp0.." ^&^& git status ^>NUL 2^>NUL ^&^& git describe --tags --match "v*" --dirty 2^>NUL') do set version=%%v

-

-if not "%version%"=="" set version=!version:~1! && goto :gotversion

-

-if exist "%~dp0..\package_version" goto :getversion

-

-echo Git cannot be found, nor can package_version. Generating unknown version.

-

-set version=unknown

-

-goto :gotversion

-

-:getversion

-

-for /f "delims== tokens=2" %%v in (%~dps0..\package_version) do set version=%%v

-set version=!version:"=!

-

-:gotversion

-

-set version=!version: =!

-set version_out=#define %~2 "%version%"

-

-echo %version_out%> "%~1_temp"

-

-echo n | comp "%~1_temp" "%~1" > NUL 2> NUL

-

-if not errorlevel 1 goto exit

-

-copy /y "%~1_temp" "%~1"

-

-:exit

-

-del "%~1_temp"

+@echo off
+
+setlocal enableextensions enabledelayedexpansion
+
+for /f %%v in ('cd "%~dp0.." ^&^& git status ^>NUL 2^>NUL ^&^& git describe --tags --match "v*" --dirty 2^>NUL') do set version=%%v
+
+if not "%version%"=="" set version=!version:~1! && goto :gotversion
+
+if exist "%~dp0..\package_version" goto :getversion
+
+echo Git cannot be found, nor can package_version. Generating unknown version.
+
+set version=unknown
+
+goto :gotversion
+
+:getversion
+
+for /f "delims== tokens=2" %%v in (%~dps0..\package_version) do set version=%%v
+set version=!version:"=!
+
+:gotversion
+
+set version=!version: =!
+set version_out=#define %~2 "%version%"
+
+echo %version_out%> "%~1_temp"
+
+echo n | comp "%~1_temp" "%~1" > NUL 2> NUL
+
+if not errorlevel 1 goto exit
+
+copy /y "%~1_temp" "%~1"
+
+:exit
+
+del "%~1_temp"